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 2004年11月10日 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