matplotlib-devel Mailing List for matplotlib

Thank you Jared Wahlstrand and anyone else who has contributed to the svg 
backend. I'm making a poster with Inkscape, and had trouble importing some 
eps graphics, when I remembered that we have svg support. MPL kicks ass.

>>>>> "Tom" == Tom Denniston <tom...@al...> writes:
    Tom> I was able to work around the error simply by doing the
    Tom> obvious, making var = 0 if max(abs(vmin), abs(vmax)).  I
    Tom> think someone who understood the code better could probably
    Tom> come up with a better solution.

Hey Tom, this bug is already fixed in matplotlib svn.  Thanks for the
report.

JDH

The following code in matplotlib.ticker has a bug:

730     def scale_range(vmin, vmax, n =3D 1, threshold=3D100):
731         dv =3D abs(vmax - vmin)
732         meanv =3D 0.5*(vmax+vmin)
733 B->     var =3D dv/max(abs(vmin), abs(vmax))
734         if var < 1e-12:
735             return 1.0, 0.0
736         if abs(meanv)/dv < threshold:
737             offset =3D 0
738         elif meanv > 0:

When both dmin and dmax are 0 it results in 0 division.  I have been
unable to write a snippet of code to reproduce the problem
unfortunately.

I was able to work around the error simply by doing the obvious,
making var =3D 0 if max(abs(vmin), abs(vmax)).  I think someone who
understood the code better could probably come up with a better
solution.

--Tom

Hello,

This is my first message to the mailing list. I send a
patch to plot arrows as markers. I hope someone find
it usefull.

I needed to plot arrows as markers and I did not find
how to do it easily. Finally I changed some of the
source code (axes.py and lines.py) to do this.

To plot an arrow you have to write an 'a' plus a
number which defines the direction of the arrow. The
directions are the same that the ones in the numerical
keyboard, i.e., if you want to plot a green arrow
pointing to the left-bottom you will have to write the
string 'ga1' or 'a1g'.

I send the files for the version 0.82 of matplotlib (I
can not run properly the version 0.87 by now because I
have problems with colours and the axes(??!)). Here
are the diff outputs for the two files:

--- axes.py 2005-08-04 20:19:57.000000000 +0200
+++ axes_original.py  2005-06-15 20:50:44.000000000
+0200
@@ -89,30 +89,6 @@
     if fmt.find('-.')>=0:
         linestyle = '-.'
         fmt = fmt.replace('-.', '')
-    if fmt.find('a1')>=0:
-        marker = 'a1'
-        fmt = fmt.replace('a1', '')
-    if fmt.find('a2')>=0:
-        marker = 'a2'
-        fmt = fmt.replace('a2', '')
-    if fmt.find('a3')>=0:
-        marker = 'a3'
-        fmt = fmt.replace('a3', '')
-    if fmt.find('a4')>=0:
-        marker = 'a4'
-        fmt = fmt.replace('a4', '')
-    if fmt.find('a6')>=0:
-        marker = 'a6'
-        fmt = fmt.replace('a6', '')
-    if fmt.find('a7')>=0:
-        marker = 'a7'
-        fmt = fmt.replace('a7', '')
-    if fmt.find('a8')>=0:
-        marker = 'a8'
-        fmt = fmt.replace('a8', '')
-    if fmt.find('a9')>=0:
-        marker = 'a9'
-        fmt = fmt.replace('a9', '')

     chars = [c for c in fmt]



