matplotlib-devel Mailing List for matplotlib

John Hunter wrote:
>>>>>>"paul" =3D=3D paul cristini <pau...@un...> writes:
>
>
> paul> The pick method because of the need to click on edges did
> paul> not fullfill my needs. So I wrote a new method Called
> paul> PickBigLine that does not required a mouse click close to
> paul> the edge but close to the line you want to pick. This is
> paul> particularly useful after zooming when the edges are
> paul> sometimes out of the axis limits. =20
>
>Hi Paul,
>
>It is not clear to me what this method is for. It would help if you
>posted an example where the current pick functionality failed and the
>one you propose succeeds (perhaps you could define your function at
>the top of the file for ease of use).
>
>I have a couple of questions/comments about your code...
>
> xt, yt =3D a.get_transform().numerix_x_y(xdata, ydata)
> xt, yt =3D asarray(xt), asarray(yt)=20
>
>There is no need to call asarray since numerix_x_y returns arrays.
>
>
> =20
> xc, yc =3D xt[1]-xt[0], yt[1]-yt[0]
>
>What is the point of this? Why do you only look at the points xt[1],
>xt[0], yt[1], yt[0]? What if someone needs to click on another point
>of the line?
>
> if xc=3D=3D0.0 and yc =3D=3D 0.0: return 1000000.
> D =3D xc*xc + yc*yc
> D1 =3D -(xt[0]-xywin[0])*yc+(yt[0]-xywin[1])*xc =
 =20
> D2 =3D -(yt[0]-xywin[1])*yc-(xt[0]-xywin[0])*xc
>
>What do D1 and D2 represent? I'm having trouble understanding why,
>for example, you need to do (xt[0]-xywin[0])*yc
>
> if D2/D>1.001 or D2/D<-0.001: return 1000000.
>
>I think the 1000000.0 sentinel value should be renamed to some useful
>constant name so it will be self documenting.
>
> return abs(D1/D)
>
>
> artists =3D self.lines
> if not len(artists): return None
> ds =3D [ (dist(a),a) for a in artists]
> ds.sort()
> return ds[0][1]
>
>
> paul> I also needed to add a
> paul> new property to Line2D called tag (similar to matlab) for
> paul> sorting purposes. I wonder if you have thought of adding
> paul> such a possibility to some objects for which it can be very
> paul> useful.
>
>Does the "label" property help here. Could you give a use case?
>
>Thanks!
>
>JDH
>
Sorry for the late answer but I had problems in designing a simple exampl=
e( I
had the very bad idea to letter "l" tas a key to press). Here it is :
from pylab import *
def pick(event):
 if event.key=3D=3D'p' and event.inaxes is not None:
 ax=3Devent.inaxes
 a=3Dax.pick(event.x,event.y)
 a.set_color('g')
 a.set_linewidth(2.)
 draw()
 if event.key=3D=3D'm' and event.inaxes is not None:
 ax=3Devent.inaxes
 a=3Dax.pickBigLine(event.x,event.y)
 a.set_color('g')
 a.set_linewidth(2.)
 draw()
#########################################################################=
###
def PlotTwoLines():
# hold(True)
 plot([0.,0.],[-100.,100.])
 plot([2.,2.],[-1.,1.])
 connect('key_press_event',pick)
 xmin,xmax,ymin,ymax=3Daxis()
 axis([xmin-1.,xmax+1.,ymin*1.1,ymax*1.1])
 show()
if __name__=3D=3D'__main__':
 PlotTwoLines()
Two way for picking a line the classical pick method by using the "p"key =
and
PickBigLine by using the "m" key.
The code just draw two lines a big one and a small one. The classical pic=
k
method works prefectly if you do not zoom to see the small line. But if y=
ou do a
zoom
to see more accurately the small line then it is impossible to pick the b=
ig line
unless you use PickBigLine.
Basically, PickBigLine evaluates the orthogonal distance from the selecte=
d point
to the line by calculating the intersection between the line you want to =
select
and a line passing through the selected point which is orthogonal.
Here is a modified version of PickBigLine taking into account your remark=
s and
working with Matplotlib 0.82
-------------------------------------------------------------------------=
-------------------------
 def pickBigLine(self, x, y, trans=3DNone):
 """
 Return the Line artist under point that is closest to the x, y. =
if trans
 is None, x, and y are in window coords, 0,0 =3D lower left. Othe=
rwise,
 trans is a matplotlib transform that specifies the coordinate sys=
tem
 of x, y.
 Calculates the orthogonal distance to the line
 Note this algorithm calculates distance to the vertices of the
 polygon, so if you want to pick a patch, click on the edge!
 """
 if trans is not None:
 xywin =3D trans.xy_tup((x,y))
 else:
 xywin =3D x,y
 def dist(a):
 Cste=3D1.e6
 xdata =3D a.get_xdata(valid_only =3D True)
 ydata =3D a.get_ydata(valid_only =3D True)
 # A point is not a line
 if len(xdata) =3D=3D 1: return Cste
 xt, yt =3D a.get_transform().numerix_x_y(xdata, ydata)
 xc, yc =3D xt[1]-xt[0], yt[1]-yt[0]
 if (xc=3D=3D0.0 and yc =3D=3D 0.0): return Cste
 D =3D xc*xc + yc*yc
 D1 =3D -(xt[0]-xywin[0])*yc+(yt[0]-xywin[1])*xc
 D2 =3D -(yt[0]-xywin[1])*yc-(xt[0]-xywin[0])*xc
 if D2/D>1.00001 or D2/D<-0.00001: return Cste
 return abs(D1/sqrt(D))
 artists =3D self.lines
 =20
 if not len(artists): return None
 ds =3D [ (dist(a),a) for a in artists]
 ds.sort()
 return ds[0][1]
