matplotlib-devel Mailing List for matplotlib

Fernando Perez wrote:
> planck[~]> d .matplotlibrc
> /home/fperez
> -rw-r--r-- 1 fperez 10529 Jul 29 16:53 .matplotlibrc
> planck[~]> python -c 'import pylab'
> WARNING: Old rc filename ".matplotlibrc" found in working dir
> and and renamed to new default rc file name "matplotlibrc"
> (no leading"dot").
> planck[~]> d .matplotlibrc
> /home/fperez
> /bin/ls: .matplotlibrc: No such file or directory
> planck[~]> d .matplotlib
> /home/fperez
> total 16
> -rw-r--r-- 1 fperez 12642 Jul 29 16:53 ttffont.cache
> 
> 
> The .matplotlibrc file just goes poof!
Correct that: it does get renamed to ~/matplotlibrc. I really hope that's not 
what the original intent was! I imagine the plan was the equivalent of
mkdir ~/.matplotlib
mv ~/.matplotlibrc ~/.matplotlib/matplotlibrc
Cheers,
f

planck[~]> d .matplotlibrc
/home/fperez
-rw-r--r-- 1 fperez 10529 Jul 29 16:53 .matplotlibrc
planck[~]> python -c 'import pylab'
WARNING: Old rc filename ".matplotlibrc" found in working dir
 and and renamed to new default rc file name "matplotlibrc"
 (no leading"dot").
planck[~]> d .matplotlibrc
/home/fperez
/bin/ls: .matplotlibrc: No such file or directory
planck[~]> d .matplotlib
/home/fperez
total 16
-rw-r--r-- 1 fperez 12642 Jul 29 16:53 ttffont.cache
The .matplotlibrc file just goes poof!
Cheers,
f

John Hunter wrote:
> Anyone know of a simple fix for this
> 
> 
>>python unicode_demo.py -dSVG
> 
> 
> File "/usr/lib/python2.4/site-packages/matplotlib/backends/backend_svg.py", line 196, in draw_text
> self._svgwriter.write (svg)
> UnicodeEncodeError: 'ascii' codec can't encode character u'\xe9' in position 136: ordinal not in range(128)
I recently had to fix the same bug for ipython. Here's what my 
stumble-in-the-dark approach to unicode bug fixing (no net access at home that 
day) produced:
 def _str(self,glob,loc):
 """Evaluate to a string in the given globals/locals.
 The final output is built by calling str(), but if this fails, the
 result is encoded with the instance's codec and error handling policy,
 via a call to out.encode(self.codec,self.encoding_errors)"""
 result = []
 app = result.append
 for live, chunk in self.chunks:
 if live: app(str(eval(chunk,glob,loc)))
 else: app(chunk)
 out = ''.join(result)
 try:
 return str(out)
 except UnicodeError:
 return out.encode(self.codec,self.encoding_errors)
where the codec stuff is set via:
 Optional arguments:
 - codec('utf_8'): a string containing the name of a valid Python
 codec.
 - encoding_errors('backslashreplace'): a string with a valid error 
