matplotlib-users Mailing List for matplotlib

I've done this successfully with both the Qt4 and WX Agg backends. The part
you care about is the update method.
Here's the snippet I use for Qt. It shouldn't change except for your
imports at the top if you're using Wx. Note, I've trimmed this down a bit,
so hopefully I didn't trim out anything important:
from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as
FigureCanvas
class PlotWidget(QWidget):
 def __init__(self, parent):
 QWidget.__init__(self, parent)
 self.dpi=72
 self.figure = Figure(dpi=self.dpi, linewidth=3)
 self.canvas = FigureCanvas(self.figure)
 self.canvas.setParent(self)
 self.ax = self.figure.add_subplot(111)
 (self.__times, self.__temps) = ([], [])
 self.background = self.canvas.copy_from_bbox(self.ax.bbox)
 self.plotting_line = self.ax.plot([], color='red', lw=2)[0]
 def update(self, temp, secs):
 try:
 self.__times.append(secs)
 self.__temps.append(temp)
 self.canvas.restore_region(self.background)
 self.plotting_line.set_xdata(self.__times)
 self.plotting_line.set_ydata(self.__temps)
 self.ax.draw_artist(self.plotting_line)
 self.canvas.blit(self.ax.bbox)
 except IndexError:
 pass
 self.canvas.draw()
On Fri, Mar 12, 2010 at 12:36 PM, Gökhan Sever <gok...@gm...>wrote:
> Hello,
>
> I read a simple data stream from my computers serial port. I can nicely
> read the data using pyserial library but couldn't get it *nicely* working
> neither with WXAgg nor Qt4Agg using the following code. Although with WX I
> could get updated looks, the figure isn't very responsive in this way. I
> have looked at simple_idle_wx example but for some reason I can't make it
> work to update the canvas whenever the condition satisfied.
>
> What is the trick to make the real-time data plotted on the screen easily
> without blocking the figure itself?
>
> import serial
> import matplotlib.pyplot as plt
> plt.ion()
>
> ser = serial.Serial(0)
>
> conc = []
> while True:
> s = ser.readline()
> if s.startswith('CONC'):
> conc.append(float(s.split()[2]))
> plt.plot(conc)
> plt.show()
> plt.clf()
>
> ser.close()
>
> --
> Gökhan
>
>
> ------------------------------------------------------------------------------
> Download Intel&#174; Parallel Studio Eval
> Try the new software tools for yourself. Speed compiling, find bugs
> proactively, and fine-tune applications for parallel performance.
> See why Intel Parallel Studio got high marks during beta.
> http://p.sf.net/sfu/intel-sw-dev
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>
>

On Fri, Mar 12, 2010 at 7:45 AM, othererik <oth...@gm...> wrote:
> Here's a short example that does the opposite of what I'm looking for.  The
> goal is to take a the polygon "poly_patch" and "cut" regions out of it.
> All I've managed to achieve so far has been to show regions of the
> "poly_patch".
>
With clip_path set, things inside the clip_path is only drawn. So, I
think you're misusing clip_path.
To draw a rectangle with a hole in it, you need to create a compound
path. And, this requires some understanding of how path system works
in general.
See this,
http://matplotlib.sourceforge.net/users/path_tutorial.html
and
http://old.nabble.com/Compound-paths-to19278422.html#a19296862
Here is modified version of your script that draws a rectangle with a
hole. It concatenates two existing paths. But, often it is better to
start from scratch (but again you need to understand how path works).
And of course, the resulting compound path can be set as a clip_path
of other artist.
Regards,
-JJ
import matplotlib
from matplotlib import patches
import pylab
fig=pylab.figure()
ax=fig.add_subplot(111)
# background line
line = ax.plot( [ 1, 2, 3], [ 1, 2, 3 ] )
# mask polygon that should cover/hide the area not intersecting the
poly_patch = patches.Polygon(((1,1),(1,3),(3,3), (3,1)))
# part I would like to see through
hole_patch = patches.Circle((2,2), radius=.5, facecolor='red')
from matplotlib.bezier import make_path_regular, concatenate_paths
from matplotlib.path import Path
from matplotlib.patches import PathPatch
poly_path = make_path_regular(poly_patch.get_path())
# close the path
closed_polygon_path = Path(list(poly_path.vertices)+[(0,0)],
 list(poly_path.codes)+[Path.CLOSEPOLY])
# circle with coordinate transformed
hole_path = hole_patch.get_path()
hole_path_transformed =
hole_patch.get_patch_transform().transform_path(hole_path)
# make polygon with a hole
poly_with_hole_path = concatenate_paths([closed_polygon_path,
 hole_path_transformed])
poly_with_hole_patch = PathPatch(poly_with_hole_path)
ax.add_patch(poly_with_hole_patch)
ax.set_xlim(0, 4)
ax.set_ylim(0, 4)
pylab.show()

David Smith wrote:
> This is a bug report.
> 
> I am using matplotlib 0.99.1 on Windows. When using contour with the 
> keyword
> argument locator=ticker.FixedLocator(levels), the plot is always 
> dropping the first
> and last contour level. If there are less than 3 levels, contour.py 
> throws an
> exception.
> 
> My workaround is to duplicate the first and last levels when using the 
> fixed locator: 
> e.g. my argument becomes
> 
> locator=FixedLocator( [levels[0]] + levels + [levels[-1]] )
> 
> I have traced the problem to the last line in contour.py, method 
> _autolev() which
> strips the first and last levels if the contours are not filled:
> 
> return lev[1:-1]
> 
> This line occurs at line 682 in my version of contour.py which came with 
> the 0.991 installation.
> 
> I realize that I could specify the levels in the argument V and this 
> does work. However
> this code is embedded in GUI-ness which allows the user to choose how 
> the contours
> are selected. Passing the locator seems to be the best option code-wise.
I committed a small change to svn trunk (r8190) that I think will handle 
your use case without fouling anything else up.
Eric
> 
> Thank you,
> 
> Dave Smith
> 

On Fri, Mar 12, 2010 at 11:11 AM, jdidion <jd...@em...> wrote:
> but I
> can't figure out how to make this happen, other than to use a really fat
> line width (which I would prefer not to do)
What other way do you have in mind? I don't see any.
By the way, why not just use histogram?
Regards,
-JJ

On Fri, Mar 12, 2010 at 1:15 PM, Alex S <sch...@gm...> wrote:
> Hi there, does anyone know if there's a simple way to set an axis limit to a
> date? "viewlim_to_dt()" looks promising, but I can't figure out how to use
> it...
If you've plotted using dates, just use dates for the limits:
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta
s = datetime.now()
x = np.array([s, s + timedelta(hours=3)])
y = np.arange(1,3)
plt.plot(x,y)
plt.xlim(s - timedelta(minutes=30), s + timedelta(hours=4))
plt.show()
Ryan
-- 
Ryan May
Graduate Research Assistant
School of Meteorology
University of Oklahoma