-------------------------------------------------------------------------=
-----------
My interests are in ray tracing in geophysics. I am generating a lot of l=
ines
(thousands of) and then I need by zooming to identify trajectories conne=
cting a
source and a receiver. For example when I am picking a line I need to kno=
w to
what beam it belongs and also to what ray it coresponds (two integers for
instance). I don't know how to do it with the label property. It is an ax=
es
property not a line2D property.
If you want I can give an example of the use of the tag property I add.
Paul

>>>>> "Ted" == Ted Drain <ted...@jp...> writes:
 Ted> John, Is there anything special required to get the subplot
 Ted> configuration tool available from QtAgg? I'm in the process
 Ted> of fixing that sizing problem reported last week and the only
 Ted> way to fix it was to change how the toolbar layout works so
 Ted> I'm mucking around in the toolbar right now.
 Ted> I guess I'll sync and take a look at the Gtk backend and see
 Ted> what happens in there...
Hi Ted,
It shouldn't be hard. The subplot configuration toolbar is a pure
matplotlib widget so all it requires id for your toolbar to embed it
into a properly sized qt canvas. This means your toolbar needs to
know how to make a canvas, so you need to subclass the toolbar gor
qtagg. What I did for GTK was add a "_get_canvas(self, fig)" method
to the toolbar. 
The base class binds the new subplots.png button to
configure_subplots, which looks like this -- note the line marked with
the arrow
class NavigationToolbar2GTK(NavigationToolbar2, gtk.Toolbar):
 ...snip...
 def configure_subplots(self, button):
 toolfig = Figure(figsize=(6,3))
====> canvas = self._get_canvas(toolfig)
 toolfig.subplots_adjust(top=0.9)
 tool = SubplotTool(self.canvas.figure, toolfig)
 w = int (toolfig.bbox.width())
 h = int (toolfig.bbox.height())
 window = gtk.Window()
 window.set_title("Subplot Configuration Tool")
 window.set_default_size(w, h)
 vbox = gtk.VBox()
 window.add(vbox)
 vbox.show()
 canvas.show()
 vbox.pack_start(canvas, True, True)
 window.show()
 def _get_canvas(self, fig):
 return FigureCanvasGTK(fig)
Then in gtkagg, I subclass the toolbar with
class NavigationToolbar2GTKAgg(NavigationToolbar2GTK):
 def _get_canvas(self, fig):
 return FigureCanvasGTKAgg(fig)
You might want to try the same approach for qtagg. Of course there is
no FigureCanvasQt, but this approach will make it easier if someone
wants to add a different renderer to Qt, eg QtCairo.
JDH

On Wed, 2005年06月15日 at 09:22 -0500, John Hunter wrote: 
> >>>>> "Steve" == Steve Chaplin <ste...@ya...> writes:
> 
> Steve> Figure.get_width_height() returns width, height as floats,
> Steve> but isn't width, height of a Figure always integers, and
> Steve> wouldn't it make sense to return these as integers?
> 
> Steve> This would enable changing the code: width, height =
> Steve> figure.get_width_height() width, height = int(width),
> Steve> int(height)
> 
> Steve> to simply: width, height = figure.get_width_height()
> 
> The width and height of a figure are width/height in inches * dpi, and
> both dpi and the width/height vars can be floats. So no, these values
> don't have to be integers. In the postscript backend, for example, it
> returns the width and height of the figure in points. We could add a
> convenience kwarg to the method, since in practice it is usually used
> by GUI developers who want the dimensions in pixels
> 
> w, h = fig.get_width_height(asinteger=True)
> 
> If you think this is a good idea, feel free to add it.
> 
> JDH
My understanding is, the frontend does all its calculations in floating
point and never uses fig.get_width_height() because its always dealing
width width, height in inches and dpi.
'grep' shows that fig.get_width_height() is not used by the frontend,
its only ever used by the backends so it does not really belong in
Figure it belongs it FigureCanvas.
The value of width/height in inches * dpi does not need to be integers,
but what about the ACTUAL width, height values that the backends
produce?
The backends will either draw to the display with width, height in
integer pixels, or create an output file png, ps, svg etc, which in most
(all?) cases will have integer width, height. 
Does it make sense having an output file 1200.8 x 900.6? What use is the
fractional point/pixel?
I ran './simple_plot.py -dAgg' with
"savefig('simple_plot.png', dpi=150.1)"
to see if I would get the theoretical 1200.8 x 900.6 images.
png and jpg gave 1200 x 900
for svg I used w,h in inches of 8.1, 6.1 (and the default 72 dpi)
the svg file says the width, height is 583.2, 439.2, yet gthumb
shows the image size as 583 x 439.
So there is definitely a float-to-integer conversion/truncation for
width, height taking place.
I suggest moving Figure.get_width_height() to
FigureCanvas.get_width_height() and returning integers. If a backend
really can produce float width, height it can simply override
get_width_height().
regards,
Steve
Send instant messages to your online friends http://au.messenger.yahoo.com