matplotlib-users Mailing List for matplotlib

John Hunter wrote:
>>>>>>"Dominique" == Dominique Orban <Dom...@po...> writes:
> 
> 
>     Dominique> I notice some spurious zigzagging lines towards the top
>     Dominique> of the plot. Any idea where those might be coming from?
> 
> I don't get zigzag lines either.  Try using replacing
> matplotlib.axes.Axes.contour with the function included below (from
> CVS) and let me know if it works.
> 
>     Dominique> Also, the figure produced by the above script is
>     Dominique> flipped horizontally. The corresponding Matlab script
>     Dominique> produces the correct plot.
> 
> matplotlib supports two image / contour orientation styles, and this
> is controlled by an rc parameter.  Try (note the origin kwarg)
> 
> from matplotlib.pylab import *
> 
> def rosenbrock(x,y):
>      return 10.0 * (y-x**2)**2 + (x-1)**2
> 
> x = arange( -1.5, 1.5, 0.01 )
> y = arange( -0.5, 1.5, 0.01 )
> [X,Y] = meshgrid( x, y )
> Z = rosenbrock( X, Y )
> contour( Z, x=X, y=Y, levels = 50, origin='lower' )
> show()
> 
> 
> Amended contour function 
 > [snip]

John,

Many thanks for the update. That solves some of the issues. The 'origin' 
keyword argument restores the orientation of the plot. To account for 
the 'x' and 'y' keyword arguments, I would suggest changing the lines

	if x == None and y == None:
             y, x = indices((jmax,imax), 'd')

to

	if x is None:
             x = indices((jmax,imax), 'd')
         if y is None:
             y = indices((jmax,imax), 'd')

to account for the situation where only one of x or y is specified (I 
admit that might be unlikely but hey).

Regarding the zigzags, I notice they appear for relatively small values 
of the increment in arange() (the 3rd argument). When I decrease it to, 
say, 0.1, zigzags start to appear. For higher values, they don't. It 
makes me think they might be part of the line collections. Is anyone 
else able to reproduce this behavior?

Thanks much.
Dominique

>>>>> "Dominique" == Dominique Orban <Dom...@po...> writes:

    Dominique> I notice some spurious zigzagging lines towards the top
    Dominique> of the plot. Any idea where those might be coming from?

I don't get zigzag lines either.  Try using replacing
matplotlib.axes.Axes.contour with the function included below (from
CVS) and let me know if it works.

    Dominique> Also, the figure produced by the above script is
    Dominique> flipped horizontally. The corresponding Matlab script
    Dominique> produces the correct plot.

matplotlib supports two image / contour orientation styles, and this
is controlled by an rc parameter.  Try (note the origin kwarg)

from matplotlib.pylab import *

def rosenbrock(x,y):
     return 10.0 * (y-x**2)**2 + (x-1)**2

x = arange( -1.5, 1.5, 0.01 )
y = arange( -0.5, 1.5, 0.01 )
[X,Y] = meshgrid( x, y )
Z = rosenbrock( X, Y )
contour( Z, x=X, y=Y, levels = 50, origin='lower' )
show()


