def __init__(self, parent, title, size):
wx.Frame.__init__(self, parent, title=title, size=size)
self.menubar = wx.MenuBar()
self.file = wx.Menu()
menusavefig = self.file.Append(wx.ID_ANY, '&Save figure',\
"Save the current figure")
menuexit = self.file.Append(wx.ID_EXIT, \
'&Exit', u"Close Fourier Frame")
self.menubar.Append(self.file, '&File')
self.SetMenuBar(self.menubar)
self.figure = Figure()
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.EXPAND)
self.SetSizer(self.sizer)
self.Bind(wx.EVT_MENU, self._OnSave, menusavefig)
self.Bind(wx.EVT_MENU, self._OnClose, menuexit)
self.Bind(wx.EVT_CLOSE, self._OnClose)
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.update()
def __init__(self, parent, title):
#wx.Frame.__init__(self, parent,id,'Procesador de Imagen Raster Version 1.1.1.1', size=(1000,600))
#p = wx.Panel(self)
wx.Frame.__init__(self, parent, title=title)
self.MakeMenuBar()
self.initpos = 100
self.sp = wx.SplitterWindow(self)
self.p1 = wx.Panel(self.sp)
self.p2 = wx.Panel(self.sp,style=wx.SUNKEN_BORDER)
#self.p2.Hide()
#self.p1.wx.SetBackgroundColour("pink")
#self.p2.wx.SetBackgroundColour("sky blue")
self.sp.Initialize(self.p1)
self.sp.SetMinimumPaneSize(10)
self.sp.SplitVertically(self.p1, self.p2,self.initpos)
#ListBox
dirlist = ['o','u','y']
listBox = wx.ListBox(self.p1,-1,(20,20),(80,120),dirlist, wx.LB_SINGLE)
listBox.SetSelection(3)
#self.figure = Figure()
#self.axes = self.figure.add_subplot(111)
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self.p2, wx.ID_ANY, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.EXPAND)
self.toolbar = NavigationToolbar2Wx(self.canvas)
## self.toolbar.Realize()
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.Show()
def __init__(self, parent, ID, title, data=None, axes_label=None):
wx.MDIChildFrame.__init__(self, parent, ID, title)
self.data = data
if axes_label is None:
self.axes_title = self.GetTitle()
self.axes_xlabel = "Frequency(GHz)"
self.axes_ylabel = "Mag(dB)"
else:
self.axes_title = axes_label[0]
self.axes_xlabel = axes_label[1]
self.axes_ylabel = axes_label[2]
#GUI layout
self.Maximize()
panel = wx.Panel(self, -1, style=wx.CLIP_CHILDREN)
self.canvas = FigureCanvas(panel, -1, Figure())
toolbar = NavigationToolbar2Wx(self.canvas)
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
sizer.Add(toolbar, 0, wx.EXPAND | wx.RIGHT)
self.canvas.mpl_connect('motion_notify_event', self.UpdateStatusBar)
def __init__(self, parent, columns, df_list_ctrl):
wx.Panel.__init__(self, parent)
columns_with_neutral_selection = [''] + list(columns)
self.columns = columns
self.df_list_ctrl = df_list_ctrl
self.figure = Figure(facecolor="white", figsize=(1, 1))
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self, -1, self.figure)
chart_toolbar = NavigationToolbar2Wx(self.canvas)
self.combo_box1 = wx.ComboBox(self, choices=columns_with_neutral_selection, style=wx.CB_READONLY)
self.combo_box2 = wx.ComboBox(self, choices=columns_with_neutral_selection, style=wx.CB_READONLY)
self.Bind(wx.EVT_COMBOBOX, self.on_combo_box_select)
row_sizer = wx.BoxSizer(wx.HORIZONTAL)
row_sizer.Add(self.combo_box1, 0, wx.ALL | wx.ALIGN_CENTER, 5)
row_sizer.Add(self.combo_box2, 0, wx.ALL | wx.ALIGN_CENTER, 5)
row_sizer.Add(chart_toolbar, 0, wx.ALL, 5)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, flag=wx.EXPAND, border=5)
sizer.Add(row_sizer)
self.SetSizer(sizer)
def OnInit(self, *args, **kw):
wxInitAllImageHandlers()
self.frame = wxFrame(None, -1, "PyScope")
self.frame.fig = Figure((5, 4), 75)
self.frame.canvas = FigureCanvasWx(self.frame, -1, self.frame.fig)
self.frame.toolbar = NavigationToolbar2Wx(self.frame.canvas)
self.frame.toolbar.Realize()
# On Windows, default frame size behaviour is incorrect
# you don't need this under Linux
tw, th = self.frame.toolbar.GetSizeTuple()
fw, fh = self.frame.canvas.GetSizeTuple()
self.frame.toolbar.SetSize(wxSize(fw, th))
# Create a figure manager to manage things
self.frame.figmgr = FigureManager(self.frame.canvas, 1, self)
# Now put all into a sizer
sizer = wxBoxSizer(wxVERTICAL)
# This way of adding to sizer allows resizing
sizer.Add(self.frame.canvas, 1, wxLEFT | wxTOP | wxGROW)
# Best to allow the toolbar to resize!
sizer.Add(self.frame.toolbar, 0, wxGROW)
self.frame.SetSizer(sizer)
self.frame.Fit()
EVT_TRIG(self, self.OnTrig)
# finalize wx stuff
self.frame.SetAutoLayout(true)
self.frame.Show()
self.SetTopWindow(self.frame)
return True
def _create_canvas(self, parent):
""" Create the MPL canvas. """
# The panel lets us add additional controls.
a = self.adapter
fig = self.figure
panel = wx.Panel(parent, -1, style=wx.CLIP_CHILDREN)
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
# matplotlib commands to create a canvas
mpl_control = FigureCanvas(panel, -1, fig)
toolbar = NavigationToolbar2Wx(mpl_control)
sizer.Add(toolbar, 0, wx.EXPAND)
sizer.Add(mpl_control, 1, wx.LEFT | wx.TOP | wx.GROW)
if a.max_size:
self.figure.canvas.SetMaxSize(a.max_size)
if a.min_size:
self.figure.canvas.SetMinSize((a.min_size))
if a.padding:
for side, pad in a.padding.items():
setattr(self.figure.subplotpars, side, pad)
return panel
def __init__(self):
Frame.__init__(self, None, -1, "Test embedded wxFigure")
self.fig = Figure((5, 4), 75)
self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
# On Windows, default frame size behaviour is incorrect
# you don't need this under Linux
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
self.toolbar.SetSize(Size(fw, th))
# Create a figure manager to manage things
# Now put all into a sizer
sizer = BoxSizer(VERTICAL)
# This way of adding to sizer allows resizing
sizer.Add(self.canvas, 1, LEFT | TOP | GROW)
# Best to allow the toolbar to resize!
sizer.Add(self.toolbar, 0, GROW)
self.SetSizer(sizer)
self.Fit()
EVT_TIMER(self, TIMER_ID, self.onTimer)
def __init__(self, title='', verb=1):
wx.Frame.__init__(self, None, -1, title, size=(400, 300))
self.verb = verb
self.figure = Figure()
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
# toolbar?
# self.toolbar = NavigationToolbar2Wx(self.canvas)
# self.toolbar.Realize()
# self.sizer.Add(self.toolbar, 0, wx.BOTTOM | wx.EXPAND)
# self.toolbar.update()
# axis plotting info
self.ax = None
self.xmin = 1.0
self.xmax = 0.0
self.ymin = 1.0
self.ymax = 0.0
self.xlabel = ''
self.ylabel = ''
self.style = 'graph'
self.images = []
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.update()
def __init__(self, ):
wx.Frame.__init__(self, None, -1, 'CanvasFrame', size=(550, 350))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
t = np.arange(0.0, 3.0, 0.01)
s = np.sin(2 * np.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.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, viewPanel, overlayList, displayCtx, extraModes=None):
"""Create a ``PlotProfile``.
:arg viewPanel: A :class:`.PlotPanel` instance.
:arg overlayList: The :class:`.OverlayList` instance.
:arg displayCtx: The :class:`.DisplayContext` instance.
:arg extraModes: Extra modes to pass through to the
:class:`.Profile` constructor.
"""
if extraModes is None:
extraModes = []
modes = ['panzoom'] + extraModes
profiles.Profile.__init__(self, viewPanel, overlayList, displayCtx,
modes)
self.__canvas = viewPanel.getCanvas()
self.__axis = viewPanel.getAxis()
# Pan/zoom functionality is actually
# implemented by the NavigationToolbar2Wx
# class, but the toolbar is not actually
# shown.
self.__toolbar = NavigationToolbar2Wx(self.__canvas)
self.__toolbar.Show(False)
# This flag keeps track of
# the toolbar pan state
self.__panning = False
def __init__(self, argv):
wx.Frame.__init__(self,None,-1,
'Segment Size',size=(550,350))
parser = argparse.ArgumentParser(description="utility to plot a persistence diagram")
parser.add_argument('file')
self.args = vars(parser.parse_args(argv[1:]))
self.file = self.args['file']
pf_json = load_data(self.file, 'persistence', None, None, None)
if pf_json == None :
print "Could not load persistence file : %s" % (self.args['file'],)
exit()
self.persistences = Persistences.fromJSONDict(pf_json)
self.SetBackgroundColour(wx.NamedColour("WHITE"))
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(NavigationToolbar2Wx(self.canvas), 1, wx.LEFT | wx.TOP | wx.GROW)
self.sizer.Add(self.canvas, 8, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
self.background = self.axes.figure.canvas.copy_from_bbox(self.axes.bbox)
self.colors = ['black', 'red', 'yellow', 'orange', 'blue', 'green', 'violet']
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_KEY_UP, self.KeyEvent)
self.index = 0
self.point_Refresh()
def __init__(self, title, mins, maxs, values, *args, **kw):
super().__init__(*args, **kw)
panel = wx.Panel(self)
panel.SetBackgroundColour(wx.Colour("White"))
self.fig = Figure((5, 4), 75)
# Adjust the subplots region to leave some space for the sliders and
# buttons
self.fig.subplots_adjust(left=0.25, bottom=0.25)
self.ax = self.fig.add_axes([0.1, 0.2, 0.85, 0.75])
self.canvas = FigureCanvasWxAgg(panel, -1, self.fig)
self.toolbar = NavigationToolbar2Wx(self.canvas) # matplotlib toolbar
self.toolbar.Realize()
self.sliders = []
mins = np.atleast_1d(mins).flatten()
maxs = np.atleast_1d(maxs).flatten()
values = np.array(values).flatten()
for idx, (min_, max_, val, tit) in enumerate(
zip(mins, maxs, values, title)):
slider = CustomSlider(
panel,
val,
min_,
max_,
title=tit,
height=wx.ScreenDC().GetPPI()[0] * 0.6,
pads=wx.ScreenDC().GetPPI()[0] * 0.1,
)
slider.idx = idx
self.sliders.append(slider)
# self.highlighter2 = CustomSlider(panel, 1, 1, 8)
self.clb = wx.CheckListBox(
panel, -1, (wx.ScreenDC().GetPPI()[0] * 2, -1), wx.DefaultSize, []
)
self.retrain = wx.Button(panel, -1, "Retrain")
hsizer = wx.BoxSizer(wx.HORIZONTAL)
rsizer = wx.BoxSizer(wx.VERTICAL)
# This way of adding to sizer allows resizing
rsizer.Add(self.canvas, 1, wx.EXPAND)
for slider in self.sliders:
# | wx.LEFT | wx.RIGHT, 20)
rsizer.Add(slider, 0, wx.EXPAND | wx.RIGHT)
rsizer.Add(self.toolbar, 0, wx.GROW | wx.RIGHT)
lsizer = wx.BoxSizer(wx.VERTICAL)
lsizer.Add(self.clb, 1, wx.EXPAND)
lsizer.Add(self.retrain, 0)
hsizer.Add(lsizer, 0, wx.EXPAND)
hsizer.Add(rsizer, 1, wx.EXPAND)
self.Bind(wx.EVT_LISTBOX, self.OnListBox)
self.Bind(wx.EVT_CHECKLISTBOX, self.OnCheckListBox)
self.Bind(wx.EVT_BUTTON, self.OnRetrain)
panel.SetSizer(hsizer)
self.Layout()
self.Centre()
def _init_canvas(self):
self._c = 0
#self._fig.tight_layout()#rect=[-0.03, 0.02, 1.03, 1])
self._canvas = FigureCanvasWxAgg(self._panel, -1, self._fig)
self._toolbar = NavigationToolbar2Wx(self._canvas)
#self._cursor = Cursor(self._ax, useblit=True, color='red',
# linewidth=0.5)
self._toolbar.Realize()
def add_toolbar(self):
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
# By adding toolbar in sizer, we are able to put it at the bottom
# of the frame - so appearance is closer to GTK version.
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
# update the axes menu on the toolbar
self.toolbar.update()
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.figure = Figure()
# self.axes = self.figure.add_subplot(1,1,1)
# self.axes = self.figure.gca(projection='3d')
self.canvas = FigureCanvas(self, -1, self.figure)
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.AddLabelTool(
5, '',
wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR,
(32, 32)))
self.toolbar.Realize()
self.cb_grid = wx.CheckBox(self, -1, "显示网格", style=wx.ALIGN_RIGHT)
# self.Bind(wx.EVT_CHECKBOX, self.on_cb_grid, self.cb_grid)
self.button1 = wx.Button(self, -1, "信道幅频特性图")
self.button2 = wx.Button(self, -1, "主同步星座图")
self.button3 = wx.Button(self, -1, "均衡前星座图")
self.button4 = wx.Button(self, -1, "均衡后星座图")
self.button5 = wx.Button(self, -1, "时频资源图")
self.button1.SetBackgroundColour('black')
self.button1.SetForegroundColour('white')
self.button2.SetBackgroundColour('black')
self.button2.SetForegroundColour('white')
self.button3.SetBackgroundColour('black')
self.button3.SetForegroundColour('white')
self.button4.SetBackgroundColour('black')
self.button4.SetForegroundColour('white')
self.button5.SetBackgroundColour('black')
self.button5.SetForegroundColour('white')
self.Bind(wx.EVT_BUTTON, self.draw, self.button1)
self.Bind(wx.EVT_BUTTON, self.draw_scatter, self.button2)
self.Bind(wx.EVT_BUTTON, self.draw_3d, self.button3)
self.Bind(wx.EVT_BUTTON, self.draw_plot, self.button4)
self.Bind(wx.EVT_BUTTON, self.draw_plot, self.button5)
########开始布局############
sizer1 = wx.BoxSizer(wx.HORIZONTAL)
sizer1.Add(self.button1, 1, wx.EXPAND)
sizer1.Add(self.button2, 1, wx.EXPAND)
sizer1.Add(self.button3, 1, wx.EXPAND)
sizer1.Add(self.button4, 1, wx.EXPAND)
sizer1.Add(self.button5, 1, wx.EXPAND)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.sizer.Add(wx.StaticLine(self), 0, wx.EXPAND | wx.TOP | wx.BOTTOM,
5)
self.sizer.Add(sizer1, 0, wx.EXPAND)
self.sizer.Add(wx.StaticLine(self), 0, wx.EXPAND | wx.TOP | wx.BOTTOM,
5)
self.sizer.Add(self.cb_grid, 0, wx.ALIGN_RIGHT)
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
def __init__(self, *args, **kwargs):
wx.Window.__init__(self,*args,**kwargs)
self.figure=Figure()
#starting variables
self.x = np.linspace(0.1,20,183)
self.InY = np.sin(1./self.x)
self.OutY = np.cos(1./self.x)
self.phase = 90
self.CombinedY = self.InY*np.sin(self.phase*np.pi/180)+self.OutY*np.cos(self.phase*np.pi/180)
# print "phase is "+str(self.phase)
# print "inY is multiplied by "+str(np.cos(self.phase*np.pi/180))
# print "outY is multiplied by "+str(np.sin(self.phase**np.pi/180))
# print "Difference for inY "+str(self.CombinedY[-1]-self.InY[-1])
# print "Difference for outY "+str(self.CombinedY[-1]-self.OutY[-1])
self.sortedX = self.x
self.sortedSignal = self.CombinedY
self.noBG_Y = self.InY
self.polyOrder = 3
self.despikeKernel = 15
self.despikeThreshold = 350
self.despikeRepeat = 12
#self.decompLevel = 2
# self.waveletType = 'coif2'
# self.waveletMode = 'sym'
self.despikeOn = False
#self.medianfilterOn = False
# self.waveletOn = False
# self.despikeLength = False
self.smoothOn= False
self.windowOn= True
self.polyOn= True
self.smoothWinType = 'hamming'
self.winlens = 30
self.interp_data,self.inv_x,self.delta_inv_x = dHvA_Util.inv_field(self.x,self.InY)
self.inYState = True
self.outYState = False
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
#toolbar
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
self.toolbar.SetSize(wx.Size(fw, th))
self.toolbar.update()
self.toolbar.Show()
#sizers
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas,1,wx.EXPAND)
self.sizer.Add(self.toolbar,0,wx.GROW)
self.SetSizer(self.sizer)
self.sizer.Fit(self)
self.draw()
def _get_toolbar(self, statbar):
if matplotlib.rcParams['toolbar']=='classic':
toolbar = NavigationToolbar2Wx(self.canvas, True)
elif matplotlib.rcParams['toolbar']=='toolbar2':
toolbar = NavigationToolbar2WxAgg(self.canvas)
toolbar.set_status_bar(statbar)
else:
toolbar = None
return toolbar
def add_toolbar(self):
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
self.toolbar.SetSize(wx.Size(fw, th))
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
# update the axes menu on the toolbar
self.toolbar.update()
def __init__(self, gui):
#super(wxVisualisation, self).__init__(parent=None, id=-1)
self.fig = pl.figure()
#self.figurepanel = FigureCanvasWxAgg(self.panel, -1, self.fig)
FigureCanvasWxAgg.__init__(self, gui, -1, self.fig)
self.xlim, self.ylim, self.dataon = (), (), False
# c'est la GUI e tle modele
self.gui, self.core = gui, gui.core
# polygone d'interaction sur une zone (pour pouvoir la modifier)
self.polyInteract = None
# liste de variables, sert pour la GUI et le combobox sur les variables
self.listeNomVar = []
for mod in self.core.modelList:
for k in gui.linesDic[mod].keys():
self.listeNomVar.extend(gui.linesDic[mod][k])
self.curVar, self.curContour = None, 'Charge' # variable courante selectionne
self.curMedia, self.curOri, self.curPlan, self.curGroupe = 0, 'Z', 0, None
# variable pour savoir si on est en cours de tracage d'une zone
self.typeZone = -1
# coordonnees et zone de la zone que l'on est en train de creer
self.curZone = None # objet graphique (ligne, point, rect..)
self.x1, self.y1 = [], []
self.tempZoneVal = [] # liste de values pour polyV
self.calcE = 0
self.calcT = 0
self.calcR = 0
# dit si calcule effectue ou non
# dictionnaire qui est compose des variables de l'Aquifere
# a chaque variable est associe une liste de zones
self.listeZone, self.listeZoneText, self.listeZmedia = {}, {}, {}
for i in range(len(self.listeNomVar)):
#print self.listeNomVar[i]
self.listeZone[self.listeNomVar[i]] = []
self.listeZoneText[self.listeNomVar[i]] = []
self.listeZmedia[self.listeNomVar[i]] = []
# toolbar de la visu, de type NavigationToolbar2Wx
self.toolbar = NavigationToolbar2Wx(self)
self.toolbar.Realize()
# ajout du subplot a la figure
self.cnv = self.fig.add_axes([.05, .05, .9,
.9]) #left,bottom, wide,height
#self.toolbar.update()
self.pos = self.mpl_connect('motion_notify_event', self.onPosition)
# create the major objects:
self.Contour, self.ContourF, self.ContourLabel, self.Vector = None, None, None, None
self.Grid, self.Particles, self.Image, self.Map = None, None, None, None
self.curOri, self.curLayer = 'Z', 0
self.mesh, self.triangles = False, None
def __init__(self, parent, tuplNomVar):
self.fig = pl.figure() #(9,8), 90)
FigureCanvasWxAgg.__init__(self, parent, -1, self.fig)
self.xlim, self.ylim, self.dataon = (), (), False
#ion() #pour faire animation??
# c'est la GUI e tle modele
self.parent = parent
self.model = parent.model
self.traduit = parent.traduit
self.tradinverse = parent.tradinverse
# liste de GraphicObject selon les types
self.listeObject = []
# polygone d'interaction sur une zone (pour pouvoir la modifier)
self.polyInteract = None
# liste de variables, sert pour la GUI et le combobox sur les variables
self.listeNomVar = list(tuplNomVar)
self.listeNomVar.extend(
['PHT3D', 'Transport', 'Observation', 'Tr_Rech', 'PH_Rech'])
self.curVar, self.curContour = None, 'Charge' # variable courante selectionne
self.curLayer, self.curOri, self.curPlan, self.curGroupe = 0, 'Z', 0, None
# liste des types de zones (des constantes)
self.listeNomZone = [
Zone.POINT, Zone.LIGNE, Zone.RECT, Zone.POLY, Zone.POLYV
]
# variable pour savoir si on est en cours de tracage d'une zone
self.typeZone = -1
# coordonnees et zone de la zone que l'on est en train de creer
self.curZone = None # objet graphique (ligne, point, rect..)
self.x1, self.y1 = [], []
self.tempZoneVal = [] # liste de valeurs pour polyV
self.calcE = 0
self.calcT = 0
self.calcR = 0
# dit si calcule effectue ou non
# dictionnaire qui est compose des variables de l'Aquifere
# a chaque variable est associe une liste de zones
self.listeZone, self.listeZoneText, self.listeZlayer = {}, {}, {}
for i in range(len(self.listeNomVar)):
#print self.listeNomVar[i]
self.listeZone[self.listeNomVar[i]] = []
self.listeZoneText[self.listeNomVar[i]] = []
self.listeZlayer[self.listeNomVar[i]] = []
# toolbar de la visu, de type NavigationToolbar2Wx
self.toolbar = NavigationToolbar2Wx(self)
self.toolbar.Realize()
# ajout du subplot a la figure
self.cnv = self.fig.add_axes([.05, .05, .9,
.88]) #left,bottom, wide,height
self.toolbar.update()
self.pos = self.mpl_connect('motion_notify_event', self.onPosition)
def __init__(self, parent):
wx.Panel.__init__(self, parent)
PlotDataCore.__init__(self, parent)
toolbar = NavigationToolbar2Wx(self.canvas)
self.vbox = wx.BoxSizer(wx.VERTICAL)
self.vbox.Add(self.canvas, 1, wx.EXPAND | wx.ALL)
self.vbox.Add(toolbar, 0, wx.EXPAND)
self.SetSizer(self.vbox)
def __init__(self, full_data) :
self.full_rips_persistences = [PD.fromJSONDict(entry[0]['full_diagram']) for entry in full_data]
self.full_rips_runtimes = [format_runtime(entry[0]['runtime']) for entry in full_data]
self.sparse_rips_persistences = [[PD.fromJSONDict(e['diagram']) for e in entry[1:]] for entry in full_data]
self.sparse_rips_distances = [[(e['bottleneck_distance'],e['wasserstein_l1'],e['wasserstein_l2']) for e in entry[1:]] \
for entry in full_data]
self.sparse_rips_sparsity = [[[float(s)*100.0 for s in e['sparsity']] if 'sparsity' in e else None for e in entry[1:]] for entry in full_data]
self.sparse_rips_runtimes = [[format_runtime(e['runtime']) for e in entry[1:]] for entry in full_data]
self.simplices = [int(entry['max_simplices']) if 'max_simplices' in entry else None for entry in full_data[0][1:]]
self.epsilons = [float(entry['epsilon']) if 'epsilon' in entry else None for entry in full_data[0][1:]]
wx.Frame.__init__(self, None, -1, "Full vs. Sparse Rips Filtration", size=(550, 550))
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_KEY_UP, self.KeyEvent)
self.segment_index = 0
self.full_rips_figure = Figure()
self.full_rips_axes = self.full_rips_figure.add_subplot(111)
self.full_rips_canvas = FigureCanvas(self, -1, self.full_rips_figure)
self.full_rips_title = self.full_rips_figure.suptitle("Persistence Diagram %s of %s runtime %s" % \
(self.segment_index + 1, len(self.full_rips_persistences), \
self.full_rips_runtimes[self.segment_index]))
self.simplices_index = 0
self.sparse_rips_figure = Figure()
self.sparse_rips_axes = self.sparse_rips_figure.add_subplot(111)
self.sparse_rips_canvas = FigureCanvas(self, -1, self.sparse_rips_figure)
self.sparse_rips_title = self.sparse_rips_figure.suptitle("max simplices %s" % \
(self.simplices[self.simplices_index],))
self.sizer = wx.GridBagSizer(hgap=5, vgap=5)
self.sizer.Add(NavigationToolbar2Wx(self.full_rips_canvas), pos=(0,0), span=(1,2), flag=wx.EXPAND)
self.sizer.AddGrowableCol(1,0)
self.sizer.Add(self.full_rips_canvas, pos=(1,0), span=(8,2), flag=wx.EXPAND)
self.sizer.AddGrowableCol(9,0)
self.sizer.Add(NavigationToolbar2Wx(self.sparse_rips_canvas), pos=(9,0), span=(1,2), flag=wx.EXPAND)
self.sizer.Add(self.sparse_rips_canvas, pos=(10,0), span=(8,2), flag=wx.EXPAND)
self.SetSizer(self.sizer)
self.Fit()
self.background = self.full_rips_axes.figure.canvas.copy_from_bbox(self.full_rips_axes.bbox)
self.refresh()
def initialize_toolbar(self):
"""
Creates a matplotlib toolbar and adds it to the status bar
"""
# status bar which shows information about current mouse location
self.status_bar = wx.StatusBar(self, -1)
self.status_bar.SetFieldsCount(1)
self.SetStatusBar(self.status_bar)
# add toolbar to allow user to zoom, save, ect
self.toolbar = NavigationToolbar2Wx(self.figure_canvas)
def add_toolbar(self): """ Add a toolbar to the Canvas. """ self.toolbar = NavigationToolbar2Wx(self.canvas) self.toolbar.Realize() tw, th = self.toolbar.GetSize() cw, ch = self.canvas.GetSize() self.toolbar.SetSize(wx.Size(cw, ch))
def add_toolbar(self):
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
if wx.Platform == "__WXMAC__":
self.SetToolBar(self.toolbar)
else:
tw, th = self.toolbar.GetSize()
fw, fh = self.canvas.GetSize()
self.toolbar.SetSize(wx.Size(fw, th))
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.update()
def add_toolbar(self):
"""Copied verbatim from embedding_wx2.py"""
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
if IS_MAC:
self.SetToolBar(self.toolbar)
else:
tw, th = self.toolbar.GetSizeTuple()
fw, fh = self.canvas.GetSizeTuple()
self.toolbar.SetSize(wx.Size(fw, th))
self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
self.toolbar.update()
def __init__(self, params, diagrams, bottleneck_distances, wasserstein_distances) :
wx.Frame.__init__(self,None,-1,
'Bottleneck Distance',size=(550,350))
self.params = params
self.diagrams = diagrams
self.bottleneck_distances = bottleneck_distances
self.wasserstein_distances = wasserstein_distances
self.segment_index = 0
self.segment_start = list(set([p_['segment_start'] for p in self.params for p_ in p]))
self.segment_start.sort()
self.segment_sizes = list(set([p_['segment_size'] for p in self.params for p_ in p]))
self.segment_sizes.sort()
self.alpha = list(set([float(p_['max_simplices']) / (float(p_['segment_size'])**2) for p in self.params for p_ in p]))
self.alpha.sort()
self.runtimes = [(numpy.mean([p_['runtime'] for p in self.params for p_ in p
if p_['segment_size'] == size and float(p_['max_simplices']) / (float(p_['segment_size'])**2) == alpha]),
size, alpha) for (size, alpha) in itertools.product(self.segment_sizes, self.alpha)]
d_avg = []
for i in range(len(self.segment_sizes)) :
this_distances = [self.bottleneck_distances[j] for j in range(i,len(self.bottleneck_distances),len(self.segment_sizes))]
d0 = [[[d[j][k] for d in this_distances if d[j][k] != -1] for k in range(len(this_distances[0][0]))]
for j in range(len(this_distances[0]))]
d0_avg = [[numpy.mean(d0[j][k]) if len(d0[j][k]) != 0 else 0.0 for k in range(len(this_distances[0][0]))]
for j in range(len(this_distances[0]))]
this_distances = [self.wasserstein_distances[j] for j in range(i,len(self.wasserstein_distances),len(self.segment_sizes))]
d1 = [[[d[j][k] for d in this_distances if d[j][k] != -1] for k in range(len(this_distances[0][0]))]
for j in range(len(this_distances[0]))]
d1_avg = [[numpy.mean(d1[j][k]) if len(d1[j][k]) != 0 else 0.0 for k in range(len(this_distances[0][0]))]
for j in range(len(this_distances[0]))]
d_avg.append((d0_avg, d1_avg))
self.plot_data = [(d0[0][1:], d1[0][1:]) for (d0, d1) in d_avg]
self.colors = ['#d73027','#fc8d59','#fee090','#4575b4', '#91cf60', '#1a9850', '#91bfdb']
self.figure = Figure()
self.axes_bottleneck = self.figure.add_subplot(511)
self.axes_wasserstein = self.figure.add_subplot(512)
self.axes_runtime = self.figure.add_subplot(514)
self.axes_simplices = self.figure.add_subplot(515)
self.canvas = FigureCanvas(self, -1, self.figure)
# self.title = self.figure.suptitle("Ttile")
self.sizer = self.sizer = wx.BoxSizer(wx.VERTICAL)
i = 0
self.sizer.Add(NavigationToolbar2Wx(self.canvas), 1, wx.LEFT | wx.TOP)
self.sizer.Add(self.canvas, 8, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.background = self.axes_bottleneck.figure.canvas.copy_from_bbox(self.axes_bottleneck.bbox)
self.refresh()
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_KEY_UP, self.KeyEvent)
def __init__(self, full_data, segment_data, persistences):
self.dataset_name = ""
if isinstance(full_data.config.data_file, list):
self.dataset_name = ", ".join(
[os.path.split(f)[1] for f in full_data.config.data_file])
else:
self.dataset_name = os.path.split(full_data.config.data_file)[1]
wx.Frame.__init__(self, None, -1, self.dataset_name, size=(550, 550))
self.full_data = full_data
self.segment_data = segment_data
self.persistences = persistences
self.Bind(wx.EVT_PAINT, self.OnPaint)
self.Bind(wx.EVT_KEY_UP, self.KeyEvent)
self.label_index = 0
self.segment_index = 0
self.labels = list(
set([s.max_label() for s in self.full_data.segments]))
self.colors = [[(random.random(), random.random(), random.random())
for i in self.full_data.config.data_index]
for l in self.labels]
self.data_figure = Figure()
self.data_axes = self.data_figure.add_subplot(111)
self.data_canvas = FigureCanvas(self, -1, self.data_figure)
self.title = self.data_figure.suptitle("Line %s of %s Label %s" % \
(self.segment_index, len(self.full_data.segments),
self.full_data.segments[self.segment_index].max_label()))
self.persistence_figure = Figure()
self.persistence_axes = self.persistence_figure.add_subplot(111)
self.persistence_canvas = FigureCanvas(self, -1,
self.persistence_figure)
self.persistence_title = self.persistence_figure.suptitle("Persistence Diagram %s of %s window size %s" % \
(self.segment_index, len(self.full_data.segments),
self.segment_data.segments[self.segment_index].window_size))
self.sizer = wx.GridBagSizer(hgap=5, vgap=5)
self.sizer.Add(NavigationToolbar2Wx(self.data_canvas),
pos=(0, 0),
span=(1, 2),
flag=wx.EXPAND)
self.sizer.AddGrowableCol(1, 0)
self.sizer.Add(self.data_canvas,
pos=(1, 0),
span=(8, 2),
flag=wx.EXPAND)
self.sizer.AddGrowableCol(9, 0)
self.sizer.Add(self.persistence_canvas,
pos=(9, 0),
span=(8, 2),
flag=wx.EXPAND)
self.SetSizer(self.sizer)
self.Fit()
self.background = self.data_axes.figure.canvas.copy_from_bbox(
self.data_axes.bbox)
self.refresh()
def __init__(self, parent, id=-1, dpi=None, **kwargs):
wx.Panel.__init__(self, parent, id=id, **kwargs)
self.figure = Figure(dpi=dpi, figsize=(2, 2))
self.canvas = Canvas(self, -1, self.figure)
self.figure.set_facecolor((1, 1, 1))
self.figure.set_edgecolor((1, 1, 1))
self.canvas.SetBackgroundColour('white')
self.subplot = self.figure.add_subplot(111)
self.plot_scores = None
self.class_masks = None
self.class_names = None
self.Loadings = None
self.object_opacity = None
self.object_accuracies = None
self.leg = None
self.maskedPCA1 = None
self.maskedPCA2 = None
self.axes = None
# If the script is loaded from ClassifierGUI, load the classification weaklearners
try:
self.classifier = classifier
self.classifier_rules = classifier.algorithm.weak_learners
except:
self.classifier_rules = [('None', 0, np.array([0, 0]))]
self.chMap = p.image_channel_colors
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
POSITION_OF_CONFIGURE_SUBPLOTS_BTN = 6
self.toolbar.DeleteToolByPos(POSITION_OF_CONFIGURE_SUBPLOTS_BTN)
self.statusBar = wx.StatusBar(self, -1)
self.statusBar.SetFieldsCount(1)
self.motion_event_active = False
self.canvas.mpl_connect('motion_notify_event', self.update_status_bar)
self.canvas.mpl_connect('button_press_event', self.on_open_image)
self.hide_legend_btn = wx.Button(self, -1, " Hide legend ")
wx.EVT_BUTTON(self.hide_legend_btn, -1, self.hide_show_legend)
self.hide_legend = True
tools_sizer = wx.BoxSizer(wx.HORIZONTAL)
tools_sizer.Add(self.toolbar, 0, wx.RIGHT | wx.EXPAND)
tools_sizer.AddSpacer(5)
tools_sizer.Add(self.hide_legend_btn, 0, wx.LEFT | wx.EXPAND)
tools_sizer.AddSpacer(5)
tools_sizer.Add(self.statusBar, 0, wx.LEFT | wx.EXPAND)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.EXPAND)
sizer.Add(tools_sizer, 0, wx.EXPAND)
self.SetSizer(sizer)
def _create_canvas(self, parent):
""" Create the MPL canvas. """
# The panel lets us add additional controls.
panel = wx.Panel(parent, -1, style=wx.CLIP_CHILDREN)
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
# matplotlib commands to create a canvas
mpl_control = FigureCanvas(panel, -1, self.value)
sizer.Add(mpl_control, 1, wx.LEFT | wx.TOP | wx.GROW)
toolbar = NavigationToolbar2Wx(mpl_control)
sizer.Add(toolbar, 0, wx.EXPAND)
self.value.canvas.SetMinSize((10, 10))
return panel
