 # animate histogram

RE: [Matplotlib-users] animate histogram
I just saw the email below from John, and I was wondering why using compound paths are “goo-gobs” faster than using rectangles(patches)?

I’ve been using the candlestick function quite a bit lately. I guess using compound paths could make the candlestick function faster. I’ll give it a try.

Regards,

Christophe

···

-----Original Message-----

From: John Hunter [mailto:jdh2358@…2015…87…]

Sent: Sat 08/08/2009 09:00

To: Kaushik Ghose

Subject: Re: [Matplotlib-users] animate histogram

On Sat, Aug 8, 2009 at 6:17 AM, Kaushik Ghose<Kaushik_Ghose@…2126…> wrote:

e.g. set_height() to change the rectangles?

e.g. code

import pylab

x = pylab.rand(20)

h = pylab.hist(x)

h.set_height(1)

pylab.draw()

This is the right idea, but it is likely to be slow for animation,

since each rectangle is a separate mpl object, each with its own

graphics contexs, rendering step, etc. bar and hist were very early

functions which I wrote before we had collections and compound paths.

If I were rewriting it from scratch, I would use a compound path.

It’s a little more work upfront because you have to manually compute

the vertices and path codes, but it will be goo-gobs faster. Here is

the animated histogram for tk using compound paths

“”"

This example shows how to use a path patch to draw a bunch of

rectangles for an animated histogram

“”"

import numpy as np

import matplotlib

matplotlib.use(‘TkAgg’) # do this before importing pylab

import matplotlib.pyplot as plt

import matplotlib.patches as patches

import matplotlib.path as path

fig = plt.figure()

# histogram our data with numpy

data = np.random.randn(1000)

n, bins = np.histogram(data, 100)

# get the corners of the rectangles for the histogram

left = np.array(bins[:-1])

right = np.array(bins[1:])

bottom = np.zeros(len(left))

top = bottom + n

nrects = len(left)

# it to keep the codes aligned with the vertices

nverts = nrects*(1+3+1)

verts = np.zeros((nverts, 2))

codes = np.ones(nverts, int) * path.Path.LINETO

codes[0::5] = path.Path.MOVETO

codes[4::5] = path.Path.CLOSEPOLY

verts[0::5,0] = left

verts[0::5,1] = bottom

verts[1::5,0] = left

verts[1::5,1] = top

verts[2::5,0] = right

verts[2::5,1] = top

verts[3::5,0] = right

verts[3::5,1] = bottom

barpath = path.Path(verts, codes)

patch = patches.PathPatch(barpath, facecolor=‘green’,

edgecolor=‘yellow’, alpha=0.5)

ax.set_xlim(left, right[-1])

ax.set_ylim(bottom.min(), top.max())

def animate():

``````# simulate new data coming in

data = np.random.randn(1000)

n, bins = np.histogram(data, 100)

top = bottom + n

verts[1::5,1] = top

verts[2::5,1] = top

fig.canvas.draw()
``````

def run():

``````for i in range(100):

fig.canvas.manager.window.after(100, animate)
``````

fig.canvas.manager.window.after(100, run)

plt.show()

No virus found in this incoming message.

Checked by AVG - www.avg.com

Version: 8.5.392 / Virus Database: 270.13.49/2295 - Release Date: 08/14/09 06:10:00

I haven't profiled it, so the go-gobs was a bit speculative, but each
Rectangle is a separate object with a separate graphics context and a
separate draw step. By moving all this into a single object, the
compound path, you get a lot of savings.

JDH

···

On Wed, Aug 19, 2009 at 3:25 PM, Christophe Dupre<christophe.dupre@...2631...> wrote:

I just saw the email below from John, and I was wondering why using compound
paths are "goo-gobs" faster than using rectangles(patches)?

I've been using the candlestick function quite a bit lately. I guess using
compound paths could make the candlestick function faster. I'll give it a
try.