Amended contour function 

    def contour(self, z,
                x = None,
                y = None,
                levels = None,
                colors = None,                
                linewidths = None,
                alpha = 1.0,
                fmt='%1.3f',
                origin=None):
        """\
CONTOUR(z, x = None, y = None, levels = None, colors = None)

plots contour lines of an image z

z is a 2D array of image values
x and y are 2D arrays with coordinates of z values in the
two directions. x and y do not need to be evenly spaced but must
be of the same shape as z

levels can be a list of level values or the number of levels to be
  plotted.  If levels == None, a default number of 7 evenly spaced
  levels is plotted.

colors is one of these:

  - a tuple of matplotlib color args (string, float, rgb, etc),
    different levels will be plotted in different colors in the order
    specified

  - one string color, e.g. colors = 'r' or colors = 'red', all levels
    will be plotted in this color

  - if colors == None, the default color for lines.color in
    .matplotlibrc is used.

linewidths is one of:

   - a number - all levels will be plotted with this linewidth,
     e.g. linewidths = 0.6

   - a tuple of numbers, e.g. linewidths = (0.4, 0.8, 1.2) different
     levels will be plotted with different linewidths in the order
     specified

   - if linewidths == None, the default width in lines.linewidth in
     .matplotlibrc is used


  
reg is a 2D region number array with the same dimensions as x and
  y. The values of reg should be positive region numbers, and zero fro
  zones wich do not exist.

triangle - triangulation array - must be the same shape as reg

alpha : the default transparency of contour lines

fmt is a format string for adding a label to each collection.
  Currently this is useful for auto-legending and may be useful down
  the road for legend labeling

origin = 'upper'|'lower'|None.  If None, the rc value for image.origin
will be used

More information on reg and triangle arrays is in _contour.c

Return value is levels, collections where levels is a list of contour
levels used and collections is a list of
matplotlib.collections.LineCollection instances
"""

        if origin is None: origin = rcParams['image.origin']
        
        if origin == 'upper':
            if x is not None: x = x[::-1]
            if y is not None: y = y[::-1]
            z = z[::-1]            

        if not self._hold: self.cla()
        if which[0] == "numeric":
            z = array(z.tolist(),typecode = z.typecode())
        if len(shape(z)) != 2:
            raise TypeError("Input must be a 2D array.")
        else:
            jmax, imax = shape(z)

        region = 0
        reg = ones((jmax,imax), Int32)
        reg[:,0]=0
        triangle = zeros((jmax,imax), Int32)

        if x == None and y == None:
            y, x = indices((jmax,imax), 'd')

        rz = ravel(z)
        zmax = nxmax(rz)
        zmin = nxmin(rz)

        def autolev(N):
            return mlab.linspace(zmin, zmax, N+2)[1:-1]
        
        if levels is None: lev = autolev(7)
        else:            
            try: Nlev = int(levels)
            except TypeError:
                lev = list(levels)            
            else: lev = autolev(Nlev)

        Nlev = len(lev)
        if colors == None:
            colors = rcParams['lines.color']

        if is_string_like(colors):
            colors = [colors] * Nlev
        elif iterable(colors) and len(colors) < Nlev:
            colors = list(colors) * Nlev
        else:
            try: gray = float(colors)
            except TypeError: pass
            else:  colors = [gray] * Nlev


        tcolors = []
        for c in colors:
            tcolors.append((colorConverter.to_rgba(c, alpha),))

        if linewidths == None:
            tlinewidths = [linewidths] *Nlev
        else:
            if iterable(linewidths) and len(linewidths) < Nlev:
                linewidths = list(linewidths) * int(ceil(Nlev/len(linewidths)))
            elif not iterable(linewidths) and type(linewidths) in [int, float]:
                linewidths = [linewidths] * Nlev
            tlinewidths = [(w,) for w in linewidths]

                                      
        args = zip(lev, tcolors, tlinewidths)

        levels = []
        collections = []


        
        for level, color, width  in args:
            ntotal, nparts  = _contour.GcInit1(x, y, reg, triangle, region, z, level)
            np = zeros((nparts,), Int32)
            xp = zeros((ntotal, ), Float64)
            yp = zeros((ntotal,), Float64)
            nlist = _contour.GcTrace(np, xp, yp)
            col = LineCollection(nlist, colors=color, linewidths = width)
            col.set_label(fmt%level)
            self.add_collection(col)
            levels.append(level)
            #col.set_linestyle('dashdot') # dashed|dotted|solid|dashdot
            #dashes = 0, (4,2,8,1)
            #col.set_linestyle( (dashes,) ) # offset, onoffseq
            collections.append(col)


        if x is not None:
            rx = ravel(x)
            self.set_xlim((min(rx), max(rx)))
        else:
            self.set_xlim([0,imax])

        if y is not None:
            ry = ravel(y)
            self.set_ylim((min(ry), max(ry)))
        else:
            self.set_ylim([0,jmax])

        return levels, collections

The change picked up the top color.  However, it looks to me as though 
the yellowish color is missing from the color bar.  I see only 9 colors. 
  The is without tweaking clim.

When I do tweak clim to clim(vmin=-.1, vmax = 0.1), I see the yellowish 
color, but two of the bluer colors seem to be missing.  I see only 8 
colors in the color bar.

> To: Carol Leger <car...@sr...>
> Cc: mat...@li...
> Subject: Re: [Matplotlib-users] Color bar with discrete colors
> From: John Hunter <jdh...@ac...>
> Date: Sat, 15 Jan 2005 16:32:48 -0600
> 
> 
>>>>>>"Carol" == Carol Leger <car...@sr...> writes:
> 
> 
>     Carol> This is how I modified poormans_contour.py:
> 
> It's a bug; in the matplotlib/pylab.py function "colorbar", replace
> the line that reads
> 
>     N = 200
> 
> with
> 
>     N = cmap.N
> 
> No need to tweak the clim....
> 
> Should cure what ails ya,
> JDH
>

-- 
Ms. Carol A. Leger
SRI International			Phone: (650) 859-4114
333 Ravenswood Avenue G-273
Menlo Park, CA 94025                    e-mail: le...@sr...

On Friday 14 January 2005 14:48, Dominique Orban wrote:

I don't get any zig-zag lines on my box when I run your code...

as for being sideways, I cant tell since I don't have matlab here...

I don't have a solution, but it doesn't seem to be a matplotlib problem.

I am running, version 0.70.1

good luck,

=46l=E1vio


> Hi,
>
> When trying to plot the contours of the famous Rosenbrock function:
>
> ----------------------------------------
> from matplotlib.pylab import *
>
> def rosenbrock(x,y):
>      return 10.0 * (y-x**2)**2 + (x-1)**2
>
> x =3D arange( -1.5, 1.5, 0.01 )
> y =3D arange( -0.5, 1.5, 0.01 )
> [X,Y] =3D meshgrid( x, y )
> Z =3D rosenbrock( X, Y )
> contour( Z, x=3DX, y=3DY, levels =3D 50 )
> show()
> ----------------------------------------
>
> I notice some spurious zigzagging lines towards the top of the plot. Any
> idea where those might be coming from?
>
> Also, the figure produced by the above script is flipped horizontally.
> The corresponding Matlab script produces the correct plot.
>
> Thanks,
> Dominique
>
>
> -------------------------------------------------------
> The SF.Net email is sponsored by: Beat the post-holiday blues
> Get a FREE limited edition SourceForge.net t-shirt from ThinkGeek.
> It's fun and FREE -- well, almost....http://www.thinkgeek.com/sfshirt
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users