def show_contour_minmaxstep(self):
showlay = self.get_layers()
lay = []
for i in range( len(showlay) ):
if showlay[i]: lay.append( i )
min,max,step = self.get_minmaxstep()
print arange(min,max,step)
showContours( lay, arange(min,max,step) )
def __do_layout(self):
# begin wxGlade: pwxChartParms.__do_layout
sizer_1 = wx.BoxSizer(wx.VERTICAL)
sizer_2 = wx.BoxSizer(wx.VERTICAL)
sizer_6 = wx.StaticBoxSizer(self.sizer_6_staticbox, wx.HORIZONTAL)
sizer_5 = wx.StaticBoxSizer(self.sizer_5_staticbox, wx.HORIZONTAL)
sizer_4 = wx.StaticBoxSizer(self.sizer_4_staticbox, wx.HORIZONTAL)
sizer_3 = wx.StaticBoxSizer(self.sizer_3_staticbox, wx.HORIZONTAL)
sizer_3.Add(self.label_1, 0,
wx.ALL | wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 1)
sizer_3.Add(self.label_ctrl_trace, 1,
wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 0)
sizer_2.Add(sizer_3, 0, wx.EXPAND, 0)
sizer_4.Add(self.button_trace_color, 1, wx.EXPAND | wx.ADJUST_MINSIZE,
0)
#sizer_4.Add(self.spin_ctrl_1, 1, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.ADJUST_MINSIZE, 0)
sizer_4.Add(
self.slider_ctrl_linewd, 1,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 0)
sizer_4.Add(self.combo_box_line_type, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 0)
sizer_2.Add(sizer_4, 0, wx.EXPAND, 0)
sizer_5.Add(self.button_marker_color, 1, wx.EXPAND | wx.ADJUST_MINSIZE,
0)
#sizer_5.Add(self.spin_ctrl_marker, 1, wx.ALIGN_RIGHT|wx.ALIGN_CENTER_VERTICAL|wx.ADJUST_MINSIZE, 0)
sizer_5.Add(
self.slider_ctrl_marker, 1,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 0)
sizer_5.Add(self.combo_box_marker_type, 0,
wx.ALIGN_CENTER_VERTICAL | wx.ADJUST_MINSIZE, 0)
sizer_2.Add(sizer_5, 0, wx.EXPAND, 0)
#sizer_2.Add(self.text_ctrl_1, 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
#self.sizer = wx.BoxSizer(wx.VERTICAL)
sizer_2.Add(self.m_canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
sizer_6.Add(self.button_3, 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
sizer_6.Add(self.button_4, 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
sizer_6.Add(self.button_5, 1, wx.EXPAND | wx.ADJUST_MINSIZE, 0)
sizer_2.Add(sizer_6, 0, wx.EXPAND, 0)
sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
self.SetAutoLayout(True)
self.SetSizer(sizer_1)
sizer_1.Fit(self)
sizer_1.SetSizeHints(self)
self.Layout()
# end wxGlade
self.m_firstAxes = None
self.x = arange(10) * 1.0
self.y = arange(10) * 1.0
self.label = ''
self.lineColor = 'b'
self.lineStyle = '-'
self.lineWidth = 1
self.markerType = ''
self.markerColor = 'r'
self.markerSize = 0
self.master = None
self.linenumber = 0
def gen_colors(self, count):
cmap = matplotlib.cm.get_cmap(self.colormap)
if count == 1:
return cmap([0.5])
if count < 5:
return cmap(arange(5) / float(4))[:count]
return cmap(arange(count) / float(count - 1))
def gen_colors(self, count):
cmap = matplotlib.cm.get_cmap(self.colormap)
if count == 1:
return cmap([0.5])
if count < 5:
return cmap(arange(5) / float(4))[:count]
return cmap(arange(count) / float(count - 1))
def init_plot_data(self):
# jdh you can add a subplot directly from the fig rather than
# the fig manager
a = self.fig.add_subplot(111)
self.x = numerix.arange(120.0)*2*numerix.pi/120.0
self.x.resize((100,120))
self.y = numerix.arange(100.0)*2*numerix.pi/100.0
self.y.resize((120,100))
self.y = numerix.transpose(self.y)
z = numerix.sin(self.x) + numerix.cos(self.y)
self.im = a.imshow( z, cmap=cm.jet)#, interpolation='nearest')
def init_plot_data(self):
# jdh you can add a subplot directly from the fig rather than
# the fig manager
a = self.fig.add_subplot(111)
self.x = numerix.arange(120.0) * 2 * numerix.pi / 120.0
self.x.resize((100, 120))
self.y = numerix.arange(100.0) * 2 * numerix.pi / 100.0
self.y.resize((120, 100))
self.y = numerix.transpose(self.y)
z = numerix.sin(self.x) + numerix.cos(self.y)
self.im = a.imshow(z, cmap=cm.jet) #, interpolation='nearest')
def init_plot_data(self):
# jdh you can add a subplot directly from the fig rather than
# the fig manager
a = self.fig.add_axes([0.075, 0.1, 0.75, 0.85])
cax = self.fig.add_axes([0.85, 0.1, 0.075, 0.85])
self.x = numerix.arange(120.0) * 2 * numerix.pi / 120.0
self.x.resize((100, 120))
self.y = numerix.arange(100.0) * 2 * numerix.pi / 100.0
self.y.resize((120, 100))
self.y = numerix.transpose(self.y)
z = numerix.sin(self.x) + numerix.cos(self.y)
self.im = a.imshow(z, cmap=cm.jet) #, interpolation='nearest')
self.fig.colorbar(self.im, cax=cax, orientation='vertical')
def init_plot_data(self):
# jdh you can add a subplot directly from the fig rather than
# the fig manager
a = self.fig.add_axes([0.075,0.1,0.75,0.85])
cax = self.fig.add_axes([0.85,0.1,0.075,0.85])
self.x = numerix.arange(120.0)*2*numerix.pi/120.0
self.x.resize((100,120))
self.y = numerix.arange(100.0)*2*numerix.pi/100.0
self.y.resize((120,100))
self.y = numerix.transpose(self.y)
z = numerix.sin(self.x) + numerix.cos(self.y)
self.im = a.imshow( z, cmap=cm.jet)#, interpolation='nearest')
self.fig.colorbar(self.im,cax=cax,orientation='vertical')
def writeHatches(self):
hatchDict = dict()
sidelen = 144.0
density = 24.0
for lst, name in self.hatchPatterns.items():
ob = self.reserveObject('hatch pattern')
hatchDict[name] = ob
res = {
'Procsets':
[Name(x) for x in "PDF Text ImageB ImageC ImageI".split()]
}
self.beginStream(
ob.id, None, {
'Type': Name('Pattern'),
'PatternType': 1,
'PaintType': 1,
'TilingType': 1,
'BBox': [0, 0, sidelen, sidelen],
'XStep': sidelen,
'YStep': sidelen,
'Resources': res
})
# lst is a tuple of stroke color, fill color,
# number of - lines, number of / lines,
# number of | lines, number of \ lines
rgb = lst[0]
self.output(rgb[0], rgb[1], rgb[2], Op.setrgb_stroke)
if lst[1] is not None:
rgb = lst[1]
self.output(rgb[0], rgb[1], rgb[2], Op.setrgb_nonstroke, 0, 0,
sidelen, sidelen, Op.rectangle, Op.fill)
if lst[2]: # -
for j in arange(0.0, sidelen, density / lst[2]):
self.output(0, j, Op.moveto, sidelen, j, Op.lineto)
if lst[3]: # /
for j in arange(0.0, sidelen, density / lst[3]):
self.output(0, j, Op.moveto, sidelen - j, sidelen,
Op.lineto, sidelen - j, 0, Op.moveto, sidelen,
j, Op.lineto)
if lst[4]: # |
for j in arange(0.0, sidelen, density / lst[4]):
self.output(j, 0, Op.moveto, j, sidelen, Op.lineto)
if lst[5]: # \
for j in arange(sidelen, 0.0, -density / lst[5]):
self.output(sidelen, j, Op.moveto, j, sidelen, Op.lineto,
j, 0, Op.moveto, 0, j, Op.lineto)
self.output(Op.stroke)
self.endStream()
self.writeObject(self.hatchObject, hatchDict)
def writeHatches(self):
hatchDict = dict()
sidelen = 144.0
density = 24.0
for lst, name in self.hatchPatterns.items():
ob = self.reserveObject('hatch pattern')
hatchDict[name] = ob
res = { 'Procsets':
[ Name(x) for x in "PDF Text ImageB ImageC ImageI".split() ] }
self.beginStream(
ob.id, None,
{ 'Type': Name('Pattern'),
'PatternType': 1, 'PaintType': 1, 'TilingType': 1,
'BBox': [0, 0, sidelen, sidelen],
'XStep': sidelen, 'YStep': sidelen,
'Resources': res })
# lst is a tuple of stroke color, fill color,
# number of - lines, number of / lines,
# number of | lines, number of \ lines
rgb = lst[0]
self.output(rgb[0], rgb[1], rgb[2], Op.setrgb_stroke)
if lst[1] is not None:
rgb = lst[1]
self.output(rgb[0], rgb[1], rgb[2], Op.setrgb_nonstroke,
0, 0, sidelen, sidelen, Op.rectangle,
Op.fill)
if lst[2]: # -
for j in arange(0.0, sidelen, density/lst[2]):
self.output(0, j, Op.moveto,
sidelen, j, Op.lineto)
if lst[3]: # /
for j in arange(0.0, sidelen, density/lst[3]):
self.output(0, j, Op.moveto,
sidelen-j, sidelen, Op.lineto,
sidelen-j, 0, Op.moveto,
sidelen, j, Op.lineto)
if lst[4]: # |
for j in arange(0.0, sidelen, density/lst[4]):
self.output(j, 0, Op.moveto,
j, sidelen, Op.lineto)
if lst[5]: # \
for j in arange(sidelen, 0.0, -density/lst[5]):
self.output(sidelen, j, Op.moveto,
j, sidelen, Op.lineto,
j, 0, Op.moveto,
0, j, Op.lineto)
self.output(Op.stroke)
self.endStream()
self.writeObject(self.hatchObject, hatchDict)
def createDBGraph(self, widget):
self.axis.clear()
self.axis.set_xlabel('Samples (n)')
self.axis.set_ylabel('Value (-)')
self.axis.set_title('Another Graph (click on the columnheader to sort)')
self.axis.grid(True)
# get columns from listmodel
age = []
for row in self.listmodel:
age.append(row[1])
size = []
for row in self.listmodel:
size.append(row[2])
# get number of rows
N = len(age)
ind = arange(N) # the x locations for the groups
width = 0.35 # the width of the bars
p1 = self.axis.bar(ind, age, width, color='b')
p2 = self.axis.bar(ind+width, size, width, color='r')
# destroy graph if it already exists
while True:
try:
self.canvas2.destroy()
break
except:
print "nothing to destroy"
break
self.canvas2 = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas2.show()
self.grahview = self.wTree.get_widget("vbox2")
self.grahview.pack_start(self.canvas2, True, True)
def OnInit(self):
self.timer = wx.PyTimer(self.OnTimer)
self.numPoints = 0
self.frame = wxmpl.PlotFrame(None, -1, 'WxMpl Stripchart Demo')
self.frame.Show(True)
# The data to plot
x = arange(0.0, 200, 0.1)
y1 = 4*cos(2*pi*(x-1)/5.7)/(6+x) + 2*sin(2*pi*(x-1)/2.2)/(10)
y2 = y1 + .5
y3 = y2 + .5
y4 = y3 + .5
# Fetch and setup the axes
axes = self.frame.get_figure().gca()
axes.set_title('Stripchart Test')
axes.set_xlabel('t')
axes.set_ylabel('f(t)')
# Attach the StripCharter and define its channels
self.charter = wxmpl.StripCharter(axes)
self.charter.setChannels([
TestChannel('ch1', x, y1),
TestChannel('ch2', x, y2),
TestChannel('ch3', x, y3),
TestChannel('ch4', x, y4)
])
# Prime the pump and start the timer
self.charter.update()
self.timer.Start(100)
return True
def _process_values(self, b=None):
"""
Set the _boundaries and _values attributes based on
the input boundaries and values. Input boundaries can
be self.boundaries or the argument b.
"""
if b is None:
b = self.boundaries
if b is not None:
self._boundaries = nx.array(b)
if self.values is None:
self._values = 0.5 * (self._boundaries[:-1] + self._boundaries[1:])
if isinstance(self.norm, colors.no_norm):
self._values = (self._values + 0.00001).astype(nx.Int16)
return
self._values = nx.array(self.values)
return
if self.values is not None:
self._values = nx.array(self.values)
if self.boundaries is None:
b = nx.zeros(len(self.values) + 1, "d")
b[1:-1] = 0.5 * (self._values[:-1] - self._values[1:])
b[0] = 2.0 * b[1] - b[2]
b[-1] = 2.0 * b[-2] - b[-3]
self._boundaries = b
return
self._boundaries = nx.array(self.boundaries)
return
if isinstance(self.norm, colors.no_norm):
b = nx.arange(self.norm.vmin, self.norm.vmax + 2) - 0.5
else:
dv = self.norm.vmax - self.norm.vmin
b = self.norm.vmin + dv * self._uniform_y(self.cmap.N + 1)
self._process_values(b)
def __init__(self):
wxFrame.__init__(self,None,-1,
'CanvasFrame',size=(550,350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axes.plot(t,s)
self.axes.set_xlabel('Time (s)')
self.axes.set_ylabel('Price ($)')
self.canvas = FigureCanvas(self, -1, self.figure)
self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
self.SetSizer(self.sizer)
self.Fit()
self.statusBar = wxStatusBar(self, -1)
self.statusBar.SetFieldsCount(1)
self.SetStatusBar(self.statusBar)
self.add_toolbar() # comment this out for no toolbar
EVT_PAINT(self, self.OnPaint)
def _process_values(self, b=None):
'''
Set the _boundaries and _values attributes based on
the input boundaries and values. Input boundaries can
be self.boundaries or the argument b.
'''
if b is None:
b = self.boundaries
if b is not None:
self._boundaries = nx.array(b)
if self.values is None:
self._values = 0.5 * (self._boundaries[:-1] +
self._boundaries[1:])
if isinstance(self.norm, colors.no_norm):
self._values = (self._values + 0.00001).astype(nx.Int16)
return
self._values = nx.array(self.values)
return
if self.values is not None:
self._values = nx.array(self.values)
if self.boundaries is None:
b = nx.zeros(len(self.values) + 1, 'd')
b[1:-1] = 0.5 * (self._values[:-1] - self._values[1:])
b[0] = 2.0 * b[1] - b[2]
b[-1] = 2.0 * b[-2] - b[-3]
self._boundaries = b
return
self._boundaries = nx.array(self.boundaries)
return
if isinstance(self.norm, colors.no_norm):
b = nx.arange(self.norm.vmin, self.norm.vmax + 2) - 0.5
else:
dv = self.norm.vmax - self.norm.vmin
b = self.norm.vmin + dv * self._uniform_y(self.cmap.N + 1)
self._process_values(b)
def __init__(self):
wxFrame.__init__(self,None,-1,
'CanvasFrame',size=(550,350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axes.plot(t,s)
self.axes.set_xlabel('Time (s)')
self.axes.set_ylabel('Price ($)')
self.canvas = FigureCanvas(self, -1, self.figure)
self.canvas.mpl_connect('motion_notify_event', self.mouse_move)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
self.SetSizer(self.sizer)
self.Fit()
self.statusBar = wxStatusBar(self, -1)
self.statusBar.SetFieldsCount(1)
self.SetStatusBar(self.statusBar)
self.add_toolbar() # comment this out for no toolbar
def __init__(self):
self.widgets = gtk.glade.XML('mpl_with_glade.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self.figure = Figure(figsize=(8,6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axis.plot(t,s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas.show()
self['vboxMain'].pack_start(self.canvas, gtk.TRUE, gtk.TRUE)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, gtk.TRUE, gtk.TRUE)
self['vboxMain'].reorder_child(self['buttonClickMe'],-1)
def __init__(self, ):
wx.Frame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
self.SetBackgroundColour(wx.NamedColor("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
self.axes.set_xlabel('t')
self.axes.set_ylabel('sin(t)')
self.figure_canvas = FigureCanvas(self, -1, self.figure)
# Note that event is a MplEvent
self.figure_canvas.mpl_connect('motion_notify_event',
self.UpdateStatusBar)
self.figure_canvas.Bind(wx.EVT_ENTER_WINDOW, self.ChangeCursor)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.figure_canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
self.statusBar = wx.StatusBar(self, -1)
self.statusBar.SetFieldsCount(1)
self.SetStatusBar(self.statusBar)
self.toolbar = NavigationToolbar2Wx(self.figure_canvas)
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.Show()
def __init__(self):
self.widgets = gtk.glade.XML('mpl_with_glade.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self.figure = Figure(figsize=(8, 6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axis.plot(t, s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas.show()
self['vboxMain'].pack_start(self.canvas, gtk.TRUE, gtk.TRUE)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, gtk.TRUE, gtk.TRUE)
self['vboxMain'].reorder_child(self['buttonClickMe'], -1)
def init_plot_data(self):
a = self.fig.add_subplot(111)
x = numerix.arange(120.0)*2*numerix.pi/60.0
y = numerix.arange(100.0)*2*numerix.pi/50.0
self.x, self.y = meshgrid(x, y)
z = numerix.sin(self.x) + numerix.cos(self.y)
self.im = a.imshow( z, cmap=cm.jet)#, interpolation='nearest')
zmax = numerix.max(numerix.max(z))-ERR_TOL
ymax_i, xmax_i = numerix.nonzero(
numerix.greater_equal(z, zmax))
if self.im.origin == 'upper':
ymax_i = z.shape[0]-ymax_i
self.lines = a.plot(xmax_i,ymax_i,'ko')
self.toolbar.update() # Not sure why this is needed - ADS
def __init__(self, infile, varName, rowNum):
self.rowNum = rowNum
self.name = varName
self.y = infile.ReadVar(varName)
self.x = arange(0,self.y.shape[0])
print 'y.shape = ' + repr(self.y.shape)
if len(self.y.shape) == 1:
(self.mean, self.var, self.error, self.kappa) = stats.Stats(self.y)
def init_plot(self):
# create the initial line
x = nx.arange(0, 2 * nx.pi, 0.01)
self.l_pos_a = [((0, 0), (1, 1)), ((0, 1), (1, 0))]
self.l_pos_b = [((0, 0), (0, 1)), ((1, 1), (1, 0))]
self.line_c = LineCollection(self.l_pos_a, animated=True)
line, = p.plot(x, nx.sin(x), animated=False)
self.ax.add_collection(self.line_c)
def points(self,npoints):
"""
compute arrays of npoints equally spaced
intermediate points along the great circle.
input parameter npoints is the number of points
to compute.
Returns lons, lats (lists with longitudes and latitudes
of intermediate points in degrees).
For example npoints=10 will return arrays lons,lats of 10
equally spaced points along the great circle.
"""
# must ask for at least 2 points.
if npoints <= 1:
raise ValueError,'npoints must be greater than 1'
elif npoints == 2:
return [math.degrees(self.lon1),math.degrees(self.lon2)],[math.degrees(self.lat1),math.degrees(self.lat2)]
# can't do it if endpoints are antipodal, since
# route is undefined.
if self.antipodal:
raise ValueError,'cannot compute intermediate points on a great circle whose endpoints are antipodal'
d = self.gcarclen
delta = 1.0/(npoints-1)
f = delta*NX.arange(npoints) # f=0 is point 1, f=1 is point 2.
incdist = self.distance/(npoints-1)
lat1 = self.lat1
lat2 = self.lat2
lon1 = self.lon1
lon2 = self.lon2
# perfect sphere, use great circle formula
if self.f == 0.:
A = NX.sin((1-f)*d)/math.sin(d)
B = NX.sin(f*d)/math.sin(d)
x = A*math.cos(lat1)*math.cos(lon1)+B*math.cos(lat2)*math.cos(lon2)
y = A*math.cos(lat1)*math.sin(lon1)+B*math.cos(lat2)*math.sin(lon2)
z = A*math.sin(lat1) +B*math.sin(lat2)
lats=NX.arctan2(z,NX.sqrt(x**2+y**2))
lons=NX.arctan2(y,x)
lons = map(math.degrees,lons.tolist())
lats = map(math.degrees,lats.tolist())
# use ellipsoid formulas
else:
latpt = self.lat1
lonpt = self.lon1
azimuth = self.azimuth12
lons = [math.degrees(lonpt)]
lats = [math.degrees(latpt)]
for n in range(npoints-2):
latptnew,lonptnew,alpha21=vinc_pt(self.f,self.a,latpt,lonpt,azimuth,incdist)
d,azimuth,a21=vinc_dist(self.f,self.a,latptnew,lonptnew,lat2,lon2)
lats.append(math.degrees(latptnew))
lons.append(math.degrees(lonptnew))
latpt = latptnew; lonpt = lonptnew
lons.append(math.degrees(self.lon2))
lats.append(math.degrees(self.lat2))
return lons,lats
def init_plot_data(self):
a = self.figmgr.add_subplot(111)
self.ind = numpy.arange(60)
tmp = []
for i in range(60):
tmp.append(numpy.sin((self.ind + i) * numpy.pi / 15))
self.X = numpy.array(tmp)
self.lines = a.plot(self.X[:, 0], 'o')
self.count = 0
def init_plot_data(self):
a = self.figmgr.add_subplot(111)
self.ind = numpy.arange(60)
tmp = []
for i in range(60):
tmp.append(numpy.sin((self.ind+i)*numpy.pi/15))
self.X = numpy.array(tmp)
self.lines = a.plot(self.X[:,0],'o')
self.count = 0
def __init__(self):
self.widgets = gtk.glade.XML('mpl_with_glade.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self['windowMain'].connect('destroy', lambda x: gtk.main_quit())
self['windowMain'].move(10,10)
self.figure = Figure(figsize=(8,6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axis.plot(t,s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.canvas.set_size_request(600, 400)
self.canvas.set_events(
gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.KEY_RELEASE_MASK
)
self.canvas.set_flags(gtk.HAS_FOCUS|gtk.CAN_FOCUS)
self.canvas.grab_focus()
def keypress(widget, event):
print 'key press'
def buttonpress(widget, event):
print 'button press'
self.canvas.connect('key_press_event', keypress)
self.canvas.connect('button_press_event', buttonpress)
def onselect(xmin, xmax):
print xmin, xmax
span = HorizontalSpanSelector(self.axis, onselect, useblit=False,
rectprops=dict(alpha=0.5, facecolor='red') )
self['vboxMain'].pack_start(self.canvas, True, True)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, True, True)
self['vboxMain'].reorder_child(self['buttonClickMe'],-1)
def __init__(self):
self.widgets = gtk.glade.XML('mpl_with_glade.glade')
self.widgets.signal_autoconnect(GladeHandlers.__dict__)
self['windowMain'].connect('destroy', lambda x: gtk.main_quit())
self['windowMain'].move(10, 10)
self.figure = Figure(figsize=(8, 6), dpi=72)
self.axis = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axis.plot(t, s)
self.axis.set_xlabel('time (s)')
self.axis.set_ylabel('voltage')
self.canvas = FigureCanvas(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.canvas.set_size_request(600, 400)
self.canvas.set_events(gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.KEY_PRESS_MASK
| gtk.gdk.KEY_RELEASE_MASK)
self.canvas.set_flags(gtk.HAS_FOCUS | gtk.CAN_FOCUS)
self.canvas.grab_focus()
def keypress(widget, event):
print 'key press'
def buttonpress(widget, event):
print 'button press'
self.canvas.connect('key_press_event', keypress)
self.canvas.connect('button_press_event', buttonpress)
def onselect(xmin, xmax):
print xmin, xmax
span = HorizontalSpanSelector(self.axis,
onselect,
useblit=False,
rectprops=dict(alpha=0.5,
facecolor='red'))
self['vboxMain'].pack_start(self.canvas, True, True)
self['vboxMain'].show()
# below is optional if you want the navigation toolbar
self.navToolbar = NavigationToolbar(self.canvas, self['windowMain'])
self.navToolbar.lastDir = '/var/tmp/'
self['vboxMain'].pack_start(self.navToolbar)
self.navToolbar.show()
sep = gtk.HSeparator()
sep.show()
self['vboxMain'].pack_start(sep, True, True)
self['vboxMain'].reorder_child(self['buttonClickMe'], -1)
def gaussian_example():
"""Create graph with 4 gaussian distributions"""
x = nx.arange(-4, 4, 0.01)
list_sigma = [0.2, 0.5, 1, 2]
for sigma in list_sigma:
y = normpdf(x, 0, sigma) # unit normal
p.plot(x, y, lw=2)
p.legend(["$\sigma = %s$" % s for s in list_sigma])
p.title("Normal Gaussian Distribution")
p.savefig("results/gaussian.png") # Save graph
def _parse_args(self, *args):
X, Y, U, V, C = [None]*5
args = list(args)
if len(args) == 3 or len(args) == 5:
C = nx.ravel(args.pop(-1))
#print 'in parse_args, C:', C
V = nx.ma.asarray(args.pop(-1))
U = nx.ma.asarray(args.pop(-1))
nn = nx.shape(U)
nc = nn[0]
nr = 1
if len(nn) > 1:
nr = nn[1]
if len(args) == 2:
X, Y = [nx.ravel(a) for a in args]
if len(X) == nc and len(Y) == nr:
X, Y = [nx.ravel(a) for a in meshgrid(X, Y)]
else:
X, Y = [nx.ravel(a) for a in meshgrid(nx.arange(nc), nx.arange(nr))]
return X, Y, U, V, C
def __init__(self):
QtCore.QObject.__init__(self, None)
self.ax = p.subplot(111)
self.canvas = self.ax.figure.canvas
self.cnt = 0
# create the initial line
self.x = nx.arange(0, 2 * nx.pi, 0.01)
self.line, = p.plot(self.x, nx.sin(self.x), animated=True, lw=2)
self.background = None
def __init__(self):
QtCore.QObject.__init__(self, None)
self.ax = p.subplot(111)
self.canvas = self.ax.figure.canvas
self.cnt = 0
# create the initial line
self.x = nx.arange(0,2*nx.pi,0.01)
self.line, = p.plot(self.x, nx.sin(self.x), animated=True, lw=2)
self.background = None
def plot3d(self):
# sample taken from http://www.scipy.org/Cookbook/Matplotlib/mplot3D
ax3d = matplotlib.axes3d.Axes3D(self.fig)
plt = self.fig.axes.append(ax3d)
delta = nx.pi / 199.0
u = nx.arange(0, 2*nx.pi+(delta*2), delta*2)
v = nx.arange(0, nx.pi+delta, delta)
x=nx.outerproduct(nx.cos(u),nx.sin(v))
y=nx.outerproduct(nx.sin(u),nx.sin(v))
z=nx.outerproduct(nx.ones(nx.size(u)), nx.cos(v))
print x.shape, y.shape, z.shape
#ax3d.plot_wireframe(x,y,z)
surf = ax3d.plot_surface(x, y, z)
surf.set_array(matplotlib.mlab.linspace(0, 1.0, len(v)))
ax3d.set_xlabel('X')
ax3d.set_ylabel('Y')
ax3d.set_zlabel('Z')
self.fig.savefig('globe')
def plot_data(self):
# Use ths line if using a toolbar
a = self.fig.add_subplot(111)
# Or this one if there is no toolbar
#a = Subplot(self.fig, 111)
t = numpy.arange(0.0,3.0,0.01)
s = numpy.sin(2*numpy.pi*t)
c = numpy.cos(2*numpy.pi*t)
a.plot(t,s)
a.plot(t,c)
self.toolbar.update()
def plot3d(self):
# sample taken from http://www.scipy.org/Cookbook/Matplotlib/mplot3D
ax3d = matplotlib.axes3d.Axes3D(self.fig)
plt = self.fig.axes.append(ax3d)
delta = nx.pi / 199.0
u = nx.arange(0, 2 * nx.pi + (delta * 2), delta * 2)
v = nx.arange(0, nx.pi + delta, delta)
x = nx.outerproduct(nx.cos(u), nx.sin(v))
y = nx.outerproduct(nx.sin(u), nx.sin(v))
z = nx.outerproduct(nx.ones(nx.size(u)), nx.cos(v))
print x.shape, y.shape, z.shape
#ax3d.plot_wireframe(x,y,z)
surf = ax3d.plot_surface(x, y, z)
surf.set_array(matplotlib.mlab.linspace(0, 1.0, len(v)))
ax3d.set_xlabel('X')
ax3d.set_ylabel('Y')
ax3d.set_zlabel('Z')
self.fig.savefig('globe')
def pplot(path, x, text):
# N = float(len(x))
x = sorted([float(item) for item in x])
# ------------------ liberated from scipy.stats.morestats ------------------
N = len(x)
Ui = np.zeros(N) * 1.0
Ui[-1] = 0.5 ** (1.0 / N)
Ui[0] = 1 - Ui[-1]
i = arange(2, N)
Ui[1:-1] = (i - 0.3175) / (N + 0.365)
y = stats.norm.ppf(Ui)
## -------------------------------------------------------------------------
regressionplot(path, x, y, text, "Normal Score", pi=True)
def plot_data(self):
# Use ths line if using a toolbar
a = self.figmgr.add_subplot(111)
# Or this one if there is no toolbar
#a = Subplot(self.fig, 111)
t = numpy.arange(0.0, 3.0, 0.01)
s = numpy.sin(2 * numpy.pi * t)
c = numpy.cos(2 * numpy.pi * t)
a.plot(t, s)
a.plot(t, c)
self.toolbar.update()
def OnButton(self, evt):
"""
"""
dd = 20
t = arange(0.0, 3.0, 1.0 / dd)
s = [10 + y * y / dd + self.count for y in xrange(0, 3 * dd)]
self.count += 5
self.axes.lines.pop(0)
line, = self.axes.plot(t, s, 'r:d')
line.set_markersize(5)
self.Refresh()
evt.Skip()
def __init__(self):
gtk.Window.__init__(self,gtk.WINDOW_TOPLEVEL)
self.set_title("MixedEmotions")
self.set_border_width(10)
self.fig = Figure(figsize=(3,1), dpi=100)
self.ax = self.fig.add_subplot(111)
self.x = arange(0,2*pi,0.01) # x-array
self.lines = self.ax.plot(self.x,sin(self.x))
self.canvas = FigureCanvas(self.fig)
self.add(self.canvas)
self.figcount = 0
gtk.timeout_add(100, self.updatePlot)
def draw(self):
if not hasattr(self, 'subplot'):
self.subplot = self._figure.add_subplot(111)
theta = arange(0, 45*2*pi, 0.02)
rad = (0.8*theta/(2*pi)+1)
r = rad*(8 + sin(theta*7+rad/1.8))
x = r*cos(theta)
y = r*sin(theta)
#Now draw it
self.subplot.plot(x,y, '-r')
#Set some plot attributes
self.subplot.set_title("A polar flower (%s points)"%len(x), fontsize = 12)
self.subplot.set_xlabel("test plot", fontsize = 8)
self.subplot.set_xlim([-400, 400])
self.subplot.set_ylim([-400, 400])
def _create_plot(self):
from matplotlib.figure import Figure
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
from matplotlib.numerix import arange, sin, pi
figure = Figure(figsize=(5, 4), dpi=100)
canvas = FigureCanvas(figure) # a gtk.DrawingArea
#win.add(canvas)
axes = figure.add_subplot(111)
x = arange(0.0, 30.0, 0.01)
y = sin(2 * pi * x)
line, = axes.plot(x, y)
axes.set_title('hi mom')
axes.grid(True)
axes.set_xlabel('time')
axes.set_ylabel('volts')
def __init__(self, parent, id, title, analyse_size):
self.width, self.height = analyse_size
wx.Frame.__init__(self, parent, id, title, style=wx.DEFAULT_FRAME_STYLE & ~(wx.RESIZE_BORDER | wx.RESIZE_BOX | wx.MAXIMIZE_BOX))
self.SetBackgroundColour(wx.NamedColor("WHITE"))
self.figure = Figure(figsize=(5, 4), dpi=100)
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2*pi*t)
self.axes.plot(t, s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.TOP | wx.LEFT | wx.EXPAND)
# Capture the paint message
# EVT_PAINT(self, self.OnPaint)
# self.toolbar = MyNavigationToolbar(self.canvas, True)
# self.toolbar.Realize()
# if wx.Platform == '__WXMAC__':
# # Mac platform (OSX 10.3, MacPython) does not seem to cope with
# # having a toolbar in a sizer. This work-around gets the buttons
# # back, but at the expense of having the toolbar at the top
# self.SetToolBar(self.toolbar)
# else:
# # On Windows platform, default window size is incorrect, so set
# # toolbar width to figure width.
# tw, th = self.toolbar.GetSizeTuple()
# fw, fh = self.canvas.GetSizeTuple()
# # By adding toolbar in sizer, we are able to put it at the bottom
# # of the frame - so appearance is closer to GTK version.
# # As noted above, doesn't work for Mac.
# self.toolbar.SetSize(wxSize(fw, th))
# self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)
#
# # update the axes menu on the toolbar
# self.toolbar.update()
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.SetSizer(self.sizer)
self.Fit()
def __init__( self, strengthRange, ax, pos, decay_time=2 ) :
n = 25
t = arange(n)*2*pi/n
self.disc = array([(cos(x),sin(x)) for x in t])
self.strength = 0
self.pos = pos
self.offset = (279, 157)
self.scale = 1.35
self.max_size = 5 #0.5
self.min_size = 0.10 #0.05
self.size = self.min_size
self.color = '#ff8000'
self.decay_time = decay_time
self.strengthRange = strengthRange
self.t0 = 0
v = self.disc * self.size + self.pos
self.poly = ax.fill( v[:,0], v[:,1], self.color )
def __init__(self):
wxFrame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure(figsize=(5, 4), dpi=100)
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
# Capture the paint message
EVT_PAINT(self, self.OnPaint)
def _find_axes(self, minval, maxval):
"""
Try to find axis tick positions that are well spaced
"""
if minval >= maxval:
raise ValueError, "maxval >= minval is required"
# If there is a small differences between max and min values
# compared to the size of the largest of (abs(maxval), abs(minval))
# the function 'tasteless_ticks' is used, which in common usage is rare.
if (abs((maxval - minval)/float(max(abs(maxval),abs(minval)))) < 0.2):
tslmajor, oppaxis, step = self._tasteless_ticks(minval, maxval, 10)
else:
tslmajor, oppaxis, step = self._tasteful_ticks(minval, maxval)
min = tslmajor[0] - step
tslminor = list(arange(min, maxval + 0.2*step, 0.2*step))
tslminor = self._in_range(tslminor, minval, maxval)
return oppaxis, step, tslminor, tslmajor
def draw(self):
if not hasattr(self, 'subplot'):
self.subplot = self.figure.add_subplot(111)
theta = arange(0, 45 * 2 * pi, 0.02)
rad = (0.8 * theta / (2 * pi) + 1)
r = rad * (8 + sin(theta * 7 + rad / 1.8))
x = r * cos(theta)
y = r * sin(theta)
#Now draw it
self.subplot.plot(x, y, '-r')
#Set some plot attributes
self.subplot.set_title("A polar flower (%s points)" % len(x),
fontsize=12)
self.subplot.set_xlabel(
"Flower is from http://www.physics.emory.edu/~weeks/ideas/rose.html",
fontsize=8)
self.subplot.set_xlim([-400, 400])
self.subplot.set_ylim([-400, 400])
def _find_axes(self, minval, maxval):
"""
Try to find axis tick positions that are well spaced
"""
if minval >= maxval:
raise ValueError, "maxval >= minval is required"
# If there is a small differences between max and min values
# compared to the size of the largest of (abs(maxval), abs(minval))
# the function 'tasteless_ticks' is used, which in common usage is rare.
if (abs((maxval - minval)/float(max(abs(maxval),abs(minval)))) < 0.2):
tslmajor, oppaxis, step = self._tasteless_ticks(minval, maxval, 10)
else:
tslmajor, oppaxis, step = self._tasteful_ticks(minval, maxval)
min = tslmajor[0] - step
tslminor = list(arange(min, maxval + 0.2*step, 0.2*step))
tslminor = self._in_range(tslminor, minval, maxval)
return oppaxis, step, tslminor, tslmajor
def _h_arrows(self, length):
''' length is in arrow width units '''
minsh = self.minshaft * self.headlength
N = len(length)
length = nx.reshape(length, (N,1))
x = nx.array([0, -self.headaxislength,
-self.headlength, 0], nx.Float64)
x = x + nx.array([0,1,1,1]) * length
y = 0.5 * nx.array([1, 1, self.headwidth, 0], nx.Float64)
y = nx.repeat(y[nx.newaxis,:], N)
x0 = nx.array([0, minsh-self.headaxislength,
minsh-self.headlength, minsh], nx.Float64)
y0 = 0.5 * nx.array([1, 1, self.headwidth, 0], nx.Float64)
ii = [0,1,2,3,2,1,0]
X = nx.take(x, ii, 1)
Y = nx.take(y, ii, 1)
Y[:, 3:] *= -1
X0 = nx.take(x0, ii)
Y0 = nx.take(y0, ii)
Y0[3:] *= -1
shrink = length/minsh
X0 = shrink * X0[nx.newaxis,:]
Y0 = shrink * Y0[nx.newaxis,:]
short = nx.repeat(length < minsh, 7, 1)
#print 'short', length < minsh
X = nx.where(short, X0, X)
Y = nx.where(short, Y0, Y)
if self.pivot[:3] == 'mid':
X -= 0.5 * X[:,3, nx.newaxis]
elif self.pivot[:3] == 'tip':
X = X - X[:,3, nx.newaxis] #numpy bug? using -= does not
# work here unless we multiply
# by a float first, as with 'mid'.
tooshort = length < self.minlength
if nx.any(tooshort):
th = nx.arange(0,7,1, nx.Float64) * (nx.pi/3.0)
x1 = nx.cos(th) * self.minlength * 0.5
y1 = nx.sin(th) * self.minlength * 0.5
X1 = nx.repeat(x1[nx.newaxis, :], N, 0)
Y1 = nx.repeat(y1[nx.newaxis, :], N, 0)
tooshort = nx.repeat(tooshort, 7, 1)
X = nx.where(tooshort, X1, X)
Y = nx.where(tooshort, Y1, Y)
return X, Y
def createProjectGraph(self, widget):
while True:
try:
# empty axis if neccesary, and reset title and stuff
self.axis.clear()
self.axis.set_xlabel('Yepper')
self.axis.set_ylabel('Flabber')
self.axis.set_title('A Graph')
self.axis.grid(True)
# get data
age = self.wTree.get_widget("entry2").get_text()
size = self.wTree.get_widget("entry3").get_text()
age != ""
size != ""
N = 1
ind = arange(N) # the x locations for the groups
width = 0.35 # the width of the bars
p1 = self.axis.bar(ind, int(age), width, color='r')
p2 = self.axis.bar(ind + width, int(size), width, color='y')
self.axis.legend((p1[0], p2[0]), ("Age", "Size"), shadow=True)
#self.axis.set_xticks(ind+width, ('G1') )
self.axis.set_xlim(-width, len(ind))
self.canvas.destroy()
self.canvas = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas.show()
self.grahview = self.wTree.get_widget("vbox1")
self.grahview.pack_start(self.canvas, True, True)
break
except ValueError:
self.wDialog = gtk.glade.XML("project2.glade",
"cannotCreateProjGraph")
close = self.wDialog.get_widget("cannotCreateProjGraph")
response = close.run()
if response == gtk.RESPONSE_OK:
close.destroy()
break
def __init__(self):
wxFrame.__init__(self,None,-1,
'CanvasFrame',size=(550,350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure(figsize=(5,4), dpi=100)
self.axes = self.figure.add_subplot(111)
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
self.axes.plot(t,s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
# Capture the paint message
EVT_PAINT(self, self.OnPaint)
def __init__(self):
wxFrame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
self.SetSizer(self.sizer)
self.Fit()
self.add_toolbar() # comment this out for no toolbar
def OnInit(self):
from matplotlib.numerix import arange, sin, pi, cos
'Create the main window and insert the custom frame'
x = arange(0.0,3.0,0.01)
s = sin(2*pi*x)
c = cos(2*pi*x)
t = sin(2*pi*x) + cos(2*pi*x)
frame = ExtendedPlotFrame(None)
style = {'with':'lines', 'color':'blue','line':'solid','width':2}
style['legend'] = 'sin(x)'
frame.insertCurve(x,s, style)
style = {'with':'lines', 'color':'red','line':'solid','width':2}
style['legend'] = 'cos(x)'
frame.insertCurve(x,c, style)
style = {'with':'lines', 'color':'black','line':'solid','width':2}
#style['legend'] = 'sin(x)+cos(x)'
frame.insertCurve(x,t, style)
frame.Show(True)
return True
def __init__(self):
wxFrame.__init__(self, None, -1, "CanvasFrame", size=(550, 350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxLEFT | wxTOP | wxGROW)
self.SetSizer(self.sizer)
self.Fit()
self.add_toolbar() # comment this out for no toolbar
def test_matplotlib(request) :
# Generate and plot some simple data:
x = N.arange(0, 2*N.pi, 0.1)
y = N.sin(x)+1
pylab.ylim(8,0)
pylab.plot(y,x)
F = pylab.gcf()
# Now check everything with the defaults:
DPI = F.get_dpi()
DefaultSize = F.get_size_inches()
F.set_size_inches( (2, 5) )
filename = settings.MEDIA_ROOT + '/images/test1.png'
F.savefig(filename)
data = simplejson.dumps({'filename': filename})
return HttpResponse(data, mimetype="application/javascript")
def __init__(self):
wxFrame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
self.SetBackgroundColour(wxNamedColor("WHITE"))
self.figure = Figure(figsize=(5, 4), dpi=100)
self.axes = self.figure.add_subplot(111)
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wxBoxSizer(wxVERTICAL)
self.sizer.Add(self.canvas, 1, wxTOP | wxLEFT | wxEXPAND)
# Capture the paint message
EVT_PAINT(self, self.OnPaint)
self.toolbar = MyNavigationToolbar(self.canvas, True)
self.toolbar.Realize()
if wxPlatform == '__WXMAC__':
# Mac platform (OSX 10.3, MacPython) does not seem to cope with
# having a toolbar in a sizer. This work-around gets the buttons
# back, but at the expense of having the toolbar at the top
self.SetToolBar(self.toolbar)
else:
# On Windows platform, default window size is incorrect, so set
# toolbar width to figure width.
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
# By adding toolbar in sizer, we are able to put it at the bottom
# of the frame - so appearance is closer to GTK version.
# As noted above, doesn't work for Mac.
self.toolbar.SetSize(wxSize(fw, th))
self.sizer.Add(self.toolbar, 0, wxLEFT | wxEXPAND)
# update the axes menu on the toolbar
self.toolbar.update()
self.SetSizer(self.sizer)
self.Fit()
def _tasteless_ticks(self, minval, maxval, num_pieces):
minval0 = minval
maxval0 = maxval
rnd = int(floor(log(maxval - minval)/log(10)))
if rnd < 0:
rnd -= 1
step = (maxval - minval)/float(num_pieces)
minval = self._trunc(minval, rnd)
maxval = self._trunc(maxval + step, rnd)
step = (maxval - minval)/float(num_pieces)
tslmajor = list(arange(minval, minval+(num_pieces+1)*step, step))
tslmajor = self._in_range(tslmajor, minval0, maxval0)
oppaxis = 0
if maxval <= 0: # only negative
oppaxis = tslmajor[-1]
elif minval >= 0:
oppaxis = tslmajor[0]
return tslmajor, oppaxis, step
def createDBGraph(self, widget):
self.axis.clear()
self.axis.set_xlabel('Samples (n)')
self.axis.set_ylabel('Value (-)')
self.axis.set_title(
'Another Graph (click on the columnheader to sort)')
self.axis.grid(True)
# get columns from listmodel
age = []
for row in self.listmodel:
age.append(row[1])
size = []
for row in self.listmodel:
size.append(row[2])
# get number of rows
N = len(age)
ind = arange(N) # the x locations for the groups
width = 0.35 # the width of the bars
p1 = self.axis.bar(ind, age, width, color='b')
p2 = self.axis.bar(ind + width, size, width, color='r')
# destroy graph if it already exists
while True:
try:
self.canvas2.destroy()
break
except:
print "nothing to destroy"
break
self.canvas2 = FigureCanvasGTK(self.figure) # a gtk.DrawingArea
self.canvas2.show()
self.grahview = self.wTree.get_widget("vbox2")
self.grahview.pack_start(self.canvas2, True, True)
def do_capzone(self,event):
setActiveWindow()
if event.button==1:
if event.inaxes is not None:
x,y = event.xdata, event.ydata
xw,yw,rw,well_layers = findWell(x,y)
Ntraces_capzone = getTrace('ncap')
alpha = arange(0,2*pi-1e-6,(2*pi)/Ntraces_capzone)
step = getTrace('step'); tmax = getTrace('tmax'); nmax = getTrace('nmax')
elev = getTrace('elev'); layers = getTrace('layers'); forward = getTrace('capzoneforward')
elev = eval( '['+elev+']' )
win = getActiveWindow()
step = step * ( win[2] - win[0] )
step = -step
if forward: step = -step
zr = []
zt,zb = getLayerTopBottom(xw,yw)
for i in range(len(well_layers)):
for j in range(len(elev)):
zr.append( zb[well_layers[i]-1] + elev[j] * (zt[well_layers[i]-1]-zb[well_layers[i]-1]) )
for i in range(Ntraces_capzone):
xr = [ xw + 2*rw*cos(alpha[i]) ] ; yr = [ yw + 2*rw*sin(alpha[i]) ]
xr = len(zr)*xr; yr = len(zr)*yr;
doTracelines(xr,yr,zr,step,tmax,nmax)
