matplotlib-devel Mailing List for matplotlib

	Alright, I think its ready to go. I can't say I am thrilled with the 
performance of the TkAgg compared to the GtkAgg. I get about 62fps compared to 
112fps for gtkagg. It is still a LOT faster.
	FYI, the current state of examples/animation_blit.py does nothing, and you 
print a fps for 200 frames when only 50 are actually drawn giving an 
unrealistically high fps measurement.
	Finally, could you please send me a windows-2.4 binary of current cvs. I have 
a project that I am wanting to use the blitting for the tkagg and I want to test 
on windows. I don't have a build environment for it. If it is too much 
trouble, it is not a big deal.
Thanks,
	Charlie
John Hunter wrote:
>>>>>>"Charles" == Charles Moad <cm...@in...> writes:
> 
> 
> Charles> 	I am really close on having blit work for the tkagg.
> Charles> I committed my changes. There is one problem left I was
> Charles> hoping you could help on. I blit the axes in the right
> Charles> place, but it is blitting the upper-left of the whole
> Charles> figure. Running your test script below, this is easily
> Charles> seen. How do I pass in just the pixmap of the area of
> Charles> interest?
> 
> You are very close :-)
> 
> You need to follow the logic of the "destbuffer" in _gtkagg src. This
> will either use the who agg pixBuffer if bbox is None, or else copy
> out the proper region of the agg pixel buffer into destbuffer. There
> is a boolean "needfree" that keeps track of whether you need to free
> the memory. This is true when bbox!=None since we have to allocate a
> temporary buffer to copy the rectangle of the pixBuffer into.
> 
> You then pass destbuffer instead of pixBuffer off to the tk drawing
> routine.
> 
> Thanks!
> JDH
> 
> bool needfree = false;
> 
> agg::int8u *destbuffer = NULL;
> if (args[2].ptr() == Py_None) {
> //bbox is None; copy the entire image
> destbuffer = aggRenderer->pixBuffer;
> destwidth = srcwidth;
> destheight = srcheight;
> deststride = srcstride;
> }
> else {
> //bbox is not None; copy the image in the bbox
> 
> Bbox* clipbox = static_cast<Bbox*>(args[2].ptr());
> double l = clipbox->ll_api()->x_api()->val() ; 
> double b = clipbox->ll_api()->y_api()->val();
> double r = clipbox->ur_api()->x_api()->val() ; 
> double t = clipbox->ur_api()->y_api()->val() ;
> 
> //std::cout << b << " " 
> //		<< t << " ";
> 
> destx = (int)l;
> desty = srcheight-(int)t;
> destwidth = (int)(r-l);
> destheight = (int)(t-b);
> deststride = destwidth*4;
> 
> needfree = true;
> destbuffer = new agg::int8u[deststride*destheight]; 
> if (destbuffer ==NULL) {
> 	throw Py::MemoryError("_gtkagg could not allocate memory for destbuffer");
> }
> 
> agg::rendering_buffer destrbuf;
> destrbuf.attach(destbuffer, destwidth, destheight, deststride);
> pixfmt destpf(destrbuf);
> renderer_base destrb(destpf);
> //destrb.clear(agg::rgba(1, 0, 0));
> 
> //std::cout << "rect " << r << " " << srcheight << " " << b << " ";
> agg::rect_base<int> region(destx, desty, (int)r, srcheight-(int)b); 
> destrb.copy_from(*aggRenderer->renderingBuffer, &region, 
> 		 -destx, -desty);
> 
> 
> }
> 
> 
> gdk_draw_rgb_32_image(drawable, gc, destx, desty, 
> 			 destwidth, 
> 			 destheight, 
> 			 GDK_RGB_DITHER_NORMAL,
> 			 destbuffer,
> 			 deststride);
> 
> if (needfree) delete [] destbuffer;
> 
> Charles> - Charlie

>>>>> "Charles" == Charles Moad <cm...@in...> writes:
 Charles> 	I am really close on having blit work for the tkagg.
 Charles> I committed my changes. There is one problem left I was
 Charles> hoping you could help on. I blit the axes in the right
 Charles> place, but it is blitting the upper-left of the whole
 Charles> figure. Running your test script below, this is easily
 Charles> seen. How do I pass in just the pixmap of the area of
 Charles> interest?
