matplotlib-users Mailing List for matplotlib

I would like to announce PyUniversalLibrary version 20050623.

PyUniversalLibrary is a Python wrapper for Measurement Computing's
Universal Library for data acquisition on Microsoft Windows operating
systems.

http://www.its.caltech.edu/~astraw/pyul.html

Work in Progress
----------------

Currently PyUniversalLibrary is incomplete.  I have only wrapped the
functions which I have personally needed, primarily buffered analog
input.  If you need more functionality, you will hopefully find that
the start I have made in wrapping this library useful. I welcome your
changes and additions.  I will include them with the next release with
appropriate credit.

If I run the script below (taken straight from 
the docs except for the imports) the script fails 
with a message that matshow does not return a tuple, which 
appears true. Dropping the extra LHS variables allows the 
script to run, but produces 4 separate figures.

Thanks, 
Alan Isaac 


============================================ 

from scipy import * 
from pylab import * 
def samplemat(dims): 
    aa = zeros(dims) 
    for i in range(min(dims)): 
        aa[i,i] = i 
    return aa 

dimlist = [(12,12),(128,64),(64,512),(2048,256)] 

for d in dimlist: 
    fig, ax, im = matshow(samplemat(d)) 
show() 

Hi Danny,

Danny Shevitz wrote:
> howdy,
> 
> I have some beginner type questions with matshow.
> 
> I want the origin of the axes to be the lower left of the figure. I tried:
> 	fig=matshow(data, cmap, origin='lower')
> 
> but that didn't seem to do anything. Actually, I want to flip the figure 
> over upper left->lower right diagonal and I want to
> do this without explicitly transposing the matrix if possible.
> 
> I also am having trouble with the figure size. I am working on a weird dpi 
> (93.65) screen. I tried
> 	fig.set_figsize_inches((5.,5.))
> 	fig.set_dpi(93.6585)
> 
> But the screen dimensions still come out off. They are in fact 5 5/16" x 5 
> 5/16". Any ideas?

Even though I wrote matshow, I have to admit that it was very much a 'stumble 
in the dark' kind of code.  I basically just mucked around with imshow enough 
to get a matrix to display in the 'traditional' way (top-down, with properly 
preserved aspect ratio) and that was about it.  I'm sure the code can use 
improvements, but at the time I can't commit any effort into it, I'm afraid.

If you can extend it (the code is extremely simple) in a useful way, just send 
a patch over and I'm sure we can apply it.

Regards,

f

>>>>> "zori" == zori  <zo...@vi...> writes:

    zori> Hi, Exploring the agg.py module of the matplotlib library, I
    zori> have encauntered that I cannot represent smooth arcs. For
    zori> example, circle appears as octagon. Could you give me an
    zori> idea how to manage this and what is the reason for such
    zori> behaviour? Here is the code of the agg_test.py changed to
    zori> draw arc, but not giving the desired result:

Hi Zori,

I updated the agg_test.py example to show how to do a few more things
-- drawing curves, filling and stroking, and making affine
transformations of paths and curves.  Down the road I would like to
replace refactor backend_agg.py and _backend_agg.cpp to use this swig
wrapper of agg, so that agg users would have access to the low level
agg library for customized drawing over a mpl figure.

# this example uses the agg python module directly there is no
# documentation -- you have to know how to use the agg c++ API to use
# it
import matplotlib.agg as agg
from math import pi

## Define some colors
red = agg.rgba8(255,0,0,255)
blue = agg.rgba8(0,0,255,255)
green = agg.rgba8(0,255,0,255)
black = agg.rgba8(0,0,0,255)
white = agg.rgba8(255,255,255,255)
yellow = agg.rgba8(192,192,255,255)

## Create the rendering buffer, rasterizer, etc
width, height = 600,400
stride = width*4
buffer = agg.buffer(width, height, stride)

rbuf = agg.rendering_buffer()
rbuf.attachb(buffer)

pf = agg.pixel_format_rgba(rbuf)
rbase = agg.renderer_base_rgba(pf)
rbase.clear_rgba8(blue) 

renderer =  agg.renderer_scanline_aa_solid_rgba(rbase);
renderer.color_rgba8( red )
rasterizer = agg.rasterizer_scanline_aa()
scanline = agg.scanline_p8()

