class wxMatplotPanelSimple( wx.Panel ): def __init__( self, renderPanel, color=None, dpi=None, **kwargs ): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure # initialize Panel if 'id' not in list(kwargs.keys()): kwargs['id'] = wx.ID_ANY if 'style' not in list(kwargs.keys()): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__( self, renderPanel, **kwargs ) self.figure = Figure( None, dpi ) #self.canvas = NoRepaintCanvas( self, -1, self.figure ) self.canvas = FigureCanvasWxAgg( self, -1, self.figure ) sizer = wx.BoxSizer(); sizer.Add( self.canvas, 1, wx.EXPAND ) self.SetSizer( sizer ) self.axes = self.figure.add_subplot( 111 ) self.axes.set_aspect( 'auto' ) self.Bind(wx.EVT_SIZE, self._onSize) def _onSize( self, event = None ): pixels = tuple( [ self.GetSize()[0], self.GetSize()[1] ] ) print(pixels) #if self.canvas.GetMinSize( )[0] != pixels[0] or \ #self.canvas.GetMinSize( )[1] != pixels[1] : self.canvas.SetMinSize( pixels ) self.figure.set_size_inches( float( pixels[ 0 ] )/self.figure.get_dpi(), float( pixels[ 1 ] )/self.figure.get_dpi() ) self.canvas.draw()
class PlotPanel(wx.Panel): """The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__(self, parent, color=None, dpi=None, **kwargs): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent = parent # initialize Panel if 'id' not in kwargs.keys(): kwargs['id'] = wx.ID_ANY if 'style' not in kwargs.keys(): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__(self, parent, **kwargs) # initialize matplotlib stuff self.figure = Figure(None, dpi) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.SetColor(color) self._SetSize() self.initial_draw() self._resizeflag = False self._redrawflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor(self, rgbtuple=None): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get() clr = [c/255. for c in rgbtuple] self.figure.set_facecolor(clr) self.figure.set_edgecolor(clr) self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple)) def _onSize(self, event): self._resizeflag = True def _onIdle(self, evt): with draw_lock: if self._resizeflag: self._resizeflag = False self._SetSize() if self._redrawflag: self._redrawflag = False self.canvas.draw() def _SetSize(self): # When drawing from another thread, I think this may need a lock pixels = tuple(self.parent.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi()) def initial_draw(self): pass # abstract, to be overridden by child classes
def segmented_image(arr): """Get segmented image as a numpy array""" colors_dic = {'0':'#ffd300', '1':'#93cc93', '2':'#4970a3', '3':'#999999'} keys = list(np.unique(arr)) keys = [str(i) for i in keys] colors = [colors_dic.get(key) for key in keys] cmap = mpl.colors.ListedColormap(colors) fig = Figure() fig.set_size_inches(256/fig.get_dpi(), 256/fig.get_dpi()) fig.subplots_adjust(0,0,1,1) canvas = FigureCanvas(fig) ax = fig.gca() plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, hspace = 0, wspace = 0) ax.imshow(arr, cmap=cmap) ax.axis('off') ax.margins(0,0) canvas.draw() # draw the canvas, cache the renderer width, height = fig.get_size_inches() * fig.get_dpi() image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) return image
class MatplotlibPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)): self.parent = parent #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes) self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes) def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) def callback_enter_axes(self, event): self.parent.parent.panel_enter(event, panel=self.parent) def callback_leave_axes(self, event): self.parent.parent.panel_leave(event) def cla(self): self.ax.cla() self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I0, I, cmax=None, pois=None): if I!=None: if cmax==None: cmax = I.max() I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) self.ax.contour(I0>0, 1, colors="0.5", linewidths=1) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') if pois!=None: for i,(x,y) in enumerate(pois): self.ax.plot(x, y, 'wo', markersize=8) self.ax.text(x+1, y+1, '%d'%(i+1), bbox=dict(facecolor='w')) self.canvas.draw()
class MatplotlibPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)): self.parent = parent #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes) self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes) self.Bind(wx.EVT_ENTER_WINDOW, self.callback_enter_axes) self.Bind(wx.EVT_LEAVE_WINDOW, self.callback_leave_axes) def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) def callback_enter_axes(self, event): self.parent.parent.panel_enter(event, panel=self.parent) def callback_leave_axes(self, event): self.parent.parent.panel_leave(event) def cla(self): self.ax.cla() self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I, cmax=None): if I!=None: if cmax==None: cmax = I.max() I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') self.canvas.draw()
class myWxPlot(wx.Panel): def __init__( self, parent): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent = parent wx.Panel.__init__( self, parent) #matplotlib figure self.figure = Figure( None ) self.figure.set_facecolor( (0.7,0.7,1.) ) self.subplot = self.figure.add_subplot( 111 ) #canvas self.canvas = FigureCanvasWxAgg( self, -1, self.figure ) self.canvas.SetBackgroundColour( wx.Colour( 100,255,255 ) ) self._SetSize() self.draw2() def _SetSize( self ): size = tuple( self.parent.GetClientSize() ) self.SetSize( size ) self.canvas.SetSize( size ) self.figure.set_size_inches( float( size[0] )/self.figure.get_dpi(), float( size[1] )/self.figure.get_dpi() ) def draw(self): from mpl_toolkits.mplot3d import Axes3D import numpy as np x = np.arange(-3, 3, 0.25) y = np.arange(-3, 3, 0.25) X, Y = np.meshgrid(x, y) Z = np.sin(X)+ np.cos(Y) ax = Axes3D(self.figure) ax.plot_wireframe(X,Y,Z) def draw2(self): import numpy as np theta = np.arange(0,200, 0.1) x = 2*np.cos(theta/7) y = 3*np.sin(theta/3) self.subplot.plot(x,y, '-r') self.subplot.set_title("Sample", fontsize = 12) self.subplot.set_xlabel("x") self.subplot.set_ylabel("y") self.subplot.set_xlim([-4, 4]) self.subplot.set_ylim([-4, 4])
class MatplotlibPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)): self.parent = parent #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) self.parent = parent #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes) self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes) #self.Bind(wx.EVT_ENTER_WINDOW, self.callback_enter_axes) self.Bind(wx.EVT_LEAVE_WINDOW, self.callback_leave_axes) def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) def callback_enter_axes(self, event): self.parent.parent.panel_enter(event, panel=self.parent) def callback_leave_axes(self, event): self.parent.parent.panel_leave(event) def cla(self): self.ax.cla() self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I, cmax=None): if I!=None: if cmax==None: cmax = I.max() I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') self.canvas.draw()
class IdentifyMatplotlibPanel(wx.Panel): def __init__(self, parent, ID=-1, label="", pos=wx.DefaultPosition, size=(100, 25)): #(0) Initialize panel: wx.Panel.__init__(self, parent, ID, pos, size, wx.STATIC_BORDER, label) self.SetMinSize(size) #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8, ) * 3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() def _create_axes(self): self.ax = self.figure.add_axes((0, 0, 1, 1), axisbg=[0.5] * 3) # self.plot(None) # self.ax.plot( np.random.randn(10) ) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple(self.GetClientSize()) self.canvas.SetSize(szPixels) szInches = float(szPixels[0]) / self.figure.get_dpi(), float( szPixels[1]) / self.figure.get_dpi() self.figure.set_size_inches(szInches[0], szInches[1]) def cla(self): self.ax.cla() self.ax.set_position([0, 0, 1, 1]) self.ax.set_axis_bgcolor([0.5] * 3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0, 1), ylim=(0, 1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I, cmax=None): if I != None: if cmax == None: cmax = I.max() I[I == 0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05] * 3) self.ax.axis('image') self.canvas.draw()
class CheckMeansPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)): #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() # self.cidAxisEnter = self.canvas.mpl_connect('axes_enter_event', self.callback_enter_axes) # self.cidAxisLeave = self.canvas.mpl_connect('axes_leave_event', self.callback_leave_axes) def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) self.cax = self.figure.add_axes((0.1,0.05,0.8,0.02), axisbg=[0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) # def callback_enter_axes(self, event): # print 'buta-san in' # def callback_leave_axes(self, event): # print 'buta-san out' def cla(self): self.ax.cla() self.cax.cla() # self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I): I = np.asarray(I, dtype=float) I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower') pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') cb = pyplot.colorbar(cax=self.cax, mappable=self.ax.images[0], orientation='horizontal') pyplot.setp(cb.ax.get_xticklabels(), color='0.5') self.canvas.draw()
class PanelPlot(wx.Panel): def __init__(self, parent): wx.Panel.__init__(self, parent, style=wx.WS_EX_PROCESS_IDLE) ''', style = wx.NO_FULL_REPAINT_ON_RESIZE''' self.figure = Figure() self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.set_size() self.draw() self._resize_flag = False #self.Bind(wx.EVT_IDLE, self.on_idle) #self.Bind(wx.EVT_SIZE, self.on_size) def on_idle(self, event): #event.RequestMore() if self._resize_flag: self._resize_flag = False #wx.CallLater(500,self.set_size()) def on_size(self, event): self._resize_flag = True def set_size(self): pixels = tuple(self.GetSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches( [float(x) / self.figure.get_dpi() for x in pixels]) def draw(self): self.canvas.draw()
def getPlotImage(data_x, data_y, cols, title, line_labels, x_label, y_label, ylim=None, legend=1): cols = [(col[0] / 255.0, col[1] / 255.0, col[2] / 255.0) for col in cols] fig = Figure( # figsize=(6.4, 3.6), dpi=300, figsize=(4.8, 2.7), dpi=400, # edgecolor='k', # facecolor ='k' ) # fig.tight_layout() # fig.set_tight_layout(True) fig.subplots_adjust( bottom=0.17, right=0.95, ) canvas = FigureCanvas(fig) ax = fig.gca() n_data = len(data_y) for i in range(n_data): datum_y = data_y[i] line_label = line_labels[i] col = cols[i] args = {'color': col} if legend: args['label'] = line_label ax.plot(data_x, datum_y, **args) plt.rcParams['axes.titlesize'] = 10 # fontdict = {'fontsize': plt.rcParams['axes.titlesize'], # 'fontweight': plt.rcParams['axes.titleweight'], # 'verticalalignment': 'baseline', # 'horizontalalignment': plt.loc # } ax.set_title(title, # fontdict=fontdict ) if legend: ax.legend(fancybox=True, framealpha=0.1) ax.grid(1) ax.set_xlabel(x_label) ax.set_ylabel(y_label) if ylim is not None: ax.set_ylim(*ylim) canvas.draw() width, height = fig.get_size_inches() * fig.get_dpi() plot_img = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) return plot_img
class wxMatplotPanelSimple(wx.Panel): def __init__(self, renderPanel, color=None, dpi=None, **kwargs): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure # initialize Panel if 'id' not in list(kwargs.keys()): kwargs['id'] = wx.ID_ANY if 'style' not in list(kwargs.keys()): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__(self, renderPanel, **kwargs) self.figure = Figure(None, dpi) #self.canvas = NoRepaintCanvas( self, -1, self.figure ) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) sizer = wx.BoxSizer() sizer.Add(self.canvas, 1, wx.EXPAND) self.SetSizer(sizer) self.axes = self.figure.add_subplot(111) self.axes.set_aspect('auto') self.Bind(wx.EVT_SIZE, self._onSize) def _onSize(self, event=None): pixels = tuple([self.GetSize()[0], self.GetSize()[1]]) print(pixels) # if self.canvas.GetMinSize( )[0] != pixels[0] or \ # self.canvas.GetMinSize( )[1] != pixels[1] : self.canvas.SetMinSize(pixels) self.figure.set_size_inches( float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi()) self.canvas.draw()
def visualize(feat, labels, epoch): colors = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff', '#ff00ff', '#990000', '#999900', '#009900', '#009999'] fig = Figure(figsize=(6, 6), dpi=100) fig.clf() canvas = FigureCanvas(fig) ax = fig.gca() feat = feat.data.cpu().numpy() labels = labels.data.cpu().numpy() for i in range(10): ax.scatter(feat[labels == i, 0], feat[labels == i, 1], c=colors[i], s=1) ax.text(feat[labels == i, 0].mean(), feat[labels == i, 1].mean(), str(i), color='black', fontsize=12) ax.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc='upper right') ax.text(0, 0, "epoch=%d" % epoch) canvas.draw() if (os.path.exists(imgDir)): pass else: os.makedirs(imgDir) fig.savefig(imgDir + '/epoch=%d.jpg' % epoch) width, height = fig.get_size_inches() * fig.get_dpi() img = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) tt = transforms.ToTensor() timg = tt(img) timg.unsqueeze(0) writer.add_image('NormFace', timg, epoch)
def get_virtual_drone(): fig_scale = 1 fig = Figure(figsize=(4 * fig_scale, 3 * fig_scale), dpi=200) canvas = FigureCanvas(fig) ax = fig.gca(projection='3d') ax.set_title("Drone Position (meters)") ax.set_ylim([-0.7, 0.7]) ax.set_xlim([-0.7, 0.7]) ax.set_zlim([0, 1]) color = "#00ff00" quiver_color = "#0055ff" if d_pos != None: ax.scatter([d_pos['x']], [d_pos['y']], [d_pos['z']], color=color) if d_vel != None: ax.quiver(d_pos['x'], d_pos['y'], d_pos['z'], d_vel['x'], d_vel['y'], d_vel['z'], length=0.2, color=quiver_color) canvas.draw() width, height = fig.get_size_inches() * fig.get_dpi() image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) return image
def plot_as_image(masking: "Masking") -> "Array": """ Plot layer wise density as bar plot figure. :param masking: Masking instance :type masking: sparselearning.core.Masking :return: Numpy array representing figure (H, W, 3) :rtype: np.ndarray """ fig = Figure() canvas = FigureCanvas(fig) ax = fig.gca() density_ll = _get_density_ll(masking) bin_ll = np.arange(len(density_ll)) + 1 width = 0.8 ax.bar(bin_ll, density_ll, width, color="b") ax.set_ylabel("Density") ax.set_xlabel("Layer Number") canvas.draw() # draw the canvas, cache the renderer width, height = fig.get_size_inches() * fig.get_dpi() width, height = int(width), int(height) image = np.fromstring(canvas.tostring_rgb(), dtype="uint8").reshape(height, width, 3) return image
def get_Img_Matrix_Antialiasing(point_pos, w, x_size=128, y_size=128): point_pos = np.dot(w, point_pos) mydpi = 96 fig = Figure(figsize=(x_size / mydpi, y_size / mydpi), dpi=mydpi) fig.subplots_adjust(left=0., bottom=0., right=1., top=1., wspace=0, hspace=0) fig.set_facecolor('black') a = fig.add_subplot(111, axisbg='r') canvas = FigureCanvas(fig) # ax = fig.gca() a.axis([0, x_size, y_size, 0]) a.axis('off') a.plot(point_pos[:, 0], point_pos[:, 1], c='w') # fig.tight_layout() # plt.tight_layout() canvas.draw() # draw the canvas, cache the renderer width, height = fig.get_size_inches() * fig.get_dpi() # print(width, height) image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)[:, :, 0] return image
class PlotPlotPanel(wx.Panel): def __init__(self, parent, dpi=None, **kwargs): wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs) self.ztv_frame = self.GetTopLevelParent() self.figure = Figure(dpi=None, figsize=(1.,1.)) self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.Bind(wx.EVT_SIZE, self._onSize) self.axes_widget = AxesWidget(self.figure.gca()) self.axes_widget.connect_event('motion_notify_event', self.on_motion) self.plot_point = None def on_motion(self, evt): if evt.xdata is not None: xarg = np.abs(self.ztv_frame.plot_panel.plot_positions - evt.xdata).argmin() ydata = self.ztv_frame.plot_panel.plot_im_values[xarg] self.ztv_frame.plot_panel.cursor_position_textctrl.SetValue('{0:.6g},{1:.6g}'.format(evt.xdata, ydata)) if self.plot_point is None: self.plot_point, = self.axes.plot([evt.xdata], [ydata], 'xm') else: self.plot_point.set_data([[evt.xdata], [ydata]]) self.figure.canvas.draw() def _onSize(self, event): self._SetSize() def _SetSize(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def visualize_cos(feat, labels, epoch): colors = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff', '#ff00ff', '#990000', '#999900', '#009900', '#009999'] fig = Figure(figsize=(6, 6), dpi=100) fig.clf() canvas = FigureCanvas(fig) ax = fig.gca() feat = feat / feat.norm(2, 1).unsqueeze(1).repeat(1, 2) feat = feat.data.cpu().numpy() labels = labels.data.cpu().numpy() weight = head.state_dict()['weight'].t() weight = weight / weight.norm(2, 1).unsqueeze(1).repeat(1, 2) weight = weight.data.cpu().numpy() for i in range(10): ax.scatter(feat[labels == i, 0], feat[labels == i, 1], c=colors[i], s=1) ax.text(feat[labels == i, 0].mean(), feat[labels == i, 1].mean(), str(i), color='black', fontsize=12) ax.plot([0,weight[i][0]],[0,weight[i][1]],linewidth=2,color=colors[i]) ax.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc='upper right') ax.text(0, 0, "epoch=%d" % epoch) canvas.draw() fig.savefig(imgDir + '/cos_epoch=%d.jpg' % epoch) width, height = fig.get_size_inches() * fig.get_dpi() img = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) tt = transforms.ToTensor() timg = tt(img) timg.unsqueeze(0) writer.add_image('NormFace_cos', timg, epoch)
class Plot: def __init__(self, size, pos, x_label, x, y_label, y, title): self.x_series = x self.x_label = x_label self.y_label = y_label self.y_series = y self.title = title self.size = size self.pos = pos self.fig = Figure() self.figure = [] def draw(self, window): canvas = FigureCanvas(self.fig) ax = self.fig.gca() ax.plot(self.x_series, self.y_series) ax.set_xlabel(self.x_label) ax.set_ylabel(self.y_label) ax.set_title(self.title) ax.grid(True) canvas.draw() # draw the canvas, cache the renderer width, height = self.fig.get_size_inches() * self.fig.get_dpi() self.figure = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape( int(height), int(width), 3) self.figure = cv2.resize(self.figure, flip(self.size)) window[self.pos[0]:self.pos[0] + self.size[0], self.pos[1]:self.pos[1] + self.size[1], :] = self.figure
def my_draw(self): """ This function is used by DQL_visualization_actions.py to make video from sequence of actions """ fig = Figure() canvas = FigureCanvas(fig) ax = fig.gca() ax.imshow(self.image_playground) rect = patches.Rectangle((self.agent_window[0], self.agent_window[1]), self.agent_window[2] - self.agent_window[0], self.agent_window[3] - self.agent_window[1], linewidth=1, edgecolor='r', facecolor='none') ax.add_patch(rect) for target in [self.targets[0]]: rect2 = patches.Rectangle((target[0], target[1]), target[2] - target[0], target[3] - target[1], linewidth=1, edgecolor='b', facecolor='none') ax.add_patch(rect2) canvas.draw() width, height = fig.get_size_inches() * fig.get_dpi() return np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
def my_draw(self): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure() canvas = FigureCanvas(fig) ax = fig.gca() ax.imshow(self.image_playground) # Drawing agent window rect = patches.Rectangle((self.agent_window[0], self.agent_window[1]), self.agent_window[2] - self.agent_window[0], self.agent_window[3] - self.agent_window[1], linewidth=1, edgecolor='r', facecolor='none') ax.add_patch(rect) # Drawing target objects bouning boxes for target in [self.targets[0]]: rect2 = patches.Rectangle((target[0], target[1]), target[2] - target[0], target[3] - target[1], linewidth=1, edgecolor='b', facecolor='none') ax.add_patch(rect2) canvas.draw() # draw the canvas, cache the renderer width, height = fig.get_size_inches() * fig.get_dpi() return np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3)
def __init__(self, figure=None, logger=None, width=500, height=500): Callback.Callbacks.__init__(self) if figure is None: figure = Figure() dpi = figure.get_dpi() if dpi is None or dpi < 0.1: dpi = 100 wd_in, ht_in = float(width)/dpi, float(height)/dpi figure.set_size_inches(wd_in, ht_in) self.fig = figure if hasattr(self.fig, 'set_tight_layout'): self.fig.set_tight_layout(True) self.logger = logger self.fontsize = 10 self.ax = None self.logx = False self.logy = False self.xdata = [] self.ydata = [] # For callbacks for name in ('draw-canvas', ): self.enable_callback(name)
def __init__(self, figure: Figure): """Initialize window.""" super(FigureWindow, self).__init__(size=figure.get_size_inches() * figure.get_dpi()) chart = Chart() self.content = toga.Box(children=[chart]) chart.draw(figure)
class PlotPanel(XmlPanel): """Draw a plot (graph)""" def __init__(self, parent,elem): XmlPanel.__init__(self, parent) self.border = True self.elem = elem self.figure = Figure() self.applySize() self.plot = FigureCanvas(self,-1,self.figure) # FancyText(self,"hi") self.sizer = wx.BoxSizer(wx.VERTICAL) self.sizer.Add(self.plot, 1, wx.LEFT | wx.TOP | wx.GROW) self.SetSizer(self.sizer) self.Fit() self.render() def applySize(self): size = self.elem.attrib.get("size",None) if size: psize = self.parent.GetSize() try: size = literal_eval(size) size = (min(psize[0],size[0]), min(psize[1],size[1])) # graph can't be bigger than the xmlterm self.SetInitialSize(size) self.SetSize(size) dpi = self.figure.get_dpi() self.figure.set_size_inches(float(size[0])/dpi,float(size[1])/dpi) # self.plot.SetSize(size) self.Fit() except ValueError,e: # size is malformed print "bad size" pass return size return None
class matplotPanel(wx.Panel): def __init__(self, drawfunc, parent, id, *args, **kwargs): super(matplotPanel, self).__init__(parent, id, *args, **kwargs) self.drawfunc = drawfunc self.parent = parent self.Bind(wx.EVT_SIZE, self.OnSize) self.Bind(wx.EVT_PAINT, self.OnPaint) def _SetSize(self): # size = tuple(self.parent.GetClientSize()) size = tuple(self.GetClientSize()) # self.SetSize(size) self.figure = Figure(None) self.canvas = FigureCanvasWxAgg(self, wx.NewId(), self.figure) self.canvas.SetSize(size) dpi = self.figure.get_dpi() self.figure.set_size_inches(float(size[0]) / dpi, float(size[1]) / dpi) def OnSize(self, ev): self.Refresh() def OnPaint(self, ev): self._SetSize() dc = wx.PaintDC(self) # don't delete this line self.drawfunc(self)
def set_title(fig: Figure, ax: Axes, title: str, digital: bool): """Sets the title for the given axes to the given value. This is more particular than the default matplotlib Axes.set_title. :param Figure fig: the figure the axes is in :param Axes ax: the axes which you want to have a title :param str title: the desired title text :param bool digital: if True, a large font size is selected. Otherwise, a smaller font size is selected :returns: TextCollection that was added """ figw = fig.get_figwidth() figh = fig.get_figheight() figw_px = figw * fig.get_dpi() pad = max(int(0.3125 * figh), 1) font_size = int((8 / 1.92) * figw) if digital else int((4 / 1.92) * figw) font_size = max(5, font_size) axtitle = ax.set_title(title, pad=pad) axtitle.set_fontsize(font_size) renderer = fig.canvas.get_renderer() bb = axtitle.get_window_extent(renderer=renderer) while bb.width >= (figw_px - 26) * 0.9 and font_size > 9: font_size = max(5, font_size - 5) axtitle.set_fontsize(font_size) bb = axtitle.get_window_extent(renderer=renderer) return axtitle
class PlotPanel(wx.Panel): """ The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event. """ def __init__(self, parent, obj_id): # initialize Panel wx.Panel.__init__(self, parent, obj_id) # initialize matplotlib stuff self.figure = Figure(None, None) self.canvas = FigureCanvasWxAgg(self, wx.ID_ANY, self.figure) rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get() clr = [c / 255.0 for c in rgbtuple] self.figure.set_facecolor(clr) self.figure.set_edgecolor(clr) self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple)) self.Bind(wx.EVT_SIZE, self._on_size) def _on_size(self, event): self._set_size() def _set_size(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi()) def draw(self): pass # abstract, to be overridden by child classes
class PlotPanel(wx.Panel): """ The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event. """ def __init__(self, parent, obj_id): # initialize Panel wx.Panel.__init__(self, parent, obj_id) # initialize matplotlib stuff self.figure = Figure(None, None) self.canvas = FigureCanvasWxAgg(self, wx.ID_ANY, self.figure) rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get() clr = [c / 255. for c in rgbtuple] self.figure.set_facecolor(clr) self.figure.set_edgecolor(clr) self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple)) self.Bind(wx.EVT_SIZE, self._on_size) def _on_size(self, event): self._set_size() def _set_size(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches( float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi()) def draw(self): pass # abstract, to be overridden by child classes
class Render(object): def __init__(self, figsize=(15, 15), dpi=48): self.figsize = figsize self.dpi = dpi self.fig = Figure(figsize=figsize, dpi=dpi) self.canvas = FigureCanvas(self.fig) self.artists = [] def add_artist(self, artist): self.artists.append(artist) def new_frame(self): self.fig.clear() self.ax = self.fig.gca() self.ax.clear() for artist in self.artists: artist.remove() self.artists = [] self.ax.set_xlim(-0.1, MAP_SIZE + 1.1) self.ax.set_ylim(-0.1, MAP_SIZE + 1.1) self.ax.axis('off') def draw(self): for artist in self.artists: self.ax.add_artist(artist) self.canvas.draw() # draw the canvas, cache the renderer width, height = self.fig.get_size_inches() * self.fig.get_dpi() image = np.frombuffer(self.canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) return image
class PlotPanel (wx.Panel): """The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__( self, parent, **kwargs ): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure # initialize Panel if 'id' not in kwargs.keys(): kwargs['id'] = wx.ID_ANY if 'style' not in kwargs.keys(): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__( self, parent, **kwargs ) # initialize matplotlib stuff self.figure = Figure() self.canvas = FigureCanvasWxAgg( self, -1, self.figure ) self._SetSize() self.draw() #self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def _onSize( self, event ): self._SetSize() def _SetSize( self ): pixels = tuple( self.parent.GetClientSize() ) self.SetSize( pixels ) self.canvas.SetSize( pixels ) self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(), float( pixels[1] )/self.figure.get_dpi() ) def draw(self): pass # abstract, to be overridden by child classes
class PlotPanel (wx.Panel): """ PlotPanel class taken from http://www.scipy.org/Matplotlib_figure_in_a_wx_panel The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__(self, parent, color=None, dpi=None, **kwargs): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent = parent # initialize Panel if 'id' not in list(kwargs.keys()): kwargs['id'] = wx.ID_ANY if 'style' not in list(kwargs.keys()): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__(self, parent, **kwargs) # initialize matplotlib stuff self.figure = Figure(None, dpi) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.SetColor(color) self._SetSize() self.draw() self._resizeflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor(self, rgbtuple=None): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get() clr = [c / 255. for c in rgbtuple] self.figure.set_facecolor(clr) self.figure.set_edgecolor(clr) self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple)) def _onSize(self, event): self._resizeflag = True def _onIdle(self, evt): if self._resizeflag: self._resizeflag = False self._SetSize() def _SetSize(self): pixels = tuple(self.parent.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi()) def draw(self): # abstract, to be overridden by child classes raise NotImplementedError( "Abstract method - must be defined in subclass")
class GraphFrame(tk.Frame): def __init__(self, root, **kw): self.root = root tk.Frame.__init__(self, self.root, kw) # создание полей под объекты GUI self.frame, self.f_1, self.ax0, self.label_font, self.f_1_canvas = None, None, None, None, None self.pause_button = None self.data, self.legend = [["Имя 0", [1, 2, 3], "Name 0"]], None self.table = None self._show_time = 1000 self.show_time_var, self.show_time_label, self.show_time_entry = None, None, None self.gui_set() self.x_label = "Напряжение ЗС, В" self.y_label = "Ток МПЗ, А" def gui_set(self): # graph self.frame = tk.Frame(self, bg="gray10") self.frame.place(x=10, y=10, relwidth=1, relheight=1, width=-20, height=-40) self.f_1 = Figure(figsize=(6.5, 5.5), dpi=100, facecolor="#A9A9A9", frameon=True) self.ax0 = self.f_1.add_axes((0.1, 0.15, 0.88, 0.83), facecolor="#D3D3D3", frameon=True, yscale="linear") self.label_font = {'family': 'Arial', 'color': 'Black', 'weight': 'normal', 'size': 12, } self.f_1_canvas = FigureCanvasTkAgg(self.f_1, master=self.frame) self.f_1_canvas.get_tk_widget().pack(fill="both", expand=1) self.f_1_canvas.draw() self.resize() toolbar = NavigationToolbar2Tk(self.f_1_canvas, self) toolbar.place(x=0, rely=1, y=-35) toolbar.update() def resize(self): self.frame.update_idletasks() dx = self.frame.winfo_width() dy = self.frame.winfo_height() if dx > 1 and dx > 1: try: frame_info = self.frame.place_info() dpi = self.f_1.get_dpi() f_1_height = (float(frame_info["relheight"]) * dy + float(frame_info["height"])) / dpi f_1_width = (float(frame_info["relwidth"]) * dx + float(frame_info["width"])) / dpi self.f_1.set_size_inches(f_1_width, f_1_height) except: pass self.f_1_canvas.show() # self.f_1_canvas.get_tk_widget().pack(fill="both", expand=1) pass def plot(self, *arg, **kw): self.ax0.cla() self.ax0.plot(*arg, **kw) self.ax0.set_xlabel(self.x_label) self.ax0.set_ylabel(self.y_label) self.ax0.grid(which="both") self.f_1_canvas.draw() pass
class PlotPanel(wx.Panel): """The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__(self, parent, color=None, dpi=None, **kwargs): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure # initialize Panel if 'id' not in kwargs.keys(): kwargs['id'] = wx.ID_ANY if 'style' not in kwargs.keys(): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__(self, parent, **kwargs) # initialize matplotlib stuff self.figure = Figure(None, dpi) self.axes = self.figure.gca() self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.SetColor(color) self._SetSize() self.draw() self.axes.set_xlabel('T (s)') self.axes.set_ylabel('Alfa_max (g)') self.axes.set_title("wave curve") self.axes.grid(True) self._resizeflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor(self, rgbtuple=None): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get() clr = [c / 255. for c in rgbtuple] self.figure.set_facecolor(clr) self.figure.set_edgecolor(clr) self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple)) def _onSize(self, event): self._resizeflag = True def _onIdle(self, evt): if self._resizeflag: self._resizeflag = False self._SetSize() def _SetSize(self): pixels = tuple(self.parent.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches( float(pixels[0]) / self.figure.get_dpi(), float(pixels[1]) / self.figure.get_dpi()) def draw(self): pass # abstract, to be overridden by child classes
def __call__(self, shape, seed=None): if seed is not None: self.rng.seed(seed) else: self.rng.seed(int(time.time() * 100) % (2**32 - 1)) target_width, target_height = shape fig = Figure() canvas = FigureCanvas(fig) ax = fig.gca() ax.axis('off') def central_crop(image, new_width, new_height): image = image.copy() width, height = image.size left = (width - new_width) / 2 top = (height - new_height) / 2 right = (width + new_width) / 2 bottom = (height + new_height) / 2 image = image.crop((left, top, right, bottom)) return image if self.rng.choice([True, False], p=[self.fat_stroke_prob, 1 - self.fat_stroke_prob]): stroke_index = self.rng.randint(0, len(self.strokes)) stroke_width = self.fat_stroke_width stroke = self.strokes[ stroke_index][:int(len(self.strokes[stroke_index]) * 1)] ax.plot(*stroke, color='black', lw=stroke_width) else: n_strokes = int(self.rng.normal(5, 1)) for _ in range(n_strokes): stroke_index = self.rng.randint(0, len(self.strokes)) stroke_width = self.rng.randint(self.min_stroke_width, self.max_stroke_width) stroke = self.strokes[ stroke_index][:int(len(self.strokes[stroke_index]) * 1)] ax.plot(*stroke, color='black', lw=stroke_width) canvas.draw() # draw the canvas, cache the renderer width, height = fig.get_size_inches() * fig.get_dpi() image = np.frombuffer(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) image = Image.fromarray(image) image = image.resize( (int(1.25 * target_width), int(1.25 * target_height))) image = central_crop(image, target_width, target_height) image = image.convert('1') return np.array(image).astype('float32')
def render(self, mode='human'): """ use PCA to plot users, items and actions. :param mode: :return: """ if mode == 'rgb_array': users_vec = np.array( [u.embedding for uid, u in self.users.items()]) items_vec = np.array( [i.embedding for iid, i in self.items.items()]) # build dimensionality reduction if dims > 2 if items_vec.shape[1] > 2: if not hasattr(self, 'pca'): self.pca = PCA(n_components=2) self.pca.fit(items_vec) items = self.pca.transform(items_vec) users = self.pca.transform(users_vec) else: items, users = items_vec, users_vec fig = Figure(figsize=(5, 5)) canvas = FigureCanvas(fig) ax = fig.gca() ax.scatter(items[:, 0], items[:, 1], c='green', label='items') ax.scatter(users[:, 0], users[:, 1], c='red', label='users') # active user x, y = users[self.active_user] ax.scatter(x, y, marker='*', c='black', s=20, label='active user') # active user recommendation history # actions = self.last_actions[self.active_user] # rewards = self.last_rewards[self.active_user] # TODO: if item set will change will have problems # if self.action_is_items: # lines = [ [(x, y), a ] for a in actions] # else: # lines = [ [(x, y), (self.items[a][0], self.items[a][1])] for a in actions] # # c = [ 'yellow' if r else 'black' for r in rewards] # lc = mc.LineCollection(lines, colors=c, linewidths=2) # ax.add_collection(lc) ax.legend() ax.axis('off') canvas.draw() # draw the canvas, cache the renderer width, height = [ int(x) for x in fig.get_size_inches() * fig.get_dpi() ] image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(height, width, 3) return image else: pass
def __init__(self, figure: Figure, title: str, app: toga.App): """Initialize window.""" self.figure = figure super().__init__( title=title, size=(1, 1.35) * (figure.get_size_inches() * figure.get_dpi()) ) chart = Chart() save_button = toga.Button(label="Save", on_press=self.save_figure) save_box = toga.Box(children=[save_button]) chart_box = toga.Box( children=[chart], style=Pack(height=(figure.get_size_inches() * figure.get_dpi())[1]), ) main_box = toga.Box( children=[chart_box, save_box], style=Pack(direction=COLUMN) ) self.content = main_box chart.draw(figure) self.app = app
def create_bounding_box(image_path, image_size, model, *, dpi=120, topk=4, grid_num=5): model.eval() image = Image.open(image_path) im_h, im_w = image.size # unsqueeze for make batch_size = 1 input = totensor(image.resize([image_size, image_size])).unsqueeze(0) if cuda: input = input.cuda() output_loc, output_cnf, output_cls = model(Variable(input)) if cuda: output_loc = output_loc.cpu() output_cnf = output_cnf.cpu() output_cls = output_cls.cpu() # squeeze because batch is 1 output_cls.data.squeeze_(0), output_loc.data.squeeze_(0) output_cnf = output_cnf.data[0, 0, :, :] # get high confidence grids grids = topk_2d(output_cnf, topk) grid_size = image_size // grid_num # load image for matplotlib image = mpimg.imread(image_path) fig = Figure(figsize=(im_h / dpi, im_w / dpi), dpi=dpi) canvas = FigureCanvas(fig) ax = fig.gca() ax.imshow(image) for grid_x, grid_y in grids: x_0, x_1, y_0, y_1 = get_bbox_points(output_loc.data, grid_x, grid_y, grid_size, im_w, im_h, image_size) ax.plot([y_0, y_0, y_1, y_1, y_0], [x_0, x_1, x_1, x_0, x_0]) ax.text(y_0, x_0, f"{id_class[find_cls(output_cls[:, grid_x, grid_y])]}", bbox={'alpha': 0.5}) ax.axis('off') canvas.draw() width, height = fig.get_size_inches() * fig.get_dpi() image = np.fromstring(canvas.tostring_rgb(), dtype='uint8').reshape(int(height), int(width), 3) # numpy array -> PIL data -> tensor tensor = totensor(Image.fromarray(image)) # image is numpy array and tensor is tensor return image, tensor
def get_star_metrics(epoch, X, Y, emulated): my_dpi = 72.0 fig = Figure(figsize=(720 / my_dpi, 360 / my_dpi), dpi=my_dpi, tight_layout=True) canvas = plotting.plot_confusion_matrix(fig, X, Y, emulated) width, height = fig.get_size_inches() * fig.get_dpi() conf_mat = np.frombuffer(canvas.tostring_rgb(), dtype='uint8').reshape(1, int(height), int(width), 3) return conf_mat
class IdentifyMatplotlibPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25)): #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) # self.plot(None) # self.ax.plot( np.random.randn(10) ) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) def cla(self): self.ax.cla() self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I, cmax=None): if I!=None: if cmax==None: cmax = I.max() I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') self.canvas.draw()
def points_to_pixels(length_points: float, fig: Figure) -> float: """ Convert a length in points to a length in display coordinates. :param length_points: An absolute size, in points (1/72-th of an inch). :param fig: Provides the DPI (pixels-per-inch) setting for conversion. :return: A length in display coordinates (i.e. pixels). """ pixels_per_inch = fig.get_dpi() length_inches = length_points * INCHES_PER_POINT length_pixels = length_inches * pixels_per_inch return length_pixels
def get_sample_cornerplot(Y_nat, sampled_result): n_obj, n_sample, reg_dim = sampled_result.shape my_dpi = 72.0 fig = Figure(figsize=(720 / my_dpi, 360 / my_dpi), dpi=my_dpi, tight_layout=True) canvas = plotting.plot_sample_corner(fig, X, Y, emulated, flux_formatting, bp) width, height = fig.get_size_inches() * fig.get_dpi() img = np.frombuffer(canvas.tostring_rgb(), dtype='uint8').reshape(1, int(height), int(width), 3) return img
class myWxPlot(wx.Panel): def __init__(self, parent): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent = parent wx.Panel.__init__(self, parent) #matplotlib figure self.figure = Figure(None) self.figure.set_facecolor((0.7, 0.7, 1.)) self.subplot = self.figure.add_subplot(111) #canvas self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.canvas.SetBackgroundColour(wx.Colour(100, 255, 255)) self._SetSize() self.draw2() def _SetSize(self): size = tuple(self.parent.GetClientSize()) self.SetSize(size) self.canvas.SetSize(size) self.figure.set_size_inches( float(size[0]) / self.figure.get_dpi(), float(size[1]) / self.figure.get_dpi()) def draw(self): from mpl_toolkits.mplot3d import Axes3D import numpy as np x = np.arange(-3, 3, 0.25) y = np.arange(-3, 3, 0.25) X, Y = np.meshgrid(x, y) Z = np.sin(X) + np.cos(Y) ax = Axes3D(self.figure) ax.plot_wireframe(X, Y, Z) def draw2(self): import numpy as np theta = np.arange(0, 200, 0.1) x = 2 * np.cos(theta / 7) y = 3 * np.sin(theta / 3) self.subplot.plot(x, y, '-r') self.subplot.set_title("Sample", fontsize=12) self.subplot.set_xlabel("x") self.subplot.set_ylabel("y") self.subplot.set_xlim([-4, 4]) self.subplot.set_ylim([-4, 4])
class WXMatPlotLibPanel( wx.Panel ): def __init__( self, parent, color=None, dpi=None, **kwargs ): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure # initialize Panel if 'id' not in kwargs.keys(): kwargs['id'] = wx.ID_ANY if 'style' not in kwargs.keys(): kwargs['style'] = wx.NO_FULL_REPAINT_ON_RESIZE wx.Panel.__init__( self, parent, **kwargs ) # initialize matplotlib stuff self.figure = Figure( None, dpi ) self.canvas = FigureCanvasWxAgg( self, -1, self.figure ) #self.SetColor( color ) self._SetSize() self.draw() self._resizeflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor( self, rgbtuple=None ): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get() clr = [c/255. for c in rgbtuple] self.figure.set_facecolor( clr ) self.figure.set_edgecolor( clr ) self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) ) def _onSize( self, event ): self._resizeflag = True def _onIdle( self, evt ): if self._resizeflag: self._resizeflag = False self._SetSize() def _SetSize( self ): pixels = tuple( self.parent.GetClientSize() ) self.SetSize( pixels ) self.canvas.SetSize( pixels ) self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(), float( pixels[1] )/self.figure.get_dpi() ) def draw(self): pass # abstract, to be overridden by child classes
class MyPlotNoBlit(wx.Panel): def __init__(self, parent): wx.Panel.__init__(self,parent, -1) self.fig=Figure() self.canvas=FigureCanvas(self,-1,self.fig) self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) self._resizeFlag = True sizer=wx.BoxSizer(wx.VERTICAL) sizer.Add(self.canvas,1,wx.GROW) self.SetSizer(sizer) def _onSize(self, evt): self._resizeFlag = True def _onIdle(self, evt): if self._resizeFlag: self._resizeFlag = False self._SetSize() self.draw() def _SetSize(self, pixels=None): if not pixels: pixels = self.GetClientSize() self.canvas.SetSize(pixels) self.fig.set_size_inches(pixels[0]/self.fig.get_dpi(), pixels[1]/self.fig.get_dpi()) def Plot(self, y): a = self.fig.add_subplot(111) a.plot(y) def draw(self): print 'draw!'
class PlotPlotPanel(wx.Panel): def __init__(self, parent, dpi=None, **kwargs): wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs) self.ztv_frame = self.GetTopLevelParent() self.figure = Figure(dpi=None, figsize=(1.,1.)) self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.Bind(wx.EVT_SIZE, self._onSize) def _onSize(self, event): self._SetSize() def _SetSize(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def render_to_response(self, context): """Create a png image and write the control chart image to it""" fig = Figure(dpi=72, facecolor="white") dpi = fig.get_dpi() fig.set_size_inches( self.get_number_from_request("width", 700) / dpi, self.get_number_from_request("height", 480) / dpi, ) canvas = FigureCanvas(fig) dates, data = [], [] if context["data"] and context["data"].values(): name, points = context["data"].items()[0] dates, data = zip(*[(ti["date"], ti["value"]) for ti in points]) n_baseline_subgroups = self.get_number_from_request("n_baseline_subgroups", 2, dtype=int) n_baseline_subgroups = max(2, n_baseline_subgroups) subgroup_size = self.get_number_from_request("subgroup_size", 2, dtype=int) if not (1 < subgroup_size < 100): subgroup_size = 1 include_fit = self.request.GET.get("fit_data", "") == "true" response = HttpResponse(mimetype="image/png") if n_baseline_subgroups < 1 or n_baseline_subgroups > len(data) / subgroup_size: fig.text(0.1, 0.9, "Not enough data for control chart", fontsize=20) canvas.print_png(response) else: try: control_chart.display(fig, numpy.array(data), subgroup_size, n_baseline_subgroups, fit=include_fit, dates=dates) fig.autofmt_xdate() canvas.print_png(response) except (RuntimeError, OverflowError) as e: # pragma: nocover fig.clf() msg = "There was a problem generating your control chart:\n%s" % str(e) fig.text(0.1, 0.9, "\n".join(textwrap.wrap(msg, 40)), fontsize=12) canvas.print_png(response) return response
from matplotlib.figure import Figure panel = wx.Panel(frame) #matplotlib figure figure = Figure( None ) figure.set_facecolor( (0.7,0.7,1.) ) subplot = figure.add_subplot( 111 ) #canvas canvas = FigureCanvasWxAgg( panel, -1, figure ) canvas.SetBackgroundColour( wx.Color( 100,255,255 ) ) size = tuple( frame.GetClientSize() ) panel.SetSize( size ) canvas.SetSize( size ) figure.set_size_inches( float( size[0] )/figure.get_dpi(),float( size[1] )/figure.get_dpi() ) import numpy as np theta = np.arange(0,200, 0.1) x = 2*np.cos(theta/7) y = 3*np.sin(theta/3) subplot.plot(x,y, '-r') subplot.set_title("Sample", fontsize = 12) subplot.set_xlabel("x") subplot.set_ylabel("y") subplot.set_xlim([-4, 4]) subplot.set_ylim([-4, 4]) frame.Show() app.MainLoop()
class PlotController(DialogMixin): """ A base class for matplotlib-canvas controllers that, sets up the widgets and has image exporting functionality. """ file_filters = ("Portable Network Graphics (PNG)", "*.png"), \ ("Scalable Vector Graphics (SVG)", "*.svg"), \ ("Portable Document Format (PDF)", "*.pdf") _canvas = None @property def canvas(self): if not self._canvas: self.setup_figure() self.setup_canvas() self.setup_content() return self._canvas # ------------------------------------------------------------ # Initialisation and other internals # ------------------------------------------------------------ def __init__(self): self._proxies = dict() self.setup_figure() self.setup_canvas() self.setup_content() def setup_figure(self): style = gtk.Style() self.figure = Figure(dpi=72, edgecolor=str(style.bg[2]), facecolor=str(style.bg[0])) self.figure.subplots_adjust(hspace=0.0, wspace=0.0) def setup_canvas(self): self._canvas = FigureCanvasGTK(self.figure) def setup_content(self): raise NotImplementedError # ------------------------------------------------------------ # Update subroutines # ------------------------------------------------------------ def draw(self): try: self.figure.canvas.draw() self.fix_after_drawing() except ParseFatalException: logger.exception("Caught unhandled exception when drawing") def fix_after_drawing(self): pass # nothing to fix # ------------------------------------------------------------ # Graph exporting # ------------------------------------------------------------ def save(self, parent=None, suggest_name="graph", size="auto", num_specimens=1, offset=0.75): """ Displays a save dialog to export an image from the current plot. """ # Parse arguments: width, height = 0, 0 if size == "auto": descr, width, height, dpi = settings.OUTPUT_PRESETS[0] else: width, height, dpi = map(float, size.replace("@", "x").split("x")) # Load gui: builder = gtk.Builder() builder.add_from_file(resource_filename("pyxrd.specimen", "glade/save_graph_size.glade")) # FIXME move this to this namespace!! size_expander = builder.get_object("size_expander") cmb_presets = builder.get_object("cmb_presets") # Setup combo with presets: cmb_store = gtk.ListStore(str, int, int, float) for row in settings.OUTPUT_PRESETS: cmb_store.append(row) cmb_presets.clear() cmb_presets.set_model(cmb_store) cell = gtk.CellRendererText() cmb_presets.pack_start(cell, True) cmb_presets.add_attribute(cell, 'text', 0) def on_cmb_changed(cmb, *args): itr = cmb_presets.get_active_iter() w, h, d = cmb_store.get(itr, 1, 2, 3) entry_w.set_text(str(w)) entry_h.set_text(str(h)) entry_dpi.set_text(str(d)) cmb_presets.connect('changed', on_cmb_changed) # Setup input boxes: entry_w = builder.get_object("entry_width") entry_h = builder.get_object("entry_height") entry_dpi = builder.get_object("entry_dpi") entry_w.set_text(str(width)) entry_h.set_text(str(height)) entry_dpi.set_text(str(dpi)) # What to do when the user wants to save this: def on_accept(dialog): # Get the selected file type and name: cur_fltr = dialog.get_filter() filename = dialog.get_filename() # Add the correct extension if not present yet: for fltr in self.file_filters: if cur_fltr.get_name() == fltr[0]: if filename[len(filename) - 4:] != fltr[1][1:]: filename = "%s%s" % (filename, fltr[1][1:]) break # Get the width, height & dpi width = float(entry_w.get_text()) height = float(entry_h.get_text()) dpi = float(entry_dpi.get_text()) i_width, i_height = width / dpi, height / dpi # Save it all right! self.save_figure(filename, dpi, i_width, i_height) # Ask the user where, how and if he wants to save: self.run_save_dialog("Save Graph", on_accept, None, parent=parent, suggest_name=suggest_name, extra_widget=size_expander) def save_figure(self, filename, dpi, i_width, i_height): """ Save the current plot Arguments: filename: the filename to save to (either .png, .pdf or .svg) dpi: Dots-Per-Inch resolution i_width: the width in inch i_height: the height in inch """ # Get original settings: original_dpi = self.figure.get_dpi() original_width, original_height = self.figure.get_size_inches() # Set everything according to the user selection: self.figure.set_dpi(dpi) self.figure.set_size_inches((i_width, i_height)) self.figure.canvas.draw() # replot bbox_inches = matplotlib.transforms.Bbox.from_bounds(0, 0, i_width, i_height) # Save the figure: self.figure.savefig(filename, dpi=dpi, bbox_inches=bbox_inches) # Put everything back the way it was: self.figure.set_dpi(original_dpi) self.figure.set_size_inches((original_width, original_height)) self.figure.canvas.draw() # replot
class PhotPlotPanel(wx.Panel): def __init__(self, parent, dpi=None, **kwargs): wx.Panel.__init__(self, parent, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, **kwargs) self.ztv_frame = self.GetTopLevelParent() self.figure = Figure(dpi=None, figsize=(1.,1.)) self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self.Bind(wx.EVT_SIZE, self._onSize) self.axes_widget = AxesWidget(self.figure.gca()) self.axes_widget.connect_event('motion_notify_event', self.on_motion) self.axes_widget.connect_event('button_press_event', self.on_button_press) self.axes_widget.connect_event('button_release_event', self.on_button_release) self.axes_widget.connect_event('figure_leave_event', self.on_cursor_leave) self.button_down = False def on_button_press(self, event): self.aper_names = ['aprad', 'skyradin', 'skyradout'] self.aper_last_radii = np.array([self.ztv_frame.phot_panel.aprad, self.ztv_frame.phot_panel.skyradin, self.ztv_frame.phot_panel.skyradout]) self.button_press_xdata = event.xdata self.cur_aper_index = np.abs(self.aper_last_radii - event.xdata).argmin() self.cur_aper_name = self.aper_names[self.cur_aper_index] # but, click must be within +-N pix to be valid if np.abs(event.xdata - self.aper_last_radii[self.cur_aper_index]) <= 20: self.button_down = True def on_motion(self, event): if self.button_down: if event.xdata is not None: if self.cur_aper_name == 'aprad': self.ztv_frame.phot_panel.aprad = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad)) set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok') elif self.cur_aper_name == 'skyradin': self.ztv_frame.phot_panel.skyradin = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradin)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok') elif self.cur_aper_name == 'skyradout': self.ztv_frame.phot_panel.skyradout = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradout)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok') self.ztv_frame.phot_panel.recalc_phot() def on_button_release(self, event): if self.button_down: if event.xdata is not None: if self.cur_aper_name == 'aprad': self.ztv_frame.phot_panel.aprad = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad)) set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok') elif self.cur_aper_name == 'skyradin': self.ztv_frame.phot_panel.skyradin = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradin)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok') elif self.cur_aper_name == 'skyradout': self.ztv_frame.phot_panel.skyradout = (self.aper_last_radii[self.cur_aper_index] + (event.xdata - self.button_press_xdata)) self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradout)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok') self.ztv_frame.phot_panel.recalc_phot() self.button_down = False def on_cursor_leave(self, event): if self.button_down: if self.cur_aper_name == 'aprad': self.ztv_frame.phot_panel.aprad = self.aper_last_radii[self.cur_aper_index] self.ztv_frame.phot_panel.aprad_textctrl.SetValue('{0:.2f}'.format(self.ztv_frame.phot_panel.aprad)) set_textctrl_background_color(self.ztv_frame.phot_panel.aprad_textctrl, 'ok') elif self.cur_aper_name == 'skyradin': self.ztv_frame.phot_panel.skyradin = self.aper_last_radii[self.cur_aper_index] self.ztv_frame.phot_panel.skyradin_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradin)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradin_textctrl, 'ok') elif self.cur_aper_name == 'skyradout': self.ztv_frame.phot_panel.skyradout = self.aper_last_radii[self.cur_aper_index] self.ztv_frame.phot_panel.skyradout_textctrl.SetValue('{0:.2f}'.format( self.ztv_frame.phot_panel.skyradout)) set_textctrl_background_color(self.ztv_frame.phot_panel.skyradout_textctrl, 'ok') self.ztv_frame.phot_panel.recalc_phot() self.button_down=False def _onSize(self, event): self._SetSize() def _SetSize(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.figure.set_size_inches(float(pixels[0])/self.figure.get_dpi(), float(pixels[1])/self.figure.get_dpi())
def TRTimage( TRTcell_IDs, TRTcells, obj_area, minRank=8, alpha_max=1.0, plot_vel=True): # define size of image nx = obj_area.x_size ny = obj_area.y_size # create new figure fig = Figure() # canvas figure canvas = FigureCanvas(fig) # get dots per inch of the screen DPI = fig.get_dpi() # print "DPI", DPI fig.set_size_inches(nx/float(DPI),ny/float(DPI)) # get axis object ax = fig.add_subplot(111, aspect='equal') ## eliminates margins totally fig.subplots_adjust(left=0.0,right=1.0,bottom=0.0,top=1.0, wspace=0, hspace=0) #plt.subplots_adjust(left=0, right=1, bottom=0, top=1, wspace=0, hspace=0) # does only work with x11 display # set limits of the axis ax.set_xlim(0, nx) ax.set_ylim(0, ny) # set transparent backgroud fig.patch.set_alpha(0.0) # transparent outside of diagram ax.set_axis_bgcolor([1,0,0,0]) # transparent color inside diagram # define arrow properties head_width = 0.006 * min(obj_area.x_size,obj_area.x_size) head_length = 2 * head_width pixel_size_x_km = 0.001 * obj_area.pixel_size_x pixel_size_y_km = 0.001 * obj_area.pixel_size_y for cell in TRTcell_IDs: if TRTcells[cell].RANKr > minRank: (x0,y0) = obj_area.get_xy_from_lonlat(TRTcells[cell].lon, TRTcells[cell].lat, outside_error=False, return_int=False) y0 = (obj_area.y_size-1)-y0 # print (x0,y0) vx = TRTcells[cell].vel_x vy = TRTcells[cell].vel_y # !!!scaling of width and height is not correct, that is on map projection, but not on the ground!!! e = Ellipse( xy = (x0, y0), \ width = 2*TRTcells[cell].ell_S / pixel_size_x_km, \ height = 2*TRTcells[cell].ell_L / pixel_size_y_km, \ angle = -TRTcells[cell].angle ) ax.add_artist(e) e.set_clip_box(ax.bbox) if TRTcells[cell].RANKr <= 12: cell_color="white" alpha = (alpha_max-0.2) / 12. * TRTcells[cell].RANKr elif TRTcells[cell].RANKr <= 15: cell_color="white" alpha = alpha_max elif TRTcells[cell].RANKr <= 25: cell_color="green" alpha = alpha_max elif TRTcells[cell].RANKr <= 35: cell_color="yellow" alpha = alpha_max else: cell_color="red" alpha = alpha_max # print "cell ID: %s, cell rank: %2d, cell_color:%7s, alpha = %4.1f" % (cell, TRTcells[cell].RANKr, cell_color, alpha) e.set_alpha(alpha) # transparency: 0.0 transparent, 1 total visible e.set_facecolor(cell_color) # "white" or [1,1,1] if plot_vel: ax.arrow(x0, y0, vx, vy, head_width = head_width, head_length = head_length, fc=cell_color, ec=cell_color) if 1==1: # print " !!! convert fig to image by function fig2img !!!" ### this would avoid saving into a file, but it fills the transparent areas with "white" PIL_image = fig2img ( fig ) else: tmp_file = '/tmp/TRT_'+str(uuid4())+'.png' # print tmp_file plt.savefig(tmp_file, dpi=DPI, transparent=True) #, bbox_inches='tight' # subprocess.call("display "+tmp_file+" &", shell=True) PIL_image = PIL_Image.open(tmp_file) subprocess.call("rm "+tmp_file+" &", shell=True) return PIL_image
class MatplotlibPanel(wx.Panel): def __init__(self,parent,ID=-1,label="",pos=wx.DefaultPosition,size=(100,25), panelnum=0): #(0) Initialize panel: wx.Panel.__init__(self,parent,ID,pos,size,wx.STATIC_BORDER,label) self.SetMinSize(size) self.parent = parent self.panelnum = panelnum #(1) Create Matplotlib figure: self.figure = Figure(facecolor=(0.8,)*3) self.canvas = FigureCanvasWxAgg(self, -1, self.figure) self._resize() self._create_axes() self.cidButtonDown = self.canvas.mpl_connect('button_press_event', self.callback_button_press) def _create_axes(self): self.ax = self.figure.add_axes((0,0,1,1), axisbg=[0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[]) def _resize(self): szPixels = tuple( self.GetClientSize() ) self.canvas.SetSize(szPixels) szInches = float(szPixels[0])/self.figure.get_dpi() , float(szPixels[1])/self.figure.get_dpi() self.figure.set_size_inches( szInches[0] , szInches[1] ) def callback_button_press(self, event): xy = event.xdata, event.ydata shift = event.guiEvent.m_shiftDown if xy != (None,None): xy = map(int, np.round(xy)) if event.button==1: if shift: self.parent.parent.poi_select(xy, self.panelnum) else: #add POI self.parent.parent.poi_add(xy, self.panelnum) else: #delete closest POI self.parent.parent.poi_delete(xy, self.panelnum) def cla(self): self.ax.cla() self.ax.set_position([0,0,1,1]) self.ax.set_axis_bgcolor([0.5]*3) pyplot.setp(self.ax, xticks=[], yticks=[], xlim=(0,1), ylim=(0,1)) self.ax.axis('tight') self.canvas.draw() def plot(self, I, cmax=None): if I!=None: if cmax==None: cmax = I.max() I[I==0] = np.nan self.ax.imshow(I, interpolation='nearest', origin='lower', vmin=0, vmax=cmax) pyplot.setp(self.ax, xticks=[], yticks=[]) self.ax.set_axis_bgcolor([0.05]*3) self.ax.axis('image') self.canvas.draw() def highlight_poi(self, ind): for i,line in enumerate(self.ax.lines): if i==ind: pyplot.setp(line, color='g', markersize=12) else: pyplot.setp(line, color='w', markersize=8) self.canvas.draw() def plot_poi(self, xy): x,y = xy i = len(self.ax.texts) + 1 self.ax.plot(x, y, 'wo', markersize=8) self.ax.text(x+1, y+1, '%d'%i, bbox=dict(facecolor='w')) def replot_pois(self, pois): self.ax.lines = [] self.ax.texts = [] if pois: [self.plot_poi(xy) for xy in pois] self.canvas.draw()
class BarPanel (wx.Panel): """The BarPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__( self, parent, color=None, dpi=None, **kwargs ): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent=parent wx.Panel.__init__( self, parent, **kwargs ) # initialize matplotlib stuf self.figure = Figure( None, dpi ) self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvas(self, -1, self.figure) self.SetColor( color ) self._SetSize() self.speedup1=[1.,1.,1.,1.,1.,1.,1.] #used for rolling average self.speedup2=[1.,1.,1.,1.,1.,1.,1.] self._resizeflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor( self, rgbtuple=None ): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get() clr = [c/255. for c in rgbtuple] self.figure.set_facecolor( clr ) self.figure.set_edgecolor( clr ) self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) ) def _onSize( self, event ): self._resizeflag = True #print 'told to resize' self._SetSize() def _onIdle( self, evt ): if self._resizeflag: self._resizeflag = False #print 'told to resize' self._SetSize() def _SetSize( self ): pixels = self.GetClientSize() #tuple( self.parent.GetClientSize() ) self.SetSize( pixels ) self.canvas.SetSize( pixels ) self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(), float( pixels[1] )/self.figure.get_dpi() ) def setData(self,inValList): tempVals=inValList #if tempVals[0]==0: # tempVals[0]=1 tempVals[0]=0.00001 val1=tempVals[1]/float(tempVals[0]) if(val1<0.1):val1=0.1 val2=tempVals[2]/float(tempVals[0]) if(val2<0.1):val2=0.2 del self.speedup1[0] self.speedup1.append(val1) del self.speedup2[0] self.speedup2.append(val2) def draw(self): self.axes.clear() self.figure.subplots_adjust(top=0.83) self.axes.bar([1,2,3],[0.01,mean(self.speedup1),mean(self.speedup2)],color=['r','b','g']) self.axes.set_xticks([]) self.axes.set_yticks([]) self.axes.set_xticklabels([]) self.axes.set_yticklabels([]) self.axes.set_title('Speed Relative to GPU-ANN') self.axes.text(0.001,0.5,r'$10^-5x$') speedStr1 = '%4.3ex'%mean(self.speedup1) speedStr2 = '%4.3ex'%mean(self.speedup2) self.axes.text(2.05,mean(self.speedup1)*1.1,speedStr1) self.axes.text(3.05,mean(self.speedup2)/2.0,speedStr2) self.canvas.draw()
class PlotPanel (wx.Panel): """The PlotPanel has a Figure and a Canvas. OnSize events simply set a flag, and the actual resizing of the figure is triggered by an Idle event.""" def __init__( self, parent, color=None, dpi=None, **kwargs ): from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg from matplotlib.figure import Figure self.parent=parent wx.Panel.__init__( self, parent, **kwargs ) # initialize matplotlib stuf self.figure = Figure( None, dpi ) self.axes = self.figure.add_subplot(111) self.canvas = FigureCanvas(self, -1, self.figure) self.SetColor( color ) self._SetSize() self.x=[] self.y=[] #self.draw() self._resizeflag = False self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) def SetColor( self, rgbtuple=None ): """Set figure and canvas colours to be the same.""" if rgbtuple is None: rgbtuple = wx.SystemSettings.GetColour( wx.SYS_COLOUR_BTNFACE ).Get() clr = [c/255. for c in rgbtuple] self.figure.set_facecolor( clr ) self.figure.set_edgecolor( clr ) self.canvas.SetBackgroundColour( wx.Colour( *rgbtuple ) ) def _onSize( self, event ): self._resizeflag = True #print 'told to resize' self._SetSize() def _onIdle( self, evt ): if self._resizeflag: self._resizeflag = False #print 'told to resize' self._SetSize() def _SetSize( self ): pixels = self.GetClientSize() #tuple( self.parent.GetClientSize() ) self.SetSize( pixels ) self.canvas.SetSize( pixels ) self.figure.set_size_inches( float( pixels[0] )/self.figure.get_dpi(), float( pixels[1] )/self.figure.get_dpi() ) def draw(self): if self.x != None and self.y !=None: self.figure.subplots_adjust(left=0.145) self.axes.plot(self.x[0][1:],self.y[0][1:], 'rv',linestyle='--',linewidth=4.0) self.axes.plot(self.x[1][1:],self.y[1][1:], 'bo',linestyle=':',linewidth=2.0) self.axes.plot(self.x[2][1:],self.y[2][1:], 'g.',linestyle='-',linewidth=1.0) self.axes.legend(('PWScf','ANN','ANN-GPU'),loc='lower right',fancybox=True) self.axes.set_ylim((0,-2.0)) self.axes.set_xlabel('Timestep') self.axes.set_ylabel=('Mean Potential Energy') #self.axes.set_xlim((0,3000)) #ticks=[0.98*self.y[2].max(),self.y[2].max(),1.02*self.y[2].max()] #self.axes.set_ylim((ticks[0],ticks[2])) #strLabels=['%.3f'%(0.98*ticks[0]), # '%.3f'%ticks[1], # '%.3f'%(1.02*ticks[2])] #self.axes.set_yticklabels(strLabels) #self.axes.set_yticks(ticks) self.canvas.draw()
class MainPlotController(object): """ A controller for the main plot canvas. Sets up the widgets and has image exporting functionality. """ file_filters = ("Portable Network Graphics (PNG)", "*.png"), \ ("Scalable Vector Graphics (SVG)", "*.svg"), \ ("Portable Document Format (PDF)", "*.pdf") _canvas = None @property def canvas(self): if not self._canvas: self.setup_figure() self.setup_canvas() self.setup_content() return self._canvas # ------------------------------------------------------------ # View integration getters # ------------------------------------------------------------ def get_toolbar_widget(self, window): return NavigationToolbar(self.canvas, window) def get_canvas_widget(self): return self.canvas # ------------------------------------------------------------ # Initialization and other internals # ------------------------------------------------------------ def __init__(self, status_callback, marker_callback, *args, **kwargs): self.setup_layout_cache() self.setup_figure() self.setup_canvas() self.setup_content(status_callback, marker_callback) def setup_layout_cache(self): self.position_setup = PositionSetup() self.labels = list() self.marker_lbls = list() self._proxies = dict() self.scale = 1.0 self.stats = False self._last_pos = None def setup_figure(self): self.figure = Figure(dpi=72, facecolor="#FFFFFF", linewidth=0) self.figure.subplots_adjust(hspace=0.0, wspace=0.0) def setup_canvas(self): self._canvas = FigureCanvasGTK(self.figure) def setup_content(self, status_callback, marker_callback): # Create subplot and add it to the figure: self.plot = Subplot(self.figure, 211, facecolor=(1.0, 1.0, 1.0, 0.0)) self.plot.set_autoscale_on(False) self.figure.add_axes(self.plot) # Connect events: self.canvas.mpl_connect('draw_event', self.fix_after_drawing) self.canvas.mpl_connect('resize_event', self.fix_after_drawing) self.mtc = MotionTracker(self, status_callback) self.cc = ClickCatcher(self, marker_callback) #self.update() # ------------------------------------------------------------ # Update methods # ------------------------------------------------------------ def draw(self): self._last_pos = self.fix_before_drawing() self.figure.canvas.draw() def fix_after_drawing(self, *args): _new_pos = self.fix_before_drawing() if _new_pos != self._last_pos: self.figure.canvas.draw() self._last_pos = _new_pos return False def fix_before_drawing(self, *args): """ Fixes alignment issues due to longer labels or smaller windows Is executed after an initial draw event, since we can then retrieve the actual label dimensions and shift/resize the plot accordingly. """ renderer = get_renderer(self.figure) if not renderer or not self._canvas.get_realized(): return False # Fix left side for wide specimen labels: if len(self.labels) > 0: bbox = self._get_joint_bbox(self.labels, renderer) if bbox is not None: self.position_setup.left = self.position_setup.default_left + bbox.width # Fix top for high marker labels: if len(self.marker_lbls) > 0: bbox = self._get_joint_bbox([ label for label, flag, _ in self.marker_lbls if flag ], renderer) if bbox is not None: self.position_setup.top = self.position_setup.default_top - bbox.height # Fix bottom for x-axis label: bottom_label = self.plot.axis["bottom"].label if bottom_label is not None: bbox = self._get_joint_bbox([bottom_label], renderer) if bbox is not None: self.position_setup.bottom = self.position_setup.default_bottom + (bbox.ymax - bbox.ymin) * 2.0 # somehow we need this? # Calculate new plot position & set it: plot_pos = self.position_setup.position self.plot.set_position(plot_pos) # Adjust specimen label position for label in self.labels: label.set_x(plot_pos[0] - 0.025) # Adjust marker label position for label, flag, y_offset in self.marker_lbls: if flag: newy = plot_pos[1] + plot_pos[3] + y_offset - 0.025 label.set_y(newy) _new_pos = self.position_setup.to_string() return _new_pos def update(self, clear=False, project=None, specimens=None): """ Updates the entire plot with the given information. """ if clear: self.plot.cla() if project and specimens: self.labels, self.marker_lbls = plot_specimens( self.plot, self.position_setup, self.cc, project, specimens ) # get mixtures for the selected specimens: plot_mixtures(self.plot, project, [ mixture for mixture in project.mixtures if any(specimen in mixture.specimens for specimen in specimens) ]) update_axes( self.plot, self.position_setup, project, specimens ) self.draw() # ------------------------------------------------------------ # Plot position and size calculations # ------------------------------------------------------------ def _get_joint_bbox(self, container, renderer): bboxes = [] try: for text in container: bbox = text.get_window_extent(renderer=renderer) # the figure transform goes from relative coords->pixels and we # want the inverse of that bboxi = bbox.inverse_transformed(self.figure.transFigure) bboxes.append(bboxi) except (RuntimeError, ValueError): logger.exception("Caught unhandled exception when joining boundig boxes") return None # don't continue # this is the bbox that bounds all the bboxes, again in relative # figure coords if len(bboxes) > 0: bbox = transforms.Bbox.union(bboxes) return bbox else: return None # ------------------------------------------------------------ # Graph exporting # ------------------------------------------------------------ def save(self, parent=None, current_name="graph", size="auto", num_specimens=1, offset=0.75): """ Displays a save dialog to export an image from the current plot. """ # Parse arguments: width, height = 0, 0 if size == "auto": descr, width, height, dpi = settings.OUTPUT_PRESETS[0] else: width, height, dpi = list(map(float, size.replace("@", "x").split("x"))) # Load gui: builder = Gtk.Builder() builder.add_from_file(resource_filename("pyxrd.specimen", "glade/save_graph_size.glade")) # FIXME move this to this namespace!! size_expander = builder.get_object("size_expander") cmb_presets = builder.get_object("cmb_presets") # Setup combo with presets: cmb_store = Gtk.ListStore(str, int, int, float) for row in settings.OUTPUT_PRESETS: cmb_store.append(row) cmb_presets.clear() cmb_presets.set_model(cmb_store) cell = Gtk.CellRendererText() cmb_presets.pack_start(cell, True) cmb_presets.add_attribute(cell, 'text', 0) def on_cmb_changed(cmb, *args): itr = cmb.get_active_iter() w, h, d = cmb_store.get(itr, 1, 2, 3) entry_w.set_text(str(w)) entry_h.set_text(str(h)) entry_dpi.set_text(str(d)) cmb_presets.connect('changed', on_cmb_changed) # Setup input boxes: entry_w = builder.get_object("entry_width") entry_h = builder.get_object("entry_height") entry_dpi = builder.get_object("entry_dpi") entry_w.set_text(str(width)) entry_h.set_text(str(height)) entry_dpi.set_text(str(dpi)) # What to do when the user wants to save this: def on_accept(dialog): # Get the width, height & dpi width = float(entry_w.get_text()) height = float(entry_h.get_text()) dpi = float(entry_dpi.get_text()) i_width, i_height = width / dpi, height / dpi # Save it all right! self.save_figure(dialog.filename, dpi, i_width, i_height) # Ask the user where, how and if he wants to save: DialogFactory.get_save_dialog( "Save Graph", parent=parent, filters=self.file_filters, current_name=current_name, extra_widget=size_expander ).run(on_accept) def save_figure(self, filename, dpi, i_width, i_height): """ Save the current plot Arguments: filename: the filename to save to (either .png, .pdf or .svg) dpi: Dots-Per-Inch resolution i_width: the width in inch i_height: the height in inch """ # Get original settings: original_dpi = self.figure.get_dpi() original_width, original_height = self.figure.get_size_inches() # Set everything according to the user selection: self.figure.set_dpi(dpi) self.figure.set_size_inches((i_width, i_height)) self.figure.canvas.draw() # replot bbox_inches = matplotlib.transforms.Bbox.from_bounds(0, 0, i_width, i_height) # Save the figure: self.figure.savefig(filename, dpi=dpi, bbox_inches=bbox_inches) # Put everything back the way it was: self.figure.set_dpi(original_dpi) self.figure.set_size_inches((original_width, original_height)) self.figure.canvas.draw() # replot pass # end of class
class MyFrame(wx.Frame): def __init__(self, *args, **kwds): # begin wxGlade: MyFrame.__init__ kwds["style"] = wx.DEFAULT_FRAME_STYLE wx.Frame.__init__(self, *args, **kwds) # Menu Bar self.frame_1_menubar = wx.MenuBar() wxglade_tmp_menu = wx.Menu() wxglade_tmp_menu.Append(10, "load 4D file", "", wx.ITEM_NORMAL) wxglade_tmp_menu.Append(11, "load python data", "", wx.ITEM_NORMAL) self.frame_1_menubar.Append(wxglade_tmp_menu, "File") wxglade_tmp_menu = wx.Menu() wxglade_tmp_menu.Append(22, "Channel Properties", "", wx.ITEM_NORMAL) self.frame_1_menubar.Append(wxglade_tmp_menu, "Edit") wxglade_tmp_menu = wx.Menu() wxglade_tmp_menu.Append(30, "tft", "", wx.ITEM_NORMAL) self.frame_1_menubar.Append(wxglade_tmp_menu, "Execute") self.SetMenuBar(self.frame_1_menubar) # Menu Bar end self.frame_1_statusbar = self.CreateStatusBar(1, 0) # Tool Bar self.frame_1_toolbar = wx.ToolBar( self, -1, style=wx.TB_HORIZONTAL | wx.TB_DOCKABLE | wx.TB_TEXT | wx.TB_NOICONS ) self.SetToolBar(self.frame_1_toolbar) self.frame_1_toolbar.AddLabelTool(3, "PlotData", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "") self.frame_1_toolbar.AddLabelTool(1, "RePlot", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "") self.frame_1_toolbar.AddLabelTool(2, "ReDraw", wx.NullBitmap, wx.NullBitmap, wx.ITEM_NORMAL, "", "") self.frame_1_toolbar.AddSeparator() self.frame_1_toolbar.AddLabelTool(4, "TFT", wx.NullBitmap, wx.NullBitmap, wx.ITEM_CHECK, "", "") # Tool Bar end self.viewer = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL) self.combo_box_1 = wx.ComboBox( self, -1, choices=[".1sec", ".5sec", "1sec", "5sec", "10sec", "20sec", "30sec", "60sec"], style=wx.CB_DROPDOWN | wx.CB_DROPDOWN | wx.CB_READONLY, ) self.bitmap_button_2 = wx.BitmapButton(self, -1, wx.Bitmap("left.png", wx.BITMAP_TYPE_ANY)) self.bitmap_button_1 = wx.BitmapButton(self, -1, wx.Bitmap("right.png", wx.BITMAP_TYPE_ANY)) self.bitmap_button_3 = wx.BitmapButton(self, -1, wx.Bitmap("up.png", wx.BITMAP_TYPE_ANY)) self.bitmap_button_4 = wx.BitmapButton(self, -1, wx.Bitmap("down.png", wx.BITMAP_TYPE_ANY)) self.slider_3 = wx.Slider( self, -1, 0, 0, 1, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_LABELS | wx.SL_SELRANGE ) self.slider_1 = wx.Slider(self, -1, 1, 0, 10, style=wx.SL_VERTICAL | wx.SL_AUTOTICKS | wx.SL_LABELS) self.button_1 = wx.ToggleButton(self, -1, "AutoScale") self.slider_2 = wx.Slider(self, -1, 1, 1, 100, style=wx.SL_VERTICAL | wx.SL_AUTOTICKS | wx.SL_LABELS) self.__set_properties() self.__do_layout() self.Bind(wx.EVT_MENU, self.loaddatagui, id=10) self.Bind(wx.EVT_MENU, self.loadpythondata, id=11) self.Bind(wx.EVT_MENU, self.chproperties, id=22) self.Bind(wx.EVT_MENU, self.tftwindow, id=30) self.Bind(wx.EVT_TOOL, self.plotloadeddata, id=3) self.Bind(wx.EVT_TOOL, self.go, id=1) self.Bind(wx.EVT_TOOL, self.redraw, id=2) self.Bind(wx.EVT_TOOL, self.tftframe, id=4) self.Bind(wx.EVT_COMBOBOX, self.settimewin, self.combo_box_1) self.Bind(wx.EVT_BUTTON, self.panleft, self.bitmap_button_2) self.Bind(wx.EVT_BUTTON, self.panright, self.bitmap_button_1) self.Bind(wx.EVT_BUTTON, self.panup, self.bitmap_button_3) self.Bind(wx.EVT_BUTTON, self.pandown, self.bitmap_button_4) self.Bind(wx.EVT_COMMAND_SCROLL_THUMBTRACK, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_LINEDOWN, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_LINEUP, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.settimepnt, self.slider_3) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.numchans, self.slider_1) self.Bind(wx.EVT_COMMAND_SCROLL_ENDSCROLL, self.numchans, self.slider_1) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.numchans, self.slider_1) self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.numchans, self.slider_1) self.Bind(wx.EVT_TOGGLEBUTTON, self.autoscalehandler, self.button_1) self.Bind(wx.EVT_COMMAND_SCROLL_THUMBTRACK, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEDOWN, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_PAGEUP, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_LINEDOWN, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_BOTTOM, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_LINEUP, self.amplitudescale, self.slider_2) self.Bind(wx.EVT_COMMAND_SCROLL_THUMBRELEASE, self.amplitudescale, self.slider_2) # end wxGlade event = 0 self.dpi = 50 left, width = 0.05, 0.8 rect1 = [left, 0.2, width, 0.79] rect2 = [left, 0.1, width, 0.2] self.fig = Figure(None, dpi=self.dpi) # self.fig = Figure((8.0, 20.0), dpi=self.dpi) self.canvas = FigCanvas(self.viewer, -1, self.fig) self.redraw(event) # ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab') # ~ self.axes2 = self.fig.add_subplot(111,axisbg='#ababab', sharex=self.axes) self.axes = self.fig.add_axes(rect1, axisbg="#ababab") #####self.axes.yaxis.set_visible(False) self.axes.set_frame_on(False) self.axes2 = self.fig.add_axes(rect2, axisbg="#ababab") # , sharex=self.axes) self.axes2.axis("on") # ax2 = fig.add_axes(rect2, axisbg=axescolor, sharex=ax1) # self.axes.axis('off') event = 0 # self.loaddata(event) # fn = '/home/danc/python/data/E0053/E0053_EEGSSPLR.pym' # self.trials = 10 # #fn = '/home/danc/python/data/E0052/sim.pym' # self.origdata, self.timeaxes, self.chlabels, self.srate = retrievepythondata(fn) siz = self.GetSize() self.canvas.SetClientSize((siz[0] - 1, siz[1] - 100)) self.zoomin(event) self.pan(event) # ~ # ~ from pylab import * # ~ try: # ~ import Image # ~ except ImportError, exc: # ~ raise SystemExit("PIL must be installed to run this example") # ~ # lena = Image.open('AlbinoPython.jpg') # ~ dpi = rcParams['figure.dpi'] # ~ figsize = lena.size[0]/dpi, lena.size[1]/dpi # ~ # ~ figure(figsize=figsize) # ~ ax = axes([0,0,1,1], frameon=False) # ~ ax.set_axis_off() # self.axes.imshow(lena, origin='lower') # ~ # show() def __set_properties(self): # begin wxGlade: MyFrame.__set_properties self.SetTitle("PyPlotter") self.SetSize((600, 600)) self.frame_1_statusbar.SetStatusWidths([-1]) # statusbar fields frame_1_statusbar_fields = ["PyPlotter"] for i in range(len(frame_1_statusbar_fields)): self.frame_1_statusbar.SetStatusText(frame_1_statusbar_fields[i], i) self.frame_1_toolbar.SetToolPacking(5) self.frame_1_toolbar.SetToolSeparation(5) self.frame_1_toolbar.Realize() self.viewer.SetBackgroundColour(wx.Colour(143, 143, 188)) self.viewer.SetScrollRate(10, 10) self.combo_box_1.SetMinSize((87, 27)) self.combo_box_1.SetSelection(0) self.bitmap_button_2.SetMinSize((55, 55)) self.bitmap_button_2.Enable(False) self.bitmap_button_1.SetMinSize((55, 55)) self.bitmap_button_1.Enable(False) self.bitmap_button_3.SetMinSize((55, 55)) self.bitmap_button_3.Enable(False) self.bitmap_button_4.SetMinSize((55, 55)) self.bitmap_button_4.Enable(False) self.slider_3.SetBackgroundColour(wx.Colour(216, 216, 191)) self.slider_3.SetToolTipString("Time Slider (sec)") self.slider_3.SetFocus() self.slider_1.SetToolTipString("Number of channels") self.slider_1.Enable(False) self.button_1.SetBackgroundColour(wx.Colour(143, 143, 188)) self.button_1.SetValue(1) self.slider_2.SetToolTipString("Amplitude") self.slider_2.Enable(False) # end wxGlade def __do_layout(self): # begin wxGlade: MyFrame.__do_layout sizer_1 = wx.BoxSizer(wx.VERTICAL) sizer_2 = wx.BoxSizer(wx.HORIZONTAL) sizer_1.Add(self.viewer, 3, wx.ALL | wx.EXPAND | wx.ALIGN_BOTTOM, 0) sizer_2.Add(self.combo_box_1, 0, wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.bitmap_button_2, 0, wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.bitmap_button_1, 0, wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.bitmap_button_3, 0, wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.bitmap_button_4, 0, wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.slider_3, 6, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL, 0) sizer_2.Add(self.slider_1, 1, wx.ALL | wx.EXPAND, 0) sizer_2.Add(self.button_1, 0, 0, 0) sizer_2.Add(self.slider_2, 0, wx.ALL | wx.EXPAND | wx.ALIGN_CENTER_VERTICAL, 0) sizer_1.Add(sizer_2, 0, wx.EXPAND | wx.ALIGN_BOTTOM, 0) self.SetSizer(sizer_1) self.Layout() self.Centre() # end wxGlade # ~ self.dpi = 100 # ~ self.fig = Figure((8.0, 20.0), dpi=self.dpi) # ~ self.canvas = FigCanvas(self.viewer, -1, self.fig) # ~ sizer_1.Add(self.frame_1_toolbar, 5, wx.LEFT | wx.EXPAND) # ~ self.redraw(event) # ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab') def passdata(data): # , samplerate, channellabels): import sys print sys.argv import getopt opts, extraparams = getopt.getopt(sys.argv[1:]) # ~ data = np.random.randn(10000,10) # ~ self.origdata = data # ~ self.sr = np.float32(100.0) # ~ sp = 1/frame.sr # ~ self.timeaxes = np.arange(0,sp*1000, sp) # ~ self.chlabels = np.arange(0,244) def go(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `go' " self.draw_figure(event) # self.redraw(event) def clear(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `clear' not implemented" print self.GetSize() print self.fig.get_size_inches() x = self.canvas.GetClientSize() print x # self.canvas.SetClientSize((x[0]/2,x[1]/2)) x = self.GetSize() self.canvas.SetClientSize((x[0] / 0.8, x[1] / 0.9)) # self.canvas.Destroy() # self.fig.clear() def redraw(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `redraw' not implemented" siz = self.GetSize() self.canvas.SetClientSize((siz[0] - 1, siz[1] - 100)) self.canvas.Refresh(eraseBackground=True) def amplitudescale(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `amwxplitudescale' not implemented" print self.slider_2.GetValue() dmin = self.origdata.min() dmax = self.origdata.max() print dmin, dmax self.step = abs(dmin + dmax / 10) / self.slider_2.GetValue() print "step2", self.step # self.go(event) # ~ self.numchans(event) # return step/self.slider_2.GetValue() # self.settimewin(event) def numchans(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `numchans' not implemented" self.slider_1.SetRange(0, np.size(self.origdata, 1)) self.data = self.origdata[:, 0 : self.slider_1.GetValue()] self.label2plot = self.chlabels[0 : self.slider_1.GetValue()] # self.settimewin(event) try: self.go(event) except AttributeError: print "error" def settimewin(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `settimewin' not implemented" # ~ self.startsec = self.slider_3.GetValue() * int(self.combo_box_1.GetValue().strip('sec')) # ~ self.endsec = self.startsec + int(self.combo_box_1.GetValue().strip('sec')) self.startsec = self.slider_3.GetValue() self.endsec = self.startsec + np.float32(self.combo_box_1.GetValue().strip("sec")) print "pp", self.startsec, self.endsec self.indstart = np.argmin(abs(self.startsec - self.timeaxes)) self.indend = np.argmin(abs(self.endsec + -self.timeaxes)) print "ind", self.indstart, self.indend self.canvas.Update() self.go(event) # self.go(event) def settimepnt(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `settimepnt' not implemented" self.settimewin(event) # ~ self.timepnt = self.slider_3.GetValue() # ~ self.indstart = argmin(abs(self.timepnt - self.timeaxes)) # ~ self.indend = argmin(abs(self.timepnt+ - self.timeaxes)) # ~ # ~ print self.indstart, def setupwidgets(self): self.slider_1.Enable(enable=True) self.slider_2.Enable(enable=True) self.bitmap_button_1.Enable(True) self.bitmap_button_2.Enable(True) self.bitmap_button_3.Enable(True) self.bitmap_button_4.Enable(True) self.combo_box_1.Enable(True) x = [] for n in range(0, np.size(self.chlabels)): x.append(str(n)) # self.combo_box_1.SetItems(unicode(self.chlabels.tolist())) # self.combo_box_1.SetItems(x) print self.timeaxes[0], self.timeaxes[-1] self.slider_3.SetRange(self.timeaxes[0], self.timeaxes[-1]) def panleft(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `panleft' not implemented" event.Skip() def panright(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `panright' not implemented" event.Skip() def panup(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `panup' not implemented" try: self.e = self.s self.s = self.e - self.slider_1.GetValue() except AttributeError: print "setting" self.e = self.slider_1.GetValue() self.s = self.e + self.e if self.s < 0: print "at start of channel set" self.s = 0 self.e = self.s + self.slider_1.GetValue() self.data = self.origdata[:, self.s : self.e] print "du", self.s, self.e self.label2plot = self.chlabels[self.s : self.e] self.go(event) def pandown(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `pandown' not implemented" try: self.s = self.e self.e = self.s + self.slider_1.GetValue() except AttributeError: print "setting" self.s = self.slider_1.GetValue() self.e = self.s + self.s if self.e > np.size(self.origdata, 1): print "at end of channel set" self.e = np.size(self.origdata, 1) self.s = self.e - self.slider_1.GetValue() self.data = self.origdata[:, self.s : self.e] print "dd", self.s, self.e self.label2plot = self.chlabels[self.s : self.e] self.go(event) def loaddatagui(self, event): # wxGlade: MyFrame.<event_handler> self.datapath = "/home/danc/python/data/0611/0611piez/e,rfhp1.0Hz,COH" import os print "Event handler `loaddatagui' not implemented" dlg = wx.FileDialog(self, "Select an Data file", os.getcwd(), "", "*", wx.OPEN) if dlg.ShowModal() == wx.ID_OK: self.datapath = dlg.GetPath() dlg.Destroy() # ~ dlg = wx.MessageDialog(self, 'First you need to load MRI data file', 'MRI file error', wx.OK|wx.ICON_INFORMATION) # ~ dlg.ShowModal() # ~ dlg.Destroy() # from gui import pysel # pysel.start() # p#rint 'done', pysel.fnlist self.origdata, self.timeaxes, self.chlabels, self.srate = retrievepdf(self.datapath) # self.datapath) self.data = self.origdata self.chproperties(event) self.plotloadeddata(event) # chpropertywin.loadchannels(event) def plotloadeddata(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `plotdata' " # print pysel.fnlist # self.origdata, self.timeaxes, self.chlabels = getdata() self.data = self.origdata self.numchans(event) self.amplitudescale(event) self.settimewin(event) # print 'labels', label2plot self.setupwidgets() self.go(event) # self.numchans(event) print "step", self.step def loadpythondata(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `loadpythondata' not implemented" import os print "Event handler `loaddatagui' not implemented" dlg = wx.FileDialog( self, "Select a python file(s)", os.getcwd(), "", wildcard="Data File (*.pym)|*.pym|Dipole Report(*.drf)|*.drf", ) if dlg.ShowModal() == wx.ID_OK: self.datapath = dlg.GetPath() dlg.Destroy() self.origdata, self.timeaxes, self.chlabels = retrievepythondata(self.datapath) # self.datapath) def autoscalehandler(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `autoscalehandler' not implemented" if self.button_1.GetValue() == 0: print "manual scaling" scalewin.Show() else: print "auto scaling" scalewin.Hide() def tftinit(self, event): # wxGlade: MyFrame.<event_handler> # if self.frame_1_toolbar.GetToolState(4) == True: #depressed from meg import timef t = timef.initialize() self.redraw(event) print self.tftch, self.trials, self.srate # print 's', np.shape(self.origdata[self.indstart:self.indend,19]),np.shape(self.data[self.indstart:self.indend,19]) print "inds", self.indstart, "inde", self.indend # dif = np.size(self.data[self.indstart:self.indend:19],0); print 'dif', dif, self.indend, self.indstart dif = self.indend - self.indstart print "dif", dif, self.indend, self.indstart print "shape of data", np.shape(self.origdata[self.indstart : self.indend, self.tftch]) t.calc( data=self.origdata[self.indstart : self.indend, self.tftch], trials=self.trials, srate=self.srate, frames=dif / self.trials, freqrange=[3.0, 100], cycles=[2, 0.5], ) # self.axes.plot(self.data[self.indstart:self.indend:,i]+inc, color=[0,0,0]) # self.axes2.imshow(abs(t.tmpallallepochs))#, aspect=6,extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])));colorbar();show() # self.axes2.imshow(abs(t.tmpallallepochs))#,aspect = 1, extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0]))) self.axes2.imshow( abs(t.tmpallallepochs), extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0])), ) print "tftshape", np.shape(t.tmpallallepochs) # self.redraw(event) # self.axes2.update() self.canvas.draw() print "Event handler `tftinit' not implemented" event.Skip() def tftframe(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `tftframe' not implemented" tftframe.Show() def tftwindow(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `tftwindow' not implemented" tftframe.Show() def chproperties(self, event): # wxGlade: MyFrame.<event_handler> print "Event handler `chproperties' not implemented" chpropertywin.Show() chpropertywin.list_box_channels.SetItems(frame.chlabels) for i in frame.chlabels: index = chpropertywin.list_ctrl_1.InsertStringItem(sys.maxint, str(i)) chpropertywin.list_ctrl_1.SetStringItem(index, 1, i) # self.list_ctrl_1.SetItem(i) # self.list_ctrl_1.SetItem(frame.chlabels) chpropertywin.chcolorlist = np.tile((0, 0, 0), (len(frame.chlabels), 1)) # set all channels to black # end of class MyFrame # ----------------------------------------------------- def pan(self, event): import time def on_press(event): self.clicktime = time.time() # self.releasetime = False self.holdcheck = "yes" # on_move(event) # try: # if self.clicktime def on_release(event): self.releasetime = time.time() self.holdcheck = "no" print "you released", event.button, event.xdata, event.ydata self.canvas.draw() def on_move(event): try: if self.holdcheck == "yes": print "your pointer is at", event.xdata, event.ydata x1, x2 = self.axes.get_xlim() y1, y2 = self.axes.get_ylim() print x1, x2, y1, y2, "::::", x2 - x1, y2 - y1 self.axes.set_xlim(event.xdata + (x2 - x1) / 2, event.xdata - (x2 - x1) / 2) self.axes.set_ylim(event.ydata + (y2 - y1) / 2, event.ydata - (y2 - y1) / 2) except AttributeError: pass # print 'no click yet' cid = self.fig.canvas.mpl_connect("button_press_event", on_press) rid = self.fig.canvas.mpl_connect("button_release_event", on_release) mousemove = self.fig.canvas.mpl_connect("motion_notify_event", on_move) def zoomin(self, event): import time def on_press(event): try: self.lasttime = self.curtime except AttributeError: self.lasttime = 0 self.curtime = time.time() if np.round(self.curtime, 2) != np.round(self.lasttime, 2): tdiff = self.curtime - self.lasttime print "time diff", tdiff print "you pressed", event.button, event.xdata, event.ydata if tdiff < 0.25: tdiff = 0 x1, x2 = self.axes.get_xlim() y1, y2 = self.axes.get_ylim() print x1, x2, y1, y2 # ~ self.axes.set_xlim(x1/2,x2/2) # ~ self.axes.set_ylim(y1/2,y2/2) # self.axes.set_xlim(event.xdata-(x2-x1)/2, event.xdata+(x2-x1)/2) if event.button == 1: # zoom in self.axes.set_xlim(event.xdata - (x2 - x1) / 4, event.xdata + (x2 - x1) / 4) self.axes.set_ylim(event.ydata - (y2 - y1) / 4, event.ydata + (y2 - y1) / 4) if event.button == 3: # zoom out self.axes.set_xlim(event.xdata - (x2 - x1) * 1, event.xdata + (x2 - x1) * 1) self.axes.set_ylim(event.ydata - (y2 - y1) * 1, event.ydata + (y2 - y1) * 1) # self.axes.set_xlim(np.mean(event.xdata,x1), np.mean(event.xdata,x2)) # self.axes.set_ylim(np.mean(event.ydata,y1), np.mean(event.ydata,y2)) self.canvas.draw() cid = self.fig.canvas.mpl_connect("button_press_event", on_press) def axeslabels(self, data): # , chlabels, timelabels): chlabels = np.arange(np.size(data, 1)) timelabels = ["100", "200", "300"] # ~ if np.size(chlabels) != np.size(data,1): # ~ print np.size(chlabels), np.size(data,1) # ~ print 'channel label length differs from data' # ~ #return return chlabels, timelabels def draw_figure(self, event): # ~ try: # ~ count = count + 1 # ~ except UnboundLocalError: # ~ count = 0 # ~ if not hasattr(self, 'subplot'): # ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab') # ~ self._resizeflag = False # ~ #self.axes.bar(left=10,height=100,width=100,align='center',alpha=0.44,picker=5) # ~ self.dpi = 50 # ~ self.fig = Figure( None, dpi=self.dpi ) # ~ self.canvas = FigCanvas(self.viewer, -1, self.fig) self.redraw(event) # ~ self.axes = self.fig.add_subplot(111,axisbg='#ababab') # self.canvas.Update() # self.canvas.UpdateRegion() # self.canvas.Refresh() self.axes.clear() # ~ self.canvas.Close() # self.canvas.gui_repaint() self.canvas.Show() # ~ print 'count',count # self.axes.axis('off') self.axes.grid("on") inc = 0 print "drawshapestate", np.shape(self.origdata), np.shape(self.data), np.shape( self.timeaxes ), self.indstart, self.indend for i in range(0, np.size(self.data, 1))[::-1]: # self.axes.plot(self.origdata[self.indstart:self.indend:,i]+inc) colur = chpropertywin.chcolorlist[i] / 256.0 # ~ if i < 2: # ~ colur = (0,0,1) # ~ else: # ~ colur = (0,0,0) self.axes.plot(self.data[self.indstart : self.indend :, i] + inc, color=colur) if self.frame_1_toolbar.GetToolState(4) == True: # depressed # print 's', np.shape(self.origdata[self.indstart:self.indend,19]),np.shape(self.data[self.indstart:self.indend,19]) # t.calc(data=self.origdata[self.indstart:self.indend,19], trials=10, srate=290.64,frames=dif/10, freqrange=[5.0,70], cycles=[2, .5]) pass # self.tftinit(event) # self.axes2.imshow(abs(t.tmpallallepochs),aspect = 7, extent=(int(t.timevals[0]), int(t.timevals[-1]), int(t.freqrange[1]), int(t.freqrange[0]))) # self.axes.plot(self.data[:,i]+inc) self.axes.text(0, inc, self.label2plot[i], color=[1, 0, 0]) inc = self.step / 2 + inc # self.axes.update() # self.axes.set_xlim((self.indstart,self.indend)) # self.canvas.Update() def _onIdle(self, evt): if self._resizeflag: self._resizeflag = False self._SetSize() print "idle" def _onSize(self, event): self._resizeflag = True def _SetSize(self): pixels = tuple(self.GetClientSize()) self.SetSize(pixels) self.canvas.SetSize(pixels) self.fig.set_size_inches(float(pixels[0]) / self.fig.get_dpi(), float(pixels[1]) / self.fig.get_dpi())
class Chart(FigureCanvas): """Klasa (widget Qt) odpowiedzialna za rysowanie wykresu. Zgodnie z tym, co zasugerował Paweł, na jednym wykresie wyświetlam jeden wskaźnik i jeden oscylator, a jak ktoś będzie chciał więcej, to kliknie sobie jakiś guzik, który mu pootwiera kilka wykresów w nowym oknie.""" #margines (pionowy i poziomy oraz maksymalna wysokość/szerokość wykresu) margin, maxSize = 0.1, 0.8 #wysokość wolumenu i wykresu oscylatora volHeight, oscHeight = 0.1, 0.15 def __init__(self, parent, finObj=None, width=8, height=6, dpi=100): """Konstruktor. Tworzy domyślny wykres (liniowy z wolumenem, bez wskaźników) dla podanych danych. Domyślny rozmiar to 800x600 pixli""" self.mainPlot=None self.volumeBars=None self.oscPlot=None self.additionalLines = [] #lista linii narysowanych na wykresie (przez usera, albo przez wykrycie trendu) self.rectangles = [] #lista prostokątów (do zaznaczania świec) self.mainType = None #typ głównego wykresu self.oscType = None #typ oscylatora (RSI, momentum, ...) self.mainIndicator = None #typ wskaźnika rysowany dodatkowo na głównym wykresie (średnia krocząca, ...) self.x0, self.y0 = None,None #współrzędne początku linii self.drawingMode = False #zakładam, że możliwość rysowania będzie można włączyć/wyłączyć self.scaleType = 'linear' #rodzaj skali na osi y ('linear' lub 'log') self.grid = True #czy rysujemy grida self.setData(finObj) self.mainType='line' self.fig = Figure(figsize=(width, height), dpi=dpi) FigureCanvas.__init__(self, self.fig) self.setParent(parent) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) self.addMainPlot() self.addVolumeBars() self.mpl_connect('button_press_event', self.onClick) def setData(self, finObj, start=None, end=None, step='daily'): """Ustawiamy model danych, który ma reprezentować wykres. Następnie konieczne jest jego ponowne odrysowanie""" if(finObj==None): return; self.data=ChartData(finObj, start, end, step) if(self.mainPlot!=None): self.updatePlot() def getData(self): return self.data def setGrid(self, grid): """Włącza (True) lub wyłącza (False) rysowanie grida""" self.grid=grid self.updateMainPlot() def setMainType(self, type): """Ustawiamy typ głównego wykresu ('point','line','candlestick','none')""" self.mainType=type self.updateMainPlot() def updatePlot(self): """Odświeża wszystkie wykresy""" self.updateMainPlot() self.updateVolumeBars() self.updateOscPlot() self.draw() #self.drawGeometricFormation() #self.drawRateLines() #self.drawTrend() #self.drawCandleFormations() #self.drawGaps() def addMainPlot(self): """Rysowanie głównego wykresu (tzn. kurs w czasie)""" bounds=[self.margin, self.margin, self.maxSize, self.maxSize] self.mainPlot=self.fig.add_axes(bounds) self.updateMainPlot() def updateMainPlot(self): if(self.mainPlot==None or self.data==None or self.data.corrupted): return ax=self.mainPlot ax.clear() x=range(len(self.data.close)) if self.mainType=='line' : ax.plot(x,self.data.close,'b-',label=self.data.name) elif self.mainType=='point': ax.plot(x,self.data.close,'b.',label=self.data.name) elif self.mainType=='candlestick': self.drawCandlePlot() elif self.mainType=='bar': self.drawBarPlot() else: return if self.mainIndicator != None: self.updateMainIndicator() ax.set_xlim(x[0],x[-1]) ax.set_yscale(self.scaleType) ax.set_ylim(0.995*min(self.data.low),1.005*max(self.data.high)) for line in self.additionalLines: ax.add_line(line) line.figure.draw_artist(line) for rect in self.rectangles: ax.add_patch(rect) rect.figure.draw_artist(rect) if(self.scaleType=='log'): ax.yaxis.set_major_formatter(FormatStrFormatter('%.2f')) ax.yaxis.set_minor_formatter(FormatStrFormatter('%.2f')) for tick in ax.yaxis.get_major_ticks(): tick.label2On=True if(self.grid): tick.gridOn=True for label in (ax.get_yticklabels() + ax.get_yminorticklabels()): label.set_size(8) #legenda leg = ax.legend(loc='best', fancybox=True) leg.get_frame().set_alpha(0.5) self.formatDateAxis(self.mainPlot) self.fixTimeLabels() if(self.grid): for tick in ax.xaxis.get_major_ticks(): # print tick.get_loc() tick.gridOn=True def addVolumeBars(self): """Dodaje do wykresu wyświetlanie wolumenu.""" #tworzymy nowy wykres tylko za pierwszym razem, potem tylko pokazujemy i odświeżamy if(self.volumeBars==None): volBounds=[self.margin, self.margin, self.maxSize, self.volHeight] self.volumeBars=self.fig.add_axes(volBounds, sharex=self.mainPlot) self.updateVolumeBars() self.volumeBars.set_visible(True) self.fixPositions() self.fixTimeLabels() def rmVolumeBars(self): """Ukrywa wykres wolumenu""" if self.volumeBars==None: return self.volumeBars.set_visible(False) self.fixPositions() self.fixTimeLabels() def setScaleType(self,type): """Ustawia skalę liniową lub logarytmiczną na głównym wykresie.""" if(type) not in ['linear','log']: return self.scaleType=type self.updateMainPlot() def updateVolumeBars(self): """Odświeża rysowanie wolumenu""" if self.data==None or self.data.corrupted: return ax=self.volumeBars ax.clear() x=range(len(self.data.close)) ax.vlines(x,0,self.data.volume) ax.set_xlim(x[0],x[-1]) if(max(self.data.volume)>0): ax.set_ylim(0,1.2*max(self.data.volume)) for label in self.volumeBars.get_yticklabels(): label.set_visible(False) for o in ax.findobj(Text): o.set_visible(False) self.formatDateAxis(ax) self.fixTimeLabels() def drawCandlePlot(self): """Wyświetla główny wykres w postaci świecowej""" if self.data==None or self.data.corrupted: return ax=self.mainPlot rectsList=[] open=self.data.open close=self.data.close xvals=range(len(close)) lines=ax.vlines(xvals,self.data.low,self.data.high,label=self.data.name,linewidth=0.5) lines.set_zorder(lines.get_zorder()-1) for i in xvals: height=max(abs(close[i]-open[i]),0.001) width=0.7 x=i-width/2 y=min(open[i],close[i]) print x,y,width,height if open[i]<=close[i]: rectsList.append(Rectangle((x,y),width,height,facecolor='w',edgecolor='k',linewidth=0.5)) else: rectsList.append(Rectangle((x,y),width,height,facecolor='k',edgecolor='k',linewidth=0.5)) ax.add_collection(PatchCollection(rectsList,match_original=True)) def drawBarPlot(self): """Rysuje główny wykres w postaci barowej.""" if self.data==None or self.data.corrupted: return ax=self.mainPlot x=range(len(self.data.close)) lines1=ax.vlines(x,self.data.low,self.data.high,label=self.data.name) lines2list=[] for i in x: lines2list.append(((i-0.3,self.data.open[i]),(i,self.data.open[i]))) lines2list.append(((i,self.data.close[i]),(i+0.3,self.data.close[i]))) lines2=LineCollection(lines2list) lines2.color('k') ax.add_collection(lines2) def setMainIndicator(self, type): """Ustawiamy, jaki wskaźnik chcemy wyświetlać na głównym wykresie""" self.mainIndicator=type self.updateMainPlot() def updateMainIndicator(self): """Odrysowuje wskaźnik na głównym wykresie""" if self.data==None or self.data.corrupted: return ax=self.mainPlot type=self.mainIndicator ax.hold(True) #hold on x=range(len(self.data.close)) if type=='SMA': indicValues=self.data.movingAverage('SMA') elif type=='WMA': indicValues=self.data.movingAverage('WMA') elif type=='EMA': indicValues=self.data.movingAverage('EMA') elif type=='bollinger': if self.data.bollinger('upper')!=None: ax.plot(x,self.data.bollinger('upper'),'r-',label=type) indicValues=self.data.bollinger('lower') else: ax.hold(False) return if indicValues!=None: ax.plot(x,indicValues,'r-',label=type) ax.hold(False) #hold off def setOscPlot(self, type): """Dodaje pod głównym wykresem wykres oscylatora danego typu lub ukrywa""" if type not in ['momentum','CCI','RSI','ROC','williams']: """Ukrywa wykres oscylatora""" if self.oscPlot==None: return self.oscPlot.set_visible(False) self.fixPositions() self.fixTimeLabels() else: self.oscType=type if self.oscPlot==None: oscBounds=[self.margin, self.margin, self.maxSize, self.oscHeight] self.oscPlot=self.fig.add_axes(oscBounds, sharex=self.mainPlot) self.updateOscPlot() self.oscPlot.set_visible(True) self.fixPositions() self.fixTimeLabels() def updateOscPlot(self): """Odrysowuje wykres oscylatora""" if self.oscPlot==None or self.data.corrupted: return ax=self.oscPlot type=self.oscType ax.clear() if type == 'momentum': oscData=self.data.momentum() elif type == 'CCI': oscData=self.data.CCI() elif type == 'ROC': oscData=self.data.ROC() elif type == 'RSI': oscData=self.data.RSI() elif type == 'williams': oscData=self.data.williams() elif type == 'TRIN': oscData=self.data.TRIN() elif type == 'mcClellan': oscData=self.data.mcClellan() elif type == 'adLine': oscData=self.data.adLine() else: return if oscData!=None: x=range(len(self.data.close)) ax.plot(x,oscData,'g-',label=type) ax.set_xlim(x[0],x[-1]) #legenda leg = ax.legend(loc='best', fancybox=True) leg.get_frame().set_alpha(0.5) self.formatDateAxis(self.oscPlot) self.fixOscLabels() self.fixTimeLabels() def fixOscLabels(self): """Metoda ustawia zakres osi poprawny dla danego oscylatora. Ponadto przenosi etykiety na prawą stronę, żeby nie nachodziły na kurs akcji""" ax=self.oscPlot type=self.oscType if type == 'ROC': ax.set_ylim(-100, 100) elif type == 'RSI': ax.set_ylim(0, 100) ax.set_yticks([30,70]) elif type == 'williams': ax.set_ylim(-100,0) for tick in ax.yaxis.get_major_ticks(): tick.label1On = False tick.label2On = True tick.label2.set_size(7) def formatDateAxis(self,ax): """Formatuje etykiety osi czasu.""" chartWidth=int(self.fig.get_figwidth()*self.fig.get_dpi()*self.maxSize) t = TextPath((0,0), '9999-99-99', size=7) labelWidth = int(t.get_extents().width) num_ticks=chartWidth/labelWidth/2 length=len(self.data.date) if(length>num_ticks): step=length/num_ticks else: step=1 x=range(0,length,step) ax.xaxis.set_major_locator(FixedLocator(x)) ticks=ax.get_xticks() labels=[] for i, label in enumerate(ax.get_xticklabels()): label.set_size(7) index=int(ticks[i]) if(index>=len(self.data.date)): labels.append('') else: labels.append(self.data.date[index].strftime("%Y-%m-%d")) label.set_horizontalalignment('center') ax.xaxis.set_major_formatter(FixedFormatter(labels)) def fixTimeLabels(self): """Włącza wyświetlanie etykiet osi czasu pod odpowiednim (tzn. najniższym) wykresem, a usuwa w pozostałych""" #oscylator jest zawsze na samym dole if self.oscPlot!=None and self.oscPlot.get_visible(): for label in self.mainPlot.get_xticklabels(): label.set_visible(False) for label in self.volumeBars.get_xticklabels(): label.set_visible(False) for label in self.oscPlot.get_xticklabels(): label.set_visible(True) #jeśli nie ma oscylatora to pod wolumenem elif self.volumeBars!=None and self.volumeBars.get_visible(): for label in self.mainPlot.get_xticklabels(): label.set_visible(False) for label in self.volumeBars.get_xticklabels(): label.set_visible(True) #a jak jest tylko duży wykres to pod nim else: for label in self.mainPlot.get_xticklabels(): label.set_visible(True) def fixPositions(self): """Dopasowuje wymiary i pozycje wykresów tak żeby zawsze wypełniały całą przestrzeń. Główny wykres puchnie albo się kurczy, a wolumen i oscylator przesuwają się w górę lub dół.""" #na początek wszystko spychamy na sam dół mainBounds=[self.margin, self.margin, self.maxSize, self.maxSize] volBounds=[self.margin, self.margin, self.maxSize, self.volHeight] oscBounds=[self.margin, self.margin, self.maxSize, self.oscHeight] #oscylator wypycha wolumen w górę i kurczy maina if self.oscPlot!=None and self.oscPlot.get_visible(): mainBounds[1]+=self.oscHeight mainBounds[3]-=self.oscHeight volBounds[1]+=self.oscHeight self.oscPlot.set_position(oscBounds) #wolumen kolejny raz kurczy maina if self.volumeBars.get_visible(): mainBounds[1]+=self.volHeight mainBounds[3]-=self.volHeight self.volumeBars.set_position(volBounds) self.mainPlot.set_position(mainBounds) def setDrawingMode(self, mode): """Włączamy (True) lub wyłączamy (False) tryb rysowania po wykresie""" self.drawingMode=mode self.x0, self.y0 = None,None def drawLine(self, x0, y0, x1, y1, color='black', lwidth = 1.0, lstyle = '-'): """Rysuje linie (trend) na wykresie """ newLine=Line2D([x0,x1],[y0,y1], linewidth = lwidth, linestyle=lstyle, color=color) self.mainPlot.add_line(newLine) self.additionalLines.append(newLine) newLine.figure.draw_artist(newLine) self.blit(self.mainPlot.bbox) #blit to taki redraw def clearLines(self): """Usuwa wszystkie linie narysowane dodatkowo na wykresie (tzn. nie kurs i nie wskaźniki)""" for line in self.additionalLines: line.remove() self.additionalLines = [] self.draw() self.blit(self.mainPlot.bbox) def clearLastLine(self): """Usuwa ostatnią linię narysowaną na wykresie.""" if self.additionalLines==[]: return self.additionalLines[-1].remove() self.additionalLines.remove(self.additionalLines[-1]) self.draw() self.blit(self.mainPlot.bbox) def drawRectangle(self, x, y, width, height, colour='blue', lwidth = 2.0, lstyle = 'dashed'): """Zaznacza prostokątem lukę/formację świecową czy coś tam jeszcze""" newRect=Rectangle((x,y),width,height,facecolor='none',edgecolor=colour,linewidth=lwidth,linestyle=lstyle) self.mainPlot.add_patch(newRect) self.rectangles.append(newRect) newRect.figure.draw_artist(newRect) self.blit(self.mainPlot.bbox) #blit to taki redraw def clearRectangles(self): """Usuwa prostokąty""" for rect in self.rectangles: rect.remove() self.rectangles = [] self.draw() self.blit(self.mainPlot.bbox) def onClick(self, event): """Rysujemy linię pomiędzy dwoma kolejnymi kliknięciami.""" if self.drawingMode==False: return if event.button==3: self.clearLastLine() if event.button==2: self.clearLines() elif event.button==1: if self.x0==None or self.y0==None : self.x0, self.y0 = event.xdata, event.ydata self.firstPoint=True else: x1, y1 = event.xdata, event.ydata self.drawLine(self.x0,self.y0,x1,y1) self.x0, self.y0 = None,None def drawTrend(self): self.clearLines() a, b = trend.regression(self.data.close) trend.optimizedTrend(self.data.close) #self.drawTrendLine(0, b, len(self.data.close)-1, a*(len(self.data.close)-1) + b, 'y', 2.0) sup, res = trend.getChannelLines(self.data.close) self.drawLine(sup[0][1], sup[0][0], sup[len(sup)-1][1], sup[len(sup)-1][0], 'g') self.drawLine(res[0][1], res[0][0], res[len(res)-1][1], res[len(res)-1][0], 'r') if len(self.data.close) > 30: sup, res = trend.getChannelLines(self.data.close, 1, 2) self.drawLine(sup[0][1], sup[0][0], sup[len(sup)-1][1], sup[len(sup)-1][0], 'g', 2.0) self.drawLine(res[0][1], res[0][0], res[len(res)-1][1], res[len(res)-1][0], 'r', 2.0)
class MatplotlibWidget(FigureCanvas): """Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.).""" def __init__(self, parent=None, name=None, width=5, height=4, dpi=100, bgcolor=None): QtGui.QWidget.__init__(self, parent) self.parent = parent self.fig = Figure(figsize=(width, height), dpi=dpi, facecolor=bgcolor, edgecolor=bgcolor) FigureCanvas.__init__(self, self.fig) self.setParent(parent) self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) self.updateGeometry() def sizeHint(self): w = self.fig.get_figwidth()*self.fig.get_dpi() h = self.fig.get_figheight()*self.fig.get_dpi() return QtCore.QSize(w, h) @QtCore.pyqtSlot() def clear(self): ''' Clears the figure. ''' self.fig.clear() @QtCore.pyqtSlot() def reset(self): ''' Clears the figure and prepares a new plot. The difference between this and clear() is that the latter only clears the figure, while this also prepares the canvas for the plot commands. ''' self.clear() self.axes = self.fig.add_subplot(111) self.axes.hold(False) # We want the axes cleared every time plot() is called @QtCore.pyqtSlot (wave.Wave) def plot1d (self, data, redraw=True): ''' Called to plot the specified wave. It will be passed to matplotlib's plot() as it is. This typically means that if it's a higher-D matrix, it will be plotted as a series of 1D graphs. ''' w = wave.WCast(data) self.axes.plot(w.dim[0].range, w) if redraw == True: self.draw() @QtCore.pyqtSlot (wave.Wave) def plot2d (self, data, redraw=True): ''' Called to plot the specified 2D wave. Uses matplotlib's imshow() to show the specified image. ''' self.axes.imshow(data, aspect='auto', extent=wave.WCast(data).imlim) if redraw == True: self.draw() @QtCore.pyqtSlot(wave.Wave) def plot(self, data, redraw=True): ''' Convenience wrapper for plot1d() or plot2d(). Assuming that 'data' is one single Wave (or ndarray object), it calls plot1d() or plot2d(), depending on the dimensionality of the data. ''' if hasattr(data, '__iter__') and not hasattr(data, 'ndim'): data_list = data data = data_list[0] if not hasattr(data, 'ndim'): log.error ("Don't know how to plot data type: %s" % data) return if data.ndim == 1: self.plot1d(data, redraw) elif data.ndim == 2: self.plot2d(data, redraw) else: self.axes.clear() w = data.view(wave.Wave) axinfo_str = ''.join([ ("axis %d: %f...%f (units: '%s')\n" % (j, i.offset, i.end, i.units)) for i,j in zip(w.dim, range(w.ndim))]) self.axes.text (0.05, 0.95, "Don't know how to display wave!\n\nname: " "%s\ndimensions: %d\n%s\n%s" % (w.infs('name'), w.ndim, axinfo_str, pprint.pformat(w.info)), transform=self.axes.transAxes, va='top') self.draw()
class MyPlot(wx.Panel): def __init__(self, parent): wx.Panel.__init__(self,parent, -1) self.fig = None self.canvas = None self.ax = None self.background = None self.lines = [] self._doRePlot = True self.foo = 1 self.t = time.time() self.blit_time=0 self.y = numpy.cos(numpy.arange(0.0,1.0,0.1)) self.ylim = None self.autolim = None self.span = 500 self.begin = 0 self.channels = [] self._SetSize() self.Bind(wx.EVT_IDLE, self._onIdle) self.Bind(wx.EVT_SIZE, self._onSize) self._resizeFlag = True sizer=wx.BoxSizer(wx.VERTICAL) sizer.Add(self.canvas,1,wx.GROW) self.SetSizer(sizer) self.canvas.Show() def addChannel(self, channel): self.channels.append(channel) def setTimespan(self, span): self.span = span def setYlim(self, ymin, ymax): self.ylim = [ymin, ymax] def _resizeCreateContent(self): '''Resize graph according to user input and initialize plots''' self.lines=[] for c in self.channels: data=c.getNext() line, = self.ax.plot(data[0],data[1], animated = True) self.lines.append(line) gca = self.fig.gca() #TODO: add an auto mode here if self.ylim: gca.set_ylim(self.ylim) else: if self.autolim: diff = self.autolim[1] - self.autolim[0] gca.set_ylim([self.autolim[0] - 0.1*diff, self.autolim[1] + 0.1*diff]) else: gca.set_ylim([-1,1]) gca.set_xlim([self.begin, (self.begin+self.span)]) self.ax.grid() #self.fig.clear() self.canvas.draw() self.background = None print 'content' self._doRePlot = False def _createGraphics(self): """Reallocate new figure and take care of panel resizing issues""" self.fig=Figure() self.canvas=FigureCanvas(self,-1,self.fig) self.ax = self.fig.add_subplot(111) self.ax._cachedRenderer=self.canvas.get_renderer() def _onSize(self, evt): self._resizeFlag = True def _onIdle(self, event): event.RequestMore(True) if self._resizeFlag: self._resizeFlag = False self._SetSize() self.draw_plot() #if self.foo > 2000: #u=time.time() #print self.foo/(u-self.t), self.blit_time/(u-self.t) #exit(0) def _SetSize(self, pixels=None): if not pixels: pixels = self.GetClientSize() self._createGraphics() self.canvas.SetSize(pixels) self.fig.set_size_inches(pixels[0]/self.fig.get_dpi(), pixels[1]/self.fig.get_dpi(), forward=True) self._doRePlot = True def draw_plot(self): if self._doRePlot: self._resizeCreateContent() if self.background is None: self.background = self.canvas.copy_from_bbox(self.ax.bbox) self.foo += 1 #self.y = numpy.cos(numpy.arange(0.0,1.0,0.1)+self.foo*0.1) # Optimization on the blitting: we compute the box where the changes happen changes_box = None for i in range(len(self.lines)): data=self.channels[i].getNext() if len(data[1])>0: if self.autolim: print self.autolim[0], data[1], self.autolim[1] self.autolim = [ min(self.autolim[0], min(data[1])), \ max(self.autolim[1], max(data[1])) ] else: self.autolim = [ min(data[1]), min(data[1]) ] if changes_box is None: changes_box = Bbox.unit() print '>>>>>>>>' print data[0], data[1] changes_box.update_from_data(numpy.array(data[0]), \ numpy.array(data[1]), ignore=changes_box.is_unit()) if not self._doRePlot and len(data[0]) > 0 : end = data[0][-1] if end > self.begin+self.span: self.begin += self.span self._doRePlot = True print 'do replot' self.lines[i].set_data(data[0], data[1]) else: self.lines[i].set_data([], []) if not changes_box: return #self.canvas.restore_region(self.background) for line in self.lines: self.ax.draw_artist(line) #print line.get_transform() tr = line.get_transform() changes_box_inframe = changes_box.transformed(tr) box_padding = 5 (x,y,l,w) = changes_box_inframe.bounds changes_box_inframe = Bbox.from_bounds(x-box_padding, \ y-box_padding, l+2*box_padding, w+2*box_padding) #print t0 = time.time() self.canvas.blit(None) #self.canvas.blit(changes_box_inframe) self.blit_time += time.time() - t0