You are very close :-)
You need to follow the logic of the "destbuffer" in _gtkagg src. This
will either use the who agg pixBuffer if bbox is None, or else copy
out the proper region of the agg pixel buffer into destbuffer. There
is a boolean "needfree" that keeps track of whether you need to free
the memory. This is true when bbox!=None since we have to allocate a
temporary buffer to copy the rectangle of the pixBuffer into.
You then pass destbuffer instead of pixBuffer off to the tk drawing
routine.
Thanks!
JDH
 bool needfree = false;
 agg::int8u *destbuffer = NULL;
 if (args[2].ptr() == Py_None) {
 //bbox is None; copy the entire image
 destbuffer = aggRenderer->pixBuffer;
 destwidth = srcwidth;
 destheight = srcheight;
 deststride = srcstride;
 }
 else {
 //bbox is not None; copy the image in the bbox
 
 Bbox* clipbox = static_cast<Bbox*>(args[2].ptr());
 double l = clipbox->ll_api()->x_api()->val() ; 
 double b = clipbox->ll_api()->y_api()->val();
 double r = clipbox->ur_api()->x_api()->val() ; 
 double t = clipbox->ur_api()->y_api()->val() ;
 
 //std::cout << b << " " 
 //		<< t << " ";
 destx = (int)l;
 desty = srcheight-(int)t;
 destwidth = (int)(r-l);
 destheight = (int)(t-b);
 deststride = destwidth*4;
 
 needfree = true;
 destbuffer = new agg::int8u[deststride*destheight]; 
 if (destbuffer ==NULL) {
	throw Py::MemoryError("_gtkagg could not allocate memory for destbuffer");
 }
 
 agg::rendering_buffer destrbuf;
 destrbuf.attach(destbuffer, destwidth, destheight, deststride);
 pixfmt destpf(destrbuf);
 renderer_base destrb(destpf);
 //destrb.clear(agg::rgba(1, 0, 0));
 
 //std::cout << "rect " << r << " " << srcheight << " " << b << " ";
 agg::rect_base<int> region(destx, desty, (int)r, srcheight-(int)b); 
 destrb.copy_from(*aggRenderer->renderingBuffer, &region, 
		 -destx, -desty);
 
 
 }
 gdk_draw_rgb_32_image(drawable, gc, destx, desty, 
			 destwidth, 
			 destheight, 
			 GDK_RGB_DITHER_NORMAL,
			 destbuffer,
			 deststride);
 
 if (needfree) delete [] destbuffer;
 Charles> - Charlie

	I am really close on having blit work for the tkagg. I committed my changes. 