## A polygon path
path = agg.path_storage()
path.move_to(10,10)
path.line_to(100,100)
path.line_to(200,200)
path.line_to(100,200)
path.close_polygon()

# stroke it
stroke = agg.conv_stroke_path(path)
stroke.width(3.0)
rasterizer.add_path(stroke)
agg.render_scanlines_rgba(rasterizer, scanline, renderer);

## A curved path
path = agg.path_storage()
path.move_to(200,10)
path.line_to(350,50)
path.curve3(150,200)
path.curve3(100,70)
path.close_polygon()
curve = agg.conv_curve_path(path)

# fill it
rasterizer.add_path(curve)
renderer.color_rgba8( green )
agg.render_scanlines_rgba(rasterizer, scanline, renderer);

# and stroke it
stroke = agg.conv_stroke_curve(curve)
stroke.width(5.0)
rasterizer.add_path(stroke)
renderer.color_rgba8( yellow )
agg.render_scanlines_rgba(rasterizer, scanline, renderer);

## Transforming a path
path = agg.path_storage()
path.move_to(0,0)
path.line_to(1,0)
path.line_to(1,1)
path.line_to(0,1)
path.close_polygon()

rotation = agg.trans_affine_rotation(pi/4)
scaling = agg.trans_affine_scaling(30,30)
translation = agg.trans_affine_translation(300,300)
trans = rotation*scaling*translation

transpath = agg.conv_transform_path(path, trans)
stroke = agg.conv_stroke_transpath(transpath)
stroke.width(2.0)
rasterizer.add_path(stroke)
renderer.color_rgba8( black )
agg.render_scanlines_rgba(rasterizer, scanline, renderer);

## Converting a transformed path to a curve
path = agg.path_storage()
path.move_to(0,0)
path.curve3(1,0)
path.curve3(1,1)
path.curve3(0,1)
path.close_polygon()

rotation = agg.trans_affine_rotation(pi/4)
scaling = agg.trans_affine_scaling(30,30)
translation = agg.trans_affine_translation(300,250)
trans = rotation*scaling*translation

transpath = agg.conv_transform_path(path, trans)
curvetrans = agg.conv_curve_trans(transpath)
stroke = agg.conv_stroke_curvetrans(curvetrans)
stroke.width(2.0)
rasterizer.add_path(stroke)
renderer.color_rgba8( white )
agg.render_scanlines_rgba(rasterizer, scanline, renderer);

## Display it with PIL
s = buffer.to_string()
print len(s)
import Image
im = Image.fromstring( "RGBA", (width, height), s)
im.show()

>>>>> "Jeff" == Jeff Peery <jef...@se...> writes:

    Jeff> Hello,

    Jeff> I'm plotting a simple xy plot and I'd like to highlight
    Jeff> regions that are above a threshold, say for example all
    Jeff> points y>=1.  The method I am thinking of applying is
    Jeff> getting the x,y position of the point that is above the
    Jeff> threshold and filling the region between two vertical lines
    Jeff> that are right and left of the point with a bright color.

    Jeff> I was having some difficulty filling between two vertical
    Jeff> lines, I don't think I can use axvline() with fill()?