--- lines.py        2005-08-04 20:19:57.000000000
+0200
+++ lines_original.py   2005-06-15 00:21:21.000000000
+0200
@@ -27,8 +27,7 @@
 lineStyles  = {'-':1, '--':1, '-.':1, ':':1,
'steps':1, 'None':1}
 lineMarkers =    {'.':1, ',':1, 'o':1, '^':1, 'v':1,
'<':1, '>':1, 's':1,
                   '+':1, 'x':1, 'd':1, 'D':1, '|':1,
'_':1, 'h':1, 'H':1,
-                  'p':1, '1':1, '2':1, '3':1, '4':1,
'a1':1, 'a2':1,
-                  'a3':1, 'a4':1, 'a6':1, 'a7':1,
'a8':1, 'a9':1,
+                  'p':1, '1':1, '2':1, '3':1, '4':1,
                   TICKLEFT:1,
                   TICKRIGHT:1,
                   TICKUP:1,
@@ -109,14 +108,6 @@
         '2'  : '_draw_tri_up',
         '3'  : '_draw_tri_left',
         '4'  : '_draw_tri_right',
-        'a1'  : '_draw_arrow_left_down',
-        'a2'  : '_draw_arrow_down',
-        'a3'  : '_draw_arrow_right_down',
-        'a4'  : '_draw_arrow_left',
-        'a6'  : '_draw_arrow_right',
-        'a7'  : '_draw_arrow_left_up',
-        'a8'  : '_draw_arrow_up',
-        'a9'  : '_draw_arrow_right_up',
         's'  : '_draw_square',
         'p'  : '_draw_pentagon',
         'h'  : '_draw_hexagon1',
@@ -1136,139 +1127,6 @@
                 renderer.draw_line(gc, x-offset,
y-offset, x+offset, y+offset)
                 renderer.draw_line(gc, x-offset,
y+offset, x+offset, y-offset)

-#Empiezan mis 8 flechas
-
-    def _draw_arrow_down(self, renderer, gc, xt, yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(0, +offset)
-            path.line_to(0, -offset)
-            path.line_to(-offset, 0)
-            path.move_to(+offset, 0)
-            path.line_to(0, -offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x, y+offset,
x, y-offset)
-                renderer.draw_line(gc, x, y-offset,
x+offset, y)
-                renderer.draw_line(gc, x, y-offset,
x-offset, y)
-
-    def _draw_arrow_left_down(self, renderer, gc, xt,
yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(+offset, +offset)
-            path.line_to(-offset, -offset)
-            path.line_to(-offset, 0)
-            path.move_to(0, -offset)
-            path.line_to(-offset, -offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x+offset,
y+offset, x-offset, y-offset)
-                renderer.draw_line(gc, x-offset,
y-offset, x-offset, y)
-                renderer.draw_line(gc, x-offset,
y-offset, x, y-offset)
-
-    def _draw_arrow_right_down(self, renderer, gc,
xt, yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(-offset, +offset)
-            path.line_to(+offset, -offset)
-            path.line_to(+offset, 0)
-            path.move_to(0, -offset)
-            path.line_to(+offset, -offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x-offset,
y+offset, x+offset, y-offset)
-                renderer.draw_line(gc, x+offset,
y-offset, x+offset, y)
-                renderer.draw_line(gc, x+offset,
y-offset, x, y-offset)
-
-    def _draw_arrow_left(self, renderer, gc, xt, yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(+offset,0)
-            path.line_to(-offset,0)
-            path.line_to(0,+offset)
-            path.move_to(-offset, 0)
-            path.line_to(0, -offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x+offset, y,
x-offset, y)
-                renderer.draw_line(gc, x-offset, y,
x, y+offset)
-                renderer.draw_line(gc, x-offset, y,
x, y-offset)
-
-    def _draw_arrow_right(self, renderer, gc, xt,
yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(-offset,0)
-            path.line_to(+offset,0)
-            path.line_to(0,+offset)
-            path.move_to(+offset, 0)
-            path.line_to(0, -offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x+offset, y,
x-offset, y)
-                renderer.draw_line(gc, x+offset, y,
x, y+offset)
-                renderer.draw_line(gc, x+offset, y,
x, y-offset)
-
-    def _draw_arrow_left_up(self, renderer, gc, xt,
yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(+offset, -offset)
-            path.line_to(-offset, +offset)
-            path.line_to(-offset, 0)
-            path.move_to(0, +offset)
-            path.line_to(-offset, +offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x-offset,
y+offset, x+offset, y-offset)
-                renderer.draw_line(gc, x-offset,
y+offset, x, y+offset)
-                renderer.draw_line(gc, x-offset,
y+offset, x-offset, y)
-
-    def _draw_arrow_up(self, renderer, gc, xt, yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(0, -offset)
-            path.line_to(0, +offset)
-            path.line_to(-offset, 0)
-            path.move_to(+offset, 0)
-            path.line_to(0, +offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x, y+offset,
x, y-offset)
-                renderer.draw_line(gc, x, y+offset,
x+offset, y)
-                renderer.draw_line(gc, x, y+offset,
x-offset, y)
-
-    def _draw_arrow_right_up(self, renderer, gc, xt,
yt):
-        offset =
0.5*renderer.points_to_pixels(self._markersize)
-        if self._newstyle:
-            path = agg.path_storage()
-            path.move_to(-offset, -offset)
-            path.line_to(+offset, +offset)
-            path.line_to(+offset, 0)
-            path.move_to(0, +offset)
-            path.line_to(+offset, +offset)
-            renderer.draw_markers(gc, path, None, xt,
yt, self._transform)
-        else:
-            for (x,y) in zip(xt, yt):
-                renderer.draw_line(gc, x+offset,
y+offset, x-offset, y-offset)
-                renderer.draw_line(gc, x+offset,
y+offset, x+offset, y)
-                renderer.draw_line(gc, x+offset,
y+offset, x, y+offset)
-
-#Terminan mis 8 flechas
-
-
     def update_from(self, other):
         'copy properties from other to self'
         Artist.update_from(self, other)


-------------------------------------

I think it would not be difficult to do something
similar for the last version. The shape of the arrows
can be improved to look better. This patch is only an
idea, the problem is to add new non-standard marker
names, if anyone knows a smart way of doing this it
would be apreciated. That's all.

Thank you for your fabulous module.
Pepe.



		
______________________________________________ 
LLama Gratis a cualquier PC del Mundo. 
Llamadas a fijos y móviles desde 1 céntimo por minuto. 
http://es.voice.yahoo.com

Jouni K Seppanen <jk...@ik...> writes:

> It apparently has to be font.load_char(ch, LOAD_NO_SCALE), or at least
> that produces width values that look similar to those in files saved
> by Preview.app. But acroread still complains...

It seems that I can stop the complaining by forcing the /LastChar
entry in the Font dictionary to be 255 instead of 258. The characters
(in at least Bitstream Vera Sans) mysteriously seem to be numbered
from 3 to 258, so I guess this must be some sort of an encoding issue. 
Does this ring a bell to anyone?

-- 
Jouni

>>>>> "Jouni" == Jouni K Seppanen <jk...@ik...> writes:

    Jouni> John Hunter <jdh...@ac...> writes:
    >> You shouldn't need to with the ft2font extension code, because
    >> it uses pycxx which has support for kwarg handling.  Eg in the
    >> _image.cpp src
    >> 
    >> Py::Object resize(const Py::Tuple& args, const Py::Dict&
    >> kwargs);
    Jouni>  [...]
    >> args.verify_length(2);
    >> 
    >> int norm = 1; if ( kwargs.hasKey("norm") ) norm = Py::Int(
    >> kwargs["norm"] );

    Jouni> This seems to mean that the function cannot be called using
    Jouni> the normal Python convention:

    >>>> img.resize(10,10,1)
    Jouni>   Traceback (most recent call last): File "<stdin>", line
    Jouni> 1, in ?  IndexError: Unexpected SeqBase<T> length.

The reason it raises is because I told it too :-)

  args.verify_length(2);

if you want normal python symantics, you could to something something
like (untested, freestyle code)

  int norm(0);
  if (args.length()==3)
      norm = Py::Int( args[2] );
  elif ( kwargs.hasKey("norm") ) 
    norm = Py::Int( kwargs["norm"] );

    Jouni> Instead you have to do img.resize(10,10,norm=1). This is
    Jouni> handled transparently by PyArg_ParseTupleAndKeywords: if
    Jouni> you set the format string to "ii|ii" and list the names of
    Jouni> all parameters as keywords, you automatically get the
    Jouni> normal Python convention where the last two args are
    Jouni> optional and all args are specifiable with their names.

    Jouni> But I guess this is not so important in extension code that
    Jouni> only gets called by matplotlib internals and not end users,
    Jouni> so I changed load_char to use the pycxx convention.

I do think it is useful in the pycxx extension code to stick where
possible to the cxx idioms -- for the most part the code is cleaner to
reads and helps with reference counting, etc....  You can check the
docs at 

  http://cxx.sourceforge.net/PyCXX.html

there may be a cleaner way to handle kwargs than what I suggested.

JDH

John Hunter <jdh...@ac...> writes:

> You shouldn't need to with the ft2font extension code, because it uses
> pycxx which has support for kwarg handling.  Eg in the _image.cpp src
>
>   Py::Object resize(const Py::Tuple& args, const Py::Dict& kwargs);
 [...]
>   args.verify_length(2);
>
>   int norm = 1;
>   if ( kwargs.hasKey("norm") ) norm = Py::Int( kwargs["norm"] );

This seems to mean that the function cannot be called using the normal
Python convention:

  >>> img.resize(10,10,1)
  Traceback (most recent call last):
    File "<stdin>", line 1, in ?
  IndexError: Unexpected SeqBase<T> length.

Instead you have to do img.resize(10,10,norm=1). This is handled
transparently by PyArg_ParseTupleAndKeywords: if you set the format
string to "ii|ii" and list the names of all parameters as keywords,
you automatically get the normal Python convention where the last two
args are optional and all args are specifiable with their names.

But I guess this is not so important in extension code that only gets
called by matplotlib internals and not end users, so I changed
load_char to use the pycxx convention.

-- 
Jouni