matplotlib-users Mailing List for matplotlib

>>>>> "Shin" == Shin  <sd...@em...> writes:

    Shin> My default mode of matplotlib is interactive mode, but in
    Shin> some programs I like to turn off the interactive model
    Shin> temporarily so postpone drawing until I call show(), because
    Shin> of performance concern.  Any way for swith the mode in a
    Shin> script? Thanks in advance.

from matplotlib import interactive
from matplotlib.matlab import *

plot([1,2,3])
interactive(False)  # turn off interactive mode
xlabel('hi mom')
ylabel('bye')
title('all done')
interactive(False)  # turn it back on
draw()              # draw the canvas

JDH







    Shin> ------------------------------------------------------- This
    Shin> SF.Net email is sponsored by: Sybase ASE Linux Express
    Shin> Edition - download now for FREE LinuxWorld Reader's Choice
    Shin> Award Winner for best database on Linux.
    Shin> http://ads.osdn.com/?ad_id=5588&alloc_id=12065&op=click
    Shin> _______________________________________________
    Shin> Matplotlib-users mailing list
    Shin> Mat...@li...
    Shin> https://lists.sourceforge.net/lists/listinfo/matplotlib-users

>>>>> "Nils" == Nils Wagner <nw...@me...> writes:

    Nils> Hi all, Structure plots provide a quick visual check on the
    Nils> sparsity pattern of the matrix.  A structure plot is a
    Nils> rectangular array of dots; a dot is black if the
    Nils> corresponding matrix element is nonzero otherwise it is
    Nils> white.

    Nils> Is it possible to generate such plots with scipy or should
    Nils> we switch over to matplotlib ?

Here's another implementation that uses images - likely to be much
faster for very large matrices.

import random
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.matlab import *


def spy2(Z):
    """
    SPY(Z) plots the sparsity pattern of the matrix S as an image
    """

    #binary colormap min white, max black
    cmapdata = {
         'red'  :  ((0., 1., 1.), (1., 0., 0.)),
         'green':  ((0., 1., 1.), (1., 0., 0.)),
         'blue' :  ((0., 1., 1.), (1., 0., 0.))
         }
    binary =  LinearSegmentedColormap('binary',  cmapdata, 2)

    Z = where(Z>0,1.,0.)
    imshow(transpose(Z), interpolation='nearest', cmap=binary)

def get_sparse_matrix(M,N,frac=0.1):
    'return a MxN sparse matrix with frac elements randomly filled'
    data = zeros((M,N))*0.
    for i in range(int(M*N*frac)):
        x = random.randint(0,M-1)
        y = random.randint(0,N-1)
        data[x,y] = rand()
    return data

data = get_sparse_matrix(50,60)
spy2(data)
show()

>>>>> "Nils" == Nils Wagner <nw...@me...> writes:

    Nils> Hi all, Structure plots provide a quick visual check on the
    Nils> sparsity pattern of the matrix.  A structure plot is a
    Nils> rectangular array of dots; a dot is black if the
    Nils> corresponding matrix element is nonzero otherwise it is
    Nils> white.

    Nils> Is it possible to generate such plots with scipy or should
    Nils> we switch over to matplotlib ?

A quick matplotlib implementation is below.  In matlab this function
is called "spy" and Alexander Schmolck requested this in an earlier
post.  The spy implementation uses plot markers which are fixed sizes
(in points).  For large matrices, you'll likely want to use a smaller
markersize.

Perhaps better would be to use a polygon collection setup so that the
marker sizes filled the boundaries of the matrix cell.  This would
take a little more work, and would also have a different call
signature that matlab's, since matlab also uses plots markers .  If
you have any thoughts on how you would like the implementation to
work, please share them...

JDH

from matplotlib.matlab import *

def get_xyz_where(Z, Cond):
    """
    Z and Cond are MxN matrices.  Z are data and Cond is a boolean
    matrix where some condition is satisfied.  Return value is x,y,z
    where x and y are the indices into Z and z are the values of Z at
    those indices.  x,y,z are 1D arrays

    This is a lot easier in numarray - is there a more elegant way to
    do this that works on both numeric and numarray?
    """
    
    M,N = Z.shape
    z = ravel(Z)
    ind = nonzero( ravel(Cond) )

    x = arange(M); x.shape = M,1
    X = repeat(x, N, 1)
    x = ravel(X)

    y = arange(N); y.shape = 1,N
    Y = repeat(y, M)
    y = ravel(Y)

    x = take(x, ind)
    y = take(y, ind)
    z = take(z, ind)
    return x,y,z


def spy(Z,  marker='s', markersize=10, **kwargs):
    """
    SPY(Z, **kwrags) plots the sparsity pattern of the matrix S.

    kwargs give the marker properties - see help(plot) for more
    information on marker properties


    """
    x,y,z = get_xyz_where(Z, Z>0)
    plot(x+0.5,y+0.5, linestyle='None', marker=marker,markersize=markersize, **kwargs)

M,N = 25,20
data = zeros((M,N))*0.
data[:,12] = rand(M)
data[5,:] = rand(N)
spy(data)
axis([0,M,0,N])
show()

Hi all,

Structure plots provide a quick visual check on the sparsity pattern of 
the matrix.
A structure plot is a rectangular array of dots;
a dot is black if the corresponding matrix element is nonzero otherwise 
it is white.

Is it possible to generate such plots with scipy or should we switch 
over to matplotlib ?

Nils

Reference:
http://math.nist.gov/MatrixMarket/structureplots.html

 

Hello,

On Wed, 10 Nov 2004 16:26:47 +0000 (GMT) Andy Baerdmore wrote
> Anyway, the upshot is matplotlib runs but it is not finding the
> sans font and makes a poor substitute in its place. For exampe the output
> from simple_demo.py is : ...
I think that this might be a bug in Vittorio's Debian packages.
There was a problem with the matplotlib font loading code which
made it only find fonts installed under /usr/share/matplotlib.
Since Debian hast the fonts under /usr/share/fonts they were not
found.  Maybe this was not fixed in his packages?

You can try my alternative packages at http://seehuhn.de/debian/,
which hopefully work.  Download python-matplotlib_0.63.4-2.1_i386.deb
=66rom there and install it manually with e.g.

    dpkg -i python-matplotlib_0.63.4-2.1_i386.deb

I hope this helps,
Jochen
--=20
http://seehuhn.de/

My default mode of matplotlib is interactive mode,
but in some programs I like to turn off the interactive model temporarily
so postpone drawing until I call show(), because of performance concern.
Any way for swith the mode in a script? Thanks in advance.

Daehyok Shin
UNC-CH