It sounds like axvspan is what you want

    def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):
        """
        AXVSPAN(xmin, xmax, ymin=0, ymax=1, **kwargs)

        axvspan : Axis Vertical Span.  xcoords are in data units and y coords
        are in axes (relative 0-1) units

        Draw a vertical span (regtangle) from xmin to xmax.  With the default
        values of ymin=0 and ymax=1, this always span the yrange, regardless
        of the ylim settings, even if you change them, eg with the ylim
        command.  That is, the vertical extent is in axes coords: 0=bottom,
        0.5=middle, 1.0=top but the y location is in data coordinates.

        kwargs are the kwargs to Patch, eg

          antialiased, aa
          linewidth,   lw
          edgecolor,   ec
          facecolor,   fc

        the terms on the right are aliases

        return value is the patches.Polygon instance.

            # draw a vertical green translucent rectangle from x=1.25 to 1.55 that
            # spans the yrange of the axes
            axvspan(1.25, 1.55, facecolor='g', alpha=0.5)


For another approach, see examples/fill*.py, in particular
examples/fill_between.py.

But if all you want is shading across the vertical extent over an
xrange, axvspan is the function for you,\.

JDH

>>>>> "zori" == zori  <zo...@vi...> writes:

    zori> Hi, Exploring the agg.py module of the matplotlib library, I
    zori> have encauntered that I cannot represent smooth arcs. For
    zori> example, circle appears as octagon. Could you give me an
    zori> idea how to manage this and what is the reason for such
    zori> behaviour? Here is the code of the agg_test.py changed to
    zori> draw arc, but not giving the desired result:

You have to call conv_curve on the path, and then stroke the result of
that

  curve = agg.conv_curve_path(path)
  stroke = agg.conv_stroke_curve(curve)

agg is a heavily templated library, and one or the challenges of
wrapping a template library is deciding which template combinations
need to be instantiated.  Since matplotlib's agg wrapper is
undocumented, I'll explain some of the combinations and the naming
convention now.  In the agg C++ library, the equivalent calls are
  
  typedef agg::conv_stroke<path_t> stroke_t;
  typedef agg::conv_curve<path_t> curve_t;
  agg::conv_curve<path_t> curve(path);
  agg::conv_stroke<curve_t> stroke(curve)


matplotlib basically takes the template argument and appends it to the
class name, eg

Agg C++ :                         matplotlib wrapper :
agg::conv_curve<path_t>           agg.conv_curve_path
agg::conv_stroke<curve_t>         agg.conv_stroke_curve

The typedefs (path_t, curve_t, etc) are defined in swig/agg_typedefs.h
in the swig directory of the matplotlib src distribution.  The various
curves are defined in swig/agg_conv_curve.i and the strokes in
swig/agg_conv_stroke.i

The stroke and converter classes thus defined are

  conv_curve_path        - convert path to curve, maps "path"->"curve"
  conv_curve_trans       - convert a transformed path, maps "transpath"->"curvetrans"
  conv_stroke_path       - stroke a path
  conv_stroke_transpath  - stroke a transpath
  conv_stroke_curve      - stroke a curve
  conv_stroke_transcurve - stroke a transform of a curve
  conv_stroke_curvetrans - stroke a curve of a transformed path

Hope this helps,
JDH

Dear matplotlib-users,

I have made an application for tsunami wave travel time prediction 
(slowmo.sf.net). The application uses the basemap toolkit and is developed on 
Linux. I would like to offer potential Windows users an easier way to install 
and test it than is currently available.

For this I would need a binary windows package of the basemap toolkit in a 
newer version than 0.21 which is currently available. Unfortunately I do not 
have access to the windows compilers that are necessary to make this binary 
package. I would therefore be very grateful if anyone from this list has the 
binary or could easily produce it.

Kind regards,
Jesper

Hi,
Exploring the agg.py module of the matplotlib library, I have 
encauntered that I cannot represent smooth arcs. For example, circle 
appears as octagon. Could you give me an idea how to manage this and 
what is the reason for such behaviour? Here is the code of the 
agg_test.py changed to draw arc, but not giving the desired result:

##########################
import matplotlib.agg as agg

width, height = 600,400
stride = width*4
buffer = agg.buffer(width, height, stride)

rbuf = agg.rendering_buffer()
rbuf.attachb(buffer)

red = agg.rgba8(255,0,0,255)
blue = agg.rgba8(0,0,255,255)
green = agg.rgba8(0,255,0,255)
black = agg.rgba8(0,0,0,255)
white = agg.rgba8(255,255,255,255)
yellow = agg.rgba8(192,192,255,255)


path = agg.path_storage()
path.move_to(10,10)
path.line_to(100,100)
path.line_to(200,200)
path.arc_to(100,100,0,0,1,100,200)
path.close_polygon()

stroke = agg.conv_stroke_path(path)
stroke.width(3.0)

pf = agg.pixel_format_rgba(rbuf)
rbase = agg.renderer_base_rgba(pf)
rbase.clear_rgba8(blue)

renderer =  agg.renderer_scanline_aa_solid_rgba(rbase);
renderer.color_rgba8( red )

rasterizer = agg.rasterizer_scanline_aa()
rasterizer.add_path(stroke)

scanline = agg.scanline_p8()

agg.render_scanlines_rgba(rasterizer, scanline, renderer);

s = buffer.to_string()
print len(s)
import Image
im = Image.fromstring( "RGBA", (width, height), s)
im.show()

Thank you!
Regards,
Z.Danevska