There is one problem left I was hoping you could help on. I blit the axes in 
the right place, but it is blitting the upper-left of the whole figure. 
Running your test script below, this is easily seen. How do I pass in just the 
pixmap of the area of interest?
- Charlie
John Hunter wrote:
>>>>>>"Charles" == Charles Moad <cm...@in...> writes:
> 
> 
> Charles> I added the blit method to the tkagg, but I don't know
> Charles> what needs to be done to take the bbox into account.
> Charles> Even as it stands I get 141 fps in animation_blit.py
> Charles> compared to gtk's 350 fps. Whoever is the tk expert, any
> Charles> clue on how to account for the bbox on blit updates?
> 
> Todd wrote this, but I can point you to the relevant section of code.
> 
> tkagg.blit(self._tkphoto, self.renderer._renderer, 2)
> 
> calls backends.tkagg.blit
> 
> def blit(photoimage, aggimage, colormode=1):
> tk = photoimage.tk
> try:
> tk.call("PyAggImagePhoto", photoimage, id(aggimage), colormode)
> except Tk.TclError, v:
> try:
> try:
> _tkagg.tkinit(tk.interpaddr(), 1)
> except AttributeError:
> _tkagg.tkinit(id(tk), 0)
> tk.call("PyAggImagePhoto", photoimage, id(aggimage), colormode)
> except (ImportError, AttributeError, Tk.TclError):
> raise
> 
> and PyAggImagePhoto is the relevant function which is defined in
> src/_tkagg.cpp
> 
> static int
> PyAggImagePhoto(ClientData clientdata, Tcl_Interp* interp,
> int argc, char **argv)
> {
> Tk_PhotoHandle photo;
> Tk_PhotoImageBlock block;
> PyObject* aggo;
> //...snip....
> 
> 
> 
> block.width = aggRenderer->get_width();
> block.height = aggRenderer->get_height();
> //std::cout << "w,h: " << block.width << " " << block.height << std::endl;
> block.pitch = block.width * nval;
> block.pixelPtr = aggRenderer->pixBuffer;
> /* Clear current contents */
> Tk_PhotoBlank(photo);
> /* Copy opaque block to photo image, and leave the rest to TK */
> Tk_PhotoPutBlock(photo, &block, 0, 0, block.width, block.height);
> 
> I assume the 0, 0 are the x and y offsets and block.width,
> block.height are the sizes of the rect to be transferred. By
> following the example of src/_gtkagg.cpp, you should be able to
> substitute in the information from the bbox where appropriate.
> 
> BTW, I am getting 51 FPS with Tkagg using your blit. My test script
> is below:
> 
> import matplotlib
> matplotlib.use('TkAgg')
> import sys
> import gtk, gobject
> import pylab as p
> import matplotlib.numerix as nx
> import time
> 
> ax = p.subplot(111)
> canvas = ax.figure.canvas
> 
> 
> # create the initial line
> x = nx.arange(0,2*nx.pi,0.01)
> line, = p.plot(x, nx.sin(x), animated=True)
> 
> def run(*args):
> background = canvas.copy_from_bbox(ax.bbox)
> # for profiling
> tstart = time.time()
> 
> while 1:
> # restore the clean slate background
> canvas.restore_region(background)
> # update the data
> line.set_ydata(nx.sin(x+run.cnt/10.0)) 
> # just draw the animated artist
> ax.draw_artist(line)
> # just redraw the axes rectangle
> canvas.blit(ax.bbox) 
> 
> if run.cnt==200:
> # print the timing info and quit
> print 'FPS:' , 200/(time.time()-tstart)
> sys.exit()
> 
> run.cnt += 1
> run.cnt = 0 
> 
> 
> manager = p.get_current_fig_manager()
> manager.window.after(100, run)
> 
> p.show()
> 
> 
> 

On Fri, 2005年08月05日 at 20:28 -0700,
mat...@li... wrote:
> >>>>> "John" == John Hunter <jdh...@ac...>
> writes:
> 
> John> I think we have a problem in GTK. In the script
> below, if
> John> you add a button or some other widget above the
> figure
> John> canvas, only a part of the canvas is updated in the
> John> motion_notify_event update. The distance from the
> top of
> John> the figure canvas to the part that is not updated is
> equal
> John> to the height of the widget packed above the canvas.
> You
> John> can observe this by resizing the window to make it
> taller or
> John> shorter and noting the vertical extent where the
> horizontal
> John> line disappears.
> 
> I think the answer is
> 
> def draw(self):
> # synchronous window redraw (like GTK+ 1.2 used to do)
> # Note: this does not follow the usual way that GTK
> redraws,
> # which is asynchronous redraw using calls to
> gtk_widget_queue_draw(),
> # which triggers an expose-event
> 
> # GTK+ 2.x style draw()
> #self._need_redraw = True
> #self.queue_draw()
> 
> # synchronous draw (needed for animation)
> x, y, w, h = self.allocation
> #print x, y, w, h
> self._pixmap_prepare (w, h)
> self._render_figure(self._pixmap, w, h)
> self._need_redraw = False
> self.window.draw_drawable
> (self.style.fg_gc[self.state],
> self._pixmap, 0, 0, 0, 0,
> w, h)
> ^^^^^^^^^^
That looks correct.
I was confusing the event.area rectangle with the allocation rectangle.
For event.area x,y is relative to the widget and "x,y,x,y,w,h" works.
But self.allocation x,y is relative to the parent so you need
"0,0,0,0,w,h".
Steve
Send instant messages to your online friends http://au.messenger.yahoo.com 

	Yeah, sorry I haven't had much time to work on it lately. The save 
button is pretty much a place holder for what I was going to add. My 
last headache was making multiple figures/windows work.
Thanks,
	Charlie
Jeff Whitaker wrote:
> 
> The Matplotlib.nib directory is missing in the 0.83.2 source tarball. 
> It needs to be installed in <sys.prefix>/share/matplotlib for the 
> CocoaAgg backend to work. I manually retrieved it from CVS and put it 
> there, and it seems to work - except for the 'Save Figure'
> button which doesn't seem to do anything yet.
> 
> -Jeff
>