def __init__(self, *args, **kwargs):
# pull non-standard keyword arguments
auto_refresh = kwargs.pop('auto_refresh', False)
# dynamically set the subplot positions based on the figure size
# -- only if the user hasn't customised the subplot params
figsize = kwargs.get('figsize', rcParams['figure.figsize'])
subplotpars = get_subplot_params(figsize)
use_subplotpars = 'subplotpars' not in kwargs and all([
rcParams['figure.subplot.%s' % pos]
== MPL_RCPARAMS['figure.subplot.%s' % pos]
for pos in ('left', 'bottom', 'right', 'top')
])
if use_subplotpars:
kwargs['subplotpars'] = subplotpars
# generated figure, with associated interactivity from pyplot
super(Plot, self).__init__(*args, **kwargs)
backend_mod, _, draw_if_interactive, _ = backends.pylab_setup()
try:
manager = backend_mod.new_figure_manager_given_figure(1, self)
except AttributeError:
canvas = backend_mod.FigureCanvas(self)
manager = FigureManagerBase(canvas, 1)
cid = manager.canvas.mpl_connect(
'button_press_event',
lambda ev: _pylab_helpers.Gcf.set_active(manager))
manager._cidgcf = cid
_pylab_helpers.Gcf.set_active(manager)
draw_if_interactive()
# finalise
self.set_auto_refresh(auto_refresh)
self.colorbars = []
self._coloraxes = []
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
global remote_canvas
logging.debug("mpl_multiprocess_backend.new_figure_manager()")
# get the pipe connection
parent_conn = kwargs.pop('parent_conn')
# and the threading.Event for turning events on and off
process_events = kwargs.pop('process_events')
# make a new figure
FigureClass = kwargs.pop('FigureClass', Figure)
new_fig = FigureClass(*args, **kwargs)
# the canvas is a singleton.
if not remote_canvas:
remote_canvas = FigureCanvasAggRemote(parent_conn, process_events,
new_fig)
else:
old_fig = remote_canvas.figure
new_fig.set_size_inches(old_fig.get_figwidth(),
old_fig.get_figheight())
remote_canvas.figure = new_fig
new_fig.set_canvas(remote_canvas)
# close the current figure (to keep pyplot happy)
matplotlib.pyplot.close()
return FigureManagerBase(remote_canvas, num)
def new_figure_manager_given_figure(num, figure):
"""
Create a new figure manager instance for the given figure.
"""
canvas = FigureCanvasAgg(figure)
manager = FigureManagerBase(canvas, num)
return manager
def init_plot_panel(self):
"""Initializes the main panel of the AuxiliaryPage."""
# Instantiate a figure object that will contain our plots.
self.figure = Figure()
# Initialize the figure canvas, mapping the figure object to the plot
# engine backend.
canvas = FigureCanvas(self.pan1, wx.ID_ANY, self.figure)
# Wx-Pylab magic ...
# Make our canvas the active figure manager for pylab so that when
# pylab plotting statements are executed they will operate on our
# canvas and not create a new frame and canvas for display purposes.
# This technique allows this application to execute code that uses
# pylab stataments to generate plots and embed these plots in our
# application window(s).
self.fm = FigureManagerBase(canvas, self.fignum)
_pylab_helpers.Gcf.set_active(self.fm)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(canvas)
mpl_toolbar.Realize()
# Create a vertical box sizer to manage the widgets in the main panel.
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(canvas,
1,
wx.EXPAND | wx.TOP | wx.LEFT | wx.RIGHT,
border=10)
sizer.Add(mpl_toolbar, 0, wx.EXPAND | wx.ALL, border=10)
# Associate the sizer with its container.
self.pan1.SetSizer(sizer)
sizer.Fit(self.pan1)
def new_figure_manager(num, *args, **kwargs): # called by backends/__init__.py
"""
Create a new figure manager instance
"""
if _debug: print '%s.%s()' % (self.__class__.__name__, _fn_name())
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasCairo(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
def new_figure_manager(num, *args, **kwargs): # called by backends/__init__.py
"""
Create a new figure manager instance
"""
if DEBUG: print 'backend_cairo.%s()' % _fn_name()
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasCairo(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
def new_figure_manager_paint(num, *args, **kwargs):
"""
Add a new figure num (default autoincrement). For GUI
backends, you'll need to instantiate a new window and embed
the figure in it.
"""
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasPaint(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasGDK(thisFig)
manager = FigureManagerBase(canvas, num)
# equals:
#manager = FigureManagerBase (FigureCanvasGDK (Figure(*args, **kwargs), num)
return manager
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
if DEBUG: print 'backend_agg.new_figure_manager'
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasAgg(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
def new_figure_manager(num, *args, **kwargs):
"""
Create a new figure manager instance
"""
if __debug__: verbose.report('backend_agg.new_figure_manager', 'debug-annoying')
thisFig = Figure(*args, **kwargs)
canvas = FigureCanvasAgg(thisFig)
manager = FigureManagerBase(canvas, num)
return manager
def init_plot_panel(self):
"""Initializes the plotting panel of the SimulationPage."""
INTRO_TEXT = "Phase Reconstruction and Inversion Using Simulated Data:"
# Instantiate a figure object that will contain our plots.
figure = Figure()
# Initialize the figure canvas, mapping the figure object to the plot
# engine backend.
canvas = FigureCanvas(self.pan2, wx.ID_ANY, figure)
# Wx-Pylab magic ...
# Make our canvas the active figure manager for pylab so that when
# pylab plotting statements are executed they will operate on our
# canvas and not create a new frame and canvas for display purposes.
# This technique allows this application to execute code that uses
# pylab stataments to generate plots and embed these plots in our
# application window(s).
self.fm = FigureManagerBase(canvas, self.fignum)
_pylab_helpers.Gcf.set_active(self.fm)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(canvas)
mpl_toolbar.Realize()
# Display a title above the plots.
self.pan2_intro_text = INTRO_TEXT
self.pan2_intro = wx.StaticText(self.pan2, wx.ID_ANY, label=INTRO_TEXT)
font = self.pan2_intro.GetFont()
font.SetPointSize(font.GetPointSize() + 1)
font.SetWeight(wx.BOLD)
self.pan2_intro.SetFont(font)
# Create a progress bar to be displayed during a lengthy computation.
self.pan2_gauge = WorkInProgress(self.pan2)
self.pan2_gauge.Show(False)
# Create a horizontal box sizer to hold the title and progress bar.
hbox1_sizer = wx.BoxSizer(wx.HORIZONTAL)
hbox1_sizer.Add(self.pan2_intro, 0, wx.ALIGN_CENTER_VERTICAL)
hbox1_sizer.Add((10, 25), 1) # stretchable whitespace
hbox1_sizer.Add(self.pan2_gauge, 0)
# Create a vertical box sizer to manage the widgets in the main panel.
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(hbox1_sizer, 0, wx.EXPAND|wx.ALL, border=10)
sizer.Add(canvas, 1, wx.EXPAND|wx.LEFT|wx.RIGHT, border=10)
sizer.Add(mpl_toolbar, 0, wx.EXPAND|wx.ALL, border=10)
# Associate the sizer with its container.
self.pan2.SetSizer(sizer)
sizer.Fit(self.pan2)
def __init__(self, rows=1, cols=0, title='', size=None, buffering=False):
"""
Create a new instance of the ASAPlot plotting class.
If rows < 1 then a separate call to set_panels() is required to define
the panel layout; refer to the doctext for set_panels().
"""
v = vars()
del v['self']
asaplotbase.__init__(self, **v)
_pylab_helpers.Gcf.destroy(0)
self.window = None
self.canvas = FigureCanvasAgg(self.figure)
self.figmgr = FigureManagerBase(self.canvas, 0)
# This seems necessary when using Gcf, as this is done in
# pyplot.figure. Otherwise this can cause atexit errors at cleanup
self.figmgr._cidgcf = None
_pylab_helpers.Gcf.figs[self.figmgr.num] = self.figmgr
def __init__(self, *args, **kwargs):
# pull non-standard keyword arguments
auto_refresh = kwargs.pop('auto_refresh', False)
# generated figure, with associated interactivity from pyplot
super(Plot, self).__init__(*args, **kwargs)
backend_mod, _, draw_if_interactive, _ = backends.pylab_setup()
try:
manager = backend_mod.new_figure_manager_given_figure(1, self)
except AttributeError:
canvas = backend_mod.FigureCanvas(self)
manager = FigureManagerBase(canvas, 1)
cid = manager.canvas.mpl_connect(
'button_press_event',
lambda ev: _pylab_helpers.Gcf.set_active(manager))
manager._cidgcf = cid
_pylab_helpers.Gcf.set_active(manager)
draw_if_interactive()
# finalise
self.set_auto_refresh(auto_refresh)
self.colorbars = []
self._coloraxes = []
def __init__(self, parent):
wx.Panel.__init__(self, parent, style=wx.BORDER_SUNKEN)
self.sliceFigure = Figure(frameon=True, figsize=(2, 3))
self.sliceFigure.set_facecolor('.82')
self.sliceCanvas = FigureCanvas(self, -1, self.sliceFigure)
self.sliceCanvas.SetAutoLayout(False)
self.box = Toolbar(self.sliceCanvas)
self.box.Hide()
self.box.zoom()
self.fm = FigureManagerBase(self.sliceCanvas, 1)
_pylab_helpers.Gcf.set_active(self.fm)
self.sliceAxis = self.sliceFigure.add_axes([0.1, 0.2, 0.8, 0.7])
sliceSizer = wx.BoxSizer(wx.VERTICAL)
sliceSizer.Add(self.sliceCanvas,
1,
wx.EXPAND | wx.RIGHT | wx.LEFT,
border=1)
self.SetSizer(sliceSizer)
return
def __init__(self,
parent,
id,
data,
extent,
titles,
axLabel,
vlimit,
selMask,
scale='log'):
wx.Panel.__init__(self, parent, id, style=wx.BORDER_SUNKEN)
FIGPROPS = dict(figsize=(5.0, (5.0 / 1.618)), dpi=64)
#self.SetBackgroundColour('red')
ADJUSTPROPS = dict(left=0.1,
bottom=0.1,
right=0.97,
top=0.94,
wspace=0.01,
hspace=0.01)
viewIdx = argwhere(selMask).flatten()
viewCount = size(viewIdx)
self.plotFigure = Figure(frameon=True, **FIGPROPS)
self.plotFigure.set_facecolor('.82')
self.plotCanvas = FigureCanvas(self, -1, self.plotFigure)
self.plotFigure.subplots_adjust(**ADJUSTPROPS)
fm = FigureManagerBase(self.plotCanvas, 0)
_pylab_helpers.Gcf.set_active(fm)
if (scale == 'linear'):
plotData = data
vmin = vlimit[0]
vmax = vlimit[1]
elif (scale == 'log'):
plotData = log10(data)
vmin = log10(vlimit[0])
vmax = log10(vlimit[1])
for i in range(viewCount):
plotData[viewIdx[i]][data[viewIdx[i]] == 0.0] = vmin
depth = ceil(float(viewCount / 2.0))
self.axes = [None] * int(viewCount)
self.im = [None] * int(viewCount)
if (viewCount == 1):
col = 1
row = 1
elif (viewCount == 5):
col = 3
row = 2
elif (viewCount % 3.0 == 0.0):
col = 3
row = (int(viewCount / 3.0))
elif (viewCount % 2.0 == 0.0):
col = 2
row = (int(viewCount / 2.0))
else:
print 'Plot Layout Could Not Be Built'
for i in range(viewCount):
if i == 0:
self.axes[i] = self.plotFigure.add_subplot(row, col, i + 1)
else:
self.axes[i] = self.plotFigure.add_subplot(row,
col,
i + 1,
sharex=self.axes[0],
sharey=self.axes[0])
self.im[i] = self.axes[i].imshow(plotData[viewIdx[i]].T,
origin='lower',
interpolation='nearest',
extent=extent,
aspect='auto',
vmin=vmin,
vmax=vmax)
self.axes[i].set_gid(viewIdx[i])
if viewCount > 1:
self.axes[i].text(0.01,
.92,
titles[viewIdx[i]],
fontsize=14,
bbox=dict(facecolor='white', alpha=0.5),
transform=self.axes[i].transAxes)
self.plotFigure.text(0.54,
0.01,
axLabel[0],
ha='center',
va='bottom',
fontsize=14)
self.plotFigure.text(0.01,
.5,
axLabel[1],
ha='left',
va='center',
rotation='vertical',
fontsize=14)
else:
self.axes[i].set_title(titles[viewIdx[i]])
self.axes[i].set_xlabel(axLabel[0], fontsize=14)
self.axes[i].set_ylabel(axLabel[1], fontsize=14)
self.plotFigure.colorbar(self.im[i])
if i + 1 <= viewCount - col:
setp(self.axes[i].get_xticklabels(), visible=False)
if ((i + 1) % (viewCount / row) == 0.0 and viewCount != 1):
setp(self.axes[i].get_yticklabels(), visible=False)
self.box = Toolbar(self.plotCanvas)
self.box.Hide()
multiViewSizer = wx.BoxSizer(wx.HORIZONTAL)
multiViewVert = wx.BoxSizer(wx.VERTICAL)
multiViewSizer.Add(self.plotCanvas,
1,
wx.EXPAND | wx.RIGHT | wx.LEFT,
border=1)
multiViewVert.Add(multiViewSizer,
1,
wx.EXPAND | wx.TOP | wx.BOTTOM,
border=1)
self.SetSizer(multiViewVert)
return
def __init__(self,frame,id):
wx.Panel.__init__(self,frame,id,style = wx.BORDER_RAISED)
self.v = frame.v
self.extent = frame.extent
self.step = frame.step
self.n = frame.n
z_layer = 0
self.halfstep = self.step[2]/2.0
self.figure = Figure(frameon = True)
self.figure.set_facecolor('.82')
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
self.ax1 = self.figure.add_axes([0.1,0.1,0.7,0.8])
plotExtent = ([self.extent[0,0],self.extent[0,1],
self.extent[1,0],self.extent[1,1]])
self.im = self.ax1.imshow(self.v[:,:,z_layer].T,
origin='lower',
interpolation = 'nearest',
extent = plotExtent,
vmin = amin(self.v),
vmax = amax(self.v))
self.ax1.set_title('Z Slice = ' +
str(z_layer *self.step[2] + self.halfstep) +
' Ang' ,size = 'xx-large')
self.figure.colorbar(self.im,format = '%.2e')
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
self.zselect = wx.Slider(self,-1,size = [300,40],minValue = int(0),
maxValue = int(self.n[2]-1),
style = wx.SL_AUTOTICKS)
print self.extent[2,1]
print self.halfstep
print 'TEST', str(self.extent[2,1] - self.halfstep)
self.label = wx.StaticText(self,-1,'Select Z layer: ')
self.minVal = wx.StaticText(self,-1, '0.0')
self.maxVal = wx.StaticText(self,-1, str(self.extent[2,1]
- self.halfstep))
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.label,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.minVal,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.zselect,0,wx.TOP|wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.maxVal,0,wx.LEFT|wx.RIGHT,border = 5)
vertSize.Add(self.canvas,-1,wx.EXPAND|wx.LEFT|wx.RIGHT)
vertSize.Add(mpl_toolbar,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.zselect.Bind(wx.EVT_SCROLL,self.newUnitZ)
def __init__(self,frame,id):
wx.Panel.__init__(self,frame,id,style = wx.BORDER_RAISED)
z_layer = 0
self.omf = frame.omf
self.halfstep = (float(self.omf.parameters['zstepsize'])/2.0)*1.0e10
self.figure = Figure(frameon = True)
self.figure.set_facecolor('.82')
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
self.wheel_cmap = LinearSegmentedColormap.from_list('wheel_rgby',
['red', 'green', 'blue', 'yellow', 'red'])
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
x,y = indices((100,100), dtype = float) - 50.
wheel_angle = arctan2(x,y)
self.ax1 = self.figure.add_axes([0.1,0.1,0.7,0.8])
self.angle = ma.array(arctan2(-self.omf.my[:,:,z_layer],
self.omf.mx[:,:,z_layer]),
mask=(self.omf.M[:,:,z_layer] == 0.0))
self.angle[self.angle==360] = 0.0
print ma.getdata(self.angle)
xmax = (float(self.omf.parameters['xnodes']) *
float(self.omf.parameters['xstepsize']) * 1.0e10)
ymax = (float(self.omf.parameters['ynodes']) *
float(self.omf.parameters['ystepsize']) * 1.0e10)
self.extent = [0., xmax, 0., ymax]
self.im = self.ax1.imshow(self.angle.T, origin='lower',
interpolation = 'nearest',
extent = self.extent,
cmap = self.wheel_cmap,
vmin = -pi, vmax = pi)
self.ax1.set_title('Z Slice = ' +
str(z_layer*float(self.omf.parameters['zstepsize'])* 1.0e10
+ self.halfstep) +' Ang' ,size = 'xx-large')
self.ax1.set_xlabel('$x (\AA)$', size = 'x-large')
self.ax1.set_ylabel('$y (\AA)$', size = 'x-large')
self.ax1w = self.figure.add_axes([0.75,0.4,0.3,0.2], polar=True)
self.ax1w.yaxis.set_visible(False)
self.ax1w.imshow(wheel_angle, cmap=self.wheel_cmap,
extent=[0,2*pi,0,pi])
self.ax1w.set_title('M direction\n(in-plane)')
self.zselect = wx.Slider(self,-1,size = [300,40],minValue = int(0),
maxValue = int(self.omf.dims[2]-1),
style = wx.SL_AUTOTICKS)
self.datavalue = wx.StatusBar(self,-1)
self.datavalue.SetStatusText('Angle Value: ')
self.label = wx.StaticText(self,-1,'Select Z layer: ')
self.minVal = wx.StaticText(self,-1, '0.0')
self.maxVal = wx.StaticText(self,-1, str(self.omf.dims[2]*
(float(self.omf.parameters['zstepsize'])* 1.0e10)
-self.halfstep))
#Sizer Creation
toolSize = wx.BoxSizer(wx.HORIZONTAL)
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.label,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.minVal,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.zselect,0,wx.TOP|wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.maxVal,0,wx.LEFT|wx.RIGHT,border = 5)
toolSize.Add(mpl_toolbar,0,wx.RIGHT,border = 20)
toolSize.Add(self.datavalue,0,wx.LEFT|wx.RIGHT|wx.TOP,border = 20)
vertSize.Add(self.canvas,-1,wx.EXPAND|wx.LEFT|wx.RIGHT,border = 5)
vertSize.Add(toolSize,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.zselect.Bind(wx.EVT_SCROLL,self.newMomentZ)
self.canvas.mpl_connect('motion_notify_event',self.onMouseOver)
def __init__(self, canvas):
self.fm = FigureManagerBase(canvas, -1)
def __init__(self, canvas):
# delay loading pylab until matplotlib.use() is called
from matplotlib.backend_bases import FigureManagerBase
self.fm = FigureManagerBase(canvas, -1)
def __init__(self,parent,id):
wx.Panel.__init__(self,parent,id,style=wx.BORDER_SUNKEN)
self.scale_collection = array([])
self.real_data = flipud(parent.data.T)
self.parent = parent
self.raw_data = flipud(parent.model.T)
self.scaled_data = copy(self.raw_data)
self.plot_extent = parent.plot_extent
lower_lim = amin(self.scaled_data[nonzero(self.scaled_data.real)])
finite_real = self.real_data[isfinite(self.real_data)]
finite_real = finite_real[nonzero(finite_real)]
#Hack
#self.vmin = amin(log(finite_real.real))
self.vmax = amax(log(finite_real.real))
self.vmin = self.vmax - 12
self.figure = Figure()
self.axes = self.figure.add_subplot(211)
self.canvas = FigureCanvas(self, -1, self.figure)
fm = FigureManagerBase(self.canvas, 0)
_pylab_helpers.Gcf.set_active(fm)
# Instantiate the matplotlib navigation toolbar and explicitly show it.
mpl_toolbar = Toolbar(self.canvas)
mpl_toolbar.Realize()
self.myImage = self.showImage(log(abs(self.scaled_data)),self.axes)
self.modelColor = self.figure.colorbar(self.myImage)
self.dataaxes = self.figure.add_subplot(212)
self.datamyImage = self.showImage(log(self.real_data),self.dataaxes)
self.dataColor = self.figure.colorbar(self.datamyImage)
self.scale = wx.TextCtrl(self,-1)
self.updateButton = wx.Button(self,-1,'UPDATE')
self.resetButton = wx.Button(self,-1,'RESET')
self.areaScaleButton = wx.Button(self,-1,'AUTO SCALE')
BotSize = wx.BoxSizer(wx.HORIZONTAL)
vertSize = wx.BoxSizer(wx.VERTICAL)
BotSize.Add(self.scale,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.updateButton,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.resetButton,0,wx.LEFT|wx.RIGHT,border = 5)
BotSize.Add(self.areaScaleButton,0,wx.LEFT|wx.RIGHT, border = 5)
vertSize.Add(self.canvas,-1,wx.EXPAND)
vertSize.Add(mpl_toolbar,0)
vertSize.Add(BotSize,0,wx.ALL, border = 10)
self.SetSizer(vertSize)
self.Fit()
self.updateButton.Bind(wx.EVT_BUTTON,self.update)
self.resetButton.Bind(wx.EVT_BUTTON,self.reset)
self.areaScaleButton.Bind(wx.EVT_BUTTON,self.autoScale)
def function_get_fig_manager(self):
l_manager = FigureManagerBase()
