source: sasview/src/sas/plottools/PlotPanel.py @ 3477478

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 3477478 was 3477478, checked in by Mathieu Doucet <doucetm@…>, 9 years ago

pylint fixes

  • Property mode set to 100644
File size: 74.0 KB
Line 
1"""
2    Plot panel.
3"""
4import logging
5import wx
6# Try a normal import first
7# If it fails, try specifying a version
8import matplotlib
9matplotlib.interactive(False)
10#Use the WxAgg back end. The Wx one takes too long to render
11matplotlib.use('WXAgg')
12from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
13from matplotlib.figure import Figure
14import os
15import transform
16from plottables import Data1D
17#TODO: make the plottables interactive
18from binder import BindArtist
19from matplotlib.font_manager import FontProperties
20DEBUG = False
21
22from plottables import Graph
23from plottables import Text
24from TextDialog import TextDialog
25from LabelDialog import LabelDialog
26import operator
27
28import math
29import pylab
30DEFAULT_CMAP = pylab.cm.jet
31import copy
32import numpy
33
34from sas.guiframe.events import StatusEvent
35
36def show_tree(obj, d=0):
37    """Handy function for displaying a tree of graph objects"""
38    print "%s%s" % ("-"*d, obj.__class__.__name__)
39    if 'get_children' in dir(obj):
40        for a in obj.get_children(): show_tree(a, d + 1)
41
42from convert_units import convert_unit
43
44
45def _rescale(lo, hi, step, pt=None, bal=None, scale='linear'):
46    """
47        Rescale (lo,hi) by step, returning the new (lo,hi)
48        The scaling is centered on pt, with positive values of step
49        driving lo/hi away from pt and negative values pulling them in.
50        If bal is given instead of point, it is already in [0,1] coordinates.
51
52        This is a helper function for step-based zooming.
53
54    """
55    # Convert values into the correct scale for a linear transformation
56    # TODO: use proper scale transformers
57    loprev = lo
58    hiprev = hi
59    if scale == 'log':
60        assert lo > 0
61        if lo > 0:
62            lo = math.log10(lo)
63        if hi > 0:
64            hi = math.log10(hi)
65        if pt is not None:
66            pt = math.log10(pt)
67
68    # Compute delta from axis range * %, or 1-% if persent is negative
69    if step > 0:
70        delta = float(hi - lo) * step / 100
71    else:
72        delta = float(hi - lo) * step / (100 - step)
73
74    # Add scale factor proportionally to the lo and hi values,
75    # preserving the
76    # point under the mouse
77    if bal is None:
78        bal = float(pt - lo) / (hi - lo)
79    lo = lo - (bal * delta)
80    hi = hi + (1 - bal) * delta
81
82    # Convert transformed values back to the original scale
83    if scale == 'log':
84        if (lo <= -250) or (hi >= 250):
85            lo = loprev
86            hi = hiprev
87        else:
88            lo, hi = math.pow(10., lo), math.pow(10., hi)
89    return (lo, hi)
90
91
92def CopyImage(canvas):
93    """
94    0: matplotlib plot
95    1: wx.lib.plot
96    2: other
97    """
98    bmp = wx.BitmapDataObject()
99    bmp.SetBitmap(canvas.bitmap)
100
101    wx.TheClipboard.Open()
102    wx.TheClipboard.SetData(bmp)
103    wx.TheClipboard.Close()
104
105
106class PlotPanel(wx.Panel):
107    """
108    The PlotPanel has a Figure and a Canvas. OnSize events simply set a
109    flag, and the actually redrawing of the
110    figure is triggered by an Idle event.
111    """
112    def __init__(self, parent, id=-1, xtransform=None,
113                 ytransform=None, scale='log_{10}',
114                 color=None, dpi=None, **kwargs):
115        """
116        """
117        wx.Panel.__init__(self, parent, id=id, **kwargs)
118        self.parent = parent
119        if hasattr(parent, "parent"):
120            self.parent = self.parent.parent
121        self.dimension = 1
122        self.gotLegend = 0  # to begin, legend is not picked.
123        self.legend_pos_loc = None
124        self.legend = None
125        self.line_collections_list = []
126        self.figure = Figure(None, dpi, linewidth=2.0)
127        self.color = '#b3b3b3'
128        from canvas import FigureCanvas
129        self.canvas = FigureCanvas(self, -1, self.figure)
130        self.SetColor(color)
131        self._resizeflag = True
132        self._SetSize()
133        self.subplot = self.figure.add_subplot(111)
134        self.figure.subplots_adjust(left=0.2, bottom=.2)
135        self.yscale = 'linear'
136        self.xscale = 'linear'
137        self.sizer = wx.BoxSizer(wx.VERTICAL)
138        self.sizer.Add(self.canvas, 1, wx.EXPAND)
139        #add toolbar
140        self.enable_toolbar = True
141        self.toolbar = None
142        self.add_toolbar()
143        self.SetSizer(self.sizer)
144
145        # Graph object to manage the plottables
146        self.graph = Graph()
147
148        #Boolean value to keep track of whether current legend is
149        #visible or not
150        self.legend_on = True
151        self.grid_on = False
152        #Location of legend, default is 0 or 'best'
153        self.legendLoc = 0
154        self.position = None
155        self._loc_labels = self.get_loc_label()
156
157        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu)
158
159        # Define some constants
160        self.colorlist = ['b', 'g', 'r', 'c', 'm', 'y', 'k']
161        self.symbollist = ['o', 'x', '^', 'v', '<', '>', '+',
162                           's', 'd', 'D', 'h', 'H', 'p', '-']
163
164        #List of texts currently on the plot
165        self.textList = []
166        #User scale
167        if xtransform != None:
168            self.xLabel = xtransform
169        else:
170            self.xLabel = "log10(x)"
171        if ytransform != None:
172            self.yLabel = ytransform
173        else:
174            self.yLabel = "log10(y)"
175        self.viewModel = "--"
176        # keep track if the previous transformation of x
177        # and y in Property dialog
178        self.prevXtrans = "log10(x)"
179        self.prevYtrans = "log10(y)"
180        self.scroll_id = self.canvas.mpl_connect('scroll_event', self.onWheel)
181        #taking care of dragging
182        self.motion_id = self.canvas.mpl_connect('motion_notify_event',
183                                                 self.onMouseMotion)
184        self.press_id = self.canvas.mpl_connect('button_press_event',
185                                                self.onLeftDown)
186        self.pick_id = self.canvas.mpl_connect('pick_event', self.onPick)
187        self.release_id = self.canvas.mpl_connect('button_release_event',
188                                                  self.onLeftUp)
189
190        wx.EVT_RIGHT_DOWN(self, self.onLeftDown)
191        # to turn axis off whenn resizing the panel
192        self.resizing = False
193
194        self.leftdown = False
195        self.leftup = False
196        self.mousemotion = False
197        self.axes = [self.subplot]
198        ## Fit dialog
199        self._fit_dialog = None
200        # Interactor
201        self.connect = BindArtist(self.subplot.figure)
202        #self.selected_plottable = None
203
204        # new data for the fit
205        self.fit_result = Data1D(x=[], y=[], dy=None)
206        self.fit_result.symbol = 13
207        #self.fit_result = Data1D(x=[], y=[],dx=None, dy=None)
208        self.fit_result.name = "Fit"
209        # For fit Dialog initial display
210        self.xmin = 0.0
211        self.xmax = 0.0
212        self.xminView = 0.0
213        self.xmaxView = 0.0
214        self._scale_xlo = None
215        self._scale_xhi = None
216        self._scale_ylo = None
217        self._scale_yhi = None
218        self.Avalue = None
219        self.Bvalue = None
220        self.ErrAvalue = None
221        self.ErrBvalue = None
222        self.Chivalue = None
223
224        # for 2D scale
225        if scale != 'linear':
226            scale = 'log_{10}'
227        self.scale = scale
228        self.data = None
229        self.qx_data = None
230        self.qy_data = None
231        self.xmin_2D = None
232        self.xmax_2D = None
233        self.ymin_2D = None
234        self.ymax_2D = None
235        ## store reference to the current plotted vmin and vmax of plotted image
236        ##z range in linear scale
237        self.zmin_2D = None
238        self.zmax_2D = None
239
240        #index array
241        self.index_x = None
242        self.index_y = None
243
244        #number of bins
245        self.x_bins = None
246        self.y_bins = None
247
248        ## default color map
249        self.cmap = DEFAULT_CMAP
250
251        # Dragging info
252        self.begDrag = False
253        self.xInit = None
254        self.yInit = None
255        self.xFinal = None
256        self.yFinal = None
257
258        #axes properties
259        self.xaxis_font = None
260        self.xaxis_label = None
261        self.xaxis_unit = None
262        self.xaxis_color = 'black'
263        self.xaxis_tick = None
264        self.yaxis_font = None
265        self.yaxis_label = None
266        self.yaxis_unit = None
267        self.yaxis_color = 'black'
268        self.yaxis_tick = None
269
270        # check if zoomed.
271        self.is_zoomed = False
272        # Plottables
273        self.plots = {}
274
275        # Default locations
276        self._default_save_location = os.getcwd()
277        # let canvas know about axes
278        self.canvas.set_panel(self)
279        self.ly = None
280        self.q_ctrl = None
281        #Bind focus to change the border color
282        self.canvas.Bind(wx.EVT_SET_FOCUS, self.on_set_focus)
283        self.canvas.Bind(wx.EVT_KILL_FOCUS, self.on_kill_focus)
284
285    def _SetInitialSize(self,):
286        """
287        """
288        pixels = self.parent.GetClientSize()
289        self.canvas.SetSize(pixels)
290        self.figure.set_size_inches(pixels[0] / self.figure.get_dpi(),
291                                    pixels[1] / self.figure.get_dpi(), forward=True)
292
293    def On_Paint(self, event):
294        """
295        """
296        self.canvas.SetBackgroundColour(self.color)
297
298    def on_set_focus(self, event):
299        """
300        Send to the parenet the current panel on focus
301        """
302        # light blue
303        self.color = '#0099f7'
304        self.figure.set_edgecolor(self.color)
305        if self.parent and self.window_caption:
306            self.parent.send_focus_to_datapanel(self.window_caption)
307        self.draw()
308
309    def on_kill_focus(self, event):
310        """
311        Reset the panel color
312        """
313        # light grey
314        self.color = '#b3b3b3'
315        self.figure.set_edgecolor(self.color)
316        self.draw()
317
318    def set_resizing(self, resizing=False):
319        """
320        Set the resizing (True/False)
321        """
322        pass  # Not implemented
323
324    def schedule_full_draw(self, func='append'):
325        """
326        Put self in schedule to full redraw list
327        """
328        pass  # Not implemented
329
330    def add_toolbar(self):
331        """
332        add toolbar
333        """
334        self.enable_toolbar = True
335        from toolbar import NavigationToolBar
336        self.toolbar = NavigationToolBar(parent=self, canvas=self.canvas)
337        self.toolbar.Realize()
338        ## The 'SetToolBar()' is not working on MAC: JHC
339        #if IS_MAC:
340        # Mac platform (OSX 10.3, MacPython) does not seem to cope with
341        # having a toolbar in a sizer. This work-around gets the buttons
342        # back, but at the expense of having the toolbar at the top
343        #self.SetToolBar(self.toolbar)
344        #else:
345        # On Windows platform, default window size is incorrect, so set
346        # toolbar width to figure width.
347        tw, th = self.toolbar.GetSizeTuple()
348        fw, fh = self.canvas.GetSizeTuple()
349        # By adding toolbar in sizer, we are able to put it at the bottom
350        # of the frame - so appearance is closer to GTK version.
351        # As noted above, doesn't work for Mac.
352        self.toolbar.SetSize(wx.Size(fw, th))
353        self.sizer.Add(self.toolbar, 0, wx.LEFT | wx.EXPAND)
354
355        # update the axes menu on the toolbar
356        self.toolbar.update()
357
358    def onLeftDown(self, event):
359        """
360        left button down and ready to drag
361        """
362        # Check that the LEFT button was pressed
363        if event.button == 1:
364            self.leftdown = True
365            ax = event.inaxes
366            if ax != None:
367                self.xInit, self.yInit = event.xdata, event.ydata
368                try:
369                    pos_x = float(event.xdata)  # / size_x
370                    pos_y = float(event.ydata)  # / size_y
371                    pos_x = "%8.3g" % pos_x
372                    pos_y = "%8.3g" % pos_y
373                    self.position = str(pos_x), str(pos_y)
374                    wx.PostEvent(self.parent, StatusEvent(status=self.position))
375                except:
376                    self.position = None
377
378    def onLeftUp(self, event):
379        """
380        Dragging is done
381        """
382        # Check that the LEFT button was released
383        if event.button == 1:
384            self.leftdown = False
385            self.mousemotion = False
386            self.leftup = True
387
388        #release the legend
389        if self.gotLegend == 1:
390            self.gotLegend = 0
391            self.set_legend_alpha(1)
392
393    def set_legend_alpha(self, alpha=1):
394        """
395        Set legend alpha
396        """
397        if self.legend != None:
398            self.legend.legendPatch.set_alpha(alpha)
399
400    def onPick(self, event):
401        """
402        On pick legend
403        """
404        legend = self.legend
405        if event.artist == legend:
406            #gets the box of the legend.
407            bbox = self.legend.get_window_extent()
408            #get mouse coordinates at time of pick.
409            self.mouse_x = event.mouseevent.x
410            self.mouse_y = event.mouseevent.y
411            #get legend coordinates at time of pick.
412            self.legend_x = bbox.xmin
413            self.legend_y = bbox.ymin
414            #indicates we picked up the legend.
415            self.gotLegend = 1
416            self.set_legend_alpha(0.5)
417
418    def _on_legend_motion(self, event):
419        """
420        On legend in motion
421        """
422        ax = event.inaxes
423        if ax == None:
424            return
425        # Event occurred inside a plotting area
426        lo_x, hi_x = ax.get_xlim()
427        lo_y, hi_y = ax.get_ylim()
428        # How much the mouse moved.
429        x = mouse_diff_x = self.mouse_x - event.x
430        y = mouse_diff_y = self.mouse_y - event.y
431        # Put back inside
432        if x < lo_x:
433            x = lo_x
434        if x > hi_x:
435            x = hi_x
436        if y < lo_y:
437            y = lo_y
438        if y > hi_y:
439            y = hi_y
440        # Move the legend from its previous location by that same amount
441        loc_in_canvas = self.legend_x - mouse_diff_x, \
442                        self.legend_y - mouse_diff_y
443        # Transform into legend coordinate system
444        trans_axes = self.legend.parent.transAxes.inverted()
445        loc_in_norm_axes = trans_axes.transform_point(loc_in_canvas)
446        self.legend_pos_loc = tuple(loc_in_norm_axes)
447        self.legend._loc = self.legend_pos_loc
448        self.resizing = True
449        self.canvas.set_resizing(self.resizing)
450        self.canvas.draw()
451
452    def onMouseMotion(self, event):
453        """
454        check if the left button is press and the mouse in moving.
455        computer delta for x and y coordinates and then calls draghelper
456        to perform the drag
457        """
458        self.cusor_line(event)
459        if self.gotLegend == 1:
460            self._on_legend_motion(event)
461            return
462        if self.enable_toolbar:
463            #Disable dragging without the toolbar to allow zooming with toolbar
464            return
465        self.mousemotion = True
466        if self.leftdown == True and self.mousemotion == True:
467            ax = event.inaxes
468            if ax != None:  # the dragging is perform inside the figure
469                self.xFinal, self.yFinal = event.xdata, event.ydata
470                # Check whether this is the first point
471                if self.xInit == None:
472                    self.xInit = self.xFinal
473                    self.yInit = self.yFinal
474
475                xdelta = self.xFinal - self.xInit
476                ydelta = self.yFinal - self.yInit
477
478                if self.xscale == 'log':
479                    xdelta = math.log10(self.xFinal) - math.log10(self.xInit)
480                if self.yscale == 'log':
481                    ydelta = math.log10(self.yFinal) - math.log10(self.yInit)
482                self._dragHelper(xdelta, ydelta)
483            else:  # no dragging is perform elsewhere
484                self._dragHelper(0, 0)
485
486    def cusor_line(self, event):
487        """
488        """
489        pass
490
491    def _offset_graph(self):
492        """
493        Zoom and offset the graph to the last known settings
494        """
495        for ax in self.axes:
496            if self._scale_xhi is not None and self._scale_xlo is not None:
497                ax.set_xlim(self._scale_xlo, self._scale_xhi)
498            if self._scale_yhi is not None and self._scale_ylo is not None:
499                ax.set_ylim(self._scale_ylo, self._scale_yhi)
500
501    def _dragHelper(self, xdelta, ydelta):
502        """
503        dragging occurs here
504        """
505        # Event occurred inside a plotting area
506        for ax in self.axes:
507            lo, hi = ax.get_xlim()
508            newlo, newhi = lo - xdelta, hi - xdelta
509            if self.xscale == 'log':
510                if lo > 0:
511                    newlo = math.log10(lo) - xdelta
512                if hi > 0:
513                    newhi = math.log10(hi) - xdelta
514            if self.xscale == 'log':
515                self._scale_xlo = math.pow(10, newlo)
516                self._scale_xhi = math.pow(10, newhi)
517                ax.set_xlim(math.pow(10, newlo), math.pow(10, newhi))
518            else:
519                self._scale_xlo = newlo
520                self._scale_xhi = newhi
521                ax.set_xlim(newlo, newhi)
522
523            lo, hi = ax.get_ylim()
524            newlo, newhi = lo - ydelta, hi - ydelta
525            if self.yscale == 'log':
526                if lo > 0:
527                    newlo = math.log10(lo) - ydelta
528                if hi > 0:
529                    newhi = math.log10(hi) - ydelta
530            if  self.yscale == 'log':
531                self._scale_ylo = math.pow(10, newlo)
532                self._scale_yhi = math.pow(10, newhi)
533                ax.set_ylim(math.pow(10, newlo), math.pow(10, newhi))
534            else:
535                self._scale_ylo = newlo
536                self._scale_yhi = newhi
537                ax.set_ylim(newlo, newhi)
538        self.canvas.draw_idle()
539
540    def resetFitView(self):
541        """
542        For fit Dialog initial display
543        """
544        self.xmin = 0.0
545        self.xmax = 0.0
546        self.xminView = 0.0
547        self.xmaxView = 0.0
548        self._scale_xlo = None
549        self._scale_xhi = None
550        self._scale_ylo = None
551        self._scale_yhi = None
552        self.Avalue = None
553        self.Bvalue = None
554        self.ErrAvalue = None
555        self.ErrBvalue = None
556        self.Chivalue = None
557
558    def onWheel(self, event):
559        """
560        Process mouse wheel as zoom events
561
562        :param event: Wheel event
563
564        """
565        ax = event.inaxes
566        step = event.step
567
568        if ax != None:
569            # Event occurred inside a plotting area
570            lo, hi = ax.get_xlim()
571            lo, hi = _rescale(lo, hi, step,
572                              pt=event.xdata, scale=ax.get_xscale())
573            if not self.xscale == 'log' or lo > 0:
574                self._scale_xlo = lo
575                self._scale_xhi = hi
576                ax.set_xlim((lo, hi))
577
578            lo, hi = ax.get_ylim()
579            lo, hi = _rescale(lo, hi, step, pt=event.ydata,
580                              scale=ax.get_yscale())
581            if not self.yscale == 'log' or lo > 0:
582                self._scale_ylo = lo
583                self._scale_yhi = hi
584                ax.set_ylim((lo, hi))
585        else:
586            # Check if zoom happens in the axes
587            xdata, ydata = None, None
588            x, y = event.x, event.y
589
590            for ax in self.axes:
591                insidex, _ = ax.xaxis.contains(event)
592                if insidex:
593                    xdata, _ = ax.transAxes.inverted().transform_point((x, y))
594                insidey, _ = ax.yaxis.contains(event)
595                if insidey:
596                    _, ydata = ax.transAxes.inverted().transform_point((x, y))
597            if xdata is not None:
598                lo, hi = ax.get_xlim()
599                lo, hi = _rescale(lo, hi, step,
600                                  bal=xdata, scale=ax.get_xscale())
601                if not self.xscale == 'log' or lo > 0:
602                    self._scale_xlo = lo
603                    self._scale_xhi = hi
604                    ax.set_xlim((lo, hi))
605            if ydata is not None:
606                lo, hi = ax.get_ylim()
607                lo, hi = _rescale(lo, hi, step, bal=ydata,
608                                  scale=ax.get_yscale())
609                if not self.yscale == 'log' or lo > 0:
610                    self._scale_ylo = lo
611                    self._scale_yhi = hi
612                    ax.set_ylim((lo, hi))
613        self.canvas.draw_idle()
614
615    def returnTrans(self):
616        """
617        Return values and labels used by Fit Dialog
618        """
619        return self.xLabel, self.yLabel, self.Avalue, self.Bvalue, \
620                self.ErrAvalue, self.ErrBvalue, self.Chivalue
621
622    def setTrans(self, xtrans, ytrans):
623        """
624
625        :param xtrans: set x transformation on Property dialog
626        :param ytrans: set y transformation on Property dialog
627
628        """
629        self.prevXtrans = xtrans
630        self.prevYtrans = ytrans
631
632    def onFitting(self, event):
633        """
634        when clicking on linear Fit on context menu , display Fitting Dialog
635        """
636        list = {}
637        menu = event.GetEventObject()
638        id = event.GetId()
639        self.set_selected_from_menu(menu, id)
640        plotlist = self.graph.returnPlottable()
641        if self.graph.selected_plottable is not None:
642            for item in plotlist:
643                if item.id == self.graph.selected_plottable:
644                    list[item] = plotlist[item]
645        else:
646            list = plotlist
647        from fitDialog import LinearFit
648
649        if len(list.keys()) > 0:
650            first_item = list.keys()[0]
651            dlg = LinearFit(parent=None, plottable=first_item,
652                            push_data=self.onFitDisplay,
653                            transform=self.returnTrans,
654                            title='Linear Fit')
655
656            if (self.xmin != 0.0)and (self.xmax != 0.0)\
657                and(self.xminView != 0.0)and (self.xmaxView != 0.0):
658                dlg.setFitRange(self.xminView, self.xmaxView,
659                                self.xmin, self.xmax)
660            dlg.ShowModal()
661
662    def set_selected_from_menu(self, menu, id):
663        """
664        Set selected_plottable from context menu selection
665
666        :param menu: context menu item
667        :param id: menu item id
668        """
669        if len(self.plots) < 1:
670            return
671        name = menu.GetHelpString(id)
672        for plot in self.plots.values():
673            if plot.name == name:
674                self.graph.selected_plottable = plot.id
675                break
676
677    def linear_plottable_fit(self, plot):
678        """
679            when clicking on linear Fit on context menu, display Fitting Dialog
680
681            :param plot: PlotPanel owning the graph
682
683        """
684        from fitDialog import LinearFit
685        if self._fit_dialog is not None:
686            return
687        self._fit_dialog = LinearFit(None, plot, self.onFitDisplay,
688                                     self.returnTrans, -1, 'Linear Fit')
689        # Set the zoom area
690        if self._scale_xhi is not None and self._scale_xlo is not None:
691            self._fit_dialog.set_fit_region(self._scale_xlo, self._scale_xhi)
692        # Register the close event
693        self._fit_dialog.register_close(self._linear_fit_close)
694        # Show a non-model dialog
695        self._fit_dialog.Show()
696
697    def _linear_fit_close(self):
698        """
699        A fit dialog was closed
700        """
701        self._fit_dialog = None
702
703    def _onProperties(self, event):
704        """
705        when clicking on Properties on context menu ,
706        The Property dialog is displayed
707        The user selects a transformation for x or y value and
708        a new plot is displayed
709        """
710        if self._fit_dialog is not None:
711            self._fit_dialog.Destroy()
712            self._fit_dialog = None
713        plot_list = self.graph.returnPlottable()
714        if len(plot_list.keys()) > 0:
715            first_item = plot_list.keys()[0]
716            if first_item.x != []:
717                from PropertyDialog import Properties
718                dial = Properties(self, -1, 'Properties')
719                dial.setValues(self.prevXtrans, self.prevYtrans, self.viewModel)
720                if dial.ShowModal() == wx.ID_OK:
721                    self.xLabel, self.yLabel, self.viewModel = dial.getValues()
722                    if self.viewModel == "Linear y vs x":
723                        self.xLabel = "x"
724                        self.yLabel = "y"
725                        self.viewModel = "--"
726                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
727                    if self.viewModel == "Guinier lny vs x^(2)":
728                        self.xLabel = "x^(2)"
729                        self.yLabel = "ln(y)"
730                        self.viewModel = "--"
731                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
732                    if self.viewModel == "XS Guinier ln(y*x) vs x^(2)":
733                        self.xLabel = "x^(2)"
734                        self.yLabel = "ln(y*x)"
735                        self.viewModel = "--"
736                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
737                    if self.viewModel == "Porod y*x^(4) vs x^(4)":
738                        self.xLabel = "x^(4)"
739                        self.yLabel = "y*x^(4)"
740                        self.viewModel = "--"
741                        dial.setValues(self.xLabel, self.yLabel, self.viewModel)
742                    self._onEVT_FUNC_PROPERTY()
743                dial.Destroy()
744
745    def set_yscale(self, scale='linear'):
746        """
747        Set the scale on Y-axis
748
749        :param scale: the scale of y-axis
750
751        """
752        self.subplot.set_yscale(scale, nonposy='clip')
753        self.yscale = scale
754
755    def get_yscale(self):
756        """
757
758        :return: Y-axis scale
759
760        """
761        return self.yscale
762
763    def set_xscale(self, scale='linear'):
764        """
765        Set the scale on x-axis
766
767        :param scale: the scale of x-axis
768
769        """
770        self.subplot.set_xscale(scale)
771        self.xscale = scale
772
773    def get_xscale(self):
774        """
775
776        :return: x-axis scale
777
778        """
779        return self.xscale
780
781    def SetColor(self, rgbtuple):
782        """
783        Set figure and canvas colours to be the same
784
785        """
786        if not rgbtuple:
787            rgbtuple = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNFACE).Get()
788        col = [c / 255.0 for c in rgbtuple]
789        self.figure.set_facecolor(col)
790        self.figure.set_edgecolor(self.color)
791        self.canvas.SetBackgroundColour(wx.Colour(*rgbtuple))
792
793    def _onSize(self, event):
794        """
795        """
796        self._resizeflag = True
797
798    def _onIdle(self, evt):
799        """
800        """
801        if self._resizeflag:
802            self._resizeflag = False
803            self._SetSize()
804            self.draw()
805
806    def _SetSize(self, pixels=None):
807        """
808        This method can be called to force the Plot to be a desired size,
809         which defaults to the ClientSize of the panel
810
811        """
812        if not pixels:
813            pixels = tuple(self.GetClientSize())
814        self.canvas.SetSize(pixels)
815        self.figure.set_size_inches(float(pixels[0]) / self.figure.get_dpi(),
816                                    float(pixels[1]) / self.figure.get_dpi())
817
818    def draw(self):
819        """
820        Where the actual drawing happens
821
822        """
823        self.figure.canvas.draw_idle()
824
825    def legend_picker(self, legend, event):
826        """
827            Pick up the legend patch
828        """
829        return self.legend.legendPatch.contains(event)
830
831    def get_loc_label(self):
832        """
833        Associates label to a specific legend location
834        """
835        _labels = {}
836        i = 0
837        _labels['best'] = i
838        i += 1
839        _labels['upper right'] = i
840        i += 1
841        _labels['upper left'] = i
842        i += 1
843        _labels['lower left'] = i
844        i += 1
845        _labels['lower right'] = i
846        i += 1
847        _labels['right'] = i
848        i += 1
849        _labels['center left'] = i
850        i += 1
851        _labels['center right'] = i
852        i += 1
853        _labels['lower center'] = i
854        i += 1
855        _labels['upper center'] = i
856        i += 1
857        _labels['center'] = i
858        return _labels
859
860    def onSaveImage(self, evt):
861        """
862        Implement save image
863        """
864        self.toolbar.save(evt)
865
866    def onContextMenu(self, event):
867        """
868        Default context menu for a plot panel
869
870        """
871        # Slicer plot popup menu
872        id = wx.NewId()
873        slicerpop = wx.Menu()
874        slicerpop.Append(id, '&Save image', 'Save image as PNG')
875        wx.EVT_MENU(self, id, self.onSaveImage)
876
877        id = wx.NewId()
878        slicerpop.Append(id, '&Printer setup', 'Set image size')
879        wx.EVT_MENU(self, id, self.onPrinterSetup)
880
881        id = wx.NewId()
882        slicerpop.Append(id, '&Printer Preview', 'Set image size')
883        wx.EVT_MENU(self, id, self.onPrinterPreview)
884
885        id = wx.NewId()
886        slicerpop.Append(id, '&Print image', 'Print image ')
887        wx.EVT_MENU(self, id, self.onPrint)
888
889        id = wx.NewId()
890        slicerpop.Append(id, '&Copy', 'Copy to the clipboard')
891        wx.EVT_MENU(self, id, self.OnCopyFigureMenu)
892
893        #id = wx.NewId()
894        #slicerpop.Append(id, '&Load 1D data file')
895        #wx.EVT_MENU(self, id, self._onLoad1DData)
896
897        id = wx.NewId()
898        slicerpop.AppendSeparator()
899        slicerpop.Append(id, '&Properties')
900        wx.EVT_MENU(self, id, self._onProperties)
901
902        id = wx.NewId()
903        slicerpop.AppendSeparator()
904        slicerpop.Append(id, '&Linear Fit')
905        wx.EVT_MENU(self, id, self.onFitting)
906
907        id = wx.NewId()
908        slicerpop.AppendSeparator()
909        slicerpop.Append(id, '&Toggle Legend On/Off', 'Toggle Legend On/Off')
910        wx.EVT_MENU(self, id, self.onLegend)
911
912        loc_menu = wx.Menu()
913        for label in self._loc_labels:
914            id = wx.NewId()
915            loc_menu.Append(id, str(label), str(label))
916            wx.EVT_MENU(self, id, self.onChangeLegendLoc)
917        id = wx.NewId()
918        slicerpop.AppendMenu(id, '&Modify Legend Location', loc_menu)
919
920        id = wx.NewId()
921        slicerpop.Append(id, '&Modify Y Axis Label')
922        wx.EVT_MENU(self, id, self._on_yaxis_label)
923        id = wx.NewId()
924        slicerpop.Append(id, '&Modify X Axis Label')
925        wx.EVT_MENU(self, id, self._on_xaxis_label)
926
927        try:
928            # mouse event
929            pos_evt = event.GetPosition()
930            pos = self.ScreenToClient(pos_evt)
931        except:
932            # toolbar event
933            pos_x, pos_y = self.toolbar.GetPositionTuple()
934            pos = (pos_x, pos_y + 5)
935
936        self.PopupMenu(slicerpop, pos)
937
938    def onToolContextMenu(self, event):
939        """
940        ContextMenu from toolbar
941
942        :param event: toolbar event
943        """
944        # reset postion
945        self.position = None
946        if self.graph.selected_plottable != None:
947            self.graph.selected_plottable = None
948
949        self.onContextMenu(event)
950
951# modified kieranrcampbell ILL june2012
952    def onLegend(self, legOnOff):
953        """
954        Toggles whether legend is visible/not visible
955        """
956        self.legend_on = legOnOff
957        if not self.legend_on:
958            for ax in self.axes:
959                self.remove_legend(ax)
960        else:
961            # sort them by labels
962            handles, labels = self.subplot.get_legend_handles_labels()
963            hl = sorted(zip(handles, labels),
964                        key=operator.itemgetter(1))
965            handles2, labels2 = zip(*hl)
966            self.line_collections_list = handles2
967            self.legend = self.subplot.legend(handles2, labels2,
968                                              prop=FontProperties(size=10),
969                                              loc=self.legendLoc)
970            if self.legend != None:
971                self.legend.set_picker(self.legend_picker)
972                self.legend.set_axes(self.subplot)
973                self.legend.set_zorder(20)
974
975        self.subplot.figure.canvas.draw_idle()
976
977    def onChangeLegendLoc(self, event):
978        """
979        Changes legend loc based on user input
980        """
981        menu = event.GetEventObject()
982        label = menu.GetLabel(event.GetId())
983        self.ChangeLegendLoc(label)
984
985    def ChangeLegendLoc(self, label):
986        """
987        Changes legend loc based on user input
988        """
989        self.legendLoc = label
990        self.legend_pos_loc = None
991        # sort them by labels
992        handles, labels = self.subplot.get_legend_handles_labels()
993        hl = sorted(zip(handles, labels),
994                    key=operator.itemgetter(1))
995        handles2, labels2 = zip(*hl)
996        self.line_collections_list = handles2
997        self.legend = self.subplot.legend(handles2, labels2,
998                                          prop=FontProperties(size=10),
999                                          loc=self.legendLoc)
1000        if self.legend != None:
1001            self.legend.set_picker(self.legend_picker)
1002            self.legend.set_axes(self.subplot)
1003            self.legend.set_zorder(20)
1004        self.subplot.figure.canvas.draw_idle()
1005
1006    def remove_legend(self, ax=None):
1007        """
1008        Remove legend for ax or the current axes.
1009        """
1010        from pylab import gca
1011        if ax is None:
1012            ax = gca()
1013        ax.legend_ = None
1014
1015    def _on_addtext(self, event):
1016        """
1017        Allows you to add text to the plot
1018        """
1019        pos_x = 0
1020        pos_y = 0
1021        if self.position != None:
1022            pos_x, pos_y = self.position
1023        else:
1024            pos_x, pos_y = 0.01, 1.00
1025
1026        textdial = TextDialog(None, -1, 'Add Custom Text')
1027        if textdial.ShowModal() == wx.ID_OK:
1028            try:
1029                FONT = FontProperties()
1030                label = textdial.getText()
1031                xpos = pos_x
1032                ypos = pos_y
1033                font = FONT.copy()
1034                font.set_size(textdial.getSize())
1035                font.set_family(textdial.getFamily())
1036                font.set_style(textdial.getStyle())
1037                font.set_weight(textdial.getWeight())
1038                colour = textdial.getColor()
1039                if len(label) > 0 and xpos > 0 and ypos > 0:
1040                    new_text = self.subplot.text(str(xpos), str(ypos), label,
1041                                                 fontproperties=font,
1042                                                 color=colour)
1043                    self.textList.append(new_text)
1044                    self.subplot.figure.canvas.draw_idle()
1045            except:
1046                if self.parent != None:
1047                    msg = "Add Text: Error. Check your property values..."
1048                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1049                else:
1050                    raise
1051        textdial.Destroy()
1052        #Have a pop up box come up for user to type in the
1053        #text that they want to add...then create text Plottable
1054        #based on this and plot it at user designated coordinates
1055
1056    def onGridOnOff(self, gridon_off):
1057        """
1058        Allows ON/OFF Grid
1059        """
1060        self.grid_on = gridon_off
1061
1062        self.subplot.figure.canvas.draw_idle()
1063
1064    def _on_xaxis_label(self, event):
1065        """
1066        Allows you to add text to the plot
1067        """
1068        xaxis_label, xaxis_unit, xaxis_font, xaxis_color, \
1069                     is_ok, is_tick = self._on_axis_label(axis='x')
1070        if not is_ok:
1071            return
1072
1073        self.xaxis_label = xaxis_label
1074        self.xaxis_unit = xaxis_unit
1075        self.xaxis_font = xaxis_font
1076        self.xaxis_color = xaxis_color
1077        if is_tick:
1078            self.xaxis_tick = xaxis_font
1079
1080        if self.data != None:
1081            # 2D
1082            self.xaxis(self.xaxis_label, self.xaxis_unit, \
1083                        self.xaxis_font, self.xaxis_color, self.xaxis_tick)
1084            self.subplot.figure.canvas.draw_idle()
1085        else:
1086            # 1D
1087            self._check_zoom_plot()
1088
1089    def _check_zoom_plot(self):
1090        """
1091        Check the zoom range and plot (1D only)
1092        """
1093        xlo, xhi = self.subplot.get_xlim()
1094        ylo, yhi = self.subplot.get_ylim()
1095        ## Set the view scale for all plots
1096        self._onEVT_FUNC_PROPERTY(False)
1097        if self.is_zoomed:
1098            # Recover the x,y limits
1099            self.subplot.set_xlim((xlo, xhi))
1100            self.subplot.set_ylim((ylo, yhi))
1101
1102    @property
1103    def is_zoomed(self):
1104        toolbar_zoomed = self.toolbar.GetToolEnabled(self.toolbar.wx_ids['Back'])
1105        return self._is_zoomed or toolbar_zoomed
1106
1107    @is_zoomed.setter
1108    def is_zoomed(self, value):
1109        self._is_zoomed = value
1110
1111    def _on_yaxis_label(self, event):
1112        """
1113        Allows you to add text to the plot
1114        """
1115        yaxis_label, yaxis_unit, yaxis_font, yaxis_color, \
1116                        is_ok, is_tick = self._on_axis_label(axis='y')
1117        if not is_ok:
1118            return
1119
1120        self.yaxis_label = yaxis_label
1121        self.yaxis_unit = yaxis_unit
1122        self.yaxis_font = yaxis_font
1123        self.yaxis_color = yaxis_color
1124        if is_tick:
1125            self.yaxis_tick = yaxis_font
1126
1127        if self.data != None:
1128            # 2D
1129            self.yaxis(self.yaxis_label, self.yaxis_unit, \
1130                        self.yaxis_font, self.yaxis_color, self.yaxis_tick)
1131            self.subplot.figure.canvas.draw_idle()
1132        else:
1133            # 1D
1134            self._check_zoom_plot()
1135
1136    def _on_axis_label(self, axis='x'):
1137        """
1138        Modify axes labels
1139
1140        :param axis: x or y axis [string]
1141        """
1142        is_ok = True
1143        title = 'Modify %s axis label' % axis
1144        font = 'serif'
1145        colour = 'black'
1146        if axis == 'x':
1147            label = self.xaxis_label
1148            unit = self.xaxis_unit
1149        else:
1150            label = self.yaxis_label
1151            unit = self.yaxis_unit
1152        textdial = TextDialog(None, -1, title, label, unit)
1153        if textdial.ShowModal() == wx.ID_OK:
1154            try:
1155                FONT = FontProperties()
1156                font = FONT.copy()
1157                font.set_size(textdial.getSize())
1158                font.set_family(textdial.getFamily())
1159                font.set_style(textdial.getStyle())
1160                font.set_weight(textdial.getWeight())
1161                unit = textdial.getUnit()
1162                colour = textdial.getColor()
1163                is_tick = textdial.getTickLabel()
1164                label_temp = textdial.getText()
1165                if label_temp.count("\%s" % "\\") > 0:
1166                    if self.parent != None:
1167                        msg = "Add Label: Error. Can not use double '\\' "
1168                        msg += "characters..."
1169                        wx.PostEvent(self.parent, StatusEvent(status=msg))
1170                else:
1171                    label = label_temp
1172            except:
1173                if self.parent != None:
1174                    msg = "Add Label: Error. Check your property values..."
1175                    wx.PostEvent(self.parent, StatusEvent(status=msg))
1176                else:
1177                    pass
1178        else:
1179            is_ok = False
1180            is_tick = True
1181        textdial.Destroy()
1182        return label, unit, font, colour, is_ok, is_tick
1183
1184    def _on_removetext(self, event):
1185        """
1186        Removes all text from the plot.
1187        Eventually, add option to remove specific text boxes
1188        """
1189        num_text = len(self.textList)
1190        if num_text < 1:
1191            if self.parent != None:
1192                msg = "Remove Text: Nothing to remove.  "
1193                wx.PostEvent(self.parent, StatusEvent(status=msg))
1194            else:
1195                raise
1196            return
1197        txt = self.textList[num_text - 1]
1198        try:
1199            text_remove = txt.get_text()
1200            txt.remove()
1201            if self.parent != None:
1202                msg = "Removed Text: '%s'. " % text_remove
1203                wx.PostEvent(self.parent, StatusEvent(status=msg))
1204        except:
1205            if self.parent != None:
1206                msg = "Remove Text: Error occurred. "
1207                wx.PostEvent(self.parent, StatusEvent(status=msg))
1208            else:
1209                raise
1210        self.textList.remove(txt)
1211
1212        self.subplot.figure.canvas.draw_idle()
1213
1214    def properties(self, prop):
1215        """
1216        Set some properties of the graph.
1217        The set of properties is not yet determined.
1218
1219        """
1220        # The particulars of how they are stored and manipulated (e.g., do
1221        # we want an inventory internally) is not settled.  I've used a
1222        # property dictionary for now.
1223        #
1224        # How these properties interact with a user defined style file is
1225        # even less clear.
1226
1227        # Properties defined by plot
1228        self.subplot.set_xlabel(r"$%s$" % prop["xlabel"])
1229        self.subplot.set_ylabel(r"$%s$" % prop["ylabel"])
1230        self.subplot.set_title(prop["title"])
1231
1232    def clear(self):
1233        """Reset the plot"""
1234        # TODO: Redraw is brutal.  Render to a backing store and swap in
1235        # TODO: rather than redrawing on the fly.
1236        self.subplot.clear()
1237        self.subplot.hold(True)
1238
1239    def render(self):
1240        """Commit the plot after all objects are drawn"""
1241        # TODO: this is when the backing store should be swapped in.
1242        if self.legend_on:
1243            ax = self.subplot
1244            ax.texts = self.textList
1245            try:
1246                handles, labels = ax.get_legend_handles_labels()
1247                # sort them by labels
1248                hl = sorted(zip(handles, labels),
1249                            key=operator.itemgetter(1))
1250                handles2, labels2 = zip(*hl)
1251                self.line_collections_list = handles2
1252                self.legend = ax.legend(handles2, labels2,
1253                                        prop=FontProperties(size=10),
1254                                        loc=self.legendLoc)
1255                if self.legend != None:
1256                    self.legend.set_picker(self.legend_picker)
1257                    self.legend.set_axes(self.subplot)
1258                    self.legend.set_zorder(20)
1259
1260            except:
1261                self.legend = ax.legend(prop=FontProperties(size=10),
1262                                        loc=self.legendLoc)
1263
1264    def xaxis(self, label, units, font=None, color='black', t_font=None):
1265        """xaxis label and units.
1266
1267        Axis labels know about units.
1268
1269        We need to do this so that we can detect when axes are not
1270        commesurate.  Currently this is ignored other than for formatting
1271        purposes.
1272
1273        """
1274
1275        self.xcolor = color
1276        if units.count("{") > 0 and units.count("$") < 2:
1277            units = '$' + units + '$'
1278        if label.count("{") > 0 and label.count("$") < 2:
1279            label = '$' + label + '$'
1280        if units != "":
1281            label = label + " (" + units + ")"
1282        if font:
1283            self.subplot.set_xlabel(label, fontproperties=font, color=color)
1284            if t_font != None:
1285                for tick in self.subplot.xaxis.get_major_ticks():
1286                    tick.label.set_fontproperties(t_font)
1287                for line in self.subplot.xaxis.get_ticklines():
1288                    size = t_font.get_size()
1289                    line.set_markersize(size / 3)
1290        else:
1291            self.subplot.set_xlabel(label, color=color)
1292        pass
1293
1294    def yaxis(self, label, units, font=None, color='black', t_font=None):
1295        """yaxis label and units."""
1296        self.ycolor = color
1297        if units.count("{") > 0 and units.count("$") < 2:
1298            units = '$' + units + '$'
1299        if label.count("{") > 0 and label.count("$") < 2:
1300            label = '$' + label + '$'
1301        if units != "":
1302            label = label + " (" + units + ")"
1303        if font:
1304            self.subplot.set_ylabel(label, fontproperties=font, color=color)
1305            if t_font != None:
1306                for tick_label in self.subplot.get_yticklabels():
1307                    tick_label.set_fontproperties(t_font)
1308                for line in self.subplot.yaxis.get_ticklines():
1309                    size = t_font.get_size()
1310                    line.set_markersize(size / 3)
1311        else:
1312            self.subplot.set_ylabel(label, color=color)
1313        pass
1314
1315    def _connect_to_xlim(self, callback):
1316        """Bind the xlim change notification to the callback"""
1317        def process_xlim(axes):
1318            lo, hi = subplot.get_xlim()
1319            callback(lo, hi)
1320        self.subplot.callbacks.connect('xlim_changed', process_xlim)
1321
1322    def interactive_points(self, x, y, dx=None, dy=None, name='', color=0,
1323                           symbol=0, markersize=5, zorder=1, id=None,
1324                           label=None, hide_error=False):
1325        """Draw markers with error bars"""
1326        self.subplot.set_yscale('linear')
1327        self.subplot.set_xscale('linear')
1328        if id is None:
1329            id = name
1330        from plottable_interactor import PointInteractor
1331        p = PointInteractor(self, self.subplot, zorder=zorder, id=id)
1332        if p.markersize != None:
1333            markersize = p.markersize
1334        p.points(x, y, dx=dx, dy=dy, color=color, symbol=symbol, zorder=zorder,
1335                 markersize=markersize, label=label, hide_error=hide_error)
1336
1337        self.subplot.set_yscale(self.yscale, nonposy='clip')
1338        self.subplot.set_xscale(self.xscale)
1339
1340    def interactive_curve(self, x, y, dy=None, name='', color=0,
1341                          symbol=0, zorder=1, id=None, label=None):
1342        """Draw markers with error bars"""
1343        self.subplot.set_yscale('linear')
1344        self.subplot.set_xscale('linear')
1345        if id is None:
1346            id = name
1347        from plottable_interactor import PointInteractor
1348        p = PointInteractor(self, self.subplot, zorder=zorder, id=id)
1349        p.curve(x, y, dy=dy, color=color, symbol=symbol, zorder=zorder,
1350                label=label)
1351
1352        self.subplot.set_yscale(self.yscale, nonposy='clip')
1353        self.subplot.set_xscale(self.xscale)
1354
1355    def plottable_selected(self, id):
1356        """
1357        Called to register a plottable as selected
1358        """
1359        #TODO: check that it really is in the list of plottables
1360        self.graph.selected_plottable = id
1361
1362    def points(self, x, y, dx=None, dy=None,
1363               color=0, symbol=0, marker_size=5, label=None,
1364               id=None, hide_error=False):
1365        """Draw markers with error bars"""
1366
1367        # Convert tuple (lo,hi) to array [(x-lo),(hi-x)]
1368        if dx != None and type(dx) == type(()):
1369            dx = nx.vstack((x - dx[0], dx[1] - x)).transpose()
1370        if dy != None and type(dy) == type(()):
1371            dy = nx.vstack((y - dy[0], dy[1] - y)).transpose()
1372        if dx == None and dy == None:
1373            self.subplot.plot(x, y, color=self._color(color),
1374                              marker=self._symbol(symbol),
1375                              markersize=marker_size,
1376                              linestyle='',
1377                              label=label)
1378        else:
1379            col = self._color(color)
1380            if hide_error:
1381                self.subplot.plot(x, y, color=col,
1382                                  marker=self._symbol(symbol),
1383                                  markersize=marker_size,
1384                                  linestyle='',
1385                                  label=label)
1386            else:
1387                self.subplot.errorbar(x, y, yerr=dy, xerr=None,
1388                                      ecolor=col, capsize=2, linestyle='',
1389                                      barsabove=False,
1390                                      mec=col, mfc=col,
1391                                      marker=self._symbol(symbol),
1392                                      markersize=marker_size,
1393                                      lolims=False, uplims=False,
1394                                      xlolims=False, xuplims=False, label=label)
1395
1396        self.subplot.set_yscale(self.yscale, nonposy='clip')
1397        self.subplot.set_xscale(self.xscale)
1398
1399    def _onToggleScale(self, event):
1400        """
1401        toggle axis and replot image
1402
1403        """
1404        zmin_2D_temp = self.zmin_2D
1405        zmax_2D_temp = self.zmax_2D
1406        if self.scale == 'log_{10}':
1407            self.scale = 'linear'
1408            if not self.zmin_2D is None:
1409                zmin_2D_temp = math.pow(10, self.zmin_2D)
1410            if not self.zmax_2D is None:
1411                zmax_2D_temp = math.pow(10, self.zmax_2D)
1412        else:
1413            self.scale = 'log_{10}'
1414            if not self.zmin_2D is None:
1415                # min log value: no log(negative)
1416                if self.zmin_2D <= 0:
1417                    zmin_2D_temp = -32
1418                else:
1419                    zmin_2D_temp = math.log10(self.zmin_2D)
1420            if not self.zmax_2D is None:
1421                zmax_2D_temp = math.log10(self.zmax_2D)
1422
1423        self.image(data=self.data, qx_data=self.qx_data,
1424                   qy_data=self.qy_data, xmin=self.xmin_2D,
1425                   xmax=self.xmax_2D,
1426                   ymin=self.ymin_2D, ymax=self.ymax_2D,
1427                   cmap=self.cmap, zmin=zmin_2D_temp,
1428                   zmax=zmax_2D_temp)
1429
1430    def image(self, data, qx_data, qy_data, xmin, xmax, ymin, ymax,
1431              zmin, zmax, color=0, symbol=0, markersize=0,
1432              label='data2D', cmap=DEFAULT_CMAP):
1433        """
1434        Render the current data
1435
1436        """
1437        self.data = data
1438        self.qx_data = qx_data
1439        self.qy_data = qy_data
1440        self.xmin_2D = xmin
1441        self.xmax_2D = xmax
1442        self.ymin_2D = ymin
1443        self.ymax_2D = ymax
1444        self.zmin_2D = zmin
1445        self.zmax_2D = zmax
1446        c = self._color(color)
1447        # If we don't have any data, skip.
1448        if self.data == None:
1449            return
1450        if self.data.ndim == 1:
1451            output = self._build_matrix()
1452        else:
1453            output = copy.deepcopy(self.data)
1454        # check scale
1455        if self.scale == 'log_{10}':
1456            try:
1457                if  self.zmin_2D <= 0  and len(output[output > 0]) > 0:
1458                    zmin_temp = self.zmin_2D
1459                    output[output > 0] = numpy.log10(output[output > 0])
1460                    #In log scale Negative values are not correct in general
1461                    #output[output<=0] = math.log(numpy.min(output[output>0]))
1462                elif self.zmin_2D <= 0:
1463                    zmin_temp = self.zmin_2D
1464                    output[output > 0] = numpy.zeros(len(output))
1465                    output[output <= 0] = -32
1466                else:
1467                    zmin_temp = self.zmin_2D
1468                    output[output > 0] = numpy.log10(output[output > 0])
1469                    #In log scale Negative values are not correct in general
1470                    #output[output<=0] = math.log(numpy.min(output[output>0]))
1471            except:
1472                #Too many problems in 2D plot with scale
1473                pass
1474
1475        else:
1476            zmin_temp = self.zmin_2D
1477        self.cmap = cmap
1478        if self.dimension != 3:
1479            #Re-adjust colorbar
1480            self.subplot.figure.subplots_adjust(left=0.2, right=.8, bottom=.2)
1481
1482            im = self.subplot.imshow(output, interpolation='nearest',
1483                                     origin='lower',
1484                                     vmin=zmin_temp, vmax=self.zmax_2D,
1485                                     cmap=self.cmap,
1486                                     extent=(self.xmin_2D, self.xmax_2D,
1487                                             self.ymin_2D, self.ymax_2D))
1488
1489            cbax = self.subplot.figure.add_axes([0.84, 0.2, 0.02, 0.7])
1490        else:
1491            # clear the previous 2D from memory
1492            # mpl is not clf, so we do
1493            self.subplot.figure.clear()
1494
1495            self.subplot.figure.subplots_adjust(left=0.1, right=.8, bottom=.1)
1496
1497            X = self.x_bins[0:-1]
1498            Y = self.y_bins[0:-1]
1499            X, Y = numpy.meshgrid(X, Y)
1500
1501            try:
1502                # mpl >= 1.0.0
1503                ax = self.subplot.figure.gca(projection='3d')
1504                #ax.disable_mouse_rotation()
1505                cbax = self.subplot.figure.add_axes([0.84, 0.1, 0.02, 0.8])
1506                if len(X) > 60:
1507                    ax.disable_mouse_rotation()
1508            except:
1509                # mpl < 1.0.0
1510                try:
1511                    from mpl_toolkits.mplot3d import Axes3D
1512                except:
1513                    logging.error("PlotPanel could not import Axes3D")
1514                self.subplot.figure.clear()
1515                ax = Axes3D(self.subplot.figure)
1516                if len(X) > 60:
1517                    ax.cla()
1518                cbax = None
1519            self.subplot.figure.canvas.resizing = False
1520            im = ax.plot_surface(X, Y, output, rstride=1, cstride=1, cmap=cmap,
1521                                 linewidth=0, antialiased=False)
1522            self.subplot.set_axis_off()
1523
1524        if cbax == None:
1525            ax.set_frame_on(False)
1526            cb = self.subplot.figure.colorbar(im, shrink=0.8, aspect=20)
1527        else:
1528            cb = self.subplot.figure.colorbar(im, cax=cbax)
1529        cb.update_bruteforce(im)
1530        cb.set_label('$' + self.scale + '$')
1531        if self.dimension != 3:
1532            self.figure.canvas.draw_idle()
1533        else:
1534            self.figure.canvas.draw()
1535
1536    def _build_matrix(self):
1537        """
1538        Build a matrix for 2d plot from a vector
1539        Returns a matrix (image) with ~ square binning
1540        Requirement: need 1d array formats of
1541        self.data, self.qx_data, and self.qy_data
1542        where each one corresponds to z, x, or y axis values
1543
1544        """
1545        # No qx or qy given in a vector format
1546        if self.qx_data == None or self.qy_data == None \
1547                or self.qx_data.ndim != 1 or self.qy_data.ndim != 1:
1548            # do we need deepcopy here?
1549            return copy.deepcopy(self.data)
1550
1551        # maximum # of loops to fillup_pixels
1552        # otherwise, loop could never stop depending on data
1553        max_loop = 1
1554        # get the x and y_bin arrays.
1555        self._get_bins()
1556        # set zero to None
1557
1558        #Note: Can not use scipy.interpolate.Rbf:
1559        # 'cause too many data points (>10000)<=JHC.
1560        # 1d array to use for weighting the data point averaging
1561        #when they fall into a same bin.
1562        weights_data = numpy.ones([self.data.size])
1563        # get histogram of ones w/len(data); this will provide
1564        #the weights of data on each bins
1565        weights, xedges, yedges = numpy.histogram2d(x=self.qy_data,
1566                                                    y=self.qx_data,
1567                                                    bins=[self.y_bins, self.x_bins],
1568                                                    weights=weights_data)
1569        # get histogram of data, all points into a bin in a way of summing
1570        image, xedges, yedges = numpy.histogram2d(x=self.qy_data,
1571                                                  y=self.qx_data,
1572                                                  bins=[self.y_bins, self.x_bins],
1573                                                  weights=self.data)
1574        # Now, normalize the image by weights only for weights>1:
1575        # If weight == 1, there is only one data point in the bin so
1576        # that no normalization is required.
1577        image[weights > 1] = image[weights > 1] / weights[weights > 1]
1578        # Set image bins w/o a data point (weight==0) as None (was set to zero
1579        # by histogram2d.)
1580        image[weights == 0] = None
1581
1582        # Fill empty bins with 8 nearest neighbors only when at least
1583        #one None point exists
1584        loop = 0
1585
1586        # do while loop until all vacant bins are filled up up
1587        #to loop = max_loop
1588        while not(numpy.isfinite(image[weights == 0])).all():
1589            if loop >= max_loop:  # this protects never-ending loop
1590                break
1591            image = self._fillup_pixels(image=image, weights=weights)
1592            loop += 1
1593
1594        return image
1595
1596    def _get_bins(self):
1597        """
1598        get bins
1599        set x_bins and y_bins into self, 1d arrays of the index with
1600        ~ square binning
1601        Requirement: need 1d array formats of
1602        self.qx_data, and self.qy_data
1603        where each one corresponds to  x, or y axis values
1604        """
1605        # No qx or qy given in a vector format
1606        if self.qx_data == None or self.qy_data == None \
1607                or self.qx_data.ndim != 1 or self.qy_data.ndim != 1:
1608            # do we need deepcopy here?
1609            return copy.deepcopy(self.data)
1610
1611        # find max and min values of qx and qy
1612        xmax = self.qx_data.max()
1613        xmin = self.qx_data.min()
1614        ymax = self.qy_data.max()
1615        ymin = self.qy_data.min()
1616
1617        # calculate the range of qx and qy: this way, it is a little
1618        # more independent
1619        x_size = xmax - xmin
1620        y_size = ymax - ymin
1621
1622        # estimate the # of pixels on each axes
1623        npix_y = int(math.floor(math.sqrt(len(self.qy_data))))
1624        npix_x = int(math.floor(len(self.qy_data) / npix_y))
1625
1626        # bin size: x- & y-directions
1627        xstep = x_size / (npix_x - 1)
1628        ystep = y_size / (npix_y - 1)
1629
1630        # max and min taking account of the bin sizes
1631        xmax = xmax + xstep / 2.0
1632        xmin = xmin - xstep / 2.0
1633        ymax = ymax + ystep / 2.0
1634        ymin = ymin - ystep / 2.0
1635
1636        # store x and y bin centers in q space
1637        x_bins = numpy.linspace(xmin, xmax, npix_x)
1638        y_bins = numpy.linspace(ymin, ymax, npix_y)
1639
1640        #set x_bins and y_bins
1641        self.x_bins = x_bins
1642        self.y_bins = y_bins
1643
1644    def _fillup_pixels(self, image=None, weights=None):
1645        """
1646        Fill z values of the empty cells of 2d image matrix
1647        with the average over up-to next nearest neighbor points
1648
1649        :param image: (2d matrix with some zi = None)
1650
1651        :return: image (2d array )
1652
1653        :TODO: Find better way to do for-loop below
1654
1655        """
1656        # No image matrix given
1657        if image == None or numpy.ndim(image) != 2 \
1658                or numpy.isfinite(image).all() \
1659                or weights == None:
1660            return image
1661        # Get bin size in y and x directions
1662        len_y = len(image)
1663        len_x = len(image[1])
1664        temp_image = numpy.zeros([len_y, len_x])
1665        weit = numpy.zeros([len_y, len_x])
1666        # do for-loop for all pixels
1667        for n_y in range(len(image)):
1668            for n_x in range(len(image[1])):
1669                # find only null pixels
1670                if weights[n_y][n_x] > 0 or numpy.isfinite(image[n_y][n_x]):
1671                    continue
1672                else:
1673                    # find 4 nearest neighbors
1674                    # check where or not it is at the corner
1675                    if n_y != 0 and numpy.isfinite(image[n_y - 1][n_x]):
1676                        temp_image[n_y][n_x] += image[n_y - 1][n_x]
1677                        weit[n_y][n_x] += 1
1678                    if n_x != 0 and numpy.isfinite(image[n_y][n_x - 1]):
1679                        temp_image[n_y][n_x] += image[n_y][n_x - 1]
1680                        weit[n_y][n_x] += 1
1681                    if n_y != len_y - 1 and numpy.isfinite(image[n_y + 1][n_x]):
1682                        temp_image[n_y][n_x] += image[n_y + 1][n_x]
1683                        weit[n_y][n_x] += 1
1684                    if n_x != len_x - 1 and numpy.isfinite(image[n_y][n_x + 1]):
1685                        temp_image[n_y][n_x] += image[n_y][n_x + 1]
1686                        weit[n_y][n_x] += 1
1687                    # go 4 next nearest neighbors when no non-zero
1688                    # neighbor exists
1689                    if n_y != 0 and n_x != 0 and\
1690                         numpy.isfinite(image[n_y - 1][n_x - 1]):
1691                        temp_image[n_y][n_x] += image[n_y - 1][n_x - 1]
1692                        weit[n_y][n_x] += 1
1693                    if n_y != len_y - 1 and n_x != 0 and \
1694                        numpy.isfinite(image[n_y + 1][n_x - 1]):
1695                        temp_image[n_y][n_x] += image[n_y + 1][n_x - 1]
1696                        weit[n_y][n_x] += 1
1697                    if n_y != len_y and n_x != len_x - 1 and \
1698                        numpy.isfinite(image[n_y - 1][n_x + 1]):
1699                        temp_image[n_y][n_x] += image[n_y - 1][n_x + 1]
1700                        weit[n_y][n_x] += 1
1701                    if n_y != len_y - 1 and n_x != len_x - 1 and \
1702                        numpy.isfinite(image[n_y + 1][n_x + 1]):
1703                        temp_image[n_y][n_x] += image[n_y + 1][n_x + 1]
1704                        weit[n_y][n_x] += 1
1705
1706        # get it normalized
1707        ind = (weit > 0)
1708        image[ind] = temp_image[ind] / weit[ind]
1709
1710        return image
1711
1712    def curve(self, x, y, dy=None, color=0, symbol=0, label=None):
1713        """Draw a line on a graph, possibly with confidence intervals."""
1714        c = self._color(color)
1715        self.subplot.set_yscale('linear')
1716        self.subplot.set_xscale('linear')
1717
1718        self.subplot.plot(x, y, color=c, marker='',
1719                          linestyle='-', label=label)
1720        self.subplot.set_yscale(self.yscale)
1721        self.subplot.set_xscale(self.xscale)
1722
1723    def _color(self, c):
1724        """Return a particular colour"""
1725        return self.colorlist[c % len(self.colorlist)]
1726
1727    def _symbol(self, s):
1728        """Return a particular symbol"""
1729        return self.symbollist[s % len(self.symbollist)]
1730
1731    def _replot(self, remove_fit=False):
1732        """
1733        Rescale the plottables according to the latest
1734        user selection and update the plot
1735
1736        :param remove_fit: Fit line will be removed if True
1737
1738        """
1739        self.graph.reset_scale()
1740        self._onEVT_FUNC_PROPERTY(remove_fit=remove_fit)
1741        #TODO: Why do we have to have the following line?
1742        self.fit_result.reset_view()
1743        self.graph.render(self)
1744        self.subplot.figure.canvas.draw_idle()
1745
1746    def _onEVT_FUNC_PROPERTY(self, remove_fit=True, show=True):
1747        """
1748        Receive the x and y transformation from myDialog,
1749        Transforms x and y in View
1750        and set the scale
1751        """
1752        # The logic should be in the right order
1753        # Delete first, and then get the whole list...
1754        if remove_fit:
1755            self.graph.delete(self.fit_result)
1756        self.ly = None
1757        self.q_ctrl = None
1758        list = self.graph.returnPlottable()
1759        # Changing the scale might be incompatible with
1760        # currently displayed data (for instance, going
1761        # from ln to log when all plotted values have
1762        # negative natural logs).
1763        # Go linear and only change the scale at the end.
1764        self.set_xscale("linear")
1765        self.set_yscale("linear")
1766        _xscale = 'linear'
1767        _yscale = 'linear'
1768        for item in list:
1769            item.setLabel(self.xLabel, self.yLabel)
1770
1771            # control axis labels from the panel itself
1772            yname, yunits = item.get_yaxis()
1773            if self.yaxis_label != None:
1774                yname = self.yaxis_label
1775                yunits = self.yaxis_unit
1776            else:
1777                self.yaxis_label = yname
1778                self.yaxis_unit = yunits
1779            xname, xunits = item.get_xaxis()
1780            if self.xaxis_label != None:
1781                xname = self.xaxis_label
1782                xunits = self.xaxis_unit
1783            else:
1784                self.xaxis_label = xname
1785                self.xaxis_unit = xunits
1786            # Goes through all possible scales
1787            if self.xLabel == "x":
1788                item.transformX(transform.toX, transform.errToX)
1789                self.graph._xaxis_transformed("%s" % xname, "%s" % xunits)
1790            if self.xLabel == "x^(2)":
1791                item.transformX(transform.toX2, transform.errToX2)
1792                xunits = convert_unit(2, xunits)
1793                self.graph._xaxis_transformed("%s^{2}" % xname, "%s" % xunits)
1794            if self.xLabel == "x^(4)":
1795                item.transformX(transform.toX4, transform.errToX4)
1796                xunits = convert_unit(4, xunits)
1797                self.graph._xaxis_transformed("%s^{4}" % xname, "%s" % xunits)
1798            if self.xLabel == "ln(x)":
1799                item.transformX(transform.toLogX, transform.errToLogX)
1800                self.graph._xaxis_transformed("\ln\\ %s" % xname, "%s" % xunits)
1801            if self.xLabel == "log10(x)":
1802                item.transformX(transform.toX_pos, transform.errToX_pos)
1803                _xscale = 'log'
1804                self.graph._xaxis_transformed("%s" % xname, "%s" % xunits)
1805            if self.xLabel == "log10(x^(4))":
1806                item.transformX(transform.toX4, transform.errToX4)
1807                xunits = convert_unit(4, xunits)
1808                self.graph._xaxis_transformed("%s^{4}" % xname, "%s" % xunits)
1809                _xscale = 'log'
1810            if self.yLabel == "ln(y)":
1811                item.transformY(transform.toLogX, transform.errToLogX)
1812                self.graph._yaxis_transformed("\ln\\ %s" % yname, "%s" % yunits)
1813            if self.yLabel == "y":
1814                item.transformY(transform.toX, transform.errToX)
1815                self.graph._yaxis_transformed("%s" % yname, "%s" % yunits)
1816            if self.yLabel == "log10(y)":
1817                item.transformY(transform.toX_pos, transform.errToX_pos)
1818                _yscale = 'log'
1819                self.graph._yaxis_transformed("%s" % yname, "%s" % yunits)
1820            if self.yLabel == "y^(2)":
1821                item.transformY(transform.toX2, transform.errToX2)
1822                yunits = convert_unit(2, yunits)
1823                self.graph._yaxis_transformed("%s^{2}" % yname, "%s" % yunits)
1824            if self.yLabel == "1/y":
1825                item.transformY(transform.toOneOverX, transform.errOneOverX)
1826                yunits = convert_unit(-1, yunits)
1827                self.graph._yaxis_transformed("1/%s" % yname, "%s" % yunits)
1828            if self.yLabel == "y*x^(4)":
1829                item.transformY(transform.toYX4, transform.errToYX4)
1830                xunits = convert_unit(4, self.xaxis_unit)
1831                self.graph._yaxis_transformed("%s \ \ %s^{4}" % (yname, xname),
1832                                              "%s%s" % (yunits, xunits))
1833            if self.yLabel == "1/sqrt(y)":
1834                item.transformY(transform.toOneOverSqrtX,
1835                                transform.errOneOverSqrtX)
1836                yunits = convert_unit(-0.5, yunits)
1837                self.graph._yaxis_transformed("1/\sqrt{%s}" % yname,
1838                                              "%s" % yunits)
1839            if self.yLabel == "ln(y*x)":
1840                item.transformY(transform.toLogXY, transform.errToLogXY)
1841                self.graph._yaxis_transformed("\ln (%s \ \ %s)" % (yname, xname),
1842                                              "%s%s" % (yunits, self.xaxis_unit))
1843            if self.yLabel == "ln(y*x^(2))":
1844                item.transformY(transform.toLogYX2, transform.errToLogYX2)
1845                xunits = convert_unit(2, self.xaxis_unit)
1846                self.graph._yaxis_transformed("\ln (%s \ \ %s^{2})" % (yname, xname),
1847                                              "%s%s" % (yunits, xunits))
1848            if self.yLabel == "ln(y*x^(4))":
1849                item.transformY(transform.toLogYX4, transform.errToLogYX4)
1850                xunits = convert_unit(4, self.xaxis_unit)
1851                self.graph._yaxis_transformed("\ln (%s \ \ %s^{4})" % (yname, xname),
1852                                              "%s%s" % (yunits, xunits))
1853            if self.yLabel == "log10(y*x^(4))":
1854                item.transformY(transform.toYX4, transform.errToYX4)
1855                xunits = convert_unit(4, self.xaxis_unit)
1856                _yscale = 'log'
1857                self.graph._yaxis_transformed("%s \ \ %s^{4}" % (yname, xname),
1858                                              "%s%s" % (yunits, xunits))
1859            if self.viewModel == "Guinier lny vs x^(2)":
1860                item.transformX(transform.toX2, transform.errToX2)
1861                xunits = convert_unit(2, xunits)
1862                self.graph._xaxis_transformed("%s^{2}" % xname, "%s" % xunits)
1863                item.transformY(transform.toLogX, transform.errToLogX)
1864                self.graph._yaxis_transformed("\ln\ \ %s" % yname, "%s" % yunits)
1865            if self.viewModel == "Porod y*x^(4) vs x^(4)":
1866                item.transformX(transform.toX4, transform.errToX4)
1867                xunits = convert_unit(4, self.xaxis_unit)
1868                self.graph._xaxis_transformed("%s^{4}" % xname, "%s" % xunits)
1869                item.transformY(transform.toYX4, transform.errToYX4)
1870                self.graph._yaxis_transformed("%s \ \ %s^{4}" % (yname, xname),
1871                                              "%s%s" % (yunits, xunits))
1872            item.transformView()
1873
1874        # set new label and units
1875        yname = self.graph.prop["ylabel"]
1876        yunits = ''
1877        xname = self.graph.prop["xlabel"]
1878        xunits = ''
1879
1880        self.resetFitView()
1881        self.prevXtrans = self.xLabel
1882        self.prevYtrans = self.yLabel
1883        self.graph.render(self)
1884        self.set_xscale(_xscale)
1885        self.set_yscale(_yscale)
1886
1887        self.xaxis(xname, xunits, self.xaxis_font,
1888                   self.xaxis_color, self.xaxis_tick)
1889        self.yaxis(yname, yunits, self.yaxis_font,
1890                   self.yaxis_color, self.yaxis_tick)
1891        self.subplot.texts = self.textList
1892        if show:
1893            self.subplot.figure.canvas.draw_idle()
1894
1895    def onFitDisplay(self, tempx, tempy, xminView,
1896                     xmaxView, xmin, xmax, func):
1897        """
1898        Add a new plottable into the graph .In this case this plottable
1899        will be used to fit some data
1900
1901        :param tempx: The x data of fit line
1902        :param tempy: The y data of fit line
1903        :param xminView: the lower bound of fitting range
1904        :param xminView: the upper bound of  fitting range
1905        :param xmin: the lowest value of data to fit to the line
1906        :param xmax: the highest value of data to fit to the line
1907
1908        """
1909        # Saving value to redisplay in Fit Dialog when it is opened again
1910        self.Avalue, self.Bvalue, self.ErrAvalue, \
1911                      self.ErrBvalue, self.Chivalue = func
1912        self.xminView = xminView
1913        self.xmaxView = xmaxView
1914        self.xmin = xmin
1915        self.xmax = xmax
1916        #In case need to change the range of data plotted
1917        list = []
1918        list = self.graph.returnPlottable()
1919        for item in list:
1920            #item.onFitRange(xminView,xmaxView)
1921            item.onFitRange(None, None)
1922        # Create new data plottable with result
1923        self.fit_result.x = []
1924        self.fit_result.y = []
1925        self.fit_result.x = tempx
1926        self.fit_result.y = tempy
1927        self.fit_result.dx = None
1928        self.fit_result.dy = None
1929        #Load the view with the new values
1930        self.fit_result.reset_view()
1931        # Add the new plottable to the graph
1932        self.graph.add(self.fit_result)
1933        self.graph.render(self)
1934        self._offset_graph()
1935        self.subplot.figure.canvas.draw_idle()
1936
1937    def onChangeCaption(self, event):
1938        """
1939        """
1940        if self.parent == None:
1941            return
1942        # get current caption
1943        old_caption = self.window_caption
1944        # Get new caption dialog
1945        dial = LabelDialog(None, -1, 'Modify Window Title', old_caption)
1946        if dial.ShowModal() == wx.ID_OK:
1947            new_caption = dial.getText()
1948
1949            # send to guiframe to change the panel caption
1950            caption = self.parent.on_change_caption(self.window_name,
1951                                                    old_caption, new_caption)
1952
1953            # also set new caption in plot_panels list
1954            self.parent.plot_panels[self.uid].window_caption = caption
1955            # set new caption
1956            self.window_caption = caption
1957
1958        dial.Destroy()
1959
1960    def onResetGraph(self, event):
1961        """
1962        Reset the graph by plotting the full range of data
1963        """
1964        list = []
1965        list = self.graph.returnPlottable()
1966        for item in list:
1967            item.onReset()
1968        self.graph.render(self)
1969        self._onEVT_FUNC_PROPERTY(False)
1970        self.is_zoomed = False
1971        self.toolbar.update()
1972
1973    def onPrinterSetup(self, event=None):
1974        """
1975        """
1976        self.canvas.Printer_Setup(event=event)
1977        self.Update()
1978
1979    def onPrinterPreview(self, event=None):
1980        """
1981        """
1982        try:
1983            self.canvas.Printer_Preview(event=event)
1984            self.Update()
1985        except:
1986            pass
1987
1988    def onPrint(self, event=None):
1989        """
1990        """
1991        try:
1992            self.canvas.Printer_Print(event=event)
1993            self.Update()
1994        except:
1995            pass
1996
1997    def OnCopyFigureMenu(self, evt):
1998        """
1999        Copy the current figure to clipboard
2000        """
2001        try:
2002            CopyImage(self.canvas)
2003        except:
2004            print "Error in copy Image"
2005
2006
2007#---------------------------------------------------------------
2008class NoRepaintCanvas(FigureCanvasWxAgg):
2009    """
2010    We subclass FigureCanvasWxAgg, overriding the _onPaint method, so that
2011    the draw method is only called for the first two paint events. After that,
2012    the canvas will only be redrawn when it is resized.
2013
2014    """
2015    def __init__(self, *args, **kwargs):
2016        """
2017        """
2018        FigureCanvasWxAgg.__init__(self, *args, **kwargs)
2019        self._drawn = 0
2020
2021    def _onPaint(self, evt):
2022        """
2023        Called when wxPaintEvt is generated
2024
2025        """
2026        if not self._isRealized:
2027            self.realize()
2028        if self._drawn < 2:
2029            self.draw(repaint=False)
2030            self._drawn += 1
2031        self.gui_repaint(drawDC=wx.PaintDC(self))
Note: See TracBrowser for help on using the repository browser.