handling
 policy. See the codecs module documentation for details.
 These are used to encode the format string if a call to str() fails on
 the expanded result."""
 if not isinstance(format,basestring):
 raise TypeError, "needs string initializer"
 self.format = format
 self.codec = codec
 self.encoding_errors = encoding_errors
This is all in ipython's Itpl.py module, in case you want to look closer (the 
crash was there b/c that's the machinery used for prompt printing).
cheers,
f

John Hunter wrote:
> 
> Anyone know of a simple fix for this
> 
>> python unicode_demo.py -dSVG
> 
> File
> "/usr/lib/python2.4/site-packages/matplotlib/backends/backend_svg.py",
> line 196, in draw_text
> self._svgwriter.write (svg)
> UnicodeEncodeError: 'ascii' codec can't encode character u'\xe9' in
> position 136: ordinal not in range(128)
 I found this link very useful to understand this type of problems:
http://evanjones.ca/python-utf8.html
-- 
José Abílio

Anyone know of a simple fix for this
> python unicode_demo.py -dSVG
 File "/usr/lib/python2.4/site-packages/matplotlib/backends/backend_svg.py", line 196, in draw_text
 self._svgwriter.write (svg)
UnicodeEncodeError: 'ascii' codec can't encode character u'\xe9' in position 136: ordinal not in range(128)

 Hi,
First of all thank you for this great package.
1/
The matshow function computes the aspect ratio of the figure with:
 in matplotlib/pylab.py
 def matshow(*args,**kw):
 ...
 # Extract actual aspect ratio of array and make appropriately sized f=
igure
 w,h =3D figaspect(arr)
 ...
before displaying it.
figaspect takes the array as an argument and compute its aspect ratio wit=
h:
 in matplotlib/figure.py
 def figaspect(arr):
 ...
 # Extract the aspect ratio of the array
 nr,nc =3D arr.shape[:2]
 arr_ratio =3D float(nr)/nc
 ...
Could it be changed such that figaspect takes a float as its argument and=
 the 2
lines to compute arr_ratio are moved from figaspect to matshow before cal=
ling
figaspect ? (+ change the figaspect doc string)
It will make figaspect more general and allow us to create a figure with =
a given
aspect ratio without copying/pasting of nearly all the figaspect machiner=
y.
2/
Does anybody intend to add a Patch object to draw polygons with holes (I =
do not
know how to do it) ?
Thank you,
 Seb

Hello,
A few posts back, I included source code to some gauges I had whipped =
together. After some constructive advice from John Hunter (Thanks!), =
I've had time to polish them a bit and include the logarithmic ones as =
promised.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
#!/usr/bin/env python
"""
The Meter widget draws a linear meter, either horizontally or =
vertically. You supply the direction, limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 =20
 raw_value =3D -4.0
 raw_limits =3D [-10.0,10.0,5,1]
 raw_zones =3D [[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 s_length =3D 0.3
 p_length =3D 2.0
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 =20
 rect =3D [(0.2/fig_width), (0.5/fig_height),
 (p_length/fig_width), (s_length/fig_height)]
 =20
 meter =3D H_Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 meter.set_axis_off()
 fig.add_axes(meter)
 show()
"""
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
class Meter(Axes):
 def __init__(self, vertical, raw_values, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution, p_length, s_length, =
*args, **kwargs): =20
 Axes.__init__(self, *args, **kwargs)
 #Perform Checking
 if( raw_limits[0] =3D=3D raw_limits[1] ):
 raise ValueError('identical_limits_exception: %s' % =
raw_limits)
 if( raw_limits[1] > raw_limits[0] ):
 self.graph_positive =3D True
 else: #Swap the limits around
 self.graph_positive =3D False
 raw_limits[0], raw_limits[1] =3D raw_limits[1] =3D =
raw_limits[0]
 =20
 if not( ((raw_limits[2]/raw_limits[3]) % 1.0) * raw_limits[3] =
=3D=3D 0 ):	#There must be an integer number of minor ticks for each =
major tick
 raise ValueError('bad_tick_spacing_exception')
 if( raw_limits[2] <=3D 0 or raw_limits[3] <=3D 0 or =
raw_limits[2] < raw_limits[3] or raw_limits[3] > =
abs(raw_limits[1]-raw_limits[0]) ):
 raise ValueError('bad_limits_exception:%s' % raw_limits)
 for zone in raw_zones:
 if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > =
zone[0]
 zone[0], zone[1] =3D zone[1] =3D zone[0]
 if( zone[1] < raw_limits[0] or zone[0] > raw_limits[1] =
):
 raise ValueError('bad_zone_exception'%zone)
 if( zone[0] < raw_limits[0] ):
 zone[0] =3D raw_limits[0]
 if( zone[1] > raw_limits[1] ):
 zone[1] =3D raw_limits[1]
 =20
 #Adjust the scaling
 self.scaled_limits =3D []
 for limit in raw_limits:
 self.scaled_limits.append( limit * p_length / =
(raw_limits[1]-raw_limits[0]))
 =20
 #Stuff all of the variables into self.
 self.vertical =3D vertical
 self.raw_values =3D raw_values
 self.raw_limits =3D raw_limits
 self.raw_zones =3D raw_zones
 self.attribute_name =3D attribute_name
 self.field_names =3D field_names
 self.file_name =3D file_name
 self.resolution =3D resolution
 self.p_length =3D p_length
 self.s_length =3D s_length
 =20
 #Draw the meter
 self.graph_center =3D =
((self.scaled_limits[1]+self.scaled_limits[0])/2)
 for zone in raw_zones:
 self.draw_bar( zone, False)
 self.draw_bar( None, True)
 self.draw_dividers()
 self.draw_ticks()
 self.draw_needle()
 if( vertical ):
 self.text( self.s_length/2, self.scaled_limits[1]+0.05, =
self.attribute_name, size=3D12, va=3D'bottom', ha=3D'center')
 else:
 self.text( self.graph_center, self.s_length+0.05, =
self.attribute_name, size=3D12, va=3D'bottom', ha=3D'center')
 =20
 def draw_bar( self, zone, border):
 if( border ):
 start =3D self.scaled_limits[0]
 end =3D self.scaled_limits[1]
 else:
 start =3D (zone[0] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0]))
 end =3D (zone[1] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0]))
 colour =3D zone[2]
 =20
 if( not self.graph_positive ):
 start =3D -start
 end =3D -end
 =20
 s_vect =3D [ 0.0, 0.0, self.s_length, self.s_length ]
 p_vect =3D [ start, end, end, start ]
 =20
 if( border ):
 #Close the loop
 p_vect.append(start)
 s_vect.append(0.0)
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 if( self.vertical ):
 p =3D self.fill(s_vect, p_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 else:
 p =3D self.fill(p_vect, s_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 def draw_dividers( self ):
 i =3D 1
 num_fields =3D len(self.raw_values)
 while( i < num_fields ):
 s_vect =3D [
 (i * self.s_length)/num_fields,
 (i * self.s_length)/num_fields,
 ]
 p_vect =3D [
 self.scaled_limits[0],
 self.scaled_limits[1],
 ]
 if( self.vertical ):
 self.plot(s_vect, p_vect, 'b-', color=3D'black', =
linewidth=3D1.0)
 else:
 self.plot(p_vect, s_vect, 'b-', color=3D'black', =
linewidth=3D1.0)
 i +=3D 1=20
 =20
 def draw_needle( self ):
 i =3D 0 =20
 for raw_value in self.raw_values:
 =20
 if( raw_value =3D=3D None ):
 if( self.vertical ):
 self.text( ((i + 1) * =
self.s_length)/len(self.raw_values),(self.scaled_limits[0]-0.05), "%s : =
N/A" % self.field_names[i], size=3D10, va=3D'top', ha=3D'right', =
rotation=3D45)
 else:
 self.text( (self.scaled_limits[0] - 0.05), ((i + =
0.5) * self.s_length)/len(self.raw_values), "%s : N/A" % =
self.field_names[i], size=3D10, va=3D'center', ha=3D'right')
 else:
 =20
 #Clamp the value to the limits
 value =3D raw_value * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 if( raw_value < self.raw_limits[0] ):
 value =3D self.raw_limits[0] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 if( raw_value > self.raw_limits[1] ):
 value =3D self.raw_limits[1] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 =20
 if( self.vertical ):
 self.text( ((i + 1) * =
self.s_length)/len(self.raw_values),(self.scaled_limits[0] - 0.05), "%s =
: %.2f" % (self.field_names[i], raw_value), size=3D10, va=3D'top', =
ha=3D'right', rotation=3D45)=20
 else:
 self.text( (self.scaled_limits[0] - 0.05), ((i + =
0.5) * self.s_length)/len(self.raw_values), "%s : %.2f" % =
(self.field_names[i], raw_value), size=3D10, va=3D'center', =
ha=3D'right')=20
 =20
 if( not self.graph_positive ):
 value =3D -value
 =20
 s_vect =3D [
 ((i + 0 ) * self.s_length)/len(self.raw_values),
 ((i + 0.5) * self.s_length)/len(self.raw_values),
 ((i + 1 ) * self.s_length)/len(self.raw_values),
 ((i + 0.5) * self.s_length)/len(self.raw_values),
 ]
 p_vect =3D [
 value,
 value - 0.05,
 value,
 value + 0.05,
 ]
 =20
 if( self.vertical ):
 self.fill(s_vect, p_vect, 'b', alpha=3D0.4)
 else:
 self.fill(p_vect, s_vect, 'b', alpha=3D0.4)
 i +=3D 1
 =20
 =20
 def draw_ticks( self ):
 num_fields =3D len(self.raw_values)
 if( self.graph_positive ):
 offset =3D self.scaled_limits[0]
 else:
 offset =3D self.scaled_limits[1]
 i =3D 0
 j =3D self.raw_limits[0]
 while( i*self.scaled_limits[3] + self.scaled_limits[0] <=3D =
self.scaled_limits[1] ):
 if( i % (self.scaled_limits[2]/self.scaled_limits[3]) =3D=3D =
0):
 tick_length =3D self.s_length
 if( self.vertical ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( -0.05, offset, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'right')=20
 else:
 self.text( -0.05, offset, "%d" % int(j), =
size=3D10, va=3D'center', ha=3D'right')
 else:
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( offset, -0.05, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( offset, -0.05, "%d" % int(j), =
size=3D10, va=3D'top', ha=3D'center')=20
 j +=3D self.raw_limits[2]
 else:
 tick_length =3D (self.s_length/num_fields) * 0.2
 =20
 s_vect =3D [ 0.0, tick_length ]
 p_vect =3D [ offset, offset ]
 =20
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 i +=3D 1
 if( self.graph_positive ):
 offset +=3D self.scaled_limits[3]
 else:
 offset -=3D self.scaled_limits[3]
 =20
 if( i % (self.scaled_limits[2]/self.scaled_limits[3]) =3D=3D 0):
 if( self.vertical ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( -0.01, offset, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( -0.01, offset, "%d" % int(j), size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( offset, -0.1, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( offset, -0.1, "%d" % int(j), size=3D10, =
va=3D'top', ha=3D'center')=20
 =20
def make_widget( vertical, raw_values, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution=3D72 ):
 from pylab import figure, show, savefig
 =20
 p_length =3D 4.0 # Length of the Primary axis
 s_length =3D 0.3 * len(raw_values) # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 1.6
 fig_width =3D s_length + 1.1
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.9/fig_width), (1.3/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(vertical, raw_values,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,=20
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[]
 )
 else:
 fig_height =3D s_length + 0.5
 fig_width =3D p_length + 1.9
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(1.7/fig_width), (0.2/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(vertical, raw_values,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure( file_name,dpi=3Dresolution ) =20
 =20
 =20
#make_widget( False, [-3.0, 6.0, None, 0.25], [-10.0,10.0,5,1], =
[[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']], "Rx MOS (24h)", ['WLL to =
LAS','LAS to WLL','WLL to LAS','LAS to WLL'], 'multimeter.png', 100)
''' =20
 =20
if __name__=3D=3D'__main__':
 from pylab import figure, show, savefig
 =20
 vertical =3D False =20
 =20
 raw_values =3D [-3.0, 6.0, None, 0.25]
 raw_limits =3D [-10.0,10.0,5,1]
 raw_zones =3D [[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 field_names =3D ['WLL to LAS','LAS to WLL','WLL to LAS','LAS to =
WLL']
 =20
 p_length =3D 4.0 # Length of the Primary axis
 s_length =3D 0.3 * len(raw_values) # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 1.6
 fig_width =3D s_length + 1.1
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.9/fig_width), (1.3/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 else:
 fig_height =3D s_length + 0.5
 fig_width =3D p_length + 1.9
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(1.7/fig_width), (0.2/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure('multimeter',dpi=3D72)
'''

Hello,
A few posts back, I included source code to some gauges I had whipped =
together. After some constructive advice from John Hunter (Thanks!), =
I've had time to polish them a bit and include the logarithmic ones as =
promised.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
#!/usr/bin/env python
'''
The Log_Gauge widget draws a semi-circular gauge. You supply limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 raw_value =3D -4.0
 limits =3D [ left, right ]
 zone_colour =3D [[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 graph_height =3D 1.6
 graph_width =3D 2.4
 fig_height =3D graph_height
 fig_width =3D graph_width
 fig =3D figure(figsize=3D(fig_width, fig_height ))
 =20
 rect =3D [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 =20
 gauge =3D Gauge(fig, rect,
 xlim=3D( -0.1, graph_width+0.1 ),
 ylim=3D( -0.4, graph_height+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 show()
 =20
 NOTE: The limits you specify must be of this form
 for any value of 'n': 1.0*10^n
'''
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
class Log_Gauge(Axes):
 def __init__(self, raw_value, raw_limits, raw_zones, attribute_name, =
field_names, file_name, resolution, x_length, y_length, *args, =
**kwargs):
 Axes.__init__(self, *args, **kwargs)
 =20
 #Perform Checking
 if( raw_limits[0] =3D=3D raw_limits[1] ):
 raise ValueError('identical_limits_exception: %s' % =
raw_limits)
 if( raw_limits[1] > raw_limits[0] ):
 self.graph_positive =3D True
 else: #Swap the limits around
 self.graph_positive =3D False
 raw_limits[0], raw_limits[1] =3D raw_limits[1] =3D =
raw_limits[0]
 =20
 if not( math.log10(raw_limits[0]) % 1.0 =3D=3D 0 and =
math.log10(raw_limits[1]) % 1.0 =3D=3D 0 ):
 raise ValueError('bad_limits_exception:%s' % raw_limits)
 =20
 for zone in raw_zones:
 if( zone[0] > zone[1] ): #Swap the zones so zone[1] > =
zone[0]
 zone[0], zone[1] =3D zone[1], zone[0]
 if( zone[1] < raw_limits[0] or zone[0] > raw_limits[1] ):
 raise ValueError('bad_zone_exception' % zone)
 if( zone[0] < raw_limits[0] ):
 zone[0] =3D raw_limits[0]
 if( zone[1] > raw_limits[1] ):
 zone[1] =3D raw_limits[1]
 =20
 #Stuff all of the variables into self.
 self.raw_value =3D raw_value
 self.raw_limits =3D raw_limits
 self.raw_zones =3D raw_zones
 self.attribute_name =3D attribute_name
 self.field_names =3D field_names
 self.file_name =3D file_name
 self.resolution =3D resolution
 self.x_length =3D x_length
 self.y_length =3D y_length
 =20
 =20
 #Draw the arch
 for zone in raw_zones:
 self.draw_arch( zone, False )
 self.draw_arch( None, True )
 self.draw_ticks()
 self.draw_needle()
 self.draw_bounding_box()
 self.text(0.0, 0.3, attribute_name, size=3D10, va=3D'center', =
ha=3D'center')
 =20
 #The black dot
 p =3D self.plot([0.0],[0.0],'.', color=3D'#000000') =20
 =20
 def draw_arch( self, zone, border ):
 if( border ):
 start =3D self.raw_limits[0]
 end =3D self.raw_limits[1]
 else:
 start =3D zone[0]
 end =3D zone[1]
 colour =3D zone[2]
 =20
 x_vect =3D []
 y_vect =3D []
 if( self.graph_positive ):
 start_value =3D int(180 - (start - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 end_value =3D int(180 - (end - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 else:
 start_value =3D int( (end - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 end_value =3D int( (start - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 =20
 =20
 if( self.graph_positive ):
 start_value =3D (math.log10(start) - =
math.log10(self.raw_limits[1])) * 180.00 / =
-(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 end_value =3D (math.log10(end) - =
math.log10(self.raw_limits[1])) * 180.00 / =
-(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 else:
 start_value =3D (math.log10(end) - =
math.log10(self.raw_limits[0])) * 180.00 / =
+(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 end_value =3D (math.log10(start) - =
math.log10(self.raw_limits[0])) * 180.00 / =
+(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 =20
 #Draw the arch
 theta =3D start_value
 radius =3D 0.85
 while (theta >=3D end_value):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta -=3D 1
 =20
 theta =3D end_value
 radius =3D 1.0
 while (theta <=3D start_value):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta +=3D 1
 =20
 if( border ):
 #Close the loop
 x_vect.append(-0.85)
 y_vect.append(0.0)
 =20
 p =3D self.plot(x_vect, y_vect, 'b-', color=3D'black', =
linewidth=3D1.0)
 else:
 p =3D self.fill(x_vect, y_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 =20
 =20
 def draw_needle( self ):
 x_vect =3D []
 y_vect =3D []
 =20
 if self.raw_value =3D=3D None:
 self.text(0.0, 0.4, "N/A", size=3D10, va=3D'bottom', =
ha=3D'center')
 else:
 self.text(0.0, 0.4, "%.2f" % self.raw_value, size=3D10, =
va=3D'bottom', ha=3D'center')
 =20
 #Clamp the value to the limits
 if( self.raw_value < self.raw_limits[0] ):
 self.raw_value =3D self.raw_limits[0]
 if( self.raw_value > self.raw_limits[1] ):
 self.raw_value =3D self.raw_limits[1]
 =20
 theta =3D 0
 length =3D 0.95
 if( self.graph_positive ):
 angle =3D (math.log10(self.raw_value) - =
math.log10(self.raw_limits[1])) * 180.00 / =
-(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 else:
 angle =3D (math.log10(self.raw_value) - =
math.log10(self.raw_limits[0])) * 180.00 / =
+(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 =20
 while (theta <=3D 270):
 x_vect.append( length * math.cos((theta + angle) * =
(pi/180)) )
 y_vect.append( length * math.sin((theta + angle) * =
(pi/180)) )
 length =3D 0.05
 theta +=3D 90
 p =3D self.fill(x_vect, y_vect, 'b', alpha=3D0.4)
 =20
 =20
 =20
 def draw_ticks( self ):
 if( self.graph_positive ):
 angle =3D 180.0
 else:
 angle =3D 0.0
 =20
 i =3D self.raw_limits[0]
 step =3D self.raw_limits[0]
 x_vect =3D []
 y_vect =3D []
 while( i < self.raw_limits[1] ):
 while( i < (step * 10) ):
 x_vect =3D []
 y_vect =3D []
 value =3D math.log10(i)
 if( self.graph_positive ):
 angle =3D (value - math.log10(self.raw_limits[1])) * =
180.00 / -(math.log10(self.raw_limits[1]) - =
math.log10(self.raw_limits[0]))
 else:
 angle =3D (value - math.log10(self.raw_limits[0])) * =
180.00 / +(math.log10(self.raw_limits[1]) - =
math.log10(self.raw_limits[0]))
 x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
 y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
 mantissa =3D int(i / math.pow(10, =
math.ceil(math.log10(i))-1))
 if( mantissa =3D=3D 10 or mantissa =3D=3D 1 ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 else:
 self.text( x_pos, y_pos, "%d" % int(j), =
size=3D10, va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 tick_length =3D 0.15
 else:
 tick_length =3D 0.05
 x_vect.append( 1.0 * math.cos( angle * (pi/180.0)))
 x_vect.append( (1.0 - tick_length) * math.cos( angle * =
(pi/180.0)))
 y_vect.append( 1.0 * math.sin( angle * (pi/180.0)))
 y_vect.append( (1.0 - tick_length) * math.sin( angle * =
(pi/180.0)))
 p =3D self.plot(x_vect, y_vect, 'b-', linewidth=3D1, =
alpha=3D0.4, color=3D"black")
 =20
 i +=3D step
 i =3D step * 10
 step =3D step * 10
 i =3D self.raw_limits[1]
 value =3D math.log10(i)
 if( self.graph_positive ):
 angle =3D (value - math.log10(self.raw_limits[1])) * 180.00 =
/ -(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 else:
 angle =3D (value - math.log10(self.raw_limits[0])) * 180.00 =
/ +(math.log10(self.raw_limits[1]) - math.log10(self.raw_limits[0]))
 x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
 y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
 mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
 if( mantissa =3D=3D 10 ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 else:
 self.text( x_pos, y_pos, "%d" % int(j), size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90)) =20
 =わ20
 =わ20
 =わ20
 def draw_bounding_box( self ):
 x_vect =3D [
 self.x_length/2,
 self.x_length/2,
 -self.x_length/2,
 -self.x_length/2,
 self.x_length/2,
 ]
 y_vect =3D [
 -0.1,
 self.y_length,
 self.y_length,
 -0.1,
 -0.1,
 ]
 p =3D self.plot(x_vect, y_vect, 'r-', linewidth=3D0)
 =20
 =20
 =20
def make_widget( raw_value, raw_limits, raw_zones, attribute_name, =
field_names, file_name, resolution=3D72 ): =20
 from pylab import figure, show, savefig
 x_length =3D 2.4 # Length of the Primary axis
 y_length =3D 1.6 # Length of the Secondary axis
 =20
 fig_height =3D y_length
 fig_width =3D x_length
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.0/fig_width), (0.2/fig_height), (x_length/fig_width), =
(y_length/fig_height)]
 gauge =3D Log_Gauge( raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,
 x_length, y_length,
 fig, rect,
 xlim=3D( -0.1, x_length+0.1 ),
 ylim=3D( -0.4, y_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 gauge.set_axis_off()
 fig.add_axes(gauge)
 # show()
 fig.canvas.print_figure( file_name,dpi=3Dresolution ) =20
 =20
 =20
#make_widget( 0.01, [0.001,10.0], =
[[0.001,0.01,'r'],[0.01,0.1,'y'],[0.1,10.0,'g']], "Rx MOS (24h)", ['WLL =
to LAS','LAS to WLL','WLL to LAS','LAS to WLL'], 'log_gauge.png', 100)
 =20
 =20
 =20
''' =20
if __name__=3D=3D'__main__':
 from pylab import figure, show
 =20
 raw_value =3D -4.0
 limits =3D [0.0001,1.0]
 zone_colour =3D [[0.0001,0.001,'r'],[0.001,0.1,'y'],[0.1,1.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 graph_height =3D 1.6
 graph_width =3D 2.4
 fig_height =3D graph_height
 fig_width =3D graph_width
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 =20
 rect =3D [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 =20
 gauge =3D Log_Gauge(fig, rect,
 xlim=3D( -0.1, graph_width+0.1 ),
 ylim=3D( -0.4, graph_height+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 =20
 #show()
 fig.canvas.print_figure('log_gauge',dpi=3D72)
'''
 =20
 =20

Hello,
A few posts back, I included source code to some gauges I had whipped =
together. After some constructive advice from John Hunter (Thanks!), =
I've had time to polish them a bit and include the logarithmic ones as =
promised.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
#!/usr/bin/env python
"""
The Gauge widget draws a semi-circular gauge. You supply raw_limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 raw_value =3D -4.0
 raw_limits =3D [-1.0,1.0,1,0.1]
 raw_zones =3D [[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 graph_height =3D 1.6
 graph_width =3D 2.4
 fig_height =3D graph_height
 fig_width =3D graph_width
 fig =3D figure(figsize=3D(fig_width, fig_height ))
 =20
 rect =3D [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 =20
 gauge =3D Gauge(fig, rect,
 xlim=3D( -0.1, graph_width+0.1 ),
 ylim=3D( -0.4, graph_height+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 show()
"""
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
 =20
class Gauge(Axes):
 def __init__(self, raw_value, raw_limits, raw_zones, attribute_name, =
field_names, file_name, resolution, x_length, y_length, *args, =
**kwargs):
 Axes.__init__(self, *args, **kwargs)
 #Perform Checking
 if( raw_limits[0] =3D=3D raw_limits[1] ):
 raise ValueError('identical_raw_limits_exception: =
%s'%raw_limits)
 if( raw_limits[1] > raw_limits[0] ):
 self.graph_positive =3D True
 else: #Swap the raw_limits around
 self.graph_positive =3D False
 raw_limits[0], raw_limits[1] =3D raw_limits[1] =3D =
raw_limits[0]
 #There must be an integer number of minor ticks for each major =
tick
 if not( ((raw_limits[2]/raw_limits[3]) % 1.0) * raw_limits[3] =
=3D=3D 0 ): =20
 raise ValueError('bad_tick_spacing_exception')
 if( raw_limits[2] <=3D 0 or
 raw_limits[3] <=3D 0 or
 raw_limits[2] < raw_limits[3] or
 raw_limits[3] > abs(raw_limits[1]-raw_limits[0]) ):
 raise ValueError('bad_raw_limits_exception:%s' % raw_limits)
 for zone in raw_zones:
 if( zone[0] > zone[1] ): #Swap the zones so zone[1] > =
zone[0]
 zone[0], zone[1] =3D zone[1], zone[0]
 if( zone[1] < raw_limits[0] or zone[0] > raw_limits[1] ):
 raise ValueError('bad_zone_exception'%zone)
 if( zone[0] < raw_limits[0] ):
 zone[0] =3D raw_limits[0]
 if( zone[1] > raw_limits[1] ):
 zone[1] =3D raw_limits[1]
 #Stuff all of the variables into self.
 self.raw_value =3D raw_value
 self.raw_limits =3D raw_limits
 self.raw_zones =3D raw_zones
 self.attribute_name =3D attribute_name
 self.field_names =3D field_names
 self.file_name =3D file_name
 self.resolution =3D resolution
 self.x_length =3D x_length
 self.y_length =3D y_length
 =20
 =20
 #Draw the gauge
 for zone in raw_zones:
 self.draw_arch( zone, False )
 self.draw_arch( None, True )
 self.draw_ticks()
 self.draw_needle()
 self.draw_bounding_box()
 self.text(0.0, 0.2, self.attribute_name, size=3D10, =
va=3D'bottom', ha=3D'center')
 #The black dot
 p =3D self.plot([0.0],[0.0],'.', color=3D'#000000')
 def draw_arch( self, zone, border ):
 if( border ):
 start =3D self.raw_limits[0]
 end =3D self.raw_limits[1]
 else:
 start =3D zone[0]
 end =3D zone[1]
 colour =3D zone[2]
 =20
 x_vect =3D []
 y_vect =3D []
 if( self.graph_positive ):
 start_value =3D int(180 - (start - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 end_value =3D int(180 - (end - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 else:
 start_value =3D int( (end - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 end_value =3D int( (start - self.raw_limits[0]) * =
(180.0/(self.raw_limits[1]-self.raw_limits[0])))
 #Draw the arch
 theta =3D start_value
 radius =3D 0.85
 while (theta >=3D end_value):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta -=3D 1
 theta =3D end_value
 radius =3D 1.0
 while (theta <=3D start_value):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta +=3D 1
 if( border ):
 #Close the loop
 x_vect.append(-0.85)
 y_vect.append(0.0)
 p =3D self.plot(x_vect, y_vect, 'b-', color=3D'black', =
linewidth=3D1.0)
 else:
 p =3D self.fill(x_vect, y_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 def draw_needle( self ):
 x_vect =3D []
 y_vect =3D []
 if self.raw_value =3D=3D None:
 self.text(0.0, 0.4, "N/A", size=3D10, va=3D'bottom', =
ha=3D'center')
 else:
 self.text(0.0, 0.4, "%.2f" % self.raw_value, size=3D10, =
va=3D'bottom', ha=3D'center')
 #Clamp the value to the raw_limits
 if( self.raw_value < self.raw_limits[0] ):
 self.raw_value =3D self.raw_limits[0]
 if( self.raw_value > self.raw_limits[1] ):
 self.raw_value =3D self.raw_limits[1]
 theta =3D 0
 length =3D 0.95
 if( self.graph_positive ):
 angle =3D 180.0 - (self.raw_value - self.raw_limits[0]) =
*(180.0/abs(self.raw_limits[1]-self.raw_limits[0]))
 else:
 angle =3D (self.raw_value - self.raw_limits[0]) =
*(180.0/abs(self.raw_limits[1]-self.raw_limits[0]))
 while (theta <=3D 270):
 x_vect.append( length * math.cos((theta + angle) * =
(pi/180)) )
 y_vect.append( length * math.sin((theta + angle) * =
(pi/180)) )
 length =3D 0.05
 theta +=3D 90
 p =3D self.fill(x_vect, y_vect, 'b', alpha=3D0.4)
 def draw_ticks( self ):
 if( self.graph_positive ):
 angle =3D 180.0
 else:
 angle =3D 0.0
 i =3D 0
 j =3D self.raw_limits[0]
 while( i*self.raw_limits[3] + self.raw_limits[0] <=3D =
self.raw_limits[1] ):
 x_vect =3D []
 y_vect =3D []
 if( i % (self.raw_limits[2]/self.raw_limits[3]) =3D=3D 0 ):
 x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
 y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 else:
 self.text( x_pos, y_pos, "%d" % int(j), size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 tick_length =3D 0.15
 j +=3D self.raw_limits[2]
 else:
 tick_length =3D 0.05
 i +=3D 1
 x_vect.append( 1.0 * math.cos( angle * (pi/180.0)))
 x_vect.append( (1.0 - tick_length) * math.cos( angle * =
(pi/180.0)))
 y_vect.append( 1.0 * math.sin( angle * (pi/180.0)))
 y_vect.append( (1.0 - tick_length) * math.sin( angle * =
(pi/180.0)))
 p =3D self.plot(x_vect, y_vect, 'b-', linewidth=3D1, =
alpha=3D0.4, color=3D"black")
 if( self.graph_positive ):
 angle -=3D self.raw_limits[3] * =
(180.0/abs(self.raw_limits[1]-self.raw_limits[0]))
 else:
 angle +=3D self.raw_limits[3] * =
(180.0/abs(self.raw_limits[1]-self.raw_limits[0]))
 if( i % (self.raw_limits[2]/self.raw_limits[3]) =3D=3D 0 ):
 x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
 y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90))
 else:
 self.text( x_pos, y_pos, "%d" % int(j), size=3D10, =
va=3D'center', ha=3D'center', rotation=3D(angle - 90)) =20
 def draw_bounding_box( self ):
 x_vect =3D [
 self.x_length/2,
 self.x_length/2,
 -self.x_length/2,
 -self.x_length/2,
 self.x_length/2,
 ]
 y_vect =3D [
 -0.1,
 self.y_length,
 self.y_length,
 -0.1,
 -0.1,
 ]
 p =3D self.plot(x_vect, y_vect, 'r-', linewidth=3D0)
def make_widget( raw_value, raw_limits, raw_zones, attribute_name, =
field_names, file_name, resolution=3D72 ):
 from pylab import figure, show, savefig
 =20
 x_length =3D 2.4 # Length of the Primary axis
 y_length =3D 1.6 # Length of the Secondary axis
 =20
 fig_height =3D y_length
 fig_width =3D x_length
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.0/fig_width), (0.2/fig_height), (x_length/fig_width), =
(y_length/fig_height)]
 gauge =3D Gauge( raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,
 x_length, y_length,
 fig, rect,
 xlim=3D( -0.1, x_length+0.1 ),
 ylim=3D( -0.4, y_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 gauge.set_axis_off()
 fig.add_axes(gauge)
 # show()
 fig.canvas.print_figure( file_name,dpi=3Dresolution ) =20
 =20
 =20
#make_widget( -3.0, [-10.0,10.0,5,1], =
[[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']], "Rx MOS (24h)", ['WLL to =
LAS','LAS to WLL','WLL to LAS','LAS to WLL'], 'gauge.png', 100)
 =20
 =20
'''
if __name__=3D=3D'__main__':
 from pylab import figure, show
 =20
 raw_value =3D -4.0
 raw_limits =3D [-1.0,1.0,1,0.1]
 raw_zones =3D [[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 graph_height =3D 1.6
 graph_width =3D 2.4
 fig_height =3D graph_height
 fig_width =3D graph_width
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 =20
 rect =3D [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 =20
 gauge =3D Gauge(fig, rect,
 xlim=3D( -0.1, graph_width+0.1 ),
 ylim=3D( -0.4, graph_height+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 show()
 fig.canvas.print_figure('gauge',dpi=3D72)
 =20
'''
 =20

Hello,
A few posts back, I included source code to some gauges I had whipped =
together. After some constructive advice from John Hunter (Thanks!), =
I've had time to polish them a bit and include the logarithmic ones as =
promised.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
#!/usr/bin/env python
"""
The Log_Meter widget draws a logarithmic meter, either horizontally or =
vertically. You supply the direction, limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 =20
 raw_value =3D -4.0
 raw_limits =3D [-10.0,10.0,5,1]
 raw_zones =3D [[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 s_length =3D 0.3
 p_length =3D 2.0
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 =20
 rect =3D [(0.2/fig_width), (0.5/fig_height),
 (p_length/fig_width), (s_length/fig_height)]
 =20
 meter =3D Log_Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 meter.set_axis_off()
 fig.add_axes(meter)
 show()
"""
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
class Meter(Axes):
 def __init__(self, vertical, raw_value, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution, p_length, s_length, =
*args, **kwargs):
 Axes.__init__(self, *args, **kwargs)
 #Perform Checking
 if( raw_limits[0] =3D=3D raw_limits[1] ):
 raise ValueError('identical_limits_exception: %s' % =
raw_limits)
 if( raw_limits[1] > raw_limits[0] ):
 self.graph_positive =3D True
 else: #Swap the limits around
 self.graph_positive =3D False
 raw_limits[0], raw_limits[1] =3D raw_limits[1] =3D =
raw_limits[0]
 =20
 if not( math.log10(raw_limits[0]) % 1.0 =3D=3D 0 and =
math.log10(raw_limits[1]) % 1.0 =3D=3D 0 ):
 raise ValueError('bad_limits_exception:%s' % raw_limits)
 for zone in raw_zones:
 if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > =
zone[0]
 zone[0], zone[1] =3D zone[1] =3D zone[0]
 if( zone[1] < raw_limits[0] or zone[0] > raw_limits[1] =
):
 raise ValueError('bad_zone_exception'%zone)
 if( zone[0] < raw_limits[0] ):
 zone[0] =3D raw_limits[0]
 if( zone[1] > raw_limits[1] ):
 zone[1] =3D raw_limits[1]
 =20
 =20
 =20
 #Stuff all of the variables into self.
 self.vertical =3D vertical
 self.raw_value =3D raw_value
 self.raw_limits =3D raw_limits
 self.raw_zones =3D raw_zones
 self.attribute_name =3D attribute_name
 self.field_names =3D field_names
 self.file_name =3D file_name
 self.resolution =3D resolution
 self.p_length =3D p_length
 self.s_length =3D s_length
 =20
 #Draw the meter
 self.graph_center =3D =
((math.log10(self.raw_limits[0])+math.log10(self.raw_limits[1]))/2)
 for zone in raw_zones:
 self.draw_bar( zone, False)
 self.draw_bar( None, True)
 self.draw_ticks()
 self.draw_needle()
 if( vertical ):
 self.text( self.s_length/2, =
math.log10(self.raw_limits[0])-0.2, self.attribute_name, size=3D12, =
va=3D'top', ha=3D'center')
 else:
 self.text( self.graph_center, self.s_length+0.25, =
self.attribute_name, size=3D12, va=3D'bottom', ha=3D'center')
 =20
 def draw_bar( self, zone, border ):
 if( border ):
 start =3D self.raw_limits[0]
 end =3D self.raw_limits[1]
 else:
 start =3D zone[0]
 end =3D zone[1]
 colour =3D zone[2]
 =20
 if( self.graph_positive ):
 start =3D math.log10(start)
 end =3D math.log10(end)
 else:
 start =3D -math.log10(start)
 end =3D -math.log10(end)
 =20
 s_vect =3D [ 0.0, 0.0, self.s_length, self.s_length ]
 p_vect =3D [ start, end, end, start ]
 =20
 if( border ):
 #Close the loop
 p_vect.append(start)
 s_vect.append(0.0)
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 if( self.vertical ):
 p =3D self.fill(s_vect, p_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 else:
 p =3D self.fill(p_vect, s_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 def draw_needle( self ):
 if( self.raw_value =3D=3D None ):
 if( self.vertical ):
 self.text( (self.s_length + 0.05), self.graph_center, =
"N/A", size=3D10, va=3D'center', ha=3D'left')
 else:
 self.text( self.graph_center, (self.s_length + 0.05), =
"N/A", size=3D10, va=3D'bottom', ha=3D'center')
 else:
 #Clamp the value to the limits
 value =3D math.log10(self.raw_value)
 if( self.raw_value < self.raw_limits[0] ):
 value =3D math.log10(self.raw_limits[0])
 if( self.raw_value > self.raw_limits[1] ):
 value =3D math.log10(self.raw_limits[1])
 =20
 if( self.vertical ):
 self.text( (self.s_length + 0.05), value, "%.2f" % =
self.raw_value, size=3D10, va=3D'center', ha=3D'left')=20
 else:
 self.text( value, (self.s_length + 0.05), "%.2f" % =
self.raw_value, size=3D10, va=3D'bottom', ha=3D'center')=20
 =20
 if( not self.graph_positive ):
 value =3D -value
 s_vect =3D [ self.s_length/2, self.s_length, self.s_length ]
 p_vect =3D [ value + 0.00, value - 0.1, value + 0.1 ]
 =20
 if( self.vertical ):
 self.fill(s_vect, p_vect, 'black')
 else:
 self.fill(p_vect, s_vect, 'black')
 =20
 =20
 def draw_ticks( self ):
 i =3D self.raw_limits[0]
 step =3D self.raw_limits[0]
 while( i < self.raw_limits[1] ):
 while( i < (step * 10) ):
 value =3D math.log10(i)
 if( not self.graph_positive ):
 value =3D -value
 mantissa =3D int(i / math.pow(10, =
math.ceil(math.log10(i))-1))
 if( mantissa =3D=3D 10 or mantissa =3D=3D 1 ):
 if( self.vertical ):
 self.text( -0.05, value, "%g" % i, size=3D10, =
va=3D'center', ha=3D'right')
 else: =20
 self.text( value, -0.05, "%g" % i, size=3D10, =
va=3D'top', ha=3D'center')=20
 tick_length =3D self.s_length
 else:
 tick_length =3D self.s_length * 0.2
 s_vect =3D [ 0.0, tick_length ]
 p_vect =3D [ value, value ]
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 i +=3D step
 i =3D step * 10
 step =3D step * 10
 i =3D self.raw_limits[1]
 value =3D math.log10(i)
 if( not self.graph_positive ):
 value =3D -value
 mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
 if( mantissa =3D=3D 10 ):
 if( self.vertical ):
 self.text( -0.05, value, "%g" % i, size=3D10, =
va=3D'center', ha=3D'right')
 else: =20
 self.text( value, -0.05, "%g" % i, size=3D10, =
va=3D'top', ha=3D'center')=20
 =20
 =20
def make_widget( vertical, raw_value, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution=3D72 ): =20
 from pylab import figure, show, savefig
 p_length =3D 2.0 # Length of the Primary axis
 s_length =3D 0.3 # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 0.6
 fig_width =3D s_length + 1.0
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.5/fig_width), (0.4/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(vertical, raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,=20
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[]
 )
 else:
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.2/fig_width), (0.5/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(vertical, raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure( file_name,dpi=3Dresolution ) =20
 =20
 =20
#make_widget( True, 0.01, [0.001,10.0], =
[[0.001,0.01,'r'],[0.01,0.1,'y'],[0.1,10.0,'g']], "Rx MOS (24h)", ['WLL =
to LAS','LAS to WLL','WLL to LAS','LAS to WLL'], 'log_meter.png', 100)
 =20
''' =20
 =20
if __name__=3D=3D'__main__':
 from pylab import figure, show, savefig
 =20
 vertical =3D True =20
 =20
 raw_value =3D 0.1
 raw_limits =3D [0.0001,10.0,5,1]
 raw_zones =3D [[0.0001,0.001,'r'],[0.001,0.1,'y'],[0.1,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 p_length =3D 2.0 # Length of the Primary axis
 s_length =3D 0.3 # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 0.6
 fig_width =3D s_length + 1.0
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.5/fig_width), (0.4/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 else:
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.2/fig_width), (0.5/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure('log_meter',dpi=3D72)
'''

Hello,
A few posts back, I included source code to some gauges I had whipped =
together. After some constructive advice from John Hunter (Thanks!), =
I've had time to polish them a bit and include the logarithmic ones as =
promised.
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D
#!/usr/bin/env python
"""
The Meter widget draws a linear meter, either horizontally or =
vertically. You supply the direction, limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 =20
 raw_value =3D -4.0
 raw_limits =3D [-10.0,10.0,5,1]
 raw_zones =3D [[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 s_length =3D 0.3
 p_length =3D 2.0
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 =20
 rect =3D [(0.2/fig_width), (0.5/fig_height),
 (p_length/fig_width), (s_length/fig_height)]
 =20
 meter =3D H_Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 meter.set_axis_off()
 fig.add_axes(meter)
 show()
"""
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
class Meter(Axes):
 def __init__(self, vertical, raw_value, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution, p_length, s_length, =
*args, **kwargs):
 Axes.__init__(self, *args, **kwargs)
 #Perform Checking
 if( raw_limits[0] =3D=3D raw_limits[1] ):
 raise ValueError('identical_limits_exception: %s' % =
raw_limits)
 if( raw_limits[1] > raw_limits[0] ):
 self.graph_positive =3D True
 else: #Swap the limits around
 self.graph_positive =3D False
 raw_limits[0], raw_limits[1] =3D raw_limits[1] =3D =
raw_limits[0]
 =20
 if not( ((raw_limits[2]/raw_limits[3]) % 1.0) * raw_limits[3] =
=3D=3D 0 ):	#There must be an integer number of minor ticks for each =
major tick
 raise ValueError('bad_tick_spacing_exception')
 if( raw_limits[2] <=3D 0 or raw_limits[3] <=3D 0 or =
raw_limits[2] < raw_limits[3] or raw_limits[3] > =
abs(raw_limits[1]-raw_limits[0]) ):
 raise ValueError('bad_limits_exception:%s' % raw_limits)
 for zone in raw_zones:
 if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > =
zone[0]
 zone[0], zone[1] =3D zone[1] =3D zone[0]
 if( zone[1] < raw_limits[0] or zone[0] > raw_limits[1] =
):
 raise ValueError('bad_zone_exception'%zone)
 if( zone[0] < raw_limits[0] ):
 zone[0] =3D raw_limits[0]
 if( zone[1] > raw_limits[1] ):
 zone[1] =3D raw_limits[1]
 =20
 #Adjust the scaling
 self.scaled_limits =3D []
 for limit in raw_limits:
 self.scaled_limits.append( limit * p_length / =
(raw_limits[1]-raw_limits[0]))
 =20
 =20
 #Stuff all of the variables into self.
 self.vertical =3D vertical
 self.raw_value =3D raw_value
 self.raw_limits =3D raw_limits
 self.raw_zones =3D raw_zones
 self.attribute_name =3D attribute_name
 self.field_names =3D field_names
 self.file_name =3D file_name
 self.resolution =3D resolution
 self.p_length =3D p_length
 self.s_length =3D s_length
 =20
 #Draw the meter
 self.graph_center =3D =
((self.scaled_limits[1]+self.scaled_limits[0])/2)
 for zone in raw_zones:
 self.draw_bar( zone, False)
 self.draw_bar( None, True)
 self.draw_ticks()
 self.draw_needle()
 if( self.vertical ):
 self.text( self.s_length/2, self.scaled_limits[0]-0.1, =
self.attribute_name, size=3D12, va=3D'top', ha=3D'center')
 else:
 self.text( self.graph_center, self.s_length+0.25, =
self.attribute_name, size=3D12, va=3D'bottom', ha=3D'center')
 =20
 def draw_bar( self, zone, border):
 if( border ):
 start =3D self.scaled_limits[0]
 end =3D self.scaled_limits[1]
 else:
 start =3D (zone[0] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0]))
 end =3D (zone[1] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0]))
 colour =3D zone[2]
 =20
 if( not self.graph_positive ):
 start =3D -start
 end =3D -end
 =20
 s_vect =3D [ 0.0, 0.0, self.s_length, self.s_length ]
 p_vect =3D [ start, end, end, start ]
 =20
 if( border ):
 #Close the loop
 p_vect.append(start)
 s_vect.append(0.0)
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', color=3D'black', =
linewidth=3D1.5)
 else:
 if( self.vertical ):
 p =3D self.fill(s_vect, p_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 else:
 p =3D self.fill(p_vect, s_vect, colour, linewidth=3D0.0, =
alpha=3D0.4)
 def draw_needle( self ): =20
 if( self.raw_value =3D=3D None ):
 if( self.vertical ):
 self.text( (self.s_length + 0.05), self.graph_center, =
"N/A", size=3D10, va=3D'center', ha=3D'left')
 else:
 self.text( self.graph_center, (self.s_length + 0.05), =
"N/A", size=3D10, va=3D'bottom', ha=3D'center')
 else:
 #Clamp the value to the limits
 value =3D self.raw_value * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 if( self.raw_value < self.raw_limits[0] ):
 value =3D self.raw_limits[0] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 if( self.raw_value > self.raw_limits[1] ):
 value =3D self.raw_limits[1] * self.p_length / =
(self.raw_limits[1]-self.raw_limits[0])
 =20
 if( self.vertical ):
 self.text( (self.s_length + 0.05), value, "%.2f" % =
self.raw_value, size=3D10, va=3D'center', ha=3D'left')=20
 else:
 self.text( value, (self.s_length + 0.05), "%.2f" % =
self.raw_value, size=3D10, va=3D'bottom', ha=3D'center')=20
 =20
 if( not self.graph_positive ):
 value =3D -value
 s_vect =3D [ self.s_length/2, self.s_length, self.s_length ]
 p_vect =3D [ value + 0.00, value - 0.05, value + 0.05 ]
 =20
 if( self.vertical ):
 self.fill(s_vect, p_vect, 'black')
 else:
 self.fill(p_vect, s_vect, 'black')
 =20
 =20
 def draw_ticks( self ):
 if( self.graph_positive ):
 offset =3D self.scaled_limits[0]
 else:
 offset =3D self.scaled_limits[1]
 i =3D 0
 j =3D self.raw_limits[0]
 while( i*self.scaled_limits[3] + self.scaled_limits[0] <=3D =
self.scaled_limits[1] ):
 if( i % (self.scaled_limits[2]/self.scaled_limits[3]) =3D=3D =
0):
 tick_length =3D self.s_length
 if( self.vertical ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( -0.05, offset, "%.2f" % j, size=3D10, =
va=3D'center', ha=3D'right')=20
 else:
 self.text( -0.05, offset, "%d" % int(j), =
size=3D10, va=3D'center', ha=3D'right')
 else: =20
 tick_length =3D self.s_length
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( offset, -0.05, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( offset, -0.05, "%d" % int(j), =
size=3D10, va=3D'top', ha=3D'center')=20
 j +=3D self.raw_limits[2]
 else:
 tick_length =3D self.s_length * 0.2
 =20
 s_vect =3D [ 0.0, tick_length ]
 p_vect =3D [ offset, offset ]
 =20
 if( self.vertical ):
 p =3D self.plot(s_vect, p_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 else:
 p =3D self.plot(p_vect, s_vect, 'b-', linewidth=3D1, =
color=3D'black', alpha=3D0.2)
 i +=3D 1
 if( self.graph_positive ):
 offset +=3D self.scaled_limits[3]
 else:
 offset -=3D self.scaled_limits[3]
 =20
 if( i % (self.scaled_limits[2]/self.scaled_limits[3]) =3D=3D 0):
 if( self.vertical ):
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( -0.01, offset, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( -0.01, offset, "%d" % int(j), size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 if( type(self.raw_limits[2]) is types.FloatType ):
 self.text( offset, -0.1, "%.2f" % j, size=3D10, =
va=3D'top', ha=3D'center')=20
 else:
 self.text( offset, -0.1, "%d" % int(j), size=3D10, =
va=3D'top', ha=3D'center')=20
 =20
def make_widget( vertical, raw_value, raw_limits, raw_zones, =
attribute_name, field_names, file_name, resolution=3D72 ):
 from pylab import figure, show, savefig
 =20
 p_length =3D 2.0 # Length of the Primary axis
 s_length =3D 0.3 # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 0.6
 fig_width =3D s_length + 1.0
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.5/fig_width), (0.4/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(vertical, raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,=20
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[]
 )
 else:
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.2/fig_width), (0.5/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(vertical, raw_value,=20
 raw_limits, raw_zones,=20
 attribute_name, field_names,=20
 file_name, resolution,
 p_length, s_length,
 fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure( file_name,dpi=3Dresolution ) =20
 =20
 =20
#make_widget( False, -3.0, [-10.0,10.0,5,1], =
[[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']], "Rx MOS (24h)", ['WLL to =
LAS','LAS to WLL','WLL to LAS','LAS to WLL'], 'meter.png', 100)
 =20
''' =20
if __name__=3D=3D'__main__':
 from pylab import figure, show, savefig
 =20
 vertical =3D True =20
 =20
 raw_value =3D None
 raw_limits =3D [-10.0,10.0,5,1]
 raw_zones =3D [[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']]
 attribute_name =3D "Rx MOS (24h)"
 =20
 p_length =3D 2.0 # Length of the Primary axis
 s_length =3D 0.3 # Length of the Secondary axis
 =20
 if( vertical ):=20
 fig_height =3D p_length + 0.6
 fig_width =3D s_length + 1.0
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.5/fig_width), (0.4/fig_height), =
(s_length/fig_width), (p_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.2, s_length+0.1 ),
 ylim=3D( -0.1, p_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 else:
 fig_height =3D s_length + 1.0
 fig_width =3D p_length + 0.4
 fig =3D figure( figsize=3D(fig_width, fig_height) )
 rect =3D [(0.2/fig_width), (0.5/fig_height), =
(p_length/fig_width), (s_length/fig_height)]
 meter =3D Meter(fig, rect,
 xlim=3D( -0.1, p_length+0.1 ),
 ylim=3D( -0.4, s_length+0.1 ),
 xticks=3D[],
 yticks=3D[],
 )
 =20
 meter.set_axis_off()
 fig.add_axes(meter)
 # show()
 fig.canvas.print_figure('meter',dpi=3D72)
'''

>>>>> "Steve" == Steve Chaplin <ste...@ya...> writes:
 Steve> For the people that like to maximise the size of their
 Steve> graphs I've updated the key-press-event so that pressing
 Steve> 'g' toggles fullscreen mode. (It requires GTK+ 2.2 or
 Steve> higher and a window manager that honours window fullscreen
 Steve> requests).
Very nice! But I think you mean 'f', right?
JDH

For the people that like to maximise the size of their graphs
I've updated the key-press-event so that pressing 'g' toggles
fullscreen mode. (It requires GTK+ 2.2 or higher and a window manager
that honours window fullscreen requests).
Steve
Send instant messages to your online friends http://au.messenger.yahoo.com 

>>>>> "Ted" == Ted Drain <ted...@jp...> writes:
 Ted> The legend() docs state: Make a legend with existing lines
 >>>> legend()
 Ted> legend by itself will try and build a legend using the
 Ted> label property of the lines/patches/collections. You can set
 Ted> the label of a line by doing plot(x, y, label='my data') or
 Ted> line.set_label('my data'). If label is set to '_nolegend_',
 Ted> the item will not be shown in legend.
The docs say this only in reference to autolegend capability (eg when
you call legend with no arguments). And this does work
 import pylab as p
 x = p.arange( 0,3, .1 )
 p.plot( x, p.cos(x), label='cos(x)' )
 p.plot( x, p.sin(x), label='sin(x)')
 p.plot( x, 2*p.sin(x), label='_nolegend_' )
 p.legend()
 p.show()
It isn't really required in your use case, because you can simply pass
the lines and labels you want in the legend
 import pylab as p
 x = p.arange( 0,3, .1 )
 l0, = p.plot( x, p.cos(x))
 l1, = p.plot( x, p.sin(x))
 l2, = p.plot( x, 2*p.sin(x))
 p.legend((l0, l1), ('cos(x)', 'sin(x)') )
 p.show()
It would not be too much work to support the semi-auto legending of
your example
 p.legend( ( "cos(x)", "_nolegend_", "2*sin(x)" ) )
if you think this is sufficiently useful.
JDH

>>>>> "Steve" == Steve Chaplin <ste...@ya...> writes:
 Steve> Also, I see the frontend file lines.py has: import
 Steve> matplotlib.agg
matplotlib does not require the agg backend, but it does require a
minimal bit of agg functionality. Specifically, agg::path_storage us
the cross-backend path storage class, which you use in backend_cairo
in the draw_markers function. As you probably remember, I started out
with a simple list of tuples to represent a path, but eventually
decided we would be better off with a full blown, bug vetted
implementation rather than rolling our own. agg's seemed a natural
choice because the code is already in the mpl code base, and it has
the additional benefit that backend_agg can use it with no overhead.
So backend matplotlib.backends._backend_agg and matplotlib.agg are
different beasts. The first is pycxx hand written code to implement
the Renderer and GC classes; the latter is a SWIG wrapper of agg. I
would like to do away with the former and replace all of it's
functionality with the latter (I started experimenting with this in
backend_agg2). The advantage of this is that agg users could also
draw directly onto the canvas using agg primitives and would not be
limited by the mpl drawing model.
This is a long winded way of saying that I have polluted the agg
module's minimal set of cross-backend agg functionality with some
graphics capability. I think the solution is to factor matplotlib.agg
this into two modules: one lightweight which has the rendering
independent computational geometry stuff which can be used across
backends, and one which has the rendering stuff . mpl has reinvented
(for the 40th time) many of the primitives that every graphics library
needs (color storage, path storage, affine transformations, etc...).
In the grand refactoring that I've wanted to do for many moons but
haven't found the time, I've envisioned replacing a lot of this custom
stuff with agg's. The code in matplotlib.agg layed the groundwork for
this, but as I say I got a little carried away and included other
antigrain stuff too.
How about two modules, the first required ("basics") that has
rectangles, path_storage, affine transformations, etc, and another
optional ("agg" or "antigrain") which has the rendering buffers,
renderers, strokes and so on, thus keeping the cross-backend required
component as light as possible. The only objection I can think of is
that is makes C++ a core requirement for mpl, but it already is for
the _transforms and ft2font modules.
Does this sound reasonable to you? Do you have any objection to
reusing a minimal set of agg across backends?
JDH

Hi, just thought I'd check if this was a (fairly minor) bug. In the psd 
function there is:
 if NFFT % 2:
 raise ValueError, 'NFFT must be a power of 2'
But that will only check if NFFT is an even number or not. Should this 
instead be:
 if not ispower2(NFFT):
 raise ValueError, 'NFFT must be a power of 2'
?
Abe

I always thought of matplotlib as providing a graphics library neutral
frontend, which can be coupled with a choice of many backends.
However, if I choose to edit setup.py and change
BUILD_AGG = 1
to
BUILD_AGG = 0
(and BUILD_IMAGE = 0 too)
after 'python setup.py build'
I still see the message "building 'matplotlib._agg' extension"
and notice that agg.py and _agg.so still get installed.
Also, I see the frontend file lines.py has:
 import matplotlib.agg
So even if someone wishes to use just the ps, svg, cairo or gtk backends,
they must compile, install, and import agg even though they did not wish
to use it.
Steve
Send instant messages to your online friends http://au.messenger.yahoo.com 

The legend() docs state:
 Make a legend with existing lines
 >>> legend()
 legend by itself will try and build a legend using the label
 property of the lines/patches/collections. You can set the label of
 a line by doing plot(x, y, label='my data') or line.set_label('my
 data'). If label is set to '_nolegend_', the item will not be shown
 in legend.
But trying to pass '_nolegend_' doesn't seem to work. And a grep through 
the code finds no instances of '_nolegend_'.
import pylab as p
x = p.arange( 0,3, .1 )
y1 = p.cos( x )
y2 = p.sin( x )
y3 = 2*p.sin( x )
p.plot( x, y1 )
p.plot( x, y2 )
p.plot( x, y3 )
p.legend( ( "cos(x)", "_nolegend_", "2*sin(x)" ) )
p.show()

Hi,
I was creating a legend with the location variable being set to 'best'. However
when my graph contained only one point, the matplotlib code produced an error. I
found that the branch that handles the "one point case" passes the arguments to
the bbox.contains call incorrectly. I am using cvs version of the library.
The following is the patch for the problem: (Note that I edited the installed file)
--- legend.py 2005年05月20日 12:18:34.000000000 -0400
+++ /usr/lib/python2.4/site-packages/matplotlib/legend.py 2005年07月21日
11:25:08.576508496 -0400
@@ -51,7 +51,7 @@
 return False
 if n == 1:
- return bbox.contains(line[0])
+ return bbox.contains(line[0][0], line[0][1])
 p1 = line[0]
 for p2 in line[1:]:
Best regards,
Maria Khomenko

Hi,
In my work I've come across a need to plot arrows with a position
specified in data coordinates but which appear in the rendered plot with
a constant size and shape, independent of zoom or aspect ratio (as
opposed to the patch.Arrow class which acts like a vector image of an
arrow and as such changes in rendered size on zooming or aspect ratio
change).
It appeared to me that the most obvious way to implement this was as a
new arrowhead marker style for the lines.Line2D class (with no marker
shown for the first point in the line). This should allow more general
use than just as simple arrows; for example in plotting vectors.
I've attached a patch to CVS to implement this as a marker accessed
using the symbol 'a'. The marker is a triangle pointing in the correct
direction for an an arrowhead and with its point at the end of the line
segment.
There are two main problems with the attached code. Firstly as the
arrowhead is potentially pointing in a different direction for each
point the renderer.draw_markers method can't be used and plotting will
thus be slower. Secondly, for linewidth > 1 the line appears either
side of the point of the arrowhead. I can see two potential ways
around the second problem: moving the arrowhead forwards which is
unsuitable for vectors or altering the length of lines plotted where the
marker is an arrowhead which requires lots more code than it seemed
sensible to add.
Anyway, despite the problems noted I thought this code might be
generally useful.
Nick

Since this topic comes up every now and again, allow me to point out a 
resource I just happened upon:
http://www.bitjungle.com/~isoent/
On this page is a link to an XML file that is a very thorough database 
mapping Unicode code points (at least, ones that we care about) to their 
LaTeX representation. When the LaTeX representation requires a 
particular package or environment, these are provided. For example:
<char pos="840">
 <entity name="Kcy" set="iso-8879-cyr1">
 <desc>=capital KA, Cyrillic</desc>
 </entity>
 <unicode value="041A">
 <desc>CYRILLIC CAPITAL LETTER KA</desc>
 </unicode>
 <latex>
 <seq req="cyracc,amsfonts" env="cyr">K</seq>
 <seq req="fontenc:T2A">\CYRK</seq>
 </latex>
</char>
This is the mapping to end all mappings. It evens comes with convenient 
PDF references.
-- 
Robert Kern
rk...@uc...
"In the fields of hell where the grass grows high
 Are the graves of dreams allowed to die."
 -- Richard Harter

>>>>> "Jamil" == Jamil Khan <jam...@ca...> writes:
 Jamil> Apparently the mailing list doesn't do attachments. So here
 Jamil> is the source instead: - Jamil Khan
Hi Jamil -- thanks for contributing these. They look very snazzy --
nice design!
As they are they will be useful, but to make them maximally useful, I
think they should be refactored using the matplotlib API and not the
pylab interface, since gauges are typically used in GUI application
rather than one-off scripts and most application developers use the
API rather than pylab. It is a fairly easy migration -- I'll include
an example refactoring of gauge.py below. For more details on the
API, see
 http://matplotlib.sourceforge.net/faq.html#OO
Are you interested in doing this? If we get these cleaned up a bit
and documented, they would be a nice start to a new "toolkit"
 http://matplotlib.sourceforge.net/toolkits.html
Here is the modified gauge.py, which defines a Gauge as a custom
Axes. This can now be used from the pylab interface or the matplotlib
API. One other things to note: all of your setp calls could be
removed by simply passing the kwargs to the relevant function. Eg,
instead of
 p = plot(x_vect, y_vect, 'b-')
 setp(p, color='black')
 setp(p, linewidth=1.5)
you could do
 p = plot(x_vect, y_vect, 'b-')
 setp(p, color='black',linewidth=1.5)
or event better
 p = plot(x_vect, y_vect, 'b-', color='black',linewidth=1.5)
Another little trick; in several places you do things like
 temp = limits[0]
 limits[0] = limits[1]
 limits[1] = temp
With the magic of tuples, you can avoid the temporary and do this in
one line
 limits[0], limits[1] = limits[1] = limits[0]
Also, do you intend to do integer division in lines like
 graph_width/2
If not, you will want to do one of 'from __future__ import division'
or graph_width/2.
For efficiency and to save typing, you may want to replace blocks like
 x_vect = []
 x_vect.append( (graph_width/2) )
 x_vect.append( (graph_width/2) )
 x_vect.append(-(graph_width/2) )
 x_vect.append(-(graph_width/2) )
 x_vect.append( (graph_width/2) )
with 
 
 x_vect = [
 graph_width/2,
 graph_width/2,
 -graph_width/2,
 -graph_width/2,
 graph_width/2,
 ]
Final comment: your code uses tabs rather than spaces for indentation,
which can cause problems and is nonstandard. Perhaps you could
configure your editor to use spaces for indentation?
 
Thanks for the contribution!
JDH
Example refactoring of gauge.py
#!/usr/bin/env python
"""
The Gauge widget draws a semi-circular gauge. You supply limits,
shaded regions, names and the current value, and invoke it like this:
 from pylab import figure, show
 current_value = -4.0
 limits = [-1.0,1.0,1,0.1]
 zone_colour = [[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']]
 attribute_name = "Rx MOS (24h)"
 
 graph_height = 1.6
 graph_width = 2.4
 fig_height = graph_height
 fig_width = graph_width
 fig = figure(figsize=(fig_width, fig_height ))
 
 rect = [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 
 gauge = Gauge(fig, rect,
 xlim=( -0.1, graph_width+0.1 ),
 ylim=( -0.4, graph_height+0.1 ),
 xticks=[],
 yticks=[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 show()
"""
from __future__ import division
from matplotlib.figure import Figure
from matplotlib.axes import Axes
import math
import types
from math import pi
 
class Gauge(Axes):
 def __init__(self, *args, **kwargs):
 Axes.__init__(self, *args, **kwargs)
 #Perform Checking
 if( limits[0] == limits[1] ):
 raise ValueError('identical_limits_exception: %s'%limits)
 if( limits[1] > limits[0] ):
 graph_positive = True
 else: #Swap the limits around
 graph_positive = False
 limits[0], limits[1] = limits[1] = limits[0]
 #There must be an integer number of minor ticks for each major tick
 if not( ((limits[2]/limits[3]) % 1.0) * limits[3] == 0 ): 
 raise ValueError('bad_tick_spacing_exception')
 if( limits[2] <= 0 or
 limits[3] <= 0 or
 limits[2] < limits[3] or
 limits[3] > abs(limits[1]-limits[0]) ):
 raise ValueError('bad_limits_exception:%s' % limits)
 for zone in zone_colour:
 if( zone[0] > zone[1] ): #Swap the zones so zone[1] > zone[0]
 zone[0], zone[1] = zone[1], zone[0]
 if( zone[1] < limits[0] or zone[0] > limits[1] ):
 raise ValueError('bad_zone_exception'%zone)
 if( zone[0] < limits[0] ):
 zone[0] = limits[0]
 if( zone[1] > limits[1] ):
 zone[1] = limits[1]
 #Draw the arch
 for zone in zone_colour:
 self.draw_arch(limits, zone[0], zone[1], zone[2], False, graph_positive)
 self.draw_arch(limits, limits[0], limits[1], 'black', True, graph_positive)
 self.draw_ticks(limits, graph_positive)
 self.draw_needle(current_value, limits, graph_positive)
 self.draw_bounding_box(graph_width, graph_height)
 self.text(0.0, 0.2, attribute_name, size=10, va='bottom', ha='center')
 #The black dot.
 p = self.plot([0.0],[0.0],'.', color='#000000')
 def draw_arch(self, limits, start_angle, end_angle, colour, border, graph_positive):
 x_vect = []
 y_vect = []
 if( graph_positive ):
 start = int(180 - (start_angle - limits[0]) * (180.0/(limits[1]-limits[0])))
 end = int(180 - (end_angle - limits[0]) * (180.0/(limits[1]-limits[0])))
 else:
 start = int( (end_angle - limits[0]) * (180.0/(limits[1]-limits[0])))
 end = int( (start_angle - limits[0]) * (180.0/(limits[1]-limits[0])))
 #Draw the arch
 theta = start
 radius = 0.85
 while (theta >= end):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta -= 1
 theta = end
 radius = 1.0
 while (theta <= start):
 x_vect.append( radius * math.cos(theta * (pi/180)) )
 y_vect.append( radius * math.sin(theta * (pi/180)) )
 theta += 1
 if( border ):
 #Close the loop
 x_vect.append(-0.85)
 y_vect.append(0.0)
 p = self.plot(x_vect, y_vect, 'b-', color='black', linewidth=1.5)
 else:
 p = self.fill(x_vect, y_vect, colour, linewidth=0.0, alpha=0.4)
 def draw_needle(self, current_value, limits, graph_positive):
 x_vect = []
 y_vect = []
 if current_value == None:
 self.text(0.0, 0.4, "N/A", size=10, va='bottom', ha='center')
 else:
 self.text(0.0, 0.4, "%.2f" % current_value, size=10, va='bottom', ha='center')
 #Clamp the value to the limits
 if( current_value < limits[0] ):
 current_value = limits[0]
 if( current_value > limits[1] ):
 current_value = limits[1]
 theta = 0
 length = 0.95
 if( graph_positive ):
 angle = 180.0 - (current_value - limits[0]) *(180.0/abs(limits[1]-limits[0]))
 else:
 angle = (current_value - limits[0]) *(180.0/abs(limits[1]-limits[0]))
 while (theta <= 270):
 x_vect.append( length * math.cos((theta + angle) * (pi/180)) )
 y_vect.append( length * math.sin((theta + angle) * (pi/180)) )
 length = 0.05
 theta += 90
 p = self.fill(x_vect, y_vect, 'b', alpha=0.4)
 def draw_ticks(self, limits, graph_positive):
 if( graph_positive ):
 angle = 180.0
 else:
 angle = 0.0
 i = 0
 j = limits[0]
 while( i*limits[3] + limits[0] <= limits[1] ):
 x_vect = []
 y_vect = []
 if( i % (limits[2]/limits[3]) == 0 ):
 x_pos = 1.1 * math.cos( angle * (pi/180.0))
 y_pos = 1.1 * math.sin( angle * (pi/180.0))
 if( type(limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=10, va='center', ha='center', rotation=(angle - 90)) 
 else:
 self.text( x_pos, y_pos, "%d" % int(j), size=10, va='center', ha='center', rotation=(angle - 90)) 
 tick_length = 0.15
 j += limits[2]
 else:
 tick_length = 0.05
 i += 1
 x_vect.append( 1.0 * math.cos( angle * (pi/180.0)))
 x_vect.append( (1.0 - tick_length) * math.cos( angle * (pi/180.0)))
 y_vect.append( 1.0 * math.sin( angle * (pi/180.0)))
 y_vect.append( (1.0 - tick_length) * math.sin( angle * (pi/180.0)))
 p = self.plot(x_vect, y_vect, 'b-', linewidth=1, alpha=0.4, color="black")
 if( graph_positive ):
 angle -= limits[3] * (180.0/abs(limits[1]-limits[0]))
 else:
 angle += limits[3] * (180.0/abs(limits[1]-limits[0]))
 if( i % (limits[2]/limits[3]) == 0 ):
 x_pos = 1.1 * math.cos( angle * (pi/180.0))
 y_pos = 1.1 * math.sin( angle * (pi/180.0))
 if( type(limits[2]) is types.FloatType ):
 self.text( x_pos, y_pos, "%.2f" % j, size=10, va='center', ha='center', rotation=(angle - 90)) 
 else:
 self.text( x_pos, y_pos, "%d" % int(j), size=10, va='center', ha='center', rotation=(angle - 90)) 
 def draw_bounding_box(self, graph_width, graph_height):
 x_vect = [
 graph_width/2,
 graph_width/2,
 -graph_width/2,
 -graph_width/2,
 graph_width/2,
 ]
 y_vect = [
 -0.1,
 graph_height,
 graph_height,
 -0.1,
 -0.1,
 ]
 p = self.plot(x_vect, y_vect, 'r-', linewidth=0)
if __name__=='__main__':
 from pylab import figure, show
 current_value = -4.0
 limits = [-1.0,1.0,1,0.1]
 zone_colour = [[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']]
 attribute_name = "Rx MOS (24h)"
 
 graph_height = 1.6
 graph_width = 2.4
 fig_height = graph_height
 fig_width = graph_width
 fig = figure(figsize=(fig_width, fig_height ))
 
 rect = [(0.0/fig_width), (0.2/fig_height),
 (graph_width/fig_width), (graph_height/fig_height)]
 
 gauge = Gauge(fig, rect,
 xlim=( -0.1, graph_width+0.1 ),
 ylim=( -0.4, graph_height+0.1 ),
 xticks=[],
 yticks=[],
 )
 gauge.set_axis_off()
 fig.add_axes(gauge)
 show()

Apparently the mailing list doesn't do attachments. So here is the =
source instead:
 - Jamil Khan
Design Engineer,
Calyptech Pty. Ltd.
www.calyptech.com
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
linear rotary gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a semi-circular gauge. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#
#	draw_widget( 	current_value,=20
#			limits[ lower, upper, major ticks, minor ticks],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "gauge_0.png",
#			resolution in dpi
#		 )
#
#
from pylab import *
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
import math
import types
import matplotlib
matplotlib.use('Agg') # force the antigrain backend
from matplotlib.backends.backend_agg import FigureCanvasAgg
def draw_arch(limits, start_angle, end_angle, colour, border, =
graph_positive):
	x_vect =3D []
	y_vect =3D []
	if( graph_positive ):
		start =3D int(180 - (start_angle - limits[0]) * =
(180.0/(limits[1]-limits[0])))
		end =3D int(180 - (end_angle - limits[0]) * =
(180.0/(limits[1]-limits[0])))
	else:
		start =3D int( (end_angle - limits[0]) * =
(180.0/(limits[1]-limits[0])))
		end =3D int( (start_angle - limits[0]) * =
(180.0/(limits[1]-limits[0])))
=09
	#Draw the arch
	theta =3D start
	radius =3D 0.85
	while (theta >=3D end):
		x_vect.append( radius * math.cos(theta * (pi/180)) )
		y_vect.append( radius * math.sin(theta * (pi/180)) )
		theta -=3D 1
	=09
	theta =3D end
	radius =3D 1.0
	while (theta <=3D start):
		x_vect.append( radius * math.cos(theta * (pi/180)) )
		y_vect.append( radius * math.sin(theta * (pi/180)) )
		theta +=3D 1
=09
	if( border ):
		#Close the loop
		x_vect.append(-0.85)
		y_vect.append(0.0)
	=09
		p =3D plot(x_vect, y_vect, 'b-')
		setp(p, color=3D'black')
		setp(p, linewidth=3D1.5)
	else:
		p =3D fill(x_vect, y_vect, colour)
		setp(p, linewidth=3D0.0)
		setp(p, alpha=3D0.4)
=09
def draw_needle(current_value, limits, graph_positive):
	x_vect =3D []
	y_vect =3D []
=09
	if current_value =3D=3D None:
		text(0.0, 0.4, "N/A", size=3D10, va=3D'bottom', ha=3D'center')
	else:
		text(0.0, 0.4, "%.2f" % current_value, size=3D10, va=3D'bottom', =
ha=3D'center')
	=09
		#Clamp the value to the limits
		if( current_value < limits[0] ):
			current_value =3D limits[0]
		if( current_value > limits[1] ):
			current_value =3D limits[1]
=09
		theta =3D 0
		length =3D 0.95
		if( graph_positive ):
			angle =3D 180.0 - (current_value - limits[0]) =
*(180.0/abs(limits[1]-limits[0]))
		else:
			angle =3D (current_value - limits[0]) =
*(180.0/abs(limits[1]-limits[0]))
		=09
		while (theta <=3D 270):
			x_vect.append( length * math.cos((theta + angle) * (pi/180)) )
			y_vect.append( length * math.sin((theta + angle) * (pi/180)) )
			length =3D 0.05
			theta +=3D 90
	=09
		p =3D fill(x_vect, y_vect, 'b')
		setp(p, alpha=3D0.4)
	=09
=09
=09
def draw_ticks(limits, graph_positive):
	if( graph_positive ):
		angle =3D 180.0
	else:
		angle =3D 0.0
	i =3D 0
	j =3D limits[0]
	=09
	iterating =3D True
	while( i*limits[3] + limits[0] <=3D limits[1] ):
		x_vect =3D []
		y_vect =3D []
		if( i % (limits[2]/limits[3]) =3D=3D 0 ):
			x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
			y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
			if( type(limits[2]) is types.FloatType ):
				text( x_pos, y_pos, "%.2f" % j, size=3D10, va=3D'center', =
ha=3D'center', rotation=3D(angle - 90))=20
			else:
				text( x_pos, y_pos, "%d" % int(j), size=3D10, va=3D'center', =
ha=3D'center', rotation=3D(angle - 90))=20
			tick_length =3D 0.15
			j +=3D limits[2]
		else:
			tick_length =3D 0.05
		i +=3D 1
		x_vect.append( 1.0 * math.cos( angle * (pi/180.0)))
		x_vect.append( (1.0 - tick_length) * math.cos( angle * (pi/180.0)))
		y_vect.append( 1.0 * math.sin( angle * (pi/180.0)))
		y_vect.append( (1.0 - tick_length) * math.sin( angle * (pi/180.0)))
		p =3D plot(x_vect, y_vect, 'b-')
		setp(p, linewidth=3D1)
		setp(p, alpha=3D0.4)
		setp(p, color=3D"black")
		if( graph_positive ):
			angle -=3D limits[3] * (180.0/abs(limits[1]-limits[0]))
		else:
			angle +=3D limits[3] * (180.0/abs(limits[1]-limits[0]))
	if( i % (limits[2]/limits[3]) =3D=3D 0 ):
		x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
		y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
		if( type(limits[2]) is types.FloatType ):
			text( x_pos, y_pos, "%.2f" % j, size=3D10, va=3D'center', =
ha=3D'center', rotation=3D(angle - 90))=20
		else:
			text( x_pos, y_pos, "%d" % int(j), size=3D10, va=3D'center', =
ha=3D'center', rotation=3D(angle - 90)) =09
		=09
	=09
def draw_bounding_box(graph_width, graph_height):
	x_vect =3D []
	y_vect =3D []
=09
	x_vect.append( (graph_width/2) )
	x_vect.append( (graph_width/2) )
	x_vect.append(-(graph_width/2) )
	x_vect.append(-(graph_width/2) )
	x_vect.append( (graph_width/2) )
=09
	y_vect.append(-0.1)
	y_vect.append(graph_height)
	y_vect.append(graph_height)
	y_vect.append(-0.1)
	y_vect.append(-0.1)
=09
	p =3D plot(x_vect, y_vect, 'r-')
	setp(p, linewidth=3D0)
=09
=09
def draw_widget( current_value, limits, zone_colour, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 1.6
	graph_width =3D 2.4
	fig_height =3D graph_height
	fig_width =3D graph_width
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.0/fig_width), (0.2/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( -0.1, graph_width+0.1 ), ylim=3D( -0.4, =
graph_height+0.1 ), xticks=3D[], yticks=3D[])
	axis('off')
=09
	#Perform Checking
	if( limits[0] =3D=3D limits[1] ):
		raise 'identical_limits_exception', limits
	if( limits[1] > limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D limits[0]
		limits[0] =3D limits[1]
		limits[1] =3D temp
	=09
	if not( ((limits[2]/limits[3]) % 1.0) * limits[3] =3D=3D 0 ):	#There =
must be an integer number of minor ticks for each major tick
		raise 'bad_tick_spacing_exception'
	if( limits[2] <=3D 0 or limits[3] <=3D 0 or limits[2] < limits[3] or =
limits[3] > abs(limits[1]-limits[0]) ):
		raise 'bad_limits_exception', limits
	for zone in zone_colour:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < limits[0] or zone[0] > limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < limits[0] ):
			zone[0] =3D limits[0]
		if( zone[1] > limits[1] ):
			zone[1] =3D limits[1]
=09
	#Draw the arch
	for zone in zone_colour:
		draw_arch(limits, zone[0], zone[1], zone[2], False, graph_positive)
	draw_arch(limits, limits[0], limits[1], 'black', True, graph_positive)
	draw_ticks(limits, graph_positive)
	draw_needle(current_value, limits, graph_positive)
	draw_bounding_box(graph_width, graph_height)
	text(0.0, 0.2, attribute_name, size=3D10, va=3D'bottom', ha=3D'center')
=09
	#The black dot.
	p =3D plot([0.0],[0.0],'.')
	setp(p, color=3D'#000000')
=09
	savefig( filename, dpi=3Dresolution)
#draw_widget( 21.0, [4.0,20.0,4,1.0], =
[[4.0,10.0,'r'],[10.0,14.0,'y'],[14.0,20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( -10.0, [-20.0,-4,4.0,1.0], =
[[-4.0,-10.0,'r'],[-10.0,-14.0,'y'],[-14.0,-20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( -10.5, [20.0,-20.0,4.0,1.0], =
[[-20.0,-15.0,'r'],[-10.0,-15.0,'y'],[-10.0,20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( None, [4.0,20.0,4,1.0], =
[[4.0,10.0,'r'],[10.0,14.0,'y'],[14.0,20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( 1.2, [4.0,10.0,2,0.5], =
[[4.0,6.0,'r'],[6.0,8.0,'y'],[8.0,10.0,'g']], "Rx MOS (24h)", =
"gauge_1.png", 100)
draw_widget( -4.0, [-1.0,1.0,1,0.1], =
[[-1.0,0.0,'r'],[0.0,0.5,'y'],[0.5,1.0,'g']], "Rx MOS (24h)", =
"gauge_2.png", 100)
#show()
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
linear horizontal gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a horizontal linear meter. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#
#	draw_widget( 	current_value,=20
#			limits[ lower, upper, major ticks, minor ticks],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "v_meter_0.png",
#			resolution in dpi
#		 )
#
#
from pylab import *
import types
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
#import math
def draw_bar( graph_positive, graph_height, start, end, colour):
	x_vect =3D []
	y_vect =3D []
=09
	y_vect.append( 0.0 )
	y_vect.append( 0.0 )
	y_vect.append( graph_height )
	y_vect.append( graph_height )
	if( graph_positive ):
		x_vect.append( start )
		x_vect.append( end )
		x_vect.append( end )
		x_vect.append( start )
	else:
		x_vect.append( -start )
		x_vect.append( -end )
		x_vect.append( -end )
		x_vect.append( -start )
=09
	p =3D fill(x_vect, y_vect, colour)
	setp(p, linewidth=3D0.0)
	setp(p, alpha=3D0.4)
def draw_needle( graph_positive, true_value, true_limits, graph_height, =
graph_width, graph_center):
	x_vect =3D []
	y_vect =3D []
=09
	if( true_value =3D=3D None ):
		text( graph_center, (graph_height + 0.05), "N/A", size=3D10, =
va=3D'bottom', ha=3D'center')
	else:
		#Clamp the value to the limits
		value =3D true_value * graph_width / (true_limits[1]-true_limits[0])
		if( true_value < true_limits[0] ):
			value =3D true_limits[0] * graph_width / =
(true_limits[1]-true_limits[0])
		if( true_value > true_limits[1] ):
			value =3D true_limits[1] * graph_width / =
(true_limits[1]-true_limits[0])
	=09
		text( value, (graph_height + 0.05), "%.2f" % true_value, size=3D10, =
va=3D'bottom', ha=3D'center')=20
	=09
		if( not graph_positive ):
			value =3D -value
		=09
		y_vect.append( graph_height/2 )
		y_vect.append( graph_height )
		y_vect.append( graph_height )
		x_vect.append( value + 0.00 )
		x_vect.append( value - 0.1 )
		x_vect.append( value + 0.1 )
	=09
		fill(x_vect, y_vect, 'black')
=09
=09
=09
def draw_ticks( graph_positive, scaled_limits, true_limits, =
graph_height):
	if( graph_positive ):
		offset =3D scaled_limits[0]
	else:
		offset =3D scaled_limits[1]
	i =3D 0
	j =3D true_limits[0]
	while( i*scaled_limits[3] + scaled_limits[0] <=3D scaled_limits[1] ):
		x_vect =3D []
		y_vect =3D []
		if( i % (scaled_limits[2]/scaled_limits[3]) =3D=3D 0):
			tick_length =3D graph_height
			if( type(true_limits[2]) is types.FloatType ):
				text( offset, -0.05, "%.2f" % j, size=3D10, va=3D'top', =
ha=3D'center')=20
			else:
				text( offset, -0.05, "%d" % int(j), size=3D10, va=3D'top', =
ha=3D'center')=20
			j +=3D true_limits[2]
		else:
			tick_length =3D graph_height * 0.2
		y_vect.append( 0.0 )
		y_vect.append( tick_length )
		x_vect.append( offset )
		x_vect.append( offset )
		p =3D plot(x_vect, y_vect, 'b-')
		setp(p, linewidth=3D1)
		setp(p, color=3D'black')
		setp(p, alpha=3D0.2)
		i +=3D 1
		if( graph_positive ):
			offset +=3D scaled_limits[3]
		else:
			offset -=3D scaled_limits[3]
=09
	if( i % (scaled_limits[2]/scaled_limits[3]) =3D=3D 0):
		if( type(true_limits[2]) is types.FloatType ):
			text( offset, -0.05, "%.2f" % j, size=3D10, va=3D'top', =
ha=3D'center')=20
		else:
			text( offset, -0.05, "%d" % int(j), size=3D10, va=3D'top', =
ha=3D'center')=20
=09
def draw_widget( true_value, true_limits, true_zones, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 0.3
	graph_width =3D 2.0
	fig_height =3D graph_height + 1.0
	fig_width =3D graph_width + 0.4
=09
	#Perform Checking
	if( true_limits[0] =3D=3D true_limits[1] ):
		raise 'identical_limits_exception', true_limits
	if( true_limits[1] > true_limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D true_limits[0]
		true_limits[0] =3D true_limits[1]
		true_limits[1] =3D temp
	=09
	if not( ((limits[2]/limits[3]) % 1.0) * limits[3] =3D=3D 0 ):	#There =
must be an integer number of minor ticks for each major tick
		raise 'bad_tick_spacing_exception'
	if( true_limits[2] <=3D 0 or true_limits[3] <=3D 0 or true_limits[2] < =
true_limits[3] or true_limits[3] > abs(true_limits[1]-true_limits[0]) ):
		raise 'bad_limits_exception', true_limits
	for zone in true_zones:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < true_limits[0] or zone[0] > true_limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < true_limits[0] ):
			zone[0] =3D true_limits[0]
		if( zone[1] > true_limits[1] ):
			zone[1] =3D true_limits[1]
=09
	#Adjust the scaling
	scaled_limits =3D []
	for limit in true_limits:
		scaled_limits.append( limit * graph_width / =
(true_limits[1]-true_limits[0]))
=09
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.2/fig_width), (0.5/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( 0, graph_width ), ylim=3D( 0, graph_height ), =
xticks=3D[], yticks=3D[])
=09
=09
	#Draw the meter
	graph_center =3D ((scaled_limits[1]+scaled_limits[0])/2)
	for zone in true_zones:
		draw_bar(graph_positive, graph_height, (zone[0] * graph_width / =
(true_limits[1]-true_limits[0])), (zone[1] * graph_width / =
(true_limits[1]-true_limits[0])), zone[2])
	draw_ticks( graph_positive, scaled_limits, true_limits, graph_height )
	draw_needle( graph_positive, true_value, true_limits, graph_height, =
graph_width, graph_center )
	text( graph_center, graph_height+0.25, attribute_name, size=3D12, =
va=3D'bottom', ha=3D'center')
=09
	setp(gca(), xlim=3D( scaled_limits[0], scaled_limits[1] ))
=09
	savefig( filename, dpi=3Dresolution)
#draw_widget( None, [4.0,20.0,4,0.1], =
[[4.0,10.0,'r'],[10.0,14.0,'y'],[14.0,20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( 1.2, [4.0,10.0,2,0.5], =
[[4.0,6.0,'r'],[6.0,8.0,'y'],[8.0,10.0,'g']], "Rx MOS (24h)", =
"gauge_1.png", 100)
#draw_widget( -4.0, [-10.0,10.0,5.0,1.0], =
[[-10.0,0.0,'r'],[0.0,5.0,'y'],[5.0,10.0,'g']], "Rx MOS (24h)", =
"gauge_2.png", 100)
#draw_widget( -4.0, [-20.0,-4.0,4.0,1.0], =
[[-4.0,-10.0,'r'],[-10.0,-14.0,'y'],[-14.0,-20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( -11.36, [-40.0,-10.0,5.0,2.5], =
[[-40.0,-35.0,'y'],[-35.0,-15.0,'g'],[-15.0,10.0,'y']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#show()
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
linear vertical gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a vertical linear meter. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#
#	draw_widget( 	current_value,=20
#			limits[ lower, upper, major ticks, minor ticks],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "v_meter_0.png",
#			resolution in dpi
#		 )
#
#
from pylab import *
import types
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
#import math
def draw_bar( graph_positive, graph_width, start, end, colour):
	x_vect =3D []
	y_vect =3D []
=09
	if not ( graph_positive ):
		start =3D -start
		end =3D -end
	=09
	=09
	=09
	=09
	x_vect.append( 0.0 )
	x_vect.append( 0.0 )
	x_vect.append( graph_width )
	x_vect.append( graph_width )
	y_vect.append( start )
	y_vect.append( end )
	y_vect.append( end )
	y_vect.append( start )
=09
	p =3D fill(x_vect, y_vect, colour)
	setp(p, linewidth=3D0.0)
	setp(p, alpha=3D0.4)
def draw_needle( graph_positive, true_value, true_limits, graph_width, =
graph_height, graph_center ):
	x_vect =3D []
	y_vect =3D []
=09
	if( true_value =3D=3D None ):
		text( (graph_width + 0.05), graph_center, "N/A", size=3D10, =
va=3D'center', ha=3D'left')=20
	else:
		#Clamp the value to the limits
		value =3D true_value * graph_height / (true_limits[1]-true_limits[0])
		if( true_value < true_limits[0] ):
			value =3D true_limits[0] * graph_height / =
(true_limits[1]-true_limits[0])
		if( true_value > true_limits[1] ):
			value =3D true_limits[1] * graph_height / =
(true_limits[1]-true_limits[0])
	=09
		text( (graph_width + 0.05), value, "%.2f" % true_value, size=3D10, =
va=3D'center', ha=3D'left')=20
		if( not graph_positive ):
			value =3D -value
=09
			=09
		x_vect.append( graph_width/2 )
		x_vect.append( graph_width )
		x_vect.append( graph_width )
		y_vect.append( value + 0.00 )
		y_vect.append( value - 0.1 )
		y_vect.append( value + 0.1 )
	=09
		fill(x_vect, y_vect, 'black')
=09
=09
def draw_ticks( graph_positive, scaled_limits, true_limits, =
graph_width):
	if( graph_positive ):
		offset =3D scaled_limits[0]
	else:
		offset =3D scaled_limits[1]
	i =3D 0
	j =3D true_limits[0]
	while( i*scaled_limits[3] + scaled_limits[0] <=3D scaled_limits[1] ):
		x_vect =3D []
		y_vect =3D []
		if( i % (scaled_limits[2]/scaled_limits[3]) =3D=3D 0):
			tick_length =3D graph_width
			if( type(true_limits[2]) is types.FloatType ):
				text(-0.05, offset, "%.2f" % j, size=3D10, va=3D'center', =
ha=3D'right')
			else:=20
				text(-0.05, offset, "%d" % int(j), size=3D10, va=3D'center', =
ha=3D'right')
			j +=3D true_limits[2]
		else:
			tick_length =3D graph_width * 0.2
		x_vect.append( 0.0 )
		x_vect.append( tick_length )
		y_vect.append( offset )
		y_vect.append( offset )
		p =3D plot(x_vect, y_vect, 'b-')
		setp(p, linewidth=3D1)
		setp(p, color=3D'black')
		setp(p, alpha=3D0.2)
		i +=3D 1
		if( graph_positive ):
			offset +=3D scaled_limits[3]
		else:
			offset -=3D scaled_limits[3]
		=09
	if( i % (scaled_limits[2]/scaled_limits[3]) =3D=3D 0):
		if( type(true_limits[2]) is types.FloatType ):
			text(-0.05, offset, "%.2f" % j, size=3D10, va=3D'center', =
ha=3D'right')
		else:=20
			text(-0.05, offset, "%d" % int(j), size=3D10, va=3D'center', =
ha=3D'right')
=09
def draw_widget( true_value, true_limits, true_zones, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 2.0
	graph_width =3D 0.3
	fig_height =3D graph_height + 0.4
	fig_width =3D graph_width + 1.0
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.5/fig_width), (0.3/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( 0, graph_width ), ylim=3D( 0, graph_height ), =
xticks=3D[], yticks=3D[])
=09
	#Perform Checking
	if( true_limits[0] =3D=3D true_limits[1] ):
		raise 'identical_limits_exception', true_limits
	if( true_limits[1] > true_limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D true_limits[0]
		true_limits[0] =3D true_limits[1]
		true_limits[1] =3D temp
	=09
	if not( ((limits[2]/limits[3]) % 1.0) * limits[3] =3D=3D 0 ):	#There =
must be an integer number of minor ticks for each major tick
		raise 'bad_tick_spacing_exception'
	if( true_limits[2] <=3D 0 or true_limits[3] <=3D 0 or true_limits[2] < =
true_limits[3] or true_limits[3] > abs(true_limits[1]-true_limits[0]) ):
		raise 'bad_limits_exception', true_limits
	for zone in true_zones:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < true_limits[0] or zone[0] > true_limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < true_limits[0] ):
			zone[0] =3D true_limits[0]
		if( zone[1] > true_limits[1] ):
			zone[1] =3D true_limits[1]
=09
	#Adjust the scaling
	scaled_limits =3D []
	for limit in true_limits:
		scaled_limits.append( limit * graph_height / =
(true_limits[1]-true_limits[0]))
=09
=09
=09
	#Draw the meter
	graph_center =3D ((true_limits[1]+true_limits[0])/2* graph_height / =
(true_limits[1]-true_limits[0]))
	for zone in true_zones:
		draw_bar(graph_positive, graph_width, (zone[0] * graph_height / =
(true_limits[1]-true_limits[0])), (zone[1] * graph_height / =
(true_limits[1]-true_limits[0])), zone[2])
	draw_ticks( graph_positive, scaled_limits, true_limits, graph_width)
	draw_needle( graph_positive, true_value, true_limits, graph_width, =
graph_height, graph_center )
	text((graph_width/2), (scaled_limits[0]-0.1), attribute_name, =
size=3D12, va=3D'top', ha=3D'center')
=09
	setp(gca(), ylim=3D( scaled_limits[0], scaled_limits[1] ))
=09
	savefig( filename, dpi=3Dresolution)
#draw_widget( None, [4.0,20.0,4,1.0], =
[[4.0,10.0,'r'],[10.0,14.0,'y'],[14.0,20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( -10.0, [-20.0,-4.0,4.0,1.0], =
[[-4.0,-10.0,'r'],[-10.0,-14.0,'y'],[-14.0,-20.0,'g']], "Rx MOS (24h)", =
"gauge_0.png", 100)
#draw_widget( -4.5, [20.0,-20.0,4.0,1.0], =
[[12.5-20.0,-15.0,'r'],[-10.0,-15.0,'y'],[-10.0,20.0,'g']], "Rx MOS =
(24h)", "gauge_0.png", 100)
#show()
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
logarithmic rotary gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a log semi-circular gauge. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#	draw_widget( 	current_value,=20
#			limits[ left, right],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "gauge_0.png",
#			resolution in dpi
#		 )
#
#	NOTE: The limits you specify must be of this form
#		for any value of 'n': 1.0*10^n
#
from pylab import *
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
import math
import matplotlib
matplotlib.use('Agg') # force the antigrain backend
from matplotlib.backends.backend_agg import FigureCanvasAgg
def draw_arch(limits, start, end, colour, border, graph_positive):
	x_vect =3D []
	y_vect =3D []
	if( graph_positive ):
		start_value =3D int(180 - (start - limits[0]) * =
(180.0/(limits[1]-limits[0])))
		end_value =3D int(180 - (end - limits[0]) * =
(180.0/(limits[1]-limits[0])))
	else:
		start_value =3D int( (end - limits[0]) * =
(180.0/(limits[1]-limits[0])))
		end_value =3D int( (start - limits[0]) * =
(180.0/(limits[1]-limits[0])))
=09
	=09
	if( graph_positive ):
		start_value =3D (math.log10(start) - math.log10(limits[1])) * 180.00 / =
-(math.log10(limits[1]) - math.log10(limits[0]))
		end_value =3D (math.log10(end) - math.log10(limits[1])) * 180.00 / =
-(math.log10(limits[1]) - math.log10(limits[0]))
	else:
		start_value =3D (math.log10(end) - math.log10(limits[0])) * 180.00 / =
+(math.log10(limits[1]) - math.log10(limits[0]))
		end_value =3D (math.log10(start) - math.log10(limits[0])) * 180.00 =
/ +(math.log10(limits[1]) - math.log10(limits[0]))
=09
	#Draw the arch
	theta =3D start_value
	radius =3D 0.85
	while (theta >=3D end_value):
		x_vect.append( radius * math.cos(theta * (pi/180)) )
		y_vect.append( radius * math.sin(theta * (pi/180)) )
		theta -=3D 1
	=09
	theta =3D end_value
	radius =3D 1.0
	while (theta <=3D start_value):
		x_vect.append( radius * math.cos(theta * (pi/180)) )
		y_vect.append( radius * math.sin(theta * (pi/180)) )
		theta +=3D 1
=09
	if( border ):
		#Close the loop
		x_vect.append(-0.85)
		y_vect.append(0.0)
	=09
		p =3D plot(x_vect, y_vect, 'b-')
		setp(p, color=3D'black')
		setp(p, linewidth=3D1.5)
	else:
		p =3D fill(x_vect, y_vect, colour)
		setp(p, linewidth=3D0.0)
		setp(p, alpha=3D0.4)
=09
def draw_needle(current_value, limits, graph_positive):
	x_vect =3D []
	y_vect =3D []
=09
	if current_value =3D=3D None:
		text(0.0, 0.0, "N/A", size=3D10, va=3D'center', ha=3D'center')
	else:
		text(0.0, 0.0, "%.2f" % current_value, size=3D10, va=3D'center', =
ha=3D'center')
	=09
		#Clamp the value to the limits
		if( current_value < limits[0] ):
			current_value =3D limits[0]
		if( current_value > limits[1] ):
			current_value =3D limits[1]
		=09
	=09
		theta =3D 0
		length =3D 0.95
		#if( graph_positive ):=09
		#	angle =3D 180 - (current_value - limits[0]) =
*(180.0/(limits[1]-limits[0]))
		#else:
		#	angle =3D (current_value - limits[0]) =
*(180.0/(limits[1]-limits[0]))
	=09
		if( graph_positive ):
			angle =3D (math.log10(current_value) - math.log10(limits[1])) * =
180.00 / -(math.log10(limits[1]) - math.log10(limits[0]))
		else:
			angle =3D (math.log10(current_value) - math.log10(limits[0])) * =
180.00 / +(math.log10(limits[1]) - math.log10(limits[0]))
		=09
		#angle =3D 180.0-180.0*(current_value/(limits[1] - limits[0]))=20
		#while (theta <=3D 270):
=09
		x_vect.append( length * math.cos((theta + angle) * (pi/180)) )
		y_vect.append( length * math.sin((theta + angle) * (pi/180)) )
		x_vect.append( 0.2 * length * math.cos((theta + angle + 10.0) * =
(pi/180)) )
		y_vect.append( 0.2 * length * math.sin((theta + angle + 10.0) * =
(pi/180)) )
		x_vect.append( 0.15 * length * math.cos((theta + angle ) * (pi/180)) )
		y_vect.append( 0.15 * length * math.sin((theta + angle ) * (pi/180)) )
		x_vect.append( 0.2 * length * math.cos((theta + angle - 10.0) * =
(pi/180)) )
		y_vect.append( 0.2 * length * math.sin((theta + angle - 10.0) * =
(pi/180)) )
	=09
		#	length =3D 0.05
		#	theta +=3D 90
	=09
		p =3D fill(x_vect, y_vect, 'b')
		setp(p, alpha=3D0.4)
	=09
=09
=09
def draw_ticks(limits, graph_positive):
	if( graph_positive ):
		angle =3D 180.0
	else:
		angle =3D 0.0
=09
	i =3D limits[0]
	step =3D limits[0]
	x_vect =3D []
	y_vect =3D []
	while( i < limits[1] ):
		while( i < (step * 10) ):
			x_vect =3D []
			y_vect =3D []
			value =3D math.log10(i)
			if( graph_positive ):
				angle =3D (value - math.log10(limits[1])) * 180.00 / =
-(math.log10(limits[1]) - math.log10(limits[0]))
			else:
				angle =3D (value - math.log10(limits[0])) * 180.00 / =
+(math.log10(limits[1]) - math.log10(limits[0]))
			x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
			y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
			mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
			if( mantissa =3D=3D 10 or mantissa =3D=3D 1 ):
				print i, mantissa
				text( x_pos, y_pos, "%g" % i, size=3D10, va=3D'center', =
ha=3D'center', rotation=3D(angle - 90))=20
				tick_length =3D 0.15
			else:
				tick_length =3D 0.05
			x_vect.append( 1.0 * math.cos( angle * (pi/180.0)))
			x_vect.append( (1.0 - tick_length) * math.cos( angle * (pi/180.0)))
			y_vect.append( 1.0 * math.sin( angle * (pi/180.0)))
			y_vect.append( (1.0 - tick_length) * math.sin( angle * (pi/180.0)))
			p =3D plot(x_vect, y_vect, 'b-')
			setp(p, linewidth=3D1)
			setp(p, alpha=3D0.4)
			setp(p, color=3D"black")
		=09
			i +=3D step
		i =3D step * 10
		step =3D step * 10
	i =3D limits[1]
	value =3D math.log10(i)
	if( graph_positive ):
		angle =3D (value - math.log10(limits[1])) * 180.00 / =
-(math.log10(limits[1]) - math.log10(limits[0]))
	else:
		angle =3D (value - math.log10(limits[0])) * 180.00 / =
+(math.log10(limits[1]) - math.log10(limits[0]))
	x_pos =3D 1.1 * math.cos( angle * (pi/180.0))
	y_pos =3D 1.1 * math.sin( angle * (pi/180.0))
	mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
	if( mantissa =3D=3D 10 ):
		text( x_pos, y_pos, "%g" % i, size=3D10, va=3D'center', ha=3D'center', =
rotation=3D(angle - 90))=20
=09
=09
=09
def draw_bounding_box(graph_width, graph_height):
	x_vect =3D []
	y_vect =3D []
=09
	x_vect.append( (graph_width/2) )
	x_vect.append( (graph_width/2) )
	x_vect.append(-(graph_width/2) )
	x_vect.append(-(graph_width/2) )
	x_vect.append( (graph_width/2) )
=09
	y_vect.append(-0.1)
	y_vect.append(graph_height)
	y_vect.append(graph_height)
	y_vect.append(-0.1)
	y_vect.append(-0.1)
=09
	p =3D plot(x_vect, y_vect, 'r-')
	setp(p, linewidth=3D0)
=09
=09
def draw_widget( current_value, limits, zone_colour, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 1.4
	graph_width =3D 2.4
	fig_height =3D graph_height
	fig_width =3D graph_width
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.0/fig_width), (0.0/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( -0.1, graph_width+0.1 ), ylim=3D( -0.2, =
graph_height+0.1 ), xticks=3D[], yticks=3D[])
	axis('off')
=09
	#Perform Checking
	if( limits[0] =3D=3D limits[1] ):
		raise 'identical_limits_exception', limits
	if( limits[1] > limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D limits[0]
		limits[0] =3D limits[1]
		limits[1] =3D temp
	=09
	if not( math.log10(limits[0]) % 1.0 =3D=3D 0 and math.log10(limits[1]) =
% 1.0 =3D=3D 0 ):
		raise 'bad_limits_exception'
	=09
	for zone in zone_colour:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < limits[0] or zone[0] > limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < limits[0] ):
			zone[0] =3D limits[0]
		if( zone[1] > limits[1] ):
			zone[1] =3D limits[1]
=09
	#Draw the arch
	for zone in zone_colour:
		draw_arch(limits, zone[0], zone[1], zone[2], False, graph_positive)
	draw_arch(limits, limits[0], limits[1], 'black', True, graph_positive)
	draw_ticks(limits, graph_positive)
	draw_needle(current_value, limits, graph_positive)
	draw_bounding_box(graph_width, graph_height)
	text(0.0, 0.3, attribute_name, size=3D10, va=3D'center', ha=3D'center')
=09
	savefig( filename, dpi=3Dresolution)
#draw_widget( 0.02, [0.0001,1.0], [[0.0001,0.01,'g'], =
[0.01,0.05,'y'],[0.05,1.0,'r']], "Sat. Clipping", "log_0.png", 100)
#draw_widget( 0.02, [10.0,0.001], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,10.0,'r']], "Sat. Clipping", "log_0.png", 100)
#draw_widget( 0.02, [10.0,0.001], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,8.0,'r']], "Sat. Clipping", "log_0.png", 100)
#draw_widget( 20.0, [1000.0,1.0], [[1.0,10.0,'g'], =
[10.0,100.0,'y'],[100.0,1000.0,'r']], "Sat. Clipping", "log_0.png", 100)
#show()
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
logarithmic horizontal gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a log horizontal gauge. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#	draw_widget( 	current_value,=20
#			limits[ left, right],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "gauge_0.png",
#			resolution in dpi
#		 )
#
#	NOTE: The limits you specify must be of this form
#		for any value of 'n': 1.0*10^n
#
from pylab import *
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
import math
import matplotlib
matplotlib.use('Agg') # force the antigrain backend
from matplotlib.backends.backend_agg import FigureCanvasAgg
def draw_arch(limits, start, end, colour, graph_width, graph_positive):
	x_vect =3D []
	y_vect =3D []
=09
	if( graph_positive ):
		start_value =3D math.log10(start)
		end_value =3D math.log10(end)
	else:
		start_value =3D - math.log10(start)
		end_value =3D - math.log10(end)
	=09
	y_vect.append( 0.0 )
	y_vect.append( 0.0 )
	y_vect.append( graph_width )
	y_vect.append( graph_width )
	x_vect.append( start_value )
	x_vect.append( end_value )
	x_vect.append( end_value )
	x_vect.append( start_value )
=09
	p =3D fill(x_vect, y_vect, colour)
	setp(p, linewidth=3D0.0)
	setp(p, alpha=3D0.4)
=09
def draw_needle(current_value, limits, graph_positive, graph_width, =
graph_center):
	x_vect =3D []
	y_vect =3D []
=09
	if current_value =3D=3D None:
		text( (graph_width + 0.1), graph_center, "N/A", size=3D10, =
va=3D'center', ha=3D'left')=20
	else:
		#Clamp the value to the limits
		if( current_value < limits[0] ):
			current_value =3D limits[0]
		if( current_value > limits[1] ):
			current_value =3D limits[1]
		if( graph_positive ):
			offset =3D math.log10(current_value)
		else:
			offset =3D -math.log10(current_value)
		text( offset, (graph_width + 0.1), "%g" % current_value, size=3D10, =
va=3D'center', ha=3D'left')
	=09
		y_vect.append( graph_width/2 )
		y_vect.append( graph_width )
		y_vect.append( graph_width )
		x_vect.append( offset + 0.00 )
		x_vect.append( offset - 0.1 )
		x_vect.append( offset + 0.1 )
	=09
		fill(x_vect, y_vect, 'black')
=09
=09
def draw_ticks(limits, graph_positive, graph_width):
	i =3D limits[0]
	step =3D limits[0]
	x_vect =3D []
	y_vect =3D []
	while( i < limits[1] ):
		while( i < (step * 10) ):
			x_vect =3D []
			y_vect =3D []
			value =3D math.log10(i)
			if( graph_positive ):
				offset =3D value
			else:
				offset =3D-value
			x_pos =3D 1.1 * math.cos( offset * (pi/180.0))
			y_pos =3D 1.1 * math.sin( offset * (pi/180.0))
			mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
			if( mantissa =3D=3D 10 or mantissa =3D=3D 1 ):
				text( offset, -0.05, "%g" % i, size=3D10, va=3D'top', ha=3D'center') =
				tick_length =3D graph_width
			else:
				tick_length =3D graph_width * 0.2
			y_vect.append( 0.0 )
			y_vect.append( tick_length )
			x_vect.append( offset )
			x_vect.append( offset )
			p =3D plot(x_vect, y_vect, 'b-')
			setp(p, linewidth=3D1)
			setp(p, color=3D'black')
			setp(p, alpha=3D0.2)
		=09
			i +=3D step
		i =3D step * 10
		step =3D step * 10
	i =3D limits[1]
	value =3D math.log10(i)
	if( graph_positive ):
		offset =3D value
	else:
		offset =3D-value
	mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
	if( mantissa =3D=3D 10 ):
		text( offset, -0.05, "%g" % i, size=3D10, va=3D'top', ha=3D'center')=20
=09
=09
def draw_widget( current_value, limits, zone_colour, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 0.3
	graph_width =3D 2.0
	fig_height =3D graph_height + 1.0
	fig_width =3D graph_width + 0.4
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.2/fig_width), (0.5/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( 0.0, graph_width ), ylim=3D( 0.0, graph_height ), =
xticks=3D[], yticks=3D[])
=09
	#Perform Checking
	if( limits[0] =3D=3D limits[1] ):
		raise 'identical_limits_exception', limits
	if( limits[1] > limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D limits[0]
		limits[0] =3D limits[1]
		limits[1] =3D temp
	=09
	if not( math.log10(limits[0]) % 1.0 =3D=3D 0 and math.log10(limits[1]) =
% 1.0 =3D=3D 0 ):
		raise 'bad_limits_exception'
	=09
	=09
	for zone in zone_colour:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < limits[0] or zone[0] > limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < limits[0] ):
			zone[0] =3D limits[0]
		if( zone[1] > limits[1] ):
			zone[1] =3D limits[1]
=09
	#Draw the arch
	graph_center =3D ((math.log10(limits[1])+math.log10(limits[0]))/2.0)
	for zone in zone_colour:
		draw_arch(limits, zone[0], zone[1], zone[2], graph_height, =
graph_positive)
	draw_ticks(limits, graph_positive, graph_height)
	draw_needle(current_value, limits, graph_positive, graph_height, =
graph_center)
	if( graph_positive ):
		setp(gca(), xlim=3D( math.log10(limits[0]), math.log10(limits[1]) ))
		text( graph_center, -0.3, attribute_name, size=3D12, va=3D'top', =
ha=3D'center')
	else:
		setp(gca(), xlim=3D( -math.log10(limits[1]), -math.log10(limits[0]) ))
		text( -graph_center, -0.3, attribute_name, size=3D12, va=3D'top', =
ha=3D'center')
=09
	savefig( filename, dpi=3Dresolution)
=09
#draw_widget( 0.02, [0.0001,1.0], [[0.0001,0.01,'g'], =
[0.01,0.05,'y'],[0.05,1.0,'r']], "Normal", "log_0.png", 100)
#draw_widget( 0.02, [1.0,0.0001], [[0.0001,0.01,'g'], =
[0.01,0.05,'y'],[0.05,1.0,'r']], "Backwards", "log_0.png", 100)
#draw_widget( 0.02, [0.001,10.0], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,10.0,'r']], "None", "log_0.png", 100)
#draw_widget( 0.20, [10.0,0.001], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,10.0,'r']], "Shmoo", "log_0.png", 100)
#draw_widget( 20.0, [1000.0,1.0], [[1.0,10.0,'g'], =
[10.0,100.0,'y'],[100.0,1000.0,'r']], "> 1.0", "log_0.png", 100)
#show()
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
logarithmic vertical gauge
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=
#!/usr/bin/env python
#
#	This program draws a log vertical gauge. You supply limits,
#	shaded regions, names and the current value, and invoke=20
#	it like this:
#	draw_widget( 	current_value,=20
#			limits[ left, right],
#			shaded zones [	[lower,upper,colour],
#					[lower,upper,colour],
#					...],=20
#			name "MOS",=20
#			filename "gauge_0.png",
#			resolution in dpi
#		 )
#
#	NOTE: The limits you specify must be of this form
#		for any value of 'n': 1.0*10^n
#
from pylab import *
#from matplotlib.patches import Patch, Rectangle, Circle, Polygon, =
Wedge, Shadow, bbox_artist
import math
import matplotlib
matplotlib.use('Agg') # force the antigrain backend
from matplotlib.backends.backend_agg import FigureCanvasAgg
def draw_arch(limits, start, end, colour, graph_width, graph_positive):
	x_vect =3D []
	y_vect =3D []
=09
	if( graph_positive ):
		start_value =3D math.log10(start)
		end_value =3D math.log10(end)
	else:
		start_value =3D - math.log10(start)
		end_value =3D - math.log10(end)
	=09
	x_vect.append( 0.0 )
	x_vect.append( 0.0 )
	x_vect.append( graph_width )
	x_vect.append( graph_width )
	y_vect.append( start_value )
	y_vect.append( end_value )
	y_vect.append( end_value )
	y_vect.append( start_value )
=09
	p =3D fill(x_vect, y_vect, colour)
	setp(p, linewidth=3D0.0)
	setp(p, alpha=3D0.4)
=09
def draw_needle(current_value, limits, graph_positive, graph_width, =
graph_center):
	x_vect =3D []
	y_vect =3D []
=09
	if current_value =3D=3D None:
		text( (graph_width + 0.05), graph_center, "N/A", size=3D10, =
va=3D'center', ha=3D'left')=20
	else:
		#Clamp the value to the limits
		if( current_value < limits[0] ):
			current_value =3D limits[0]
		if( current_value > limits[1] ):
			current_value =3D limits[1]
		if( graph_positive ):
			offset =3D math.log10(current_value)
		else:
			offset =3D -math.log10(current_value)
		text( (graph_width + 0.05), offset, "%g" % current_value, size=3D10, =
va=3D'center', ha=3D'left')
	=09
		x_vect.append( graph_width/2 )
		x_vect.append( graph_width )
		x_vect.append( graph_width )
		y_vect.append( offset + 0.00 )
		y_vect.append( offset - 0.1 )
		y_vect.append( offset + 0.1 )
	=09
		fill(x_vect, y_vect, 'black')
=09
=09
def draw_ticks(limits, graph_positive, graph_width):
	i =3D limits[0]
	step =3D limits[0]
	x_vect =3D []
	y_vect =3D []
	while( i < limits[1] ):
		while( i < (step * 10) ):
			x_vect =3D []
			y_vect =3D []
			value =3D math.log10(i)
			if( graph_positive ):
				offset =3D value
			else:
				offset =3D-value
			x_pos =3D 1.1 * math.cos( offset * (pi/180.0))
			y_pos =3D 1.1 * math.sin( offset * (pi/180.0))
			mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
			if( mantissa =3D=3D 10 or mantissa =3D=3D 1 ):
				text(-0.05, offset, "%g" % i, size=3D10, va=3D'center', =
ha=3D'right')=20
				tick_length =3D graph_width
			else:
				tick_length =3D graph_width * 0.2
			x_vect.append( 0.0 )
			x_vect.append( tick_length )
			y_vect.append( offset )
			y_vect.append( offset )
			p =3D plot(x_vect, y_vect, 'b-')
			setp(p, linewidth=3D1)
			setp(p, color=3D'black')
			setp(p, alpha=3D0.2)
		=09
			i +=3D step
		i =3D step * 10
		step =3D step * 10
	i =3D limits[1]
	value =3D math.log10(i)
	if( graph_positive ):
		offset =3D value
	else:
		offset =3D-value
	x_pos =3D 1.1 * math.cos( offset * (pi/180.0))
	y_pos =3D 1.1 * math.sin( offset * (pi/180.0))
	mantissa =3D int(i / math.pow(10, math.ceil(math.log10(i))-1))
	if( mantissa =3D=3D 10 ):
		text(-0.05, offset, "%g" % i, size=3D10, va=3D'center', ha=3D'right')=20
=09
=09
def draw_widget( current_value, limits, zone_colour, attribute_name, =
filename, resolution=3D72 ):
	graph_height =3D 2.0
	graph_width =3D 0.3
	fig_height =3D graph_height + 0.4
	fig_width =3D graph_width + 1.0
=09
	figure(figsize=3D(fig_width, fig_height ))
	a =3D axes([(0.5/fig_width), (0.3/fig_height), (graph_width/fig_width), =
(graph_height/fig_height)])
	setp(a, xlim=3D( 0.0, graph_width ), ylim=3D( 0.0, graph_height ), =
xticks=3D[], yticks=3D[])
=09
	#Perform Checking
	if( limits[0] =3D=3D limits[1] ):
		raise 'identical_limits_exception', limits
	if( limits[1] > limits[0] ):
		graph_positive =3D True
	else:	#Swap the limits around
		graph_positive =3D False
		temp =3D limits[0]
		limits[0] =3D limits[1]
		limits[1] =3D temp
	=09
	if not( math.log10(limits[0]) % 1.0 =3D=3D 0 and math.log10(limits[1]) =
% 1.0 =3D=3D 0 ):
		raise 'bad_limits_exception'
	=09
	=09
	for zone in zone_colour:
		if( zone[0] > zone[1] ):	#Swap the zones so zone[1] > zone[0]
			temp =3D zone[0]
			zone[0] =3D zone[1]
			zone[1] =3D temp
		if( zone[1] < limits[0] or zone[0] > limits[1] ):
			raise 'bad_zone_exception', zone
		if( zone[0] < limits[0] ):
			zone[0] =3D limits[0]
		if( zone[1] > limits[1] ):
			zone[1] =3D limits[1]
=09
	#Draw the arch
	graph_center =3D ((math.log10(limits[1])+math.log10(limits[0]))/2.0)
	for zone in zone_colour:
		draw_arch(limits, zone[0], zone[1], zone[2], graph_width, =
graph_positive)
	draw_ticks(limits, graph_positive, graph_width)
	draw_needle(current_value, limits, graph_positive, graph_width, =
graph_center)
	if( graph_positive ):
		setp(gca(), ylim=3D( math.log10(limits[0]), math.log10(limits[1]) ))
		text((graph_width/2), (math.log10(limits[0])-0.1), attribute_name, =
size=3D12, va=3D'top', ha=3D'center')
	else:
		setp(gca(), ylim=3D( -math.log10(limits[1]), -math.log10(limits[0]) ))
		text((graph_width/2), -(math.log10(limits[1])+0.1), attribute_name, =
size=3D12, va=3D'top', ha=3D'center')
=09
	savefig( filename, dpi=3Dresolution)
=09
#draw_widget( 0.02, [0.0001,1.0], [[0.0001,0.01,'g'], =
[0.01,0.05,'y'],[0.05,1.0,'r']], "Normal", "log_0.png", 100)
#draw_widget( 0.02, [1.0,0.0001], [[0.0001,0.01,'g'], =
[0.01,0.05,'y'],[0.05,1.0,'r']], "Backwards", "log_0.png", 100)
#draw_widget( 0.02, [0.001,10.0], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,10.0,'r']], "None", "log_0.png", 100)
#draw_widget( 0.20, [10.0,0.001], [[0.001,0.1,'g'], =
[0.1,0.5,'y'],[0.5,10.0,'r']], "Shmoo", "log_0.png", 100)
#draw_widget( 20.0, [1000.0,1.0], [[1.0,10.0,'g'], =
[10.0,100.0,'y'],[100.0,1000.0,'r']], "> 1.0", "log_0.png", 100)
#show()

Normally, this would have been a bugfix release, but I reorganized the
matplotlib configuration files so thought it best to tick the version
number. All of the configuration files and dirs (matplotlibrc,
tex.cache, ttffont.cache ) now reside in $HOME/.matplotlib (on windows
C:\Documents and Settings\youracct\.matplotlib). Please rename your
.matplotlibrc file to matplotlibrc and put it there.
Other changes are 
2005年07月07日 Added Eric's MA set_xdata Line2D fix - JDH
2005年07月06日 Made HOME/.matplotlib the new config dir where the
 matplotlibrc file, the ttf.cache, and the tex.cache live.
 The new default filenames in .matplotlib have no leading
 dot and are not hidden. Eg, the new names are matplotlibrc
 tex.cache ttffont.cache. This is how ipython does it so it
 must be right. If old files are found, a warning is issued
 and they are moved to the new location. Also fixed
 texmanager to put all files, including temp files in
 ~/.matplotlib/tex.cache, which allows you to usetex in
 non-writable dirs.
2005年07月05日 Fixed bug #1231611 in subplots adjust layout. The problem
 was that the text cacheing mechanism was not using the
 transformation affine in the key. - JDH
2005年07月05日 Fixed default backend import problem when using API (SF bug
 # 1209354 - see API_CHANGES for more info - JDH
2005年07月04日 backend_gtk.py: require PyGTK version 2.0.0 or higher - SC
2005年06月30日 setupext.py: added numarray_inc_dirs for building against
 numarray when not installed in standard location - ADS
2005年06月27日 backend_svg.py: write figure width, height as int, not float.
 Update to fix some of the pychecker warnings - SC
 
2005年06月23日 Updated examples/agg_test.py to demonstrate curved paths
 and fills - JDH
2005年06月21日 Moved some texmanager and backend_agg tex caching to class
 level rather than instance level - JDH
2005年06月20日 setupext.py: fix problem where _nc_backend_gdk is installed to the
 wrong directory - SC
2005年06月19日 Added 10.4 support for CocoaAgg. - CM
2005年06月18日 Move Figure.get_width_height() to FigureCanvasBase and return
 int instead of float. - SC
2005年06月18日 Applied Ted Drain's QtAgg patch: 1) Changed the toolbar to
 be a horizontal bar of push buttons instead of a QToolbar
 and updated the layout algorithms in the main window
 accordingly. This eliminates the ability to drag and drop
 the toolbar and detach it from the window. 2) Updated the
 resize algorithm in the main window to show the correct
 size for the plot widget as requested. This works almost
 correctly right now. It looks to me like the final size of
 the widget is off by the border of the main window but I
 haven't figured out a way to get that information yet. We
 could just add a small margin to the new size but that
 seems a little hacky. 3) Changed the x/y location label to
 be in the toolbar like the Tk backend instead of as a
 status line at the bottom of the widget. 4) Changed the
 toolbar pixmaps to use the ppm files instead of the png
 files. I noticed that the Tk backend buttons looked much
 nicer and it uses the ppm files so I switched them.
2005年06月17日 Modified the gtk backend to not queue mouse motion events.
 This allows for live updates when dragging a slider. - CM
2005年06月17日 Added starter CocoaAgg backend. Only works on OS 10.3 for
 now and requires PyObjC. (10.4 is high priority) - CM
2005年06月17日 Upgraded pyparsing and applied Paul McGuire's suggestions
 for speeding things up. This more than doubles the speed
 of mathtext in my simple tests. JDH
2005年06月16日 Applied David Cooke's subplot make_key patch
Downloads at http://matplotlib.sf.net
Enjoy!
JDH

That's good to know. I tried googling it, but I guess I should've also 
checked CVS as well. I'm sure it's better than my hack anyways -- just 
good to have my scripts working again. I tend to prefer the subplot(w, 
h, n) since most of my plotting is automated, and it's more of a pain to 
have to convert the parameters to a string first, etc.
A
Eric Firing wrote:
> Abe,
>
> That bug has been fixed in CVS; like you, I tripped over it in 0.82 
> and tracked it down--but someone else had already fixed it. A 
> workaround, if you don't want to install from CVS, is to use the old 
> subplot(211) form instead of subplot(2,1,1).
>
> Eric
>
> Abraham Schneider wrote:
>
>> Hi. I just installed the newest version of matplotlib (0.82), and 
>> discovered all my subplots were ending on top of each other. After 
>> going through my code and verifying everything looked okay, I tried a 
>> simple:
>>
>> subplot(2, 1, 1); plot(range(0, 10)); subplot(2, 2, 2); plot(range(0, 
>> 10))
>>
>> and still only got one subplot. I went to the matplotlib code, and 
>> after some prodding, discovered that all the keys for the _seen map 
>> were exactly the same. Going to the _make_key function revealed that 
>> my use of subplot (i.e. three seperate arguments), was not working. 
>> Here is a fix that seems to work for me:
>>
>> (int _make_key function):
>> if iterable(args[0]):
>> key = tuple(args[0]), tuple( fixitems(kwargs.items()))
>> ## NEW
>> elif len(args) > 1:
>> key = args, tuple( fixitems(kwargs.items()))
>> ## \NEW
>> else:
>> key = args[0], tuple(fixitems( kwargs.items()))
>>
>> Abe
>>
>>
>>
>> -------------------------------------------------------
>> This SF.Net email is sponsored by the 'Do More With Dual!' webinar 
>> happening
>> July 14 at 8am PDT/11am EDT. We invite you to explore the latest in dual
>> core and dual graphics technology at this free one hour event hosted 
>> by HP,
>> AMD, and NVIDIA. To register visit http://www.hp.com/go/dualwebinar
>> _______________________________________________
>> Matplotlib-devel mailing list
>> Mat...@li...
>> https://lists.sourceforge.net/lists/listinfo/matplotlib-devel
>
>
>
>
> -------------------------------------------------------
> This SF.Net email is sponsored by the 'Do More With Dual!' webinar 
> happening
> July 14 at 8am PDT/11am EDT. We invite you to explore the latest in dual
> core and dual graphics technology at this free one hour event hosted 
> by HP,
> AMD, and NVIDIA. To register visit http://www.hp.com/go/dualwebinar
> _______________________________________________
> Matplotlib-devel mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-devel