Ticket #16590: classic-plot.py.patch

File classic-plot.py.patch, 127.1 KB (added by ryexander, 6 years ago)

classic branch

  • wx/lib/plot.py

     
    2727#
    2828# Oct 15, 2004  Gordon Williams (g_will@cyberus.ca)
    2929#   - Imported modules given leading underscore to name.
    30 #   - Added Cursor Line Tracking and User Point Labels. 
     30#   - Added Cursor Line Tracking and User Point Labels.
    3131#   - Demo for Cursor Line Tracking and Point Labels.
    3232#   - Size of plot preview frame adjusted to show page better.
    3333#   - Added helper functions PositionUserToScreen and PositionScreenToUser in PlotCanvas.
     
    4242#   - Added PolySpline class and modified demo 1 and 2 to use it
    4343#   - Added center and diagonal lines option (Set/GetEnableCenterLines,
    4444#     Set/GetEnableDiagonals)
    45 #   - Added anti-aliasing option with optional high-resolution mode 
     45#   - Added anti-aliasing option with optional high-resolution mode
    4646#     (Set/GetEnableAntiAliasing, Set/GetEnableHiRes) and demo
    4747#   - Added option to specify exact number of tick marks to use for each axis
    4848#     (SetXSpec(<number>, SetYSpec(<number>) -- work like 'min', but with
    4949#     <number> tick marks)
    50 #   - Added support for background and foreground colours (enabled via 
     50#   - Added support for background and foreground colours (enabled via
    5151#     SetBackgroundColour/SetForegroundColour on a PlotCanvas instance)
    52 #   - Changed PlotCanvas printing initialization from occuring in __init__ to 
     52#   - Changed PlotCanvas printing initialization from occuring in __init__ to
    5353#     occur on access. This will postpone any IPP and / or CUPS warnings
    54 #     which appear on stderr on some Linux systems until printing functionality 
     54#     which appear on stderr on some Linux systems until printing functionality
    5555#     is actually used.
    56 #   
    5756#
     57#
    5858
    5959"""
    6060This is a simple light weight plotting module that can be used with
     
    6161Boa or easily integrated into your own wxPython application.  The
    6262emphasis is on small size and fast plotting for large data sets.  It
    6363has a reasonable number of features to do line and scatter graphs
    64 easily as well as simple bar graphs.  It is not as sophisticated or 
    65 as powerful as SciPy Plt or Chaco.  Both of these are great packages 
     64easily as well as simple bar graphs.  It is not as sophisticated or
     65as powerful as SciPy Plt or Chaco.  Both of these are great packages
    6666but consume huge amounts of computer resources for simple plots.
    6767They can be found at http://scipy.com
    6868
     
    8585    -Doc strings and lots of comments
    8686    -Optimizations for large number of points
    8787    -Legends
    88    
     88
    8989Did a lot of work here to speed markers up. Only a factor of 4
    9090improvement though. Lines are much faster than markers, especially
    9191filled markers.  Stay away from circles and triangles unless you
     
    108108    Right mouse click - zoom out centred on click location.
    109109"""
    110110
    111 import  string as _string
    112 import  time as _time
    113 import  sys
    114 import  wx
     111import string as _string
     112import time as _time
     113import sys
     114import wx
    115115
    116116# Needs NumPy
    117117try:
    118     import numpy.oldnumeric as _Numeric
     118    import numpy as np
    119119except:
    120     msg= """
     120    msg = """
    121121    This module requires the NumPy module, which could not be
    122122    imported.  It probably is not installed (it's not part of the
    123123    standard Python distribution). See the Numeric Python site
    124124    (http://numpy.scipy.org) for information on downloading source or
    125125    binaries."""
    126     raise ImportError, "NumPy not found.\n" + msg
     126    raise ImportError("NumPy not found.\n" + msg)
    127127
    128128
    129 
    130129#
    131130# Plotting classes...
    132131#
    133132class PolyPoints:
     133
    134134    """Base Class for lines and markers
    135135        - All methods are private.
    136136    """
    137137
    138138    def __init__(self, points, attr):
    139         self._points = _Numeric.array(points).astype(_Numeric.Float64)
     139        self._points = np.array(points).astype(np.float64)
    140140        self._logscale = (False, False)
    141141        self._pointSize = (1.0, 1.0)
    142         self.currentScale= (1,1)
    143         self.currentShift= (0,0)
     142        self.currentScale = (1, 1)
     143        self.currentShift = (0, 0)
    144144        self.scaled = self.points
    145145        self.attributes = {}
    146146        self.attributes.update(self._attributes)
    147         for name, value in attr.items():   
     147        for name, value in attr.items():
    148148            if name not in self._attributes.keys():
    149                 raise KeyError, "Style attribute incorrect. Should be one of %s" % self._attributes.keys()
     149                raise KeyError(
     150                    "Style attribute incorrect. Should be one of %s" % self._attributes.keys())
    150151            self.attributes[name] = value
    151        
     152
    152153    def setLogScale(self, logscale):
    153154        self._logscale = logscale
    154    
     155
    155156    def __getattr__(self, name):
    156157        if name == 'points':
    157             if len(self._points)>0:
    158                 data = _Numeric.array(self._points,copy=True)
     158            if len(self._points) > 0:
     159                data = np.array(self._points, copy=True)
    159160                if self._logscale[0]:
    160161                    data = self.log10(data, 0)
    161162                if self._logscale[1]:
     
    164165            else:
    165166                return self._points
    166167        else:
    167             raise AttributeError, name
    168            
     168            raise AttributeError(name)
     169
    169170    def log10(self, data, ind):
    170         data = _Numeric.compress(data[:,ind]>0,data,0)
    171         data[:,ind] = _Numeric.log10(data[:,ind])
     171        data = np.compress(data[:, ind] > 0, data, 0)
     172        data[:, ind] = np.log10(data[:, ind])
    172173        return data
    173174
    174175    def boundingBox(self):
     
    175176        if len(self.points) == 0:
    176177            # no curves to draw
    177178            # defaults to (-1,-1) and (1,1) but axis can be set in Draw
    178             minXY= _Numeric.array([-1.0,-1.0])
    179             maxXY= _Numeric.array([ 1.0, 1.0])
     179            minXY = np.array([-1.0, -1.0])
     180            maxXY = np.array([1.0, 1.0])
    180181        else:
    181             minXY= _Numeric.minimum.reduce(self.points)
    182             maxXY= _Numeric.maximum.reduce(self.points)
     182            minXY = np.minimum.reduce(self.points)
     183            maxXY = np.maximum.reduce(self.points)
    183184        return minXY, maxXY
    184185
    185     def scaleAndShift(self, scale=(1,1), shift=(0,0)):
     186    def scaleAndShift(self, scale=(1, 1), shift=(0, 0)):
    186187        if len(self.points) == 0:
    187188            # no curves to draw
    188189            return
    189190        if (scale is not self.currentScale) or (shift is not self.currentShift):
    190191            # update point scaling
    191             self.scaled = scale*self.points+shift
    192             self.currentScale= scale
    193             self.currentShift= shift
     192            self.scaled = scale * self.points + shift
     193            self.currentScale = scale
     194            self.currentShift = shift
    194195        # else unchanged use the current scaling
    195        
     196
    196197    def getLegend(self):
    197198        return self.attributes['legend']
    198199
    199     def getClosestPoint(self, pntXY, pointScaled= True):
     200    def getClosestPoint(self, pntXY, pointScaled=True):
    200201        """Returns the index of closest point on the curve, pointXY, scaledXY, distance
    201202            x, y in user coords
    202203            if pointScaled == True based on screen coords
     
    203204            if pointScaled == False based on user coords
    204205        """
    205206        if pointScaled == True:
    206             #Using screen coords
     207            # Using screen coords
    207208            p = self.scaled
    208             pxy = self.currentScale * _Numeric.array(pntXY)+ self.currentShift
     209            pxy = self.currentScale * np.array(pntXY) + self.currentShift
    209210        else:
    210             #Using user coords
     211            # Using user coords
    211212            p = self.points
    212             pxy = _Numeric.array(pntXY)
    213         #determine distance for each point
    214         d= _Numeric.sqrt(_Numeric.add.reduce((p-pxy)**2,1)) #sqrt(dx^2+dy^2)
    215         pntIndex = _Numeric.argmin(d)
     213            pxy = np.array(pntXY)
     214        # determine distance for each point
     215        d = np.sqrt(np.add.reduce((p - pxy) ** 2, 1))  # sqrt(dx^2+dy^2)
     216        pntIndex = np.argmin(d)
    216217        dist = d[pntIndex]
    217218        return [pntIndex, self.points[pntIndex], self.scaled[pntIndex] / self._pointSize, dist]
    218        
    219        
     219
     220
    220221class PolyLine(PolyPoints):
     222
    221223    """Class to define line type and style
    222224        - All methods except __init__ are private.
    223225    """
    224    
     226
    225227    _attributes = {'colour': 'black',
    226228                   'width': 1,
    227                    'style': wx.SOLID,
     229                   'style': wx.PENSTYLE_SOLID,
    228230                   'legend': ''}
    229231
    230232    def __init__(self, points, **attr):
    231233        """
    232234        Creates PolyLine object
    233        
     235
    234236        :param `points`: sequence (array, tuple or list) of (x,y) points making up line
    235237        :keyword `attr`: keyword attributes, default to:
    236238
    237          ==========================  ================================ 
    238          'colour'= 'black'           wx.Pen Colour any wx.NamedColour
     239         ==========================  ================================
     240         'colour'= 'black'           wx.Pen Colour any wx.Colour
    239241         'width'= 1                  Pen width
    240          'style'= wx.SOLID           wx.Pen style
     242         'style'= wx.PENSTYLE_SOLID  wx.Pen style
    241243         'legend'= ''                Line Legend to display
    242          ==========================  ================================ 
     244         ==========================  ================================
    243245
    244246        """
    245247        PolyPoints.__init__(self, points, attr)
    246248
    247     def draw(self, dc, printerScale, coord= None):
     249    def draw(self, dc, printerScale, coord=None):
    248250        colour = self.attributes['colour']
    249251        width = self.attributes['width'] * printerScale * self._pointSize[0]
    250         style= self.attributes['style']
     252        style = self.attributes['style']
    251253        if not isinstance(colour, wx.Colour):
    252             colour = wx.NamedColour(colour)
     254            colour = wx.Colour(colour)
    253255        pen = wx.Pen(colour, width, style)
    254256        pen.SetCap(wx.CAP_BUTT)
    255257        dc.SetPen(pen)
    256258        if coord == None:
    257             if len(self.scaled): # bugfix for Mac OS X
     259            if len(self.scaled):  # bugfix for Mac OS X
    258260                dc.DrawLines(self.scaled)
    259261        else:
    260             dc.DrawLines(coord) # draw legend line
     262            dc.DrawLines(coord)  # draw legend line
    261263
    262264    def getSymExtent(self, printerScale):
    263265        """Width and Height of Marker"""
    264         h= self.attributes['width'] * printerScale * self._pointSize[0]
    265         w= 5 * h
    266         return (w,h)
     266        h = self.attributes['width'] * printerScale * self._pointSize[0]
     267        w = 5 * h
     268        return (w, h)
    267269
     270
    268271class PolySpline(PolyLine):
     272
    269273    """Class to define line type and style
    270274        - All methods except __init__ are private.
    271275    """
     
    272276
    273277    _attributes = {'colour': 'black',
    274278                   'width': 1,
    275                    'style': wx.SOLID,
     279                   'style': wx.PENSTYLE_SOLID,
    276280                   'legend': ''}
    277281
    278282    def __init__(self, points, **attr):
     
    282286        :param `points`: sequence (array, tuple or list) of (x,y) points making up spline
    283287        :keyword `attr`: keyword attributes, default to:
    284288
    285          ==========================  ================================ 
    286          'colour'= 'black'           wx.Pen Colour any wx.NamedColour
     289         ==========================  ================================
     290         'colour'= 'black'           wx.Pen Colour any wx.Colour
    287291         'width'= 1                  Pen width
    288          'style'= wx.SOLID           wx.Pen style
     292         'style'= wx.PENSTYLE_SOLID  wx.Pen style
    289293         'legend'= ''                Line Legend to display
    290          ==========================  ================================ 
     294         ==========================  ================================
    291295
    292296        """
    293297        PolyLine.__init__(self, points, **attr)
    294298
    295     def draw(self, dc, printerScale, coord= None):
     299    def draw(self, dc, printerScale, coord=None):
    296300        colour = self.attributes['colour']
    297301        width = self.attributes['width'] * printerScale * self._pointSize[0]
    298         style= self.attributes['style']
     302        style = self.attributes['style']
    299303        if not isinstance(colour, wx.Colour):
    300             colour = wx.NamedColour(colour)
     304            colour = wx.Colour(colour)
    301305        pen = wx.Pen(colour, width, style)
    302306        pen.SetCap(wx.CAP_ROUND)
    303307        dc.SetPen(pen)
    304308        if coord == None:
    305             if len(self.scaled): # bugfix for Mac OS X
     309            if len(self.scaled):  # bugfix for Mac OS X
    306310                dc.DrawSpline(self.scaled)
    307311        else:
    308             dc.DrawLines(coord) # draw legend line
     312            dc.DrawLines(coord)  # draw legend line
    309313
     314
    310315class PolyMarker(PolyPoints):
     316
    311317    """Class to define marker type and style
    312318        - All methods except __init__ are private.
    313319    """
    314  
     320
    315321    _attributes = {'colour': 'black',
    316322                   'width': 1,
    317323                   'size': 2,
    318324                   'fillcolour': None,
    319                    'fillstyle': wx.SOLID,
     325                   'fillstyle': wx.BRUSHSTYLE_SOLID,
    320326                   'marker': 'circle',
    321327                   'legend': ''}
    322328
     
    327333        :param `points`: sequence (array, tuple or list) of (x,y) points
    328334        :keyword `attr`: keyword attributes, default to:
    329335
    330          ============================  ================================ 
    331          'colour'= 'black'             wx.Pen Colour any wx.NamedColour
    332          'width'= 1                    Pen width
    333          'size'= 2                     Marker size
    334          'fillcolour'= same as colour  wx.Brush Colour any wx.NamedColour
    335          'fillstyle'= wx.SOLID         wx.Brush fill style (use wx.TRANSPARENT for no fill)
    336          'style'= wx.SOLID             wx.Pen style
    337          'marker'= 'circle'            Marker shape
    338          'legend'= ''                  Line Legend to display
    339          ============================  ================================ 
     336         ================================ ================================
     337         'colour'= 'black'                wx.Pen Colour any wx.Colour
     338         'width'= 1                       Pen width
     339         'size'= 2                        Marker size
     340         'fillcolour'= same as colour     wx.Brush Colour any wx.Colour
     341         'fillstyle'= wx.BRUSHSTYLE_SOLID wx.Brush fill style (use wx.BRUSHSTYLE_TRANSPARENT for no fill)
     342         'style'= wx.FONTFAMILY_SOLID     wx.Pen style
     343         'marker'= 'circle'               Marker shape
     344         'legend'= ''                     Line Legend to display
     345         ================================ ================================
    340346
    341347         Marker Shapes:
    342348         - 'circle'
     
    347353         - 'cross'
    348354         - 'plus'
    349355        """
    350      
     356
    351357        PolyPoints.__init__(self, points, attr)
    352358
    353     def draw(self, dc, printerScale, coord= None):
     359    def draw(self, dc, printerScale, coord=None):
    354360        colour = self.attributes['colour']
    355361        width = self.attributes['width'] * printerScale * self._pointSize[0]
    356362        size = self.attributes['size'] * printerScale * self._pointSize[0]
     
    359365        marker = self.attributes['marker']
    360366
    361367        if colour and not isinstance(colour, wx.Colour):
    362             colour = wx.NamedColour(colour)
     368            colour = wx.Colour(colour)
    363369        if fillcolour and not isinstance(fillcolour, wx.Colour):
    364             fillcolour = wx.NamedColour(fillcolour)
    365            
     370            fillcolour = wx.Colour(fillcolour)
     371
    366372        dc.SetPen(wx.Pen(colour, width))
    367373        if fillcolour:
    368             dc.SetBrush(wx.Brush(fillcolour,fillstyle))
     374            dc.SetBrush(wx.Brush(fillcolour, fillstyle))
    369375        else:
    370376            dc.SetBrush(wx.Brush(colour, fillstyle))
    371377        if coord == None:
    372             if len(self.scaled): # bugfix for Mac OS X
     378            if len(self.scaled):  # bugfix for Mac OS X
    373379                self._drawmarkers(dc, self.scaled, marker, size)
    374380        else:
    375             self._drawmarkers(dc, coord, marker, size) # draw legend marker
     381            self._drawmarkers(dc, coord, marker, size)  # draw legend marker
    376382
    377383    def getSymExtent(self, printerScale):
    378384        """Width and Height of Marker"""
    379         s= 5*self.attributes['size'] * printerScale * self._pointSize[0]
    380         return (s,s)
     385        s = 5 * self.attributes['size'] * printerScale * self._pointSize[0]
     386        return (s, s)
    381387
    382     def _drawmarkers(self, dc, coords, marker,size=1):
    383         f = eval('self._' +marker)
     388    def _drawmarkers(self, dc, coords, marker, size=1):
     389        f = eval('self._' + marker)
    384390        f(dc, coords, size)
    385391
    386392    def _circle(self, dc, coords, size=1):
    387         fact= 2.5*size
    388         wh= 5.0*size
    389         rect= _Numeric.zeros((len(coords),4),_Numeric.Float)+[0.0,0.0,wh,wh]
    390         rect[:,0:2]= coords-[fact,fact]
    391         dc.DrawEllipseList(rect.astype(_Numeric.Int32))
     393        fact = 2.5 * size
     394        wh = 5.0 * size
     395        rect = np.zeros((len(coords), 4), np.float) + [0.0, 0.0, wh, wh]
     396        rect[:, 0:2] = coords - [fact, fact]
     397        dc.DrawEllipseList(rect.astype(np.int32))
    392398
    393399    def _dot(self, dc, coords, size=1):
    394400        dc.DrawPointList(coords)
    395401
    396402    def _square(self, dc, coords, size=1):
    397         fact= 2.5*size
    398         wh= 5.0*size
    399         rect= _Numeric.zeros((len(coords),4),_Numeric.Float)+[0.0,0.0,wh,wh]
    400         rect[:,0:2]= coords-[fact,fact]
    401         dc.DrawRectangleList(rect.astype(_Numeric.Int32))
     403        fact = 2.5 * size
     404        wh = 5.0 * size
     405        rect = np.zeros((len(coords), 4), np.float) + [0.0, 0.0, wh, wh]
     406        rect[:, 0:2] = coords - [fact, fact]
     407        dc.DrawRectangleList(rect.astype(np.int32))
    402408
    403409    def _triangle(self, dc, coords, size=1):
    404         shape= [(-2.5*size,1.44*size), (2.5*size,1.44*size), (0.0,-2.88*size)]
    405         poly= _Numeric.repeat(coords,3)
    406         poly.shape= (len(coords),3,2)
     410        shape = [(-2.5 * size, 1.44 * size),
     411                 (2.5 * size, 1.44 * size), (0.0, -2.88 * size)]
     412        poly = np.repeat(coords, 3, 0)
     413        poly.shape = (len(coords), 3, 2)
    407414        poly += shape
    408         dc.DrawPolygonList(poly.astype(_Numeric.Int32))
     415        dc.DrawPolygonList(poly.astype(np.int32))
    409416
    410417    def _triangle_down(self, dc, coords, size=1):
    411         shape= [(-2.5*size,-1.44*size), (2.5*size,-1.44*size), (0.0,2.88*size)]
    412         poly= _Numeric.repeat(coords,3)
    413         poly.shape= (len(coords),3,2)
     418        shape = [(-2.5 * size, -1.44 * size),
     419                 (2.5 * size, -1.44 * size), (0.0, 2.88 * size)]
     420        poly = np.repeat(coords, 3, 0)
     421        poly.shape = (len(coords), 3, 2)
    414422        poly += shape
    415         dc.DrawPolygonList(poly.astype(_Numeric.Int32))
    416      
     423        dc.DrawPolygonList(poly.astype(np.int32))
     424
    417425    def _cross(self, dc, coords, size=1):
    418         fact= 2.5*size
    419         for f in [[-fact,-fact,fact,fact],[-fact,fact,fact,-fact]]:
    420             lines= _Numeric.concatenate((coords,coords),axis=1)+f
    421             dc.DrawLineList(lines.astype(_Numeric.Int32))
     426        fact = 2.5 * size
     427        for f in [[-fact, -fact, fact, fact], [-fact, fact, fact, -fact]]:
     428            lines = np.concatenate((coords, coords), axis=1) + f
     429            dc.DrawLineList(lines.astype(np.int32))
    422430
    423431    def _plus(self, dc, coords, size=1):
    424         fact= 2.5*size
    425         for f in [[-fact,0,fact,0],[0,-fact,0,fact]]:
    426             lines= _Numeric.concatenate((coords,coords),axis=1)+f
    427             dc.DrawLineList(lines.astype(_Numeric.Int32))
     432        fact = 2.5 * size
     433        for f in [[-fact, 0, fact, 0], [0, -fact, 0, fact]]:
     434            lines = np.concatenate((coords, coords), axis=1) + f
     435            dc.DrawLineList(lines.astype(np.int32))
    428436
     437
    429438class PlotGraphics:
     439
    430440    """Container to hold PolyXXX objects and graph labels
    431441        - All methods except __init__ are private.
    432442    """
    433443
    434     def __init__(self, objects, title='', xLabel='', yLabel= ''):
     444    def __init__(self, objects, title='', xLabel='', yLabel=''):
    435445        """Creates PlotGraphics object
    436446        objects - list of PolyXXX objects to make graph
    437447        title - title shown at top of graph
     
    438448        xLabel - label shown on x-axis
    439449        yLabel - label shown on y-axis
    440450        """
    441         if type(objects) not in [list,tuple]:
    442             raise TypeError, "objects argument should be list or tuple"
     451        if type(objects) not in [list, tuple]:
     452            raise TypeError("objects argument should be list or tuple")
    443453        self.objects = objects
    444         self.title= title
    445         self.xLabel= xLabel
    446         self.yLabel= yLabel
     454        self.title = title
     455        self.xLabel = xLabel
     456        self.yLabel = yLabel
    447457        self._pointSize = (1.0, 1.0)
    448458
    449459    def setLogScale(self, logscale):
    450460        if type(logscale) != tuple:
    451             raise TypeError, 'logscale must be a tuple of bools, e.g. (False, False)'
     461            raise TypeError(
     462                'logscale must be a tuple of bools, e.g. (False, False)')
    452463        if len(self.objects) == 0:
    453464            return
    454465        for o in self.objects:
    455466            o.setLogScale(logscale)
    456        
     467
    457468    def boundingBox(self):
    458469        p1, p2 = self.objects[0].boundingBox()
    459470        for o in self.objects[1:]:
    460471            p1o, p2o = o.boundingBox()
    461             p1 = _Numeric.minimum(p1, p1o)
    462             p2 = _Numeric.maximum(p2, p2o)
     472            p1 = np.minimum(p1, p1o)
     473            p2 = np.maximum(p2, p2o)
    463474        return p1, p2
    464475
    465     def scaleAndShift(self, scale=(1,1), shift=(0,0)):
     476    def scaleAndShift(self, scale=(1, 1), shift=(0, 0)):
    466477        for o in self.objects:
    467478            o.scaleAndShift(scale, shift)
    468479
    469480    def setPrinterScale(self, scale):
    470481        """Thickens up lines and markers only for printing"""
    471         self.printerScale= scale
     482        self.printerScale = scale
    472483
    473     def setXLabel(self, xLabel= ''):
     484    def setXLabel(self, xLabel=''):
    474485        """Set the X axis label on the graph"""
    475         self.xLabel= xLabel
     486        self.xLabel = xLabel
    476487
    477     def setYLabel(self, yLabel= ''):
     488    def setYLabel(self, yLabel=''):
    478489        """Set the Y axis label on the graph"""
    479         self.yLabel= yLabel
    480        
    481     def setTitle(self, title= ''):
     490        self.yLabel = yLabel
     491
     492    def setTitle(self, title=''):
    482493        """Set the title at the top of graph"""
    483         self.title= title
     494        self.title = title
    484495
    485496    def getXLabel(self):
    486497        """Get x axis label string"""
     
    490501        """Get y axis label string"""
    491502        return self.yLabel
    492503
    493     def getTitle(self, title= ''):
     504    def getTitle(self, title=''):
    494505        """Get the title at the top of graph"""
    495506        return self.title
    496507
    497508    def draw(self, dc):
    498509        for o in self.objects:
    499             #t=_time.clock()          # profile info
     510            # t=_time.clock()          # profile info
    500511            o._pointSize = self._pointSize
    501512            o.draw(dc, self.printerScale)
    502513            #dt= _time.clock()-t
    503             #print o, "time=", dt
     514            #print(o, "time=", dt)
    504515
    505516    def getSymExtent(self, printerScale):
    506517        """Get max width and height of lines and markers symbols for legend"""
     
    509520        for o in self.objects[1:]:
    510521            o._pointSize = self._pointSize
    511522            oSymExt = o.getSymExtent(printerScale)
    512             symExt = _Numeric.maximum(symExt, oSymExt)
     523            symExt = np.maximum(symExt, oSymExt)
    513524        return symExt
    514    
     525
    515526    def getLegendNames(self):
    516527        """Returns list of legend names"""
    517         lst = [None]*len(self)
     528        lst = [None] * len(self)
    518529        for i in range(len(self)):
    519             lst[i]= self.objects[i].getLegend()
     530            lst[i] = self.objects[i].getLegend()
    520531        return lst
    521            
     532
    522533    def __len__(self):
    523534        return len(self.objects)
    524535
     
    526537        return self.objects[item]
    527538
    528539
    529 #-------------------------------------------------------------------------------
     540#-------------------------------------------------------------------------
    530541# Main window that you will want to import into your application.
    531542
    532543class PlotCanvas(wx.Panel):
     544
    533545    """
    534546    Subclass of a wx.Panel which holds two scrollbars and the actual
    535547    plotting canvas (self.canvas). It allows for simple general plotting
     
    539551                 size=wx.DefaultSize, style=0, name="plotCanvas"):
    540552        """Constructs a panel, which can be a child of a frame or
    541553        any other non-control window"""
    542    
     554
    543555        wx.Panel.__init__(self, parent, id, pos, size, style, name)
    544556
    545         sizer = wx.FlexGridSizer(2,2,0,0)
     557        sizer = wx.FlexGridSizer(2, 2, 0, 0)
    546558        self.canvas = wx.Window(self, -1)
    547559        self.sb_vert = wx.ScrollBar(self, -1, style=wx.SB_VERTICAL)
    548         self.sb_vert.SetScrollbar(0,1000,1000,1000)
     560        self.sb_vert.SetScrollbar(0, 1000, 1000, 1000)
    549561        self.sb_hor = wx.ScrollBar(self, -1, style=wx.SB_HORIZONTAL)
    550         self.sb_hor.SetScrollbar(0,1000,1000,1000)
     562        self.sb_hor.SetScrollbar(0, 1000, 1000, 1000)
    551563
    552564        sizer.Add(self.canvas, 1, wx.EXPAND)
    553565        sizer.Add(self.sb_vert, 0, wx.EXPAND)
    554566        sizer.Add(self.sb_hor, 0, wx.EXPAND)
    555         sizer.Add((0,0))
    556        
     567        sizer.Add((0, 0))
     568
    557569        sizer.AddGrowableRow(0, 1)
    558570        sizer.AddGrowableCol(0, 1)
    559571
    560572        self.sb_vert.Show(False)
    561573        self.sb_hor.Show(False)
    562        
     574
    563575        self.SetSizer(sizer)
    564576        self.Fit()
    565577
    566         self.border = (1,1)
     578        self.border = (1, 1)
    567579
    568580        self.SetBackgroundColour("white")
    569        
     581
    570582        # Create some mouse events for zooming
    571583        self.canvas.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
    572584        self.canvas.Bind(wx.EVT_LEFT_UP, self.OnMouseLeftUp)
     
    583595
    584596        # set curser as cross-hairs
    585597        self.canvas.SetCursor(wx.CROSS_CURSOR)
    586         self.HandCursor = wx.CursorFromImage(Hand.GetImage())
    587         self.GrabHandCursor = wx.CursorFromImage(GrabHand.GetImage())
    588         self.MagCursor = wx.CursorFromImage(MagPlus.GetImage())
    589            
     598        self.HandCursor = wx.Cursor(Hand.GetImage())
     599        self.GrabHandCursor = wx.Cursor(GrabHand.GetImage())
     600        self.MagCursor = wx.Cursor(MagPlus.GetImage())
     601
    590602        # Things for printing
    591603        self._print_data = None
    592         self._pageSetupData= None
     604        self._pageSetupData = None
    593605        self.printerScale = 1
    594         self.parent= parent
     606        self.parent = parent
    595607
    596608        # scrollbar variables
    597609        self._sb_ignore = False
     
    600612        self._sb_yfullrange = 0
    601613        self._sb_xunit = 0
    602614        self._sb_yunit = 0
    603        
     615
    604616        self._dragEnabled = False
    605         self._screenCoordinates = _Numeric.array([0.0, 0.0])
    606        
     617        self._screenCoordinates = np.array([0.0, 0.0])
     618
    607619        self._logscale = (False, False)
    608620
    609621        # Zooming variables
    610         self._zoomInFactor =  0.5
     622        self._zoomInFactor = 0.5
    611623        self._zoomOutFactor = 2
    612         self._zoomCorner1= _Numeric.array([0.0, 0.0]) # left mouse down corner
    613         self._zoomCorner2= _Numeric.array([0.0, 0.0])   # left mouse up corner
    614         self._zoomEnabled= False
    615         self._hasDragged= False
    616        
     624        self._zoomCorner1 = np.array([0.0, 0.0]) # left mouse down corner
     625        self._zoomCorner2 = np.array([0.0, 0.0])   # left mouse up corner
     626        self._zoomEnabled = False
     627        self._hasDragged = False
     628
    617629        # Drawing Variables
    618630        self.last_draw = None
    619         self._pointScale= 1
    620         self._pointShift= 0
    621         self._xSpec= 'auto'
    622         self._ySpec= 'auto'
    623         self._gridEnabled= False
    624         self._legendEnabled= False
    625         self._titleEnabled= True
     631        self._pointScale = 1
     632        self._pointShift = 0
     633        self._xSpec = 'auto'
     634        self._ySpec = 'auto'
     635        self._gridEnabled = False
     636        self._legendEnabled = False
     637        self._titleEnabled = True
    626638        self._centerLinesEnabled = False
    627639        self._diagonalsEnabled = False
    628        
     640
    629641        # Fonts
    630642        self._fontCache = {}
    631         self._fontSizeAxis= 10
    632         self._fontSizeTitle= 15
    633         self._fontSizeLegend= 7
     643        self._fontSizeAxis = 10
     644        self._fontSizeTitle = 15
     645        self._fontSizeLegend = 7
    634646
    635647        # pointLabels
    636         self._pointLabelEnabled= False
    637         self.last_PointLabel= None
    638         self._pointLabelFunc= None
     648        self._pointLabelEnabled = False
     649        self.last_PointLabel = None
     650        self._pointLabelFunc = None
    639651        self.canvas.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
    640652        if sys.platform != "darwin":
    641653            self._logicalFunction = wx.EQUIV  # (NOT src) XOR dst
    642654        else:
    643             self._logicalFunction = wx.COPY  # wx.EQUIV not supported on Mac OS X
     655            # wx.EQUIV not supported on Mac OS X
     656            self._logicalFunction = wx.COPY
    644657
    645658        self._useScientificNotation = False
    646        
     659
    647660        self._antiAliasingEnabled = False
    648661        self._hiResEnabled = False
    649662        self._pointSize = (1.0, 1.0)
     
    654667        # OnSize called to make sure the buffer is initialized.
    655668        # This might result in OnSize getting called twice on some
    656669        # platforms at initialization, but little harm done.
    657         self.OnSize(None) # sets the initial size based on client size
     670        self.OnSize(None)  # sets the initial size based on client size
    658671
    659         self._gridColour = wx.NamedColour('black')
     672        self._gridColour = wx.BLACK
    660673
    661674    def SetCursor(self, cursor):
    662675        self.canvas.SetCursor(cursor)
    663        
     676
    664677    def GetGridColour(self):
    665678        return self._gridColour
    666679
     
    668681        if isinstance(colour, wx.Colour):
    669682            self._gridColour = colour
    670683        else:
    671             self._gridColour = wx.NamedColour(colour)
     684            self._gridColour = wx.Colour(colour)
    672685
    673        
    674686    # SaveFile
    675     def SaveFile(self, fileName= ''):
     687    def SaveFile(self, fileName=''):
    676688        """Saves the file to the type specified in the extension. If no file
    677689        name is specified a dialog box is provided.  Returns True if sucessful,
    678690        otherwise False.
    679        
     691
    680692        .bmp  Save a Windows bitmap file.
    681693        .xbm  Save an X bitmap file.
    682694        .xpm  Save an XPM bitmap file.
     
    689701            "xpm": wx.BITMAP_TYPE_XPM,       # Save an XPM bitmap file.
    690702            "jpg": wx.BITMAP_TYPE_JPEG,      # Save a JPG file.
    691703            "png": wx.BITMAP_TYPE_PNG,       # Save a PNG file.
    692             }
     704        }
    693705
    694706        fType = _string.lower(fileName[-3:])
    695707        dlg1 = None
     
    697709
    698710            if dlg1:                   # FileDialog exists: Check for extension
    699711                dlg2 = wx.MessageDialog(self, 'File name extension\n'
    700                 'must be one of\nbmp, xbm, xpm, png, or jpg',
    701                 'File Name Error', wx.OK | wx.ICON_ERROR)
     712                                        'must be one of\nbmp, xbm, xpm, png, or jpg',
     713                                        'File Name Error', wx.OK | wx.ICON_ERROR)
    702714                try:
    703715                    dlg2.ShowModal()
    704716                finally:
    705717                    dlg2.Destroy()
    706             else:                      # FileDialog doesn't exist: just check one
     718            # FileDialog doesn't exist: just check one
     719            else:
    707720                dlg1 = wx.FileDialog(
    708                     self, 
     721                    self,
    709722                    "Choose a file with extension bmp, gif, xbm, xpm, png, or jpg", ".", "",
    710723                    "BMP files (*.bmp)|*.bmp|XBM files (*.xbm)|*.xbm|XPM file (*.xpm)|*.xpm|PNG files (*.png)|*.png|JPG files (*.jpg)|*.jpg",
    711                     wx.SAVE|wx.OVERWRITE_PROMPT
    712                     )
     724                    wx.SAVE | wx.OVERWRITE_PROMPT
     725                )
    713726
    714727            if dlg1.ShowModal() == wx.ID_OK:
    715728                fileName = dlg1.GetPath()
     
    722735            dlg1.Destroy()
    723736
    724737        # Save Bitmap
    725         res= self._Buffer.SaveFile(fileName, extensions[fType])
     738        res = self._Buffer.SaveFile(fileName, extensions[fType])
    726739        return res
    727740
    728741    @property
     
    736749    @property
    737750    def pageSetupData(self):
    738751        if not self._pageSetupData:
    739             self._pageSetupData= wx.PageSetupDialogData()
    740             self._pageSetupData.SetMarginBottomRight((25,25))
    741             self._pageSetupData.SetMarginTopLeft((25,25))
     752            self._pageSetupData = wx.PageSetupDialogData()
     753            self._pageSetupData.SetMarginBottomRight((25, 25))
     754            self._pageSetupData.SetMarginTopLeft((25, 25))
    742755            self._pageSetupData.SetPrintData(self.print_data)
    743756        return self._pageSetupData
    744757
     
    749762        dlg = wx.PageSetupDialog(self.parent, data)
    750763        try:
    751764            if dlg.ShowModal() == wx.ID_OK:
    752                 data = dlg.GetPageSetupData() # returns wx.PageSetupDialogData
     765                data = dlg.GetPageSetupData()  # returns wx.PageSetupDialogData
    753766                # updates page parameters from dialog
    754                 self.pageSetupData.SetMarginBottomRight(data.GetMarginBottomRight())
     767                self.pageSetupData.SetMarginBottomRight(
     768                    data.GetMarginBottomRight())
    755769                self.pageSetupData.SetMarginTopLeft(data.GetMarginTopLeft())
    756770                self.pageSetupData.SetPrintData(data.GetPrintData())
    757                 self._print_data=wx.PrintData(data.GetPrintData()) # updates print_data
     771                self._print_data = wx.PrintData(
     772                    data.GetPrintData())  # updates print_data
    758773        finally:
    759774            dlg.Destroy()
    760                
     775
    761776    def Printout(self, paper=None):
    762777        """Print current plot."""
    763778        if paper != None:
     
    767782        out = PlotPrintout(self)
    768783        print_ok = printer.Print(self.parent, out)
    769784        if print_ok:
    770             self._print_data = wx.PrintData(printer.GetPrintDialogData().GetPrintData())
     785            self._print_data = wx.PrintData(
     786                printer.GetPrintDialogData().GetPrintData())
    771787        out.Destroy()
    772788
    773789    def PrintPreview(self):
     
    775791        printout = PlotPrintout(self)
    776792        printout2 = PlotPrintout(self)
    777793        self.preview = wx.PrintPreview(printout, printout2, self.print_data)
    778         if not self.preview.Ok():
    779             wx.MessageDialog(self, "Print Preview failed.\n" \
    780                                "Check that default printer is configured\n", \
    781                                "Print error", wx.OK|wx.CENTRE).ShowModal()
     794        if not self.preview.IsOk():
     795            wx.MessageDialog(self, "Print Preview failed.\n"
     796                             "Check that default printer is configured\n",
     797                             "Print error", wx.OK | wx.CENTRE).ShowModal()
    782798        self.preview.SetZoom(40)
    783799        # search up tree to find frame instance
    784         frameInst= self
     800        frameInst = self
    785801        while not isinstance(frameInst, wx.Frame):
    786             frameInst= frameInst.GetParent()
     802            frameInst = frameInst.GetParent()
    787803        frame = wx.PreviewFrame(self.preview, frameInst, "Preview")
    788804        frame.Initialize()
    789805        frame.SetPosition(self.GetPosition())
    790         frame.SetSize((600,550))
     806        frame.SetSize((600, 550))
    791807        frame.Centre(wx.BOTH)
    792808        frame.Show(True)
    793809
    794810    def setLogScale(self, logscale):
    795811        if type(logscale) != tuple:
    796             raise TypeError, 'logscale must be a tuple of bools, e.g. (False, False)'
     812            raise TypeError(
     813                'logscale must be a tuple of bools, e.g. (False, False)')
    797814        if self.last_draw is not None:
    798             graphics, xAxis, yAxis= self.last_draw
     815            graphics, xAxis, yAxis = self.last_draw
    799816            graphics.setLogScale(logscale)
    800817            self.last_draw = (graphics, None, None)
    801818        self.SetXSpec('min')
     
    804821
    805822    def getLogScale(self):
    806823        return self._logscale
    807    
    808     def SetFontSizeAxis(self, point= 10):
     824
     825    def SetFontSizeAxis(self, point=10):
    809826        """Set the tick and axis label font size (default is 10 point)"""
    810         self._fontSizeAxis= point
    811        
     827        self._fontSizeAxis = point
     828
    812829    def GetFontSizeAxis(self):
    813830        """Get current tick and axis label font size in points"""
    814831        return self._fontSizeAxis
    815    
    816     def SetFontSizeTitle(self, point= 15):
     832
     833    def SetFontSizeTitle(self, point=15):
    817834        """Set Title font size (default is 15 point)"""
    818         self._fontSizeTitle= point
     835        self._fontSizeTitle = point
    819836
    820837    def GetFontSizeTitle(self):
    821838        """Get current Title font size in points"""
    822839        return self._fontSizeTitle
    823    
    824     def SetFontSizeLegend(self, point= 7):
     840
     841    def SetFontSizeLegend(self, point=7):
    825842        """Set Legend font size (default is 7 point)"""
    826         self._fontSizeLegend= point
    827        
     843        self._fontSizeLegend = point
     844
    828845    def GetFontSizeLegend(self):
    829846        """Get current Legend font size in points"""
    830847        return self._fontSizeLegend
     
    831848
    832849    def SetShowScrollbars(self, value):
    833850        """Set True to show scrollbars"""
    834         if value not in [True,False]:
    835             raise TypeError, "Value should be True or False"
     851        if value not in [True, False]:
     852            raise TypeError("Value should be True or False")
    836853        if value == self.GetShowScrollbars():
    837854            return
    838855        self.sb_vert.Show(value)
     
    867884
    868885    def SetEnableDrag(self, value):
    869886        """Set True to enable drag."""
    870         if value not in [True,False]:
    871             raise TypeError, "Value should be True or False"
     887        if value not in [True, False]:
     888            raise TypeError("Value should be True or False")
    872889        if value:
    873890            if self.GetEnableZoom():
    874891                self.SetEnableZoom(False)
     
    876893        else:
    877894            self.SetCursor(wx.CROSS_CURSOR)
    878895        self._dragEnabled = value
    879    
     896
    880897    def GetEnableDrag(self):
    881898        return self._dragEnabled
    882    
     899
    883900    def SetEnableZoom(self, value):
    884901        """Set True to enable zooming."""
    885         if value not in [True,False]:
    886             raise TypeError, "Value should be True or False"
     902        if value not in [True, False]:
     903            raise TypeError("Value should be True or False")
    887904        if value:
    888905            if self.GetEnableDrag():
    889906                self.SetEnableDrag(False)
     
    890907            self.SetCursor(self.MagCursor)
    891908        else:
    892909            self.SetCursor(wx.CROSS_CURSOR)
    893         self._zoomEnabled= value
     910        self._zoomEnabled = value
    894911
    895912    def GetEnableZoom(self):
    896913        """True if zooming enabled."""
     
    898915
    899916    def SetEnableGrid(self, value):
    900917        """Set True, 'Horizontal' or 'Vertical' to enable grid."""
    901         if value not in [True,False,'Horizontal','Vertical']:
    902             raise TypeError, "Value should be True, False, Horizontal or Vertical"
    903         self._gridEnabled= value
     918        if value not in [True, False, 'Horizontal', 'Vertical']:
     919            raise TypeError(
     920                "Value should be True, False, Horizontal or Vertical")
     921        self._gridEnabled = value
    904922        self.Redraw()
    905923
    906924    def GetEnableGrid(self):
     
    909927
    910928    def SetEnableCenterLines(self, value):
    911929        """Set True, 'Horizontal' or 'Vertical' to enable center line(s)."""
    912         if value not in [True,False,'Horizontal','Vertical']:
    913             raise TypeError, "Value should be True, False, Horizontal or Vertical"
    914         self._centerLinesEnabled= value
     930        if value not in [True, False, 'Horizontal', 'Vertical']:
     931            raise TypeError(
     932                "Value should be True, False, Horizontal or Vertical")
     933        self._centerLinesEnabled = value
    915934        self.Redraw()
    916935
    917936    def GetEnableCenterLines(self):
     
    919938        return self._centerLinesEnabled
    920939
    921940    def SetEnableDiagonals(self, value):
    922         """Set True, 'Bottomleft-Topright' or 'Bottomright-Topleft' to enable 
     941        """Set True, 'Bottomleft-Topright' or 'Bottomright-Topleft' to enable
    923942        center line(s)."""
    924         if value not in [True,False,'Bottomleft-Topright','Bottomright-Topleft']:
    925             raise TypeError, "Value should be True, False, Bottomleft-Topright or Bottomright-Topleft"
    926         self._diagonalsEnabled= value
     943        if value not in [True, False, 'Bottomleft-Topright', 'Bottomright-Topleft']:
     944            raise TypeError(
     945                "Value should be True, False, Bottomleft-Topright or Bottomright-Topleft")
     946        self._diagonalsEnabled = value
    927947        self.Redraw()
    928948
    929949    def GetEnableDiagonals(self):
     
    932952
    933953    def SetEnableLegend(self, value):
    934954        """Set True to enable legend."""
    935         if value not in [True,False]:
    936             raise TypeError, "Value should be True or False"
    937         self._legendEnabled= value
     955        if value not in [True, False]:
     956            raise TypeError("Value should be True or False")
     957        self._legendEnabled = value
    938958        self.Redraw()
    939959
    940960    def GetEnableLegend(self):
     
    943963
    944964    def SetEnableTitle(self, value):
    945965        """Set True to enable title."""
    946         if value not in [True,False]:
    947             raise TypeError, "Value should be True or False"
    948         self._titleEnabled= value
     966        if value not in [True, False]:
     967            raise TypeError("Value should be True or False")
     968        self._titleEnabled = value
    949969        self.Redraw()
    950970
    951971    def GetEnableTitle(self):
     
    954974
    955975    def SetEnablePointLabel(self, value):
    956976        """Set True to enable pointLabel."""
    957         if value not in [True,False]:
    958             raise TypeError, "Value should be True or False"
    959         self._pointLabelEnabled= value
    960         self.Redraw()  #will erase existing pointLabel if present
     977        if value not in [True, False]:
     978            raise TypeError("Value should be True or False")
     979        self._pointLabelEnabled = value
     980        self.Redraw()  # will erase existing pointLabel if present
    961981        self.last_PointLabel = None
    962982
    963983    def GetEnablePointLabel(self):
     
    968988        """Sets the function with custom code for pointLabel drawing
    969989            ******** more info needed ***************
    970990        """
    971         self._pointLabelFunc= func
     991        self._pointLabelFunc = func
    972992
    973993    def GetPointLabelFunc(self):
    974994        """Returns pointLabel Drawing Function"""
     
    976996
    977997    def Reset(self):
    978998        """Unzoom the plot."""
    979         self.last_PointLabel = None        #reset pointLabel
     999        self.last_PointLabel = None  # reset pointLabel
    9801000        if self.last_draw is not None:
    9811001            self._Draw(self.last_draw[0])
    982        
    983     def ScrollRight(self, units):         
     1002
     1003    def ScrollRight(self, units):
    9841004        """Move view right number of axis units."""
    985         self.last_PointLabel = None        #reset pointLabel
     1005        self.last_PointLabel = None  # reset pointLabel
    9861006        if self.last_draw is not None:
    987             graphics, xAxis, yAxis= self.last_draw
    988             xAxis= (xAxis[0]+units, xAxis[1]+units)
    989             self._Draw(graphics,xAxis,yAxis)
     1007            graphics, xAxis, yAxis = self.last_draw
     1008            xAxis = (xAxis[0] + units, xAxis[1] + units)
     1009            self._Draw(graphics, xAxis, yAxis)
    9901010
    9911011    def ScrollUp(self, units):
    9921012        """Move view up number of axis units."""
    993         self.last_PointLabel = None        #reset pointLabel
     1013        self.last_PointLabel = None  # reset pointLabel
    9941014        if self.last_draw is not None:
    995              graphics, xAxis, yAxis= self.last_draw
    996              yAxis= (yAxis[0]+units, yAxis[1]+units)
    997              self._Draw(graphics,xAxis,yAxis)
     1015            graphics, xAxis, yAxis = self.last_draw
     1016            yAxis = (yAxis[0] + units, yAxis[1] + units)
     1017            self._Draw(graphics, xAxis, yAxis)
    9981018
    9991019    def GetXY(self, event):
    10001020        """Wrapper around _getXY, which handles log scales"""
    1001         x,y = self._getXY(event)
     1021        x, y = self._getXY(event)
    10021022        if self.getLogScale()[0]:
    1003             x = _Numeric.power(10,x)
     1023            x = np.power(10, x)
    10041024        if self.getLogScale()[1]:
    1005             y = _Numeric.power(10,y)
    1006         return x,y
    1007        
    1008     def _getXY(self,event):
     1025            y = np.power(10, y)
     1026        return x, y
     1027
     1028    def _getXY(self, event):
    10091029        """Takes a mouse event and returns the XY user axis values."""
    1010         x,y= self.PositionScreenToUser(event.GetPosition())
    1011         return x,y
     1030        x, y = self.PositionScreenToUser(event.GetPosition())
     1031        return x, y
    10121032
    10131033    def PositionUserToScreen(self, pntXY):
    10141034        """Converts User position to Screen Coordinates"""
    1015         userPos= _Numeric.array(pntXY)
    1016         x,y= userPos * self._pointScale + self._pointShift
    1017         return x,y
    1018        
     1035        userPos = np.array(pntXY)
     1036        x, y = userPos * self._pointScale + self._pointShift
     1037        return x, y
     1038
    10191039    def PositionScreenToUser(self, pntXY):
    10201040        """Converts Screen position to User Coordinates"""
    1021         screenPos= _Numeric.array(pntXY)
    1022         x,y= (screenPos-self._pointShift)/self._pointScale
    1023         return x,y
    1024        
    1025     def SetXSpec(self, type= 'auto'):
     1041        screenPos = np.array(pntXY)
     1042        x, y = (screenPos - self._pointShift) / self._pointScale
     1043        return x, y
     1044
     1045    def SetXSpec(self, type='auto'):
    10261046        """xSpec- defines x axis type. Can be 'none', 'min' or 'auto'
    10271047        where:
    1028        
     1048
    10291049        * 'none' - shows no axis or tick mark values
    10301050        * 'min' - shows min bounding box values
    10311051        * 'auto' - rounds axis range to sensible values
    10321052        * <number> - like 'min', but with <number> tick marks
    10331053        """
    1034         self._xSpec= type
    1035        
    1036     def SetYSpec(self, type= 'auto'):
     1054        self._xSpec = type
     1055
     1056    def SetYSpec(self, type='auto'):
    10371057        """ySpec- defines x axis type. Can be 'none', 'min' or 'auto'
    10381058        where:
    10391059
     
    10421062        * 'auto' - rounds axis range to sensible values
    10431063        * <number> - like 'min', but with <number> tick marks
    10441064        """
    1045         self._ySpec= type
     1065        self._ySpec = type
    10461066
    10471067    def GetXSpec(self):
    10481068        """Returns current XSpec for axis"""
    10491069        return self._xSpec
    1050    
     1070
    10511071    def GetYSpec(self):
    10521072        """Returns current YSpec for axis"""
    10531073        return self._ySpec
    1054    
     1074
    10551075    def GetXMaxRange(self):
    10561076        xAxis = self._getXMaxRange()
    10571077        if self.getLogScale()[0]:
    1058             xAxis = _Numeric.power(10,xAxis)
     1078            xAxis = np.power(10, xAxis)
    10591079        return xAxis
    10601080
    10611081    def _getXMaxRange(self):
    10621082        """Returns (minX, maxX) x-axis range for displayed graph"""
    1063         graphics= self.last_draw[0]
     1083        graphics = self.last_draw[0]
    10641084        p1, p2 = graphics.boundingBox()     # min, max points of graphics
    1065         xAxis = self._axisInterval(self._xSpec, p1[0], p2[0]) # in user units
     1085        xAxis = self._axisInterval(self._xSpec, p1[0], p2[0])  # in user units
    10661086        return xAxis
    10671087
    10681088    def GetYMaxRange(self):
    10691089        yAxis = self._getYMaxRange()
    10701090        if self.getLogScale()[1]:
    1071             yAxis = _Numeric.power(10,yAxis)
     1091            yAxis = np.power(10, yAxis)
    10721092        return yAxis
    10731093
    10741094    def _getYMaxRange(self):
    10751095        """Returns (minY, maxY) y-axis range for displayed graph"""
    1076         graphics= self.last_draw[0]
     1096        graphics = self.last_draw[0]
    10771097        p1, p2 = graphics.boundingBox()     # min, max points of graphics
    10781098        yAxis = self._axisInterval(self._ySpec, p1[1], p2[1])
    10791099        return yAxis
     
    10811101    def GetXCurrentRange(self):
    10821102        xAxis = self._getXCurrentRange()
    10831103        if self.getLogScale()[0]:
    1084             xAxis = _Numeric.power(10,xAxis)
     1104            xAxis = np.power(10, xAxis)
    10851105        return xAxis
    10861106
    10871107    def _getXCurrentRange(self):
    10881108        """Returns (minX, maxX) x-axis for currently displayed portion of graph"""
    10891109        return self.last_draw[1]
    1090    
     1110
    10911111    def GetYCurrentRange(self):
    10921112        yAxis = self._getYCurrentRange()
    10931113        if self.getLogScale()[1]:
    1094             yAxis = _Numeric.power(10,yAxis)
     1114            yAxis = np.power(10, yAxis)
    10951115        return yAxis
    10961116
    10971117    def _getYCurrentRange(self):
     
    10981118        """Returns (minY, maxY) y-axis for currently displayed portion of graph"""
    10991119        return self.last_draw[2]
    11001120
    1101     def Draw(self, graphics, xAxis = None, yAxis = None, dc = None):
     1121    def Draw(self, graphics, xAxis=None, yAxis=None, dc=None):
    11021122        """Wrapper around _Draw, which handles log axes"""
    1103        
     1123
    11041124        graphics.setLogScale(self.getLogScale())
    1105        
     1125
    11061126        # check Axis is either tuple or none
    1107         if type(xAxis) not in [type(None),tuple]:
    1108             raise TypeError, "xAxis should be None or (minX,maxX)"+str(type(xAxis))
    1109         if type(yAxis) not in [type(None),tuple]:
    1110             raise TypeError, "yAxis should be None or (minY,maxY)"+str(type(xAxis))
    1111              
     1127        if type(xAxis) not in [type(None), tuple]:
     1128            raise TypeError(
     1129                "xAxis should be None or (minX,maxX)" + str(type(xAxis)))
     1130        if type(yAxis) not in [type(None), tuple]:
     1131            raise TypeError(
     1132                "yAxis should be None or (minY,maxY)" + str(type(xAxis)))
     1133
    11121134        # check case for axis = (a,b) where a==b caused by improper zooms
    11131135        if xAxis != None:
    11141136            if xAxis[0] == xAxis[1]:
    11151137                return
    11161138            if self.getLogScale()[0]:
    1117                 xAxis = _Numeric.log10(xAxis)
     1139                xAxis = np.log10(xAxis)
    11181140        if yAxis != None:
    11191141            if yAxis[0] == yAxis[1]:
    11201142                return
    11211143            if self.getLogScale()[1]:
    1122                 yAxis = _Numeric.log10(yAxis)
     1144                yAxis = np.log10(yAxis)
    11231145        self._Draw(graphics, xAxis, yAxis, dc)
    1124        
    1125     def _Draw(self, graphics, xAxis = None, yAxis = None, dc = None):
     1146
     1147    def _Draw(self, graphics, xAxis=None, yAxis=None, dc=None):
    11261148        """\
    11271149        Draw objects in graphics with specified x and y axis.
    11281150        graphics- instance of PlotGraphics with list of PolyXXX objects
    11291151        xAxis - tuple with (min, max) axis range to view
    11301152        yAxis - same as xAxis
    1131         dc - drawing context - doesn't have to be specified.   
     1153        dc - drawing context - doesn't have to be specified.
    11321154        If it's not, the offscreen buffer is used
    11331155        """
    11341156
    11351157        if dc == None:
    1136             # sets new dc and clears it 
     1158            # sets new dc and clears it
    11371159            dc = wx.BufferedDC(wx.ClientDC(self.canvas), self._Buffer)
    1138             bbr = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
     1160            bbr = wx.Brush(self.GetBackgroundColour(), wx.BRUSHSTYLE_SOLID)
    11391161            dc.SetBackground(bbr)
    11401162            dc.SetBackgroundMode(wx.SOLID)
    11411163            dc.Clear()
     
    11431165            if not isinstance(dc, wx.GCDC):
    11441166                try:
    11451167                    dc = wx.GCDC(dc)
    1146                 except Exception, exception:
     1168                except Exception:
    11471169                    pass
    11481170                else:
    11491171                    if self._hiResEnabled:
    1150                         dc.SetMapMode(wx.MM_TWIPS) # high precision - each logical unit is 1/20 of a point
    1151                     self._pointSize = tuple(1.0 / lscale for lscale in dc.GetLogicalScale())
     1172                        # high precision - each logical unit is 1/20 of a point
     1173                        dc.SetMapMode(wx.MM_TWIPS)
     1174                    self._pointSize = tuple(
     1175                        1.0 / lscale for lscale in dc.GetLogicalScale())
    11521176                    self._setSize()
    11531177        elif self._pointSize != (1.0, 1.0):
    11541178            self._pointSize = (1.0, 1.0)
    11551179            self._setSize()
    1156         if sys.platform in ("darwin", "win32") or not isinstance(dc, wx.GCDC):
     1180        if (sys.platform in ("darwin", "win32") or not isinstance(dc, wx.GCDC) or wx.VERSION >= (2, 9)):
    11571181            self._fontScale = sum(self._pointSize) / 2.0
    11581182        else:
    11591183            # on Linux, we need to correct the font size by a certain factor if wx.GCDC is used,
    11601184            # to make text the same size as if wx.GCDC weren't used
     1185            screenppi = map(float, wx.ScreenDC().GetPPI())
    11611186            ppi = dc.GetPPI()
    1162             self._fontScale = (96.0 / ppi[0] * self._pointSize[0] + 96.0 / ppi[1] * self._pointSize[1]) / 2.0
     1187            self._fontScale = (screenppi[
     1188                               0] / ppi[0] * self._pointSize[0] + screenppi[1] / ppi[1] * self._pointSize[1]) / 2.0
    11631189        graphics._pointSize = self._pointSize
    1164            
     1190
    11651191        dc.SetTextForeground(self.GetForegroundColour())
    11661192        dc.SetTextBackground(self.GetBackgroundColour())
    11671193
    1168         dc.BeginDrawing()
    11691194        # dc.Clear()
    1170        
     1195
    11711196        # set font size for every thing but title and legend
    11721197        dc.SetFont(self._getFont(self._fontSizeAxis))
    11731198
    1174         # sizes axis to axis type, create lower left and upper right corners of plot
     1199        # sizes axis to axis type, create lower left and upper right corners of
     1200        # plot
    11751201        if xAxis == None or yAxis == None:
    11761202            # One or both axis not specified in Draw
    11771203            p1, p2 = graphics.boundingBox()     # min, max points of graphics
    11781204            if xAxis == None:
    1179                 xAxis = self._axisInterval(self._xSpec, p1[0], p2[0]) # in user units
     1205                xAxis = self._axisInterval(
     1206                    self._xSpec, p1[0], p2[0])  # in user units
    11801207            if yAxis == None:
    11811208                yAxis = self._axisInterval(self._ySpec, p1[1], p2[1])
    11821209            # Adjust bounding box for axis spec
    1183             p1[0],p1[1] = xAxis[0], yAxis[0]     # lower left corner user scale (xmin,ymin)
    1184             p2[0],p2[1] = xAxis[1], yAxis[1]     # upper right corner user scale (xmax,ymax)
     1210            # lower left corner user scale (xmin,ymin)
     1211            p1[0], p1[1] = xAxis[0], yAxis[0]
     1212            # upper right corner user scale (xmax,ymax)
     1213            p2[0], p2[1] = xAxis[1], yAxis[1]
    11851214        else:
    11861215            # Both axis specified in Draw
    1187             p1= _Numeric.array([xAxis[0], yAxis[0]])    # lower left corner user scale (xmin,ymin)
    1188             p2= _Numeric.array([xAxis[1], yAxis[1]])     # upper right corner user scale (xmax,ymax)
     1216            # lower left corner user scale (xmin,ymin)
     1217            p1 = np.array([xAxis[0], yAxis[0]])
     1218            # upper right corner user scale (xmax,ymax)
     1219            p2 = np.array([xAxis[1], yAxis[1]])
    11891220
    1190         self.last_draw = (graphics, _Numeric.array(xAxis), _Numeric.array(yAxis))       # saves most recient values
     1221        # saves most recient values
     1222        self.last_draw = (graphics, np.array(xAxis), np.array(yAxis))
    11911223
    11921224        # Get ticks and textExtents for axis if required
    1193         if self._xSpec is not 'none':       
     1225        if self._xSpec is not 'none':
    11941226            xticks = self._xticks(xAxis[0], xAxis[1])
    1195             xTextExtent = dc.GetTextExtent(xticks[-1][1])# w h of x axis text last number on axis
    11961227        else:
    11971228            xticks = None
    1198             xTextExtent= (0,0) # No text for ticks
     1229        if xticks:
     1230            # w h of x axis text last number on axis
     1231            xTextExtent = dc.GetTextExtent(xticks[-1][1])
     1232        else:
     1233            xTextExtent = (0, 0)  # No text for ticks
    11991234        if self._ySpec is not 'none':
    12001235            yticks = self._yticks(yAxis[0], yAxis[1])
     1236        else:
     1237            yticks = None
     1238        if yticks:
    12011239            if self.getLogScale()[1]:
    12021240                yTextExtent = dc.GetTextExtent('-2e-2')
    12031241            else:
    12041242                yTextExtentBottom = dc.GetTextExtent(yticks[0][1])
    12051243                yTextExtentTop = dc.GetTextExtent(yticks[-1][1])
    1206                 yTextExtent= (max(yTextExtentBottom[0],yTextExtentTop[0]),
    1207                               max(yTextExtentBottom[1],yTextExtentTop[1]))
     1244                yTextExtent = (max(yTextExtentBottom[0], yTextExtentTop[0]),
     1245                               max(yTextExtentBottom[1], yTextExtentTop[1]))
    12081246        else:
    12091247            yticks = None
    1210             yTextExtent= (0,0) # No text for ticks
     1248            yTextExtent = (0, 0) # No text for ticks
    12111249
    12121250        # TextExtents for Title and Axis Labels
    1213         titleWH, xLabelWH, yLabelWH= self._titleLablesWH(dc, graphics)
     1251        titleWH, xLabelWH, yLabelWH = self._titleLablesWH(dc, graphics)
    12141252
    12151253        # TextExtents for Legend
    12161254        legendBoxWH, legendSymExt, legendTextExt = self._legendWH(dc, graphics)
    12171255
    12181256        # room around graph area
    1219         rhsW= max(xTextExtent[0], legendBoxWH[0])+5*self._pointSize[0] # use larger of number width or legend width
    1220         lhsW= yTextExtent[0]+ yLabelWH[1] + 3*self._pointSize[0]
    1221         bottomH= max(xTextExtent[1], yTextExtent[1]/2.)+ xLabelWH[1] + 2*self._pointSize[1]
    1222         topH= yTextExtent[1]/2. + titleWH[1]
    1223         textSize_scale= _Numeric.array([rhsW+lhsW,bottomH+topH]) # make plot area smaller by text size
    1224         textSize_shift= _Numeric.array([lhsW, bottomH])          # shift plot area by this amount
     1257        # use larger of number width or legend width
     1258        rhsW = max(xTextExtent[0], legendBoxWH[0]) + 5 * self._pointSize[0]
     1259        lhsW = yTextExtent[0] + yLabelWH[1] + 3 * self._pointSize[0]
     1260        bottomH = max(
     1261            xTextExtent[1], yTextExtent[1] / 2.) + xLabelWH[1] + 2 * self._pointSize[1]
     1262        topH = yTextExtent[1] / 2. + titleWH[1]
     1263        # make plot area smaller by text size
     1264        textSize_scale = np.array([rhsW + lhsW, bottomH + topH])
     1265        # shift plot area by this amount
     1266        textSize_shift = np.array([lhsW, bottomH])
    12251267
    12261268        # draw title if requested
    12271269        if self._titleEnabled:
    12281270            dc.SetFont(self._getFont(self._fontSizeTitle))
    1229             titlePos= (self.plotbox_origin[0]+ lhsW + (self.plotbox_size[0]-lhsW-rhsW)/2.- titleWH[0]/2.,
    1230                        self.plotbox_origin[1]- self.plotbox_size[1])
    1231             dc.DrawText(graphics.getTitle(),titlePos[0],titlePos[1])
     1271            titlePos = (self.plotbox_origin[0] + lhsW + (self.plotbox_size[0] - lhsW - rhsW) / 2. - titleWH[0] / 2.,
     1272                        self.plotbox_origin[1] - self.plotbox_size[1])
     1273            dc.DrawText(graphics.getTitle(), titlePos[0], titlePos[1])
    12321274
    12331275        # draw label text
    12341276        dc.SetFont(self._getFont(self._fontSizeAxis))
    1235         xLabelPos= (self.plotbox_origin[0]+ lhsW + (self.plotbox_size[0]-lhsW-rhsW)/2.- xLabelWH[0]/2.,
    1236                  self.plotbox_origin[1]- xLabelWH[1])
    1237         dc.DrawText(graphics.getXLabel(),xLabelPos[0],xLabelPos[1])
    1238         yLabelPos= (self.plotbox_origin[0] - 3*self._pointSize[0],
    1239                  self.plotbox_origin[1]- bottomH- (self.plotbox_size[1]-bottomH-topH)/2.+ yLabelWH[0]/2.)
     1277        xLabelPos = (self.plotbox_origin[0] + lhsW + (self.plotbox_size[0] - lhsW - rhsW) / 2. - xLabelWH[0] / 2.,
     1278                     self.plotbox_origin[1] - xLabelWH[1])
     1279        dc.DrawText(graphics.getXLabel(), xLabelPos[0], xLabelPos[1])
     1280        yLabelPos = (self.plotbox_origin[0] - 3 * self._pointSize[0],
     1281                     self.plotbox_origin[1] - bottomH - (self.plotbox_size[1] - bottomH - topH) / 2. + yLabelWH[0] / 2.)
    12401282        if graphics.getYLabel():  # bug fix for Linux
    1241             dc.DrawRotatedText(graphics.getYLabel(),yLabelPos[0],yLabelPos[1],90)
     1283            dc.DrawRotatedText(
     1284                graphics.getYLabel(), yLabelPos[0], yLabelPos[1], 90)
    12421285
    12431286        # drawing legend makers and text
    12441287        if self._legendEnabled:
    1245             self._drawLegend(dc,graphics,rhsW,topH,legendBoxWH, legendSymExt, legendTextExt)
     1288            self._drawLegend(
     1289                dc, graphics, rhsW, topH, legendBoxWH, legendSymExt, legendTextExt)
    12461290
    12471291        # allow for scaling and shifting plotted points
    1248         scale = (self.plotbox_size-textSize_scale) / (p2-p1)* _Numeric.array((1,-1))
    1249         shift = -p1*scale + self.plotbox_origin + textSize_shift * _Numeric.array((1,-1))
    1250         self._pointScale= scale / self._pointSize  # make available for mouse events
    1251         self._pointShift= shift / self._pointSize       
     1292        scale = (self.plotbox_size - textSize_scale) / \
     1293            (p2 - p1) * np.array((1, -1))
     1294        shift = -p1 * scale + self.plotbox_origin + \
     1295            textSize_shift * np.array((1, -1))
     1296        # make available for mouse events
     1297        self._pointScale = scale / self._pointSize
     1298        self._pointShift = shift / self._pointSize
    12521299        self._drawAxes(dc, p1, p2, scale, shift, xticks, yticks)
    1253        
     1300
    12541301        graphics.scaleAndShift(scale, shift)
    1255         graphics.setPrinterScale(self.printerScale)  # thicken up lines and markers if printing
    1256        
     1302        # thicken up lines and markers if printing
     1303        graphics.setPrinterScale(self.printerScale)
     1304
    12571305        # set clipping area so drawing does not occur outside axis box
    1258         ptx,pty,rectWidth,rectHeight= self._point2ClientCoord(p1, p2)
     1306        ptx, pty, rectWidth, rectHeight = self._point2ClientCoord(p1, p2)
    12591307        # allow graph to overlap axis lines by adding units to width and height
    1260         dc.SetClippingRegion(ptx*self._pointSize[0],pty*self._pointSize[1],rectWidth*self._pointSize[0]+2,rectHeight*self._pointSize[1]+1)
     1308        dc.SetClippingRegion(ptx * self._pointSize[0], pty * self._pointSize[
     1309                             1], rectWidth * self._pointSize[0] + 2, rectHeight * self._pointSize[1] + 1)
    12611310        # Draw the lines and markers
    12621311        #start = _time.clock()
    12631312        graphics.draw(dc)
    1264         # print "entire graphics drawing took: %f second"%(_time.clock() - start)
     1313        # print("entire graphics drawing took: %f second"%(_time.clock() - start))
    12651314        # remove the clipping region
    12661315        dc.DestroyClippingRegion()
    1267         dc.EndDrawing()
    12681316
    12691317        self._adjustScrollbars()
    1270        
     1318
    12711319    def Redraw(self, dc=None):
    12721320        """Redraw the existing plot."""
    12731321        if self.last_draw is not None:
    1274             graphics, xAxis, yAxis= self.last_draw
    1275             self._Draw(graphics,xAxis,yAxis,dc)
     1322            graphics, xAxis, yAxis = self.last_draw
     1323            self._Draw(graphics, xAxis, yAxis, dc)
    12761324
    12771325    def Clear(self):
    12781326        """Erase the window."""
    1279         self.last_PointLabel = None        #reset pointLabel
     1327        self.last_PointLabel = None  # reset pointLabel
    12801328        dc = wx.BufferedDC(wx.ClientDC(self.canvas), self._Buffer)
    12811329        bbr = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
    12821330        dc.SetBackground(bbr)
     
    12851333        if self._antiAliasingEnabled:
    12861334            try:
    12871335                dc = wx.GCDC(dc)
    1288             except Exception, exception:
     1336            except Exception:
    12891337                pass
    12901338        dc.SetTextForeground(self.GetForegroundColour())
    12911339        dc.SetTextBackground(self.GetBackgroundColour())
     
    12961344            Centers on the X,Y coords given in Center
    12971345            Zooms by the Ratio = (Xratio, Yratio) given
    12981346        """
    1299         self.last_PointLabel = None   #reset maker
    1300         x,y = Center
     1347        self.last_PointLabel = None  # reset maker
     1348        x, y = Center
    13011349        if self.last_draw != None:
    13021350            (graphics, xAxis, yAxis) = self.last_draw
    13031351            w = (xAxis[1] - xAxis[0]) * Ratio[0]
    13041352            h = (yAxis[1] - yAxis[0]) * Ratio[1]
    1305             xAxis = ( x - w/2, x + w/2 )
    1306             yAxis = ( y - h/2, y + h/2 )
     1353            xAxis = (x - w / 2, x + w / 2)
     1354            yAxis = (y - h / 2, y + h / 2)
    13071355            self._Draw(graphics, xAxis, yAxis)
    1308        
    1309     def GetClosestPoints(self, pntXY, pointScaled= True):
     1356
     1357    def GetClosestPoints(self, pntXY, pointScaled=True):
    13101358        """Returns list with
    13111359            [curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    13121360            list for each curve.
    13131361            Returns [] if no curves are being plotted.
    1314            
     1362
    13151363            x, y in user coords
    13161364            if pointScaled == True based on screen coords
    13171365            if pointScaled == False based on user coords
    13181366        """
    13191367        if self.last_draw == None:
    1320             #no graph available
     1368            # no graph available
    13211369            return []
    1322         graphics, xAxis, yAxis= self.last_draw
     1370        graphics, xAxis, yAxis = self.last_draw
    13231371        l = []
    1324         for curveNum,obj in enumerate(graphics):
    1325             #check there are points in the curve
     1372        for curveNum, obj in enumerate(graphics):
     1373            # check there are points in the curve
    13261374            if len(obj.points) == 0:
    1327                 continue  #go to next obj
     1375                continue  # go to next obj
    13281376            #[curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    1329             cn = [curveNum]+ [obj.getLegend()]+ obj.getClosestPoint( pntXY, pointScaled)
     1377            cn = [curveNum] + \
     1378                [obj.getLegend()] + obj.getClosestPoint(pntXY, pointScaled)
    13301379            l.append(cn)
    13311380        return l
    13321381
    1333     def GetClosestPoint(self, pntXY, pointScaled= True):
     1382    def GetClosestPoint(self, pntXY, pointScaled=True):
    13341383        """Returns list with
    13351384            [curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    13361385            list for only the closest curve.
    13371386            Returns [] if no curves are being plotted.
    1338            
     1387
    13391388            x, y in user coords
    13401389            if pointScaled == True based on screen coords
    13411390            if pointScaled == False based on user coords
    13421391        """
    1343         #closest points on screen based on screen scaling (pointScaled= True)
    1344         #list [curveNumber, index, pointXY, scaledXY, distance] for each curve
    1345         closestPts= self.GetClosestPoints(pntXY, pointScaled)
     1392        # closest points on screen based on screen scaling (pointScaled= True)
     1393        # list [curveNumber, index, pointXY, scaledXY, distance] for each curve
     1394        closestPts = self.GetClosestPoints(pntXY, pointScaled)
    13461395        if closestPts == []:
    1347             return []  #no graph present
    1348         #find one with least distance
     1396            return []  # no graph present
     1397        # find one with least distance
    13491398        dists = [c[-1] for c in closestPts]
    1350         mdist = min(dists)  #Min dist
    1351         i = dists.index(mdist)  #index for min dist
    1352         return closestPts[i]  #this is the closest point on closest curve
    1353    
     1399        mdist = min(dists)  # Min dist
     1400        i = dists.index(mdist)  # index for min dist
     1401        return closestPts[i]  # this is the closest point on closest curve
     1402
    13541403    GetClosetPoint = GetClosestPoint
    13551404
    13561405    def UpdatePointLabel(self, mDataDict):
     
    13631412            you specify.
    13641413
    13651414            This function can be called from parent window with onClick,
    1366             onMotion events etc.           
     1415            onMotion events etc.
    13671416        """
    13681417        if self.last_PointLabel != None:
    1369             #compare pointXY
    1370             if _Numeric.sometrue(mDataDict["pointXY"] != self.last_PointLabel["pointXY"]):
    1371                 #closest changed
    1372                 self._drawPointLabel(self.last_PointLabel) #erase old
    1373                 self._drawPointLabel(mDataDict) #plot new
     1418            # compare pointXY
     1419            if np.sometrue(mDataDict["pointXY"] != self.last_PointLabel["pointXY"]):
     1420                # closest changed
     1421                self._drawPointLabel(self.last_PointLabel)  # erase old
     1422                self._drawPointLabel(mDataDict)  # plot new
    13741423        else:
    1375             #just plot new with no erase
    1376             self._drawPointLabel(mDataDict) #plot new
    1377         #save for next erase
     1424            # just plot new with no erase
     1425            self._drawPointLabel(mDataDict)  # plot new
     1426        # save for next erase
    13781427        self.last_PointLabel = mDataDict
    13791428
    13801429    # event handlers **********************************
     
    13811430    def OnMotion(self, event):
    13821431        if self._zoomEnabled and event.LeftIsDown():
    13831432            if self._hasDragged:
    1384                 self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # remove old
     1433                self._drawRubberBand(
     1434                    self._zoomCorner1, self._zoomCorner2)  # remove old
    13851435            else:
    1386                 self._hasDragged= True
     1436                self._hasDragged = True
    13871437            self._zoomCorner2[0], self._zoomCorner2[1] = self._getXY(event)
    1388             self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # add new
     1438            self._drawRubberBand(
     1439                self._zoomCorner1, self._zoomCorner2)  # add new
    13891440        elif self._dragEnabled and event.LeftIsDown():
    13901441            coordinates = event.GetPosition()
    1391             newpos, oldpos = map(_Numeric.array, map(self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
    1392             dist = newpos-oldpos
     1442            newpos, oldpos = map(np.array, map(
     1443                self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
     1444            dist = newpos - oldpos
    13931445            self._screenCoordinates = coordinates
    13941446
    13951447            if self.last_draw is not None:
    1396                 graphics, xAxis, yAxis= self.last_draw
     1448                graphics, xAxis, yAxis = self.last_draw
    13971449                yAxis -= dist[1]
    13981450                xAxis -= dist[0]
    1399                 self._Draw(graphics,xAxis,yAxis)
    1400            
    1401     def OnMouseLeftDown(self,event):
    1402         self._zoomCorner1[0], self._zoomCorner1[1]= self._getXY(event)
    1403         self._screenCoordinates = _Numeric.array(event.GetPosition())
     1451                self._Draw(graphics, xAxis, yAxis)
     1452
     1453    def OnMouseLeftDown(self, event):
     1454        self._zoomCorner1[0], self._zoomCorner1[1] = self._getXY(event)
     1455        self._screenCoordinates = np.array(event.GetPosition())
    14041456        if self._dragEnabled:
    14051457            self.SetCursor(self.GrabHandCursor)
    14061458            self.canvas.CaptureMouse()
     
    14081460    def OnMouseLeftUp(self, event):
    14091461        if self._zoomEnabled:
    14101462            if self._hasDragged == True:
    1411                 self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # remove old
    1412                 self._zoomCorner2[0], self._zoomCorner2[1]= self._getXY(event)
     1463                self._drawRubberBand(
     1464                    self._zoomCorner1, self._zoomCorner2)  # remove old
     1465                self._zoomCorner2[0], self._zoomCorner2[1] = self._getXY(event)
    14131466                self._hasDragged = False  # reset flag
    1414                 minX, minY= _Numeric.minimum( self._zoomCorner1, self._zoomCorner2)
    1415                 maxX, maxY= _Numeric.maximum( self._zoomCorner1, self._zoomCorner2)
    1416                 self.last_PointLabel = None        #reset pointLabel
     1467                minX, minY = np.minimum(self._zoomCorner1, self._zoomCorner2)
     1468                maxX, maxY = np.maximum(self._zoomCorner1, self._zoomCorner2)
     1469                self.last_PointLabel = None  # reset pointLabel
    14171470                if self.last_draw != None:
    1418                     self._Draw(self.last_draw[0], xAxis = (minX,maxX), yAxis = (minY,maxY), dc = None)
    1419             #else: # A box has not been drawn, zoom in on a point
    1420             ## this interfered with the double click, so I've disables it.
     1471                    self._Draw(
     1472                        self.last_draw[0], xAxis=(minX, maxX), yAxis = (minY, maxY), dc = None)
     1473            # else: # A box has not been drawn, zoom in on a point
     1474            # this interfered with the double click, so I've disables it.
    14211475            #    X,Y = self._getXY(event)
    14221476            #    self.Zoom( (X,Y), (self._zoomInFactor,self._zoomInFactor) )
    14231477        if self._dragEnabled:
     
    14251479            if self.canvas.HasCapture():
    14261480                self.canvas.ReleaseMouse()
    14271481
    1428     def OnMouseDoubleClick(self,event):
     1482    def OnMouseDoubleClick(self, event):
    14291483        if self._zoomEnabled:
    14301484            # Give a little time for the click to be totally finished
    14311485            # before (possibly) removing the scrollbars and trigering
    14321486            # size events, etc.
    1433             wx.FutureCall(200,self.Reset)
    1434        
    1435     def OnMouseRightDown(self,event):
     1487            wx.CallLater(200, self.Reset)
     1488
     1489    def OnMouseRightDown(self, event):
    14361490        if self._zoomEnabled:
    1437             X,Y = self._getXY(event)
    1438             self.Zoom( (X,Y), (self._zoomOutFactor, self._zoomOutFactor) )
     1491            X, Y = self._getXY(event)
     1492            self.Zoom((X, Y), (self._zoomOutFactor, self._zoomOutFactor))
    14391493
    14401494    def OnPaint(self, event):
    14411495        # All that is needed here is to draw the buffer to screen
    14421496        if self.last_PointLabel != None:
    1443             self._drawPointLabel(self.last_PointLabel) #erase old
     1497            self._drawPointLabel(self.last_PointLabel)  # erase old
    14441498            self.last_PointLabel = None
    14451499        dc = wx.BufferedPaintDC(self.canvas, self._Buffer)
    14461500        if self._antiAliasingEnabled:
    14471501            try:
    14481502                dc = wx.GCDC(dc)
    1449             except Exception, exception:
     1503            except Exception:
    14501504                pass
    14511505
    1452     def OnSize(self,event):
     1506    def OnSize(self, event):
    14531507        # The Buffer init is done here, to make sure the buffer is always
    14541508        # the same size as the Window
    1455         Size  = self.canvas.GetClientSize()
     1509        Size = self.canvas.GetClientSize()
    14561510        Size.width = max(1, Size.width)
    14571511        Size.height = max(1, Size.height)
    1458        
     1512
    14591513        # Make new offscreen bitmap: this bitmap will always have the
    14601514        # current drawing in it, so it can be used to save the image to
    14611515        # a file, or whatever.
    1462         self._Buffer = wx.EmptyBitmap(Size.width, Size.height)
     1516        self._Buffer = wx.Bitmap(Size.width, Size.height)
    14631517        self._setSize()
    14641518
    1465         self.last_PointLabel = None        #reset pointLabel
     1519        self.last_PointLabel = None  # reset pointLabel
    14661520
    14671521        if self.last_draw is None:
    14681522            self.Clear()
    14691523        else:
    14701524            graphics, xSpec, ySpec = self.last_draw
    1471             self._Draw(graphics,xSpec,ySpec)
     1525            self._Draw(graphics, xSpec, ySpec)
    14721526
    14731527    def OnLeave(self, event):
    14741528        """Used to erase pointLabel when mouse outside window"""
    14751529        if self.last_PointLabel != None:
    1476             self._drawPointLabel(self.last_PointLabel) #erase old
     1530            self._drawPointLabel(self.last_PointLabel)  # erase old
    14771531            self.last_PointLabel = None
    14781532
    14791533    def OnScroll(self, evt):
     
    14801534        if not self._adjustingSB:
    14811535            self._sb_ignore = True
    14821536            sbpos = evt.GetPosition()
    1483        
     1537
    14841538            if evt.GetOrientation() == wx.VERTICAL:
    1485                 fullrange,pagesize = self.sb_vert.GetRange(),self.sb_vert.GetPageSize()
    1486                 sbpos = fullrange-pagesize-sbpos
    1487                 dist = sbpos*self._sb_yunit-(self._getYCurrentRange()[0]-self._sb_yfullrange[0])
     1539                fullrange, pagesize = self.sb_vert.GetRange(
     1540                ), self.sb_vert.GetPageSize()
     1541                sbpos = fullrange - pagesize - sbpos
     1542                dist = sbpos * self._sb_xunit - \
     1543                    (self._getXCurrentRange()[0] - self._sb_xfullrange)
    14881544                self.ScrollUp(dist)
    1489            
     1545
    14901546            if evt.GetOrientation() == wx.HORIZONTAL:
    1491                 dist = sbpos*self._sb_xunit-(self._getXCurrentRange()[0]-self._sb_xfullrange[0])
     1547                dist = sbpos * self._sb_xunit - \
     1548                    (self._getXCurrentRange()[0] - self._sb_xfullrange[0])
    14921549                self.ScrollRight(dist)
    1493                
     1550
    14941551    # Private Methods **************************************************
    14951552    def _setSize(self, width=None, height=None):
    14961553        """DC width and height."""
    14971554        if width == None:
    1498             (self.width,self.height) = self.canvas.GetClientSize()
     1555            (self.width, self.height) = self.canvas.GetClientSize()
    14991556        else:
    1500             self.width, self.height= width,height   
    1501         self.width *= self._pointSize[0] # high precision
    1502         self.height *= self._pointSize[1] # high precision
    1503         self.plotbox_size = 0.97*_Numeric.array([self.width, self.height])
    1504         xo = 0.5*(self.width-self.plotbox_size[0])
    1505         yo = self.height-0.5*(self.height-self.plotbox_size[1])
    1506         self.plotbox_origin = _Numeric.array([xo, yo])
    1507    
     1557            self.width, self.height = width, height
     1558        self.width *= self._pointSize[0]  # high precision
     1559        self.height *= self._pointSize[1]  # high precision
     1560        self.plotbox_size = 0.97 * np.array([self.width, self.height])
     1561        xo = 0.5 * (self.width - self.plotbox_size[0])
     1562        yo = self.height - 0.5 * (self.height - self.plotbox_size[1])
     1563        self.plotbox_origin = np.array([xo, yo])
     1564
    15081565    def _setPrinterScale(self, scale):
    15091566        """Used to thicken lines and increase marker size for print out."""
    15101567        # line thickness on printer is very thin at 600 dot/in. Markers small
    1511         self.printerScale= scale
    1512      
     1568        self.printerScale = scale
     1569
    15131570    def _printDraw(self, printDC):
    15141571        """Used for printing."""
    15151572        if self.last_draw != None:
    1516             graphics, xSpec, ySpec= self.last_draw
    1517             self._Draw(graphics,xSpec,ySpec,printDC)
     1573            graphics, xSpec, ySpec = self.last_draw
     1574            self._Draw(graphics, xSpec, ySpec, printDC)
    15181575
    15191576    def _drawPointLabel(self, mDataDict):
    15201577        """Draws and erases pointLabels"""
     
    15211578        width = self._Buffer.GetWidth()
    15221579        height = self._Buffer.GetHeight()
    15231580        if sys.platform != "darwin":
    1524             tmp_Buffer = wx.EmptyBitmap(width,height)
     1581            tmp_Buffer = wx.Bitmap(width, height)
    15251582            dcs = wx.MemoryDC()
    15261583            dcs.SelectObject(tmp_Buffer)
    15271584            dcs.Clear()
     
    15281585        else:
    15291586            tmp_Buffer = self._Buffer.GetSubBitmap((0, 0, width, height))
    15301587            dcs = wx.MemoryDC(self._Buffer)
    1531         dcs.BeginDrawing()
    1532         self._pointLabelFunc(dcs,mDataDict)  #custom user pointLabel function
    1533         dcs.EndDrawing()
     1588        self._pointLabelFunc(dcs, mDataDict)  # custom user pointLabel function
    15341589
    1535         dc = wx.ClientDC( self.canvas )
    1536         #this will erase if called twice
     1590        dc = wx.ClientDC(self.canvas)
     1591        dc = wx.BufferedDC(dc, self._Buffer)
     1592        # this will erase if called twice
    15371593        dc.Blit(0, 0, width, height, dcs, 0, 0, self._logicalFunction)
    15381594        if sys.platform == "darwin":
    15391595            self._Buffer = tmp_Buffer
    1540        
    15411596
    1542     def _drawLegend(self,dc,graphics,rhsW,topH,legendBoxWH, legendSymExt, legendTextExt):
     1597    def _drawLegend(self, dc, graphics, rhsW, topH, legendBoxWH, legendSymExt, legendTextExt):
    15431598        """Draws legend symbols and text"""
    15441599        # top right hand corner of graph box is ref corner
    1545         trhc= self.plotbox_origin+ (self.plotbox_size-[rhsW,topH])*[1,-1]
    1546         legendLHS= .091* legendBoxWH[0]  # border space between legend sym and graph box
    1547         lineHeight= max(legendSymExt[1], legendTextExt[1]) * 1.1 #1.1 used as space between lines
     1600        trhc = self.plotbox_origin + \
     1601            (self.plotbox_size - [rhsW, topH]) * [1, -1]
     1602        # border space between legend sym and graph box
     1603        legendLHS = .091 * legendBoxWH[0]
     1604        # 1.1 used as space between lines
     1605        lineHeight = max(legendSymExt[1], legendTextExt[1]) * 1.1
    15481606        dc.SetFont(self._getFont(self._fontSizeLegend))
    15491607        for i in range(len(graphics)):
    15501608            o = graphics[i]
    1551             s= i*lineHeight
    1552             if isinstance(o,PolyMarker):
     1609            s = i * lineHeight
     1610            if isinstance(o, PolyMarker):
    15531611                # draw marker with legend
    1554                 pnt= (trhc[0]+legendLHS+legendSymExt[0]/2., trhc[1]+s+lineHeight/2.)
    1555                 o.draw(dc, self.printerScale, coord= _Numeric.array([pnt]))
    1556             elif isinstance(o,PolyLine):
     1612                pnt = (trhc[0] + legendLHS + legendSymExt[0] / 2.,
     1613                       trhc[1] + s + lineHeight / 2.)
     1614                o.draw(dc, self.printerScale, coord=np.array([pnt]))
     1615            elif isinstance(o, PolyLine):
    15571616                # draw line with legend
    1558                 pnt1= (trhc[0]+legendLHS, trhc[1]+s+lineHeight/2.)
    1559                 pnt2= (trhc[0]+legendLHS+legendSymExt[0], trhc[1]+s+lineHeight/2.)
    1560                 o.draw(dc, self.printerScale, coord= _Numeric.array([pnt1,pnt2]))
     1617                pnt1 = (trhc[0] + legendLHS, trhc[1] + s + lineHeight / 2.)
     1618                pnt2 = (trhc[0] + legendLHS + legendSymExt[0],
     1619                        trhc[1] + s + lineHeight / 2.)
     1620                o.draw(dc, self.printerScale, coord=np.array([pnt1, pnt2]))
    15611621            else:
    1562                 raise TypeError, "object is neither PolyMarker or PolyLine instance"
     1622                raise TypeError(
     1623                    "object is neither PolyMarker or PolyLine instance")
    15631624            # draw legend txt
    1564             pnt= (trhc[0]+legendLHS+legendSymExt[0]+5*self._pointSize[0], trhc[1]+s+lineHeight/2.-legendTextExt[1]/2)
    1565             dc.DrawText(o.getLegend(),pnt[0],pnt[1])
    1566         dc.SetFont(self._getFont(self._fontSizeAxis)) # reset
     1625            pnt = (trhc[0] + legendLHS + legendSymExt[0] + 5 * self._pointSize[0],
     1626                   trhc[1] + s + lineHeight / 2. - legendTextExt[1] / 2)
     1627            dc.DrawText(o.getLegend(), pnt[0], pnt[1])
     1628        dc.SetFont(self._getFont(self._fontSizeAxis))  # reset
    15671629
    15681630    def _titleLablesWH(self, dc, graphics):
    15691631        """Draws Title and labels and returns width and height for each"""
     
    15701632        # TextExtents for Title and Axis Labels
    15711633        dc.SetFont(self._getFont(self._fontSizeTitle))
    15721634        if self._titleEnabled:
    1573             title= graphics.getTitle()
    1574             titleWH= dc.GetTextExtent(title)
     1635            title = graphics.getTitle()
     1636            titleWH = dc.GetTextExtent(title)
    15751637        else:
    1576             titleWH= (0,0)
     1638            titleWH = (0, 0)
    15771639        dc.SetFont(self._getFont(self._fontSizeAxis))
    1578         xLabel, yLabel= graphics.getXLabel(),graphics.getYLabel()
    1579         xLabelWH= dc.GetTextExtent(xLabel)
    1580         yLabelWH= dc.GetTextExtent(yLabel)
     1640        xLabel, yLabel = graphics.getXLabel(), graphics.getYLabel()
     1641        xLabelWH = dc.GetTextExtent(xLabel)
     1642        yLabelWH = dc.GetTextExtent(yLabel)
    15811643        return titleWH, xLabelWH, yLabelWH
    1582    
     1644
    15831645    def _legendWH(self, dc, graphics):
    15841646        """Returns the size in screen units for legend box"""
    15851647        if self._legendEnabled != True:
    1586             legendBoxWH= symExt= txtExt= (0,0)
     1648            legendBoxWH = symExt = txtExt = (0, 0)
    15871649        else:
    15881650            # find max symbol size
    1589             symExt= graphics.getSymExtent(self.printerScale)
     1651            symExt = graphics.getSymExtent(self.printerScale)
    15901652            # find max legend text extent
    15911653            dc.SetFont(self._getFont(self._fontSizeLegend))
    1592             txtList= graphics.getLegendNames()
    1593             txtExt= dc.GetTextExtent(txtList[0])
     1654            txtList = graphics.getLegendNames()
     1655            txtExt = dc.GetTextExtent(txtList[0])
    15941656            for txt in graphics.getLegendNames()[1:]:
    1595                 txtExt= _Numeric.maximum(txtExt,dc.GetTextExtent(txt))
    1596             maxW= symExt[0]+txtExt[0]   
    1597             maxH= max(symExt[1],txtExt[1])
     1657                txtExt = np.maximum(txtExt, dc.GetTextExtent(txt))
     1658            maxW = symExt[0] + txtExt[0]
     1659            maxH = max(symExt[1], txtExt[1])
    15981660            # padding .1 for lhs of legend box and space between lines
    1599             maxW= maxW* 1.1
    1600             maxH= maxH* 1.1 * len(txtList)
     1661            maxW = maxW * 1.1
     1662            maxH = maxH * 1.1 * len(txtList)
    16011663            dc.SetFont(self._getFont(self._fontSizeAxis))
    1602             legendBoxWH= (maxW,maxH)
     1664            legendBoxWH = (maxW, maxH)
    16031665        return (legendBoxWH, symExt, txtExt)
    16041666
    16051667    def _drawRubberBand(self, corner1, corner2):
    16061668        """Draws/erases rect box from corner1 to corner2"""
    1607         ptx,pty,rectWidth,rectHeight= self._point2ClientCoord(corner1, corner2)
     1669        ptx, pty, rectWidth, rectHeight = self._point2ClientCoord(
     1670            corner1, corner2)
    16081671        # draw rectangle
    1609         dc = wx.ClientDC( self.canvas )
    1610         dc.BeginDrawing()                 
     1672        dc = wx.ClientDC(self.canvas)
    16111673        dc.SetPen(wx.Pen(wx.BLACK))
    1612         dc.SetBrush(wx.Brush( wx.WHITE, wx.TRANSPARENT ) )
     1674        dc.SetBrush(wx.Brush(wx.WHITE, wx.BRUSHSTYLE_TRANSPARENT))
    16131675        dc.SetLogicalFunction(wx.INVERT)
    1614         dc.DrawRectangle( ptx,pty, rectWidth,rectHeight)
     1676        dc.DrawRectangle(ptx, pty, rectWidth, rectHeight)
    16151677        dc.SetLogicalFunction(wx.COPY)
    1616         dc.EndDrawing()
    16171678
    1618     def _getFont(self,size):
     1679    def _getFont(self, size):
    16191680        """Take font size, adjusts if printing and returns wx.Font"""
    1620         s = size*self.printerScale*self._fontScale
     1681        s = size * self.printerScale * self._fontScale
    16211682        of = self.GetFont()
    16221683        # Linux speed up to get font from cache rather than X font server
    1623         key = (int(s), of.GetFamily (), of.GetStyle (), of.GetWeight ())
    1624         font = self._fontCache.get (key, None)
     1684        key = (int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
     1685        font = self._fontCache.get(key, None)
    16251686        if font:
    16261687            return font                 # yeah! cache hit
    16271688        else:
    1628             font =  wx.Font(int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
     1689            font = wx.Font(
     1690                int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
    16291691            self._fontCache[key] = font
    16301692            return font
    16311693
    1632 
    16331694    def _point2ClientCoord(self, corner1, corner2):
    16341695        """Converts user point coords to client screen int coords x,y,width,height"""
    1635         c1= _Numeric.array(corner1)
    1636         c2= _Numeric.array(corner2)
     1696        c1 = np.array(corner1)
     1697        c2 = np.array(corner2)
    16371698        # convert to screen coords
    1638         pt1= c1*self._pointScale+self._pointShift
    1639         pt2= c2*self._pointScale+self._pointShift
     1699        pt1 = c1 * self._pointScale + self._pointShift
     1700        pt2 = c2 * self._pointScale + self._pointShift
    16401701        # make height and width positive
    1641         pul= _Numeric.minimum(pt1,pt2) # Upper left corner
    1642         plr= _Numeric.maximum(pt1,pt2) # Lower right corner
    1643         rectWidth, rectHeight= plr-pul
    1644         ptx,pty= pul
    1645         return ptx, pty, rectWidth, rectHeight 
    1646    
     1702        pul = np.minimum(pt1, pt2) # Upper left corner
     1703        plr = np.maximum(pt1, pt2) # Lower right corner
     1704        rectWidth, rectHeight = plr - pul
     1705        ptx, pty = pul
     1706        return ptx, pty, rectWidth, rectHeight
     1707
    16471708    def _axisInterval(self, spec, lower, upper):
    16481709        """Returns sensible axis range for given spec"""
    16491710        if spec == 'none' or spec == 'min' or isinstance(spec, (float, int)):
    16501711            if lower == upper:
    1651                 return lower-0.5, upper+0.5
     1712                return lower - 0.5, upper + 0.5
    16521713            else:
    16531714                return lower, upper
    16541715        elif spec == 'auto':
    1655             range = upper-lower
     1716            range = upper - lower
    16561717            if range == 0.:
    1657                 return lower-0.5, upper+0.5
    1658             log = _Numeric.log10(range)
    1659             power = _Numeric.floor(log)
    1660             fraction = log-power
     1718                return lower - 0.5, upper + 0.5
     1719            log = np.log10(range)
     1720            power = np.floor(log)
     1721            fraction = log - power
    16611722            if fraction <= 0.05:
    1662                 power = power-1
    1663             grid = 10.**power
     1723                power = power - 1
     1724            grid = 10. ** power
    16641725            lower = lower - lower % grid
    16651726            mod = upper % grid
    16661727            if mod != 0:
     
    16731734            else:
    16741735                return upper, lower
    16751736        else:
    1676             raise ValueError, str(spec) + ': illegal axis specification'
     1737            raise ValueError(str(spec) + ': illegal axis specification')
    16771738
    16781739    def _drawAxes(self, dc, p1, p2, scale, shift, xticks, yticks):
    1679        
    1680         penWidth= self.printerScale * self._pointSize[0]        # increases thickness for printing only
     1740
     1741        # increases thickness for printing only
     1742        penWidth = self.printerScale * self._pointSize[0]
    16811743        dc.SetPen(wx.Pen(self._gridColour, penWidth))
    1682        
     1744
    16831745        # set length of tick marks--long ones make grid
    16841746        if self._gridEnabled:
    1685             x,y,width,height= self._point2ClientCoord(p1,p2)
     1747            x, y, width, height = self._point2ClientCoord(p1, p2)
    16861748            if self._gridEnabled == 'Horizontal':
    1687                 yTickLength= (width/2.0 +1) * self._pointSize[1]
    1688                 xTickLength= 3 * self.printerScale * self._pointSize[0]
     1749                yTickLength = (width / 2.0 + 1) * self._pointSize[1]
     1750                xTickLength = 3 * self.printerScale * self._pointSize[0]
    16891751            elif self._gridEnabled == 'Vertical':
    1690                 yTickLength= 3 * self.printerScale * self._pointSize[1]
    1691                 xTickLength= (height/2.0 +1) * self._pointSize[0]
     1752                yTickLength = 3 * self.printerScale * self._pointSize[1]
     1753                xTickLength = (height / 2.0 + 1) * self._pointSize[0]
    16921754            else:
    1693                 yTickLength= (width/2.0 +1) * self._pointSize[1]
    1694                 xTickLength= (height/2.0 +1) * self._pointSize[0]
     1755                yTickLength = (width / 2.0 + 1) * self._pointSize[1]
     1756                xTickLength = (height / 2.0 + 1) * self._pointSize[0]
    16951757        else:
    1696             yTickLength= 3 * self.printerScale * self._pointSize[1]  # lengthens lines for printing
    1697             xTickLength= 3 * self.printerScale * self._pointSize[0]
     1758            # lengthens lines for printing
     1759            yTickLength = 3 * self.printerScale * self._pointSize[1]
     1760            xTickLength = 3 * self.printerScale * self._pointSize[0]
    16981761
    16991762        if self._xSpec is not 'none':
    1700             lower, upper = p1[0],p2[0]
     1763            lower, upper = p1[0], p2[0]
    17011764            text = 1
    1702             for y, d in [(p1[1], -xTickLength), (p2[1], xTickLength)]:   # miny, maxy and tick lengths
     1765            # miny, maxy and tick lengths
     1766            for y, d in [(p1[1], -xTickLength), (p2[1], xTickLength)]:
    17031767                for x, label in xticks:
    1704                     pt = scale*_Numeric.array([x, y])+shift
    1705                     dc.DrawLine(pt[0],pt[1],pt[0],pt[1] + d) # draws tick mark d units
     1768                    pt = scale * np.array([x, y]) + shift
     1769                    # draws tick mark d units
     1770                    dc.DrawLine(pt[0], pt[1], pt[0], pt[1] + d)
    17061771                    if text:
    1707                         dc.DrawText(label,pt[0],pt[1]+2*self._pointSize[1])
    1708                 a1 = scale*_Numeric.array([lower, y])+shift
    1709                 a2 = scale*_Numeric.array([upper, y])+shift
    1710                 dc.DrawLine(a1[0],a1[1],a2[0],a2[1])  # draws upper and lower axis line
     1772                        dc.DrawText(
     1773                            label, pt[0], pt[1] + 2 * self._pointSize[1])
     1774                a1 = scale * np.array([lower, y]) + shift
     1775                a2 = scale * np.array([upper, y]) + shift
     1776                # draws upper and lower axis line
     1777                dc.DrawLine(a1[0], a1[1], a2[0], a2[1])
    17111778                text = 0  # axis values not drawn on top side
    17121779
    17131780        if self._ySpec is not 'none':
    1714             lower, upper = p1[1],p2[1]
     1781            lower, upper = p1[1], p2[1]
    17151782            text = 1
    17161783            h = dc.GetCharHeight()
    17171784            for x, d in [(p1[0], -yTickLength), (p2[0], yTickLength)]:
    17181785                for y, label in yticks:
    1719                     pt = scale*_Numeric.array([x, y])+shift
    1720                     dc.DrawLine(pt[0],pt[1],pt[0]-d,pt[1])
     1786                    pt = scale * np.array([x, y]) + shift
     1787                    dc.DrawLine(pt[0], pt[1], pt[0] - d, pt[1])
    17211788                    if text:
    1722                         dc.DrawText(label,pt[0]-dc.GetTextExtent(label)[0]-3*self._pointSize[0],
    1723                                     pt[1]-0.75*h)
    1724                 a1 = scale*_Numeric.array([x, lower])+shift
    1725                 a2 = scale*_Numeric.array([x, upper])+shift
    1726                 dc.DrawLine(a1[0],a1[1],a2[0],a2[1])
     1789                        dc.DrawText(label, pt[0] - dc.GetTextExtent(label)[0] - 3 * self._pointSize[0],
     1790                                    pt[1] - 0.75 * h)
     1791                a1 = scale * np.array([x, lower]) + shift
     1792                a2 = scale * np.array([x, upper]) + shift
     1793                dc.DrawLine(a1[0], a1[1], a2[0], a2[1])
    17271794                text = 0    # axis values not drawn on right side
    17281795
    17291796        if self._centerLinesEnabled:
    17301797            if self._centerLinesEnabled in ('Horizontal', True):
    1731                 y1 = scale[1]*p1[1]+shift[1]
    1732                 y2 = scale[1]*p2[1]+shift[1]
     1798                y1 = scale[1] * p1[1] + shift[1]
     1799                y2 = scale[1] * p2[1] + shift[1]
    17331800                y = (y1 - y2) / 2.0 + y2
    1734                 dc.DrawLine(scale[0] * p1[0] + shift[0], y, scale[0] * p2[0] + shift[0], y)
     1801                dc.DrawLine(
     1802                    scale[0] * p1[0] + shift[0], y, scale[0] * p2[0] + shift[0], y)
    17351803            if self._centerLinesEnabled in ('Vertical', True):
    1736                 x1 = scale[0]*p1[0]+shift[0]
    1737                 x2 = scale[0]*p2[0]+shift[0]
     1804                x1 = scale[0] * p1[0] + shift[0]
     1805                x2 = scale[0] * p2[0] + shift[0]
    17381806                x = (x1 - x2) / 2.0 + x2
    1739                 dc.DrawLine(x, scale[1] * p1[1] + shift[1], x, scale[1] * p2[1] + shift[1])
     1807                dc.DrawLine(
     1808                    x, scale[1] * p1[1] + shift[1], x, scale[1] * p2[1] + shift[1])
    17401809
    17411810        if self._diagonalsEnabled:
    17421811            if self._diagonalsEnabled in ('Bottomleft-Topright', True):
    1743                 dc.DrawLine(scale[0] * p1[0] + shift[0], scale[1] * p1[1] + shift[1], scale[0] * p2[0] + shift[0], scale[1] * p2[1] + shift[1])
     1812                dc.DrawLine(scale[0] * p1[0] + shift[0], scale[1] * p1[1] +
     1813                            shift[1], scale[0] * p2[0] + shift[0], scale[1] * p2[1] + shift[1])
    17441814            if self._diagonalsEnabled in ('Bottomright-Topleft', True):
    1745                 dc.DrawLine(scale[0] * p1[0] + shift[0], scale[1] * p2[1] + shift[1], scale[0] * p2[0] + shift[0], scale[1] * p1[1] + shift[1])
     1815                dc.DrawLine(scale[0] * p1[0] + shift[0], scale[1] * p2[1] +
     1816                            shift[1], scale[0] * p2[0] + shift[0], scale[1] * p1[1] + shift[1])
    17461817
    17471818    def _xticks(self, *args):
    17481819        if self._logscale[0]:
     
    17501821        else:
    17511822            attr = {'numticks': self._xSpec}
    17521823            return self._ticks(*args, **attr)
    1753    
     1824
    17541825    def _yticks(self, *args):
    17551826        if self._logscale[1]:
    17561827            return self._logticks(*args)
     
    17571828        else:
    17581829            attr = {'numticks': self._ySpec}
    17591830            return self._ticks(*args, **attr)
    1760        
     1831
    17611832    def _logticks(self, lower, upper):
    1762         #lower,upper = map(_Numeric.log10,[lower,upper])
    1763         #print 'logticks',lower,upper
     1833        #lower,upper = map(np.log10,[lower,upper])
     1834        # print('logticks',lower,upper)
    17641835        ticks = []
    1765         mag = _Numeric.power(10,_Numeric.floor(lower))
    1766         if upper-lower > 6:
    1767             t = _Numeric.power(10,_Numeric.ceil(lower))
    1768             base = _Numeric.power(10,_Numeric.floor((upper-lower)/6))
     1836        mag = np.power(10, np.floor(lower))
     1837        if upper - lower > 6:
     1838            t = np.power(10, np.ceil(lower))
     1839            base = np.power(10, np.floor((upper - lower) / 6))
     1840
    17691841            def inc(t):
    1770                 return t*base-t
     1842                return t * base - t
    17711843        else:
    1772             t = _Numeric.ceil(_Numeric.power(10,lower)/mag)*mag
     1844            t = np.ceil(np.power(10, lower) / mag) * mag
     1845
    17731846            def inc(t):
    1774                 return 10**int(_Numeric.floor(_Numeric.log10(t)+1e-16))
    1775         majortick = int(_Numeric.log10(mag))
    1776         while t <= pow(10,upper):
    1777             if majortick != int(_Numeric.floor(_Numeric.log10(t)+1e-16)):
    1778                 majortick = int(_Numeric.floor(_Numeric.log10(t)+1e-16))
    1779                 ticklabel = '1e%d'%majortick
     1847                return 10 ** int(np.floor(np.log10(t) + 1e-16))
     1848        majortick = int(np.log10(mag))
     1849        while t <= pow(10, upper):
     1850            if majortick != int(np.floor(np.log10(t) + 1e-16)):
     1851                majortick = int(np.floor(np.log10(t) + 1e-16))
     1852                ticklabel = '1e%d' % majortick
    17801853            else:
    1781                 if upper-lower < 2:
    1782                     minortick = int(t/pow(10,majortick)+.5)
    1783                     ticklabel = '%de%d'%(minortick,majortick)
     1854                if upper - lower < 2:
     1855                    minortick = int(t / pow(10, majortick) + .5)
     1856                    ticklabel = '%de%d' % (minortick, majortick)
    17841857                else:
    17851858                    ticklabel = ''
    1786             ticks.append((_Numeric.log10(t), ticklabel))
     1859            ticks.append((np.log10(t), ticklabel))
    17871860            t += inc(t)
    17881861        if len(ticks) == 0:
    1789             ticks = [(0,'')]
     1862            ticks = [(0, '')]
    17901863        return ticks
    1791    
     1864
    17921865    def _ticks(self, lower, upper, numticks=None):
    17931866        if isinstance(numticks, (float, int)):
    1794             ideal = (upper-lower)/float(numticks)
     1867            ideal = (upper - lower) / float(numticks)
    17951868        else:
    1796             ideal = (upper-lower)/7.
    1797         log = _Numeric.log10(ideal)
    1798         power = _Numeric.floor(log)
     1869            ideal = (upper - lower) / 7.
     1870        log = np.log10(ideal)
     1871        power = np.floor(log)
    17991872        if isinstance(numticks, (float, int)):
    18001873            grid = ideal
    18011874        else:
    1802             fraction = log-power
     1875            fraction = log - power
    18031876            factor = 1.
    18041877            error = fraction
    18051878            for f, lf in self._multiples:
    1806                 e = _Numeric.fabs(fraction-lf)
     1879                e = np.fabs(fraction - lf)
    18071880                if e < error:
    18081881                    error = e
    18091882                    factor = f
    1810             grid = factor * 10.**power
     1883            grid = factor * 10. ** power
    18111884        if self._useScientificNotation and (power > 4 or power < -4):
    1812             format = '%+7.1e'       
     1885            format = '%+7.1e'
    18131886        elif power >= 0:
    18141887            digits = max(1, int(power))
    1815             format = '%' + `digits`+'.0f'
     1888            format = '%' + repr(digits) + '.0f'
    18161889        else:
    18171890            digits = -int(power)
    1818             format = '%'+`digits+2`+'.'+`digits`+'f'
     1891            format = '%' + repr(digits + 2) + '.' + repr(digits) + 'f'
    18191892        ticks = []
    1820         t = -grid*_Numeric.floor(-lower/grid)
     1893        t = -grid * np.floor(-lower / grid)
    18211894        while t <= upper:
    18221895            if t == -0:
    18231896                t = 0
    1824             ticks.append( (t, format % (t,)) )
     1897            ticks.append((t, format % (t,)))
    18251898            t = t + grid
    18261899        return ticks
    18271900
    1828     _multiples = [(2., _Numeric.log10(2.)), (5., _Numeric.log10(5.))]
     1901    _multiples = [(2., np.log10(2.)), (5., np.log10(5.))]
    18291902
    1830 
    18311903    def _adjustScrollbars(self):
    18321904        if self._sb_ignore:
    18331905            self._sb_ignore = False
     
    18381910
    18391911        self._adjustingSB = True
    18401912        needScrollbars = False
    1841        
     1913
    18421914        # horizontal scrollbar
    18431915        r_current = self._getXCurrentRange()
    18441916        r_max = list(self._getXMaxRange())
    18451917        sbfullrange = float(self.sb_hor.GetRange())
    18461918
    1847         r_max[0] = min(r_max[0],r_current[0])
    1848         r_max[1] = max(r_max[1],r_current[1])
    1849            
     1919        r_max[0] = min(r_max[0], r_current[0])
     1920        r_max[1] = max(r_max[1], r_current[1])
     1921
    18501922        self._sb_xfullrange = r_max
    18511923
    1852         unit = (r_max[1]-r_max[0])/float(self.sb_hor.GetRange())
    1853         pos = int((r_current[0]-r_max[0])/unit)
    1854        
     1924        unit = (r_max[1] - r_max[0]) / float(self.sb_hor.GetRange())
     1925        pos = int((r_current[0] - r_max[0]) / unit)
     1926
    18551927        if pos >= 0:
    1856             pagesize = int((r_current[1]-r_current[0])/unit)
     1928            pagesize = int((r_current[1] - r_current[0]) / unit)
    18571929
    18581930            self.sb_hor.SetScrollbar(pos, pagesize, sbfullrange, pagesize)
    18591931            self._sb_xunit = unit
     
    18661938        r_max = list(self._getYMaxRange())
    18671939        sbfullrange = float(self.sb_vert.GetRange())
    18681940
    1869         r_max[0] = min(r_max[0],r_current[0])
    1870         r_max[1] = max(r_max[1],r_current[1])
    1871            
     1941        r_max[0] = min(r_max[0], r_current[0])
     1942        r_max[1] = max(r_max[1], r_current[1])
     1943
    18721944        self._sb_yfullrange = r_max
    1873        
    1874         unit = (r_max[1]-r_max[0])/sbfullrange
    1875         pos = int((r_current[0]-r_max[0])/unit)
    1876        
     1945
     1946        unit = (r_max[1] - r_max[0]) / sbfullrange
     1947        pos = int((r_current[0] - r_max[0]) / unit)
     1948
    18771949        if pos >= 0:
    1878             pagesize = int((r_current[1]-r_current[0])/unit)
    1879             pos = (sbfullrange-1-pos-pagesize)
     1950            pagesize = int((r_current[1] - r_current[0]) / unit)
     1951            pos = (sbfullrange - 1 - pos - pagesize)
    18801952            self.sb_vert.SetScrollbar(pos, pagesize, sbfullrange, pagesize)
    18811953            self._sb_yunit = unit
    18821954            needScrollbars = needScrollbars or (pagesize != sbfullrange)
     
    18861958        self.SetShowScrollbars(needScrollbars)
    18871959        self._adjustingSB = False
    18881960
    1889 #-------------------------------------------------------------------------------
     1961#-------------------------------------------------------------------------
    18901962# Used to layout the printer page
    18911963
     1964
    18921965class PlotPrintout(wx.Printout):
     1966
    18931967    """Controls how the plot is made in printing and previewing"""
    18941968    # Do not change method names in this class,
    18951969    # we have to override wx.Printout methods here!
     1970
    18961971    def __init__(self, graph):
    18971972        """graph is instance of plotCanvas to be printed or previewed"""
    18981973        wx.Printout.__init__(self)
     
    19091984
    19101985    def OnPrintPage(self, page):
    19111986        dc = self.GetDC()  # allows using floats for certain functions
    1912 ##        print "PPI Printer",self.GetPPIPrinter()
    1913 ##        print "PPI Screen", self.GetPPIScreen()
    1914 ##        print "DC GetSize", dc.GetSize()
    1915 ##        print "GetPageSizePixels", self.GetPageSizePixels()
     1987##        print("PPI Printer",self.GetPPIPrinter())
     1988##        print("PPI Screen", self.GetPPIScreen())
     1989##        print("DC GetSize", dc.GetSize())
     1990##        print("GetPageSizePixels", self.GetPageSizePixels())
    19161991        # Note PPIScreen does not give the correct number
    19171992        # Calulate everything for printer and then scale for preview
    1918         PPIPrinter= self.GetPPIPrinter()        # printer dots/inch (w,h)
    1919         #PPIScreen= self.GetPPIScreen()          # screen dots/inch (w,h)
    1920         dcSize= dc.GetSize()                    # DC size
     1993        PPIPrinter = self.GetPPIPrinter()        # printer dots/inch (w,h)
     1994        # PPIScreen= self.GetPPIScreen()          # screen dots/inch (w,h)
     1995        dcSize = dc.GetSize()                    # DC size
    19211996        if self.graph._antiAliasingEnabled and not isinstance(dc, wx.GCDC):
    19221997            try:
    19231998                dc = wx.GCDC(dc)
    1924             except Exception, exception:
     1999            except Exception:
    19252000                pass
    19262001            else:
    19272002                if self.graph._hiResEnabled:
    1928                     dc.SetMapMode(wx.MM_TWIPS) # high precision - each logical unit is 1/20 of a point
    1929         pageSize= self.GetPageSizePixels() # page size in terms of pixcels
    1930         clientDcSize= self.graph.GetClientSize()
    1931        
     2003                    # high precision - each logical unit is 1/20 of a point
     2004                    dc.SetMapMode(wx.MM_TWIPS)
     2005        pageSize = self.GetPageSizePixels()  # page size in terms of pixcels
     2006        clientDcSize = self.graph.GetClientSize()
     2007
    19322008        # find what the margins are (mm)
    1933         margLeftSize,margTopSize= self.graph.pageSetupData.GetMarginTopLeft()
    1934         margRightSize, margBottomSize= self.graph.pageSetupData.GetMarginBottomRight()
     2009        margLeftSize, margTopSize = self.graph.pageSetupData.GetMarginTopLeft()
     2010        margRightSize, margBottomSize = self.graph.pageSetupData.GetMarginBottomRight()
    19352011
    19362012        # calculate offset and scale for dc
    1937         pixLeft= margLeftSize*PPIPrinter[0]/25.4  # mm*(dots/in)/(mm/in)
    1938         pixRight= margRightSize*PPIPrinter[0]/25.4   
    1939         pixTop= margTopSize*PPIPrinter[1]/25.4
    1940         pixBottom= margBottomSize*PPIPrinter[1]/25.4
     2013        pixLeft = margLeftSize * PPIPrinter[0] / 25.4  # mm*(dots/in)/(mm/in)
     2014        pixRight = margRightSize * PPIPrinter[0] / 25.4
     2015        pixTop = margTopSize * PPIPrinter[1] / 25.4
     2016        pixBottom = margBottomSize * PPIPrinter[1] / 25.4
    19412017
    1942         plotAreaW= pageSize[0]-(pixLeft+pixRight)
    1943         plotAreaH= pageSize[1]-(pixTop+pixBottom)
     2018        plotAreaW = pageSize[0] - (pixLeft + pixRight)
     2019        plotAreaH = pageSize[1] - (pixTop + pixBottom)
    19442020
    19452021        # ratio offset and scale to screen size if preview
    19462022        if self.IsPreview():
    1947             ratioW= float(dcSize[0])/pageSize[0]
    1948             ratioH= float(dcSize[1])/pageSize[1]
     2023            ratioW = float(dcSize[0]) / pageSize[0]
     2024            ratioH = float(dcSize[1]) / pageSize[1]
    19492025            pixLeft *= ratioW
    19502026            pixTop *= ratioH
    19512027            plotAreaW *= ratioW
    19522028            plotAreaH *= ratioH
    1953        
     2029
    19542030        # rescale plot to page or preview plot area
    1955         self.graph._setSize(plotAreaW,plotAreaH)
    1956        
     2031        self.graph._setSize(plotAreaW, plotAreaH)
     2032
    19572033        # Set offset and scale
    1958         dc.SetDeviceOrigin(pixLeft,pixTop)
     2034        dc.SetDeviceOrigin(pixLeft, pixTop)
    19592035
    19602036        # Thicken up pens and increase marker size for printing
    1961         ratioW= float(plotAreaW)/clientDcSize[0]
    1962         ratioH= float(plotAreaH)/clientDcSize[1]
    1963         aveScale= (ratioW+ratioH)/2
     2037        ratioW = float(plotAreaW) / clientDcSize[0]
     2038        ratioH = float(plotAreaH) / clientDcSize[1]
     2039        aveScale = (ratioW + ratioH) / 2
    19642040        if self.graph._antiAliasingEnabled and not self.IsPreview():
    19652041            scale = dc.GetUserScale()
    1966             dc.SetUserScale(scale[0] / self.graph._pointSize[0], scale[1] / self.graph._pointSize[1])
     2042            dc.SetUserScale(
     2043                scale[0] / self.graph._pointSize[0], scale[1] / self.graph._pointSize[1])
    19672044        self.graph._setPrinterScale(aveScale)  # tickens up pens for printing
    19682045
    19692046        self.graph._printDraw(dc)
     
    19702047        # rescale back to original
    19712048        self.graph._setSize()
    19722049        self.graph._setPrinterScale(1)
    1973         self.graph.Redraw()     #to get point label scale and shift correct
     2050        self.graph.Redraw()  # to get point label scale and shift correct
    19742051
    19752052        return True
    19762053
     
    20102087#     ...a sample implementation using the above
    20112088#
    20122089
     2090
    20132091def _draw1Objects():
    20142092    # 100 points sin function, plotted as green circles
    2015     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2093    data1 = 2. * np.pi * np.arange(200) / 200.
    20162094    data1.shape = (100, 2)
    2017     data1[:,1] = _Numeric.sin(data1[:,0])
    2018     markers1 = PolyMarker(data1, legend='Green Markers', colour='green', marker='circle',size=1)
     2095    data1[:, 1] = np.sin(data1[:, 0])
     2096    markers1 = PolyMarker(
     2097        data1, legend='Green Markers', colour='green', marker='circle', size=1)
    20192098
    20202099    # 50 points cos function, plotted as red line
    2021     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
    2022     data1.shape = (50,2)
    2023     data1[:,1] = _Numeric.cos(data1[:,0])
    2024     lines = PolySpline(data1, legend= 'Red Line', colour='red')
     2100    data1 = 2. * np.pi * np.arange(100) / 100.
     2101    data1.shape = (50, 2)
     2102    data1[:, 1] = np.cos(data1[:, 0])
     2103    lines = PolySpline(data1, legend='Red Line', colour='red')
    20252104
    20262105    # A few more points...
    2027     pi = _Numeric.pi
    2028     markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    2029                           (3.*pi/4., -1)], legend='Cross Legend', colour='blue',
     2106    pi = np.pi
     2107    markers2 = PolyMarker([(0., 0.), (pi / 4., 1.), (pi / 2, 0.),
     2108                           (3. * pi / 4., -1)], legend='Cross Legend', colour='blue',
    20302109                          marker='cross')
    2031    
    2032     return PlotGraphics([markers1, lines, markers2],"Graph Title", "X Axis", "Y Axis")
    20332110
     2111    return PlotGraphics([markers1, lines, markers2], "Graph Title", "X Axis", "Y Axis")
     2112
     2113
    20342114def _draw2Objects():
    20352115    # 100 points sin function, plotted as green dots
    2036     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2116    data1 = 2. * np.pi * np.arange(200) / 200.
    20372117    data1.shape = (100, 2)
    2038     data1[:,1] = _Numeric.sin(data1[:,0])
    2039     line1 = PolySpline(data1, legend='Green Line', colour='green', width=6, style=wx.DOT)
     2118    data1[:, 1] = np.sin(data1[:, 0])
     2119    line1 = PolySpline(
     2120        data1, legend='Green Line', colour='green', width=6, style=wx.PENSTYLE_DOT)
    20402121
    20412122    # 50 points cos function, plotted as red dot-dash
    2042     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
    2043     data1.shape = (50,2)
    2044     data1[:,1] = _Numeric.cos(data1[:,0])
    2045     line2 = PolySpline(data1, legend='Red Line', colour='red', width=3, style= wx.DOT_DASH)
     2123    data1 = 2. * np.pi * np.arange(100) / 100.
     2124    data1.shape = (50, 2)
     2125    data1[:, 1] = np.cos(data1[:, 0])
     2126    line2 = PolySpline(
     2127        data1, legend='Red Line', colour='red', width=3, style=wx.PENSTYLE_DOT_DASH)
    20462128
    20472129    # A few more points...
    2048     pi = _Numeric.pi
    2049     markers1 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    2050                           (3.*pi/4., -1)], legend='Cross Hatch Square', colour='blue', width= 3, size= 6,
    2051                           fillcolour= 'red', fillstyle= wx.CROSSDIAG_HATCH,
     2130    pi = np.pi
     2131    markers1 = PolyMarker([(0., 0.), (pi / 4., 1.), (pi / 2, 0.),
     2132                           (3. * pi / 4., -1)], legend='Cross Hatch Square', colour='blue', width=3, size=6,
     2133                          fillcolour='red', fillstyle=wx.CROSSDIAG_HATCH,
    20522134                          marker='square')
    20532135
    20542136    return PlotGraphics([markers1, line1, line2], "Big Markers with Different Line Styles")
    20552137
     2138
    20562139def _draw3Objects():
    2057     markerList= ['circle', 'dot', 'square', 'triangle', 'triangle_down',
    2058                 'cross', 'plus', 'circle']
    2059     m=[]
     2140    markerList = ['circle', 'dot', 'square', 'triangle', 'triangle_down',
     2141                  'cross', 'plus', 'circle']
     2142    m = []
    20602143    for i in range(len(markerList)):
    2061         m.append(PolyMarker([(2*i+.5,i+.5)], legend=markerList[i], colour='blue',
    2062                           marker=markerList[i]))
     2144        m.append(PolyMarker([(2 * i + .5, i + .5)], legend=markerList[i], colour='blue',
     2145                            marker=markerList[i]))
    20632146    return PlotGraphics(m, "Selection of Markers", "Minimal Axis", "No Axis")
    20642147
     2148
    20652149def _draw4Objects():
    20662150    # 25,000 point line
    2067     data1 = _Numeric.arange(5e5,1e6,10)
     2151    data1 = np.arange(5e5, 1e6, 10)
    20682152    data1.shape = (25000, 2)
    20692153    line1 = PolyLine(data1, legend='Wide Line', colour='green', width=5)
    20702154
     
    20732157                          marker='square')
    20742158    return PlotGraphics([line1, markers2], "25,000 Points", "Value X", "")
    20752159
     2160
    20762161def _draw5Objects():
    20772162    # Empty graph with axis defined but no points/lines
    2078     points=[]
     2163    points = []
    20792164    line1 = PolyLine(points, legend='Wide Line', colour='green', width=5)
    20802165    return PlotGraphics([line1], "Empty Plot With Just Axes", "Value X", "Value Y")
    20812166
     2167
    20822168def _draw6Objects():
    20832169    # Bar graph
    2084     points1=[(1,0), (1,10)]
     2170    points1 = [(1, 0), (1, 10)]
    20852171    line1 = PolyLine(points1, colour='green', legend='Feb.', width=10)
    2086     points1g=[(2,0), (2,4)]
     2172    points1g = [(2, 0), (2, 4)]
    20872173    line1g = PolyLine(points1g, colour='red', legend='Mar.', width=10)
    2088     points1b=[(3,0), (3,6)]
     2174    points1b = [(3, 0), (3, 6)]
    20892175    line1b = PolyLine(points1b, colour='blue', legend='Apr.', width=10)
    20902176
    2091     points2=[(4,0), (4,12)]
     2177    points2 = [(4, 0), (4, 12)]
    20922178    line2 = PolyLine(points2, colour='Yellow', legend='May', width=10)
    2093     points2g=[(5,0), (5,8)]
     2179    points2g = [(5, 0), (5, 8)]
    20942180    line2g = PolyLine(points2g, colour='orange', legend='June', width=10)
    2095     points2b=[(6,0), (6,4)]
     2181    points2b = [(6, 0), (6, 4)]
    20962182    line2b = PolyLine(points2b, colour='brown', legend='July', width=10)
    20972183
    20982184    return PlotGraphics([line1, line1g, line1b, line2, line2g, line2b],
    20992185                        "Bar Graph - (Turn on Grid, Legend)", "Months", "Number of Students")
     2186
     2187
    21002188def _draw7Objects():
    21012189    # Empty graph with axis defined but no points/lines
    2102     x = _Numeric.arange(1,1000,1)
    2103     y1 = 4.5*x**2
    2104     y2 = 2.2*x**3
    2105     points1 = _Numeric.transpose([x,y1])
    2106     points2 = _Numeric.transpose([x,y2])
     2190    x = np.arange(1, 1000, 1)
     2191    y1 = 4.5 * x ** 2
     2192    y2 = 2.2 * x ** 3
     2193    points1 = np.transpose([x, y1])
     2194    points2 = np.transpose([x, y2])
    21072195    line1 = PolyLine(points1, legend='quadratic', colour='blue', width=1)
    21082196    line2 = PolyLine(points2, legend='cubic', colour='red', width=1)
    2109     return PlotGraphics([line1,line2], "double log plot", "Value X", "Value Y")
     2197    return PlotGraphics([line1, line2], "double log plot", "Value X", "Value Y")
    21102198
    21112199
    21122200class TestFrame(wx.Frame):
     2201
    21132202    def __init__(self, parent, id, title):
    21142203        wx.Frame.__init__(self, parent, id, title,
    21152204                          wx.DefaultPosition, (600, 400))
     
    21202209        menu = wx.Menu()
    21212210        menu.Append(200, 'Page Setup...', 'Setup the printer page')
    21222211        self.Bind(wx.EVT_MENU, self.OnFilePageSetup, id=200)
    2123        
     2212
    21242213        menu.Append(201, 'Print Preview...', 'Show the current plot on page')
    21252214        self.Bind(wx.EVT_MENU, self.OnFilePrintPreview, id=201)
    2126        
     2215
    21272216        menu.Append(202, 'Print...', 'Print the current plot')
    21282217        self.Bind(wx.EVT_MENU, self.OnFilePrint, id=202)
    2129        
     2218
    21302219        menu.Append(203, 'Save Plot...', 'Save current plot')
    21312220        self.Bind(wx.EVT_MENU, self.OnSaveFile, id=203)
    2132        
     2221
    21332222        menu.Append(205, 'E&xit', 'Enough of this already!')
    21342223        self.Bind(wx.EVT_MENU, self.OnFileExit, id=205)
    21352224        self.mainmenu.Append(menu, '&File')
     
    21362225
    21372226        menu = wx.Menu()
    21382227        menu.Append(206, 'Draw1', 'Draw plots1')
    2139         self.Bind(wx.EVT_MENU,self.OnPlotDraw1, id=206)
     2228        self.Bind(wx.EVT_MENU, self.OnPlotDraw1, id=206)
    21402229        menu.Append(207, 'Draw2', 'Draw plots2')
    2141         self.Bind(wx.EVT_MENU,self.OnPlotDraw2, id=207)
     2230        self.Bind(wx.EVT_MENU, self.OnPlotDraw2, id=207)
    21422231        menu.Append(208, 'Draw3', 'Draw plots3')
    2143         self.Bind(wx.EVT_MENU,self.OnPlotDraw3, id=208)
     2232        self.Bind(wx.EVT_MENU, self.OnPlotDraw3, id=208)
    21442233        menu.Append(209, 'Draw4', 'Draw plots4')
    2145         self.Bind(wx.EVT_MENU,self.OnPlotDraw4, id=209)
     2234        self.Bind(wx.EVT_MENU, self.OnPlotDraw4, id=209)
    21462235        menu.Append(210, 'Draw5', 'Draw plots5')
    2147         self.Bind(wx.EVT_MENU,self.OnPlotDraw5, id=210)
     2236        self.Bind(wx.EVT_MENU, self.OnPlotDraw5, id=210)
    21482237        menu.Append(260, 'Draw6', 'Draw plots6')
    2149         self.Bind(wx.EVT_MENU,self.OnPlotDraw6, id=260)
     2238        self.Bind(wx.EVT_MENU, self.OnPlotDraw6, id=260)
    21502239        menu.Append(261, 'Draw7', 'Draw plots7')
    2151         self.Bind(wx.EVT_MENU,self.OnPlotDraw7, id=261)
     2240        self.Bind(wx.EVT_MENU, self.OnPlotDraw7, id=261)
    21522241
    21532242        menu.Append(211, '&Redraw', 'Redraw plots')
    2154         self.Bind(wx.EVT_MENU,self.OnPlotRedraw, id=211)
     2243        self.Bind(wx.EVT_MENU, self.OnPlotRedraw, id=211)
    21552244        menu.Append(212, '&Clear', 'Clear canvas')
    2156         self.Bind(wx.EVT_MENU,self.OnPlotClear, id=212)
     2245        self.Bind(wx.EVT_MENU, self.OnPlotClear, id=212)
    21572246        menu.Append(213, '&Scale', 'Scale canvas')
    2158         self.Bind(wx.EVT_MENU,self.OnPlotScale, id=213)
    2159         menu.Append(214, 'Enable &Zoom', 'Enable Mouse Zoom', kind=wx.ITEM_CHECK)
    2160         self.Bind(wx.EVT_MENU,self.OnEnableZoom, id=214)
     2247        self.Bind(wx.EVT_MENU, self.OnPlotScale, id=213)
     2248        menu.Append(
     2249            214, 'Enable &Zoom', 'Enable Mouse Zoom', kind=wx.ITEM_CHECK)
     2250        self.Bind(wx.EVT_MENU, self.OnEnableZoom, id=214)
    21612251        menu.Append(215, 'Enable &Grid', 'Turn on Grid', kind=wx.ITEM_CHECK)
    2162         self.Bind(wx.EVT_MENU,self.OnEnableGrid, id=215)
    2163         menu.Append(217, 'Enable &Drag', 'Activates dragging mode', kind=wx.ITEM_CHECK)
    2164         self.Bind(wx.EVT_MENU,self.OnEnableDrag, id=217)
    2165         menu.Append(220, 'Enable &Legend', 'Turn on Legend', kind=wx.ITEM_CHECK)
    2166         self.Bind(wx.EVT_MENU,self.OnEnableLegend, id=220)
    2167         menu.Append(222, 'Enable &Point Label', 'Show Closest Point', kind=wx.ITEM_CHECK)
    2168         self.Bind(wx.EVT_MENU,self.OnEnablePointLabel, id=222)
    2169        
    2170         menu.Append(223, 'Enable &Anti-Aliasing', 'Smooth output', kind=wx.ITEM_CHECK)
    2171         self.Bind(wx.EVT_MENU,self.OnEnableAntiAliasing, id=223)
    2172         menu.Append(224, 'Enable &High-Resolution AA', 'Draw in higher resolution', kind=wx.ITEM_CHECK)
    2173         self.Bind(wx.EVT_MENU,self.OnEnableHiRes, id=224)
    2174        
    2175         menu.Append(226, 'Enable Center Lines', 'Draw center lines', kind=wx.ITEM_CHECK)
    2176         self.Bind(wx.EVT_MENU,self.OnEnableCenterLines, id=226)
    2177         menu.Append(227, 'Enable Diagonal Lines', 'Draw diagonal lines', kind=wx.ITEM_CHECK)
    2178         self.Bind(wx.EVT_MENU,self.OnEnableDiagonals, id=227)
    2179        
    2180         menu.Append(231, 'Set Gray Background', 'Change background colour to gray')
    2181         self.Bind(wx.EVT_MENU,self.OnBackgroundGray, id=231)
    2182         menu.Append(232, 'Set &White Background', 'Change background colour to white')
    2183         self.Bind(wx.EVT_MENU,self.OnBackgroundWhite, id=232)
    2184         menu.Append(233, 'Set Red Label Text', 'Change label text colour to red')
    2185         self.Bind(wx.EVT_MENU,self.OnForegroundRed, id=233)
    2186         menu.Append(234, 'Set &Black Label Text', 'Change label text colour to black')
    2187         self.Bind(wx.EVT_MENU,self.OnForegroundBlack, id=234)
    2188        
     2252        self.Bind(wx.EVT_MENU, self.OnEnableGrid, id=215)
     2253        menu.Append(
     2254            217, 'Enable &Drag', 'Activates dragging mode', kind=wx.ITEM_CHECK)
     2255        self.Bind(wx.EVT_MENU, self.OnEnableDrag, id=217)
     2256        menu.Append(
     2257            220, 'Enable &Legend', 'Turn on Legend', kind=wx.ITEM_CHECK)
     2258        self.Bind(wx.EVT_MENU, self.OnEnableLegend, id=220)
     2259        menu.Append(
     2260            222, 'Enable &Point Label', 'Show Closest Point', kind=wx.ITEM_CHECK)
     2261        self.Bind(wx.EVT_MENU, self.OnEnablePointLabel, id=222)
     2262
     2263        menu.Append(
     2264            223, 'Enable &Anti-Aliasing', 'Smooth output', kind=wx.ITEM_CHECK)
     2265        self.Bind(wx.EVT_MENU, self.OnEnableAntiAliasing, id=223)
     2266        menu.Append(224, 'Enable &High-Resolution AA',
     2267                    'Draw in higher resolution', kind=wx.ITEM_CHECK)
     2268        self.Bind(wx.EVT_MENU, self.OnEnableHiRes, id=224)
     2269
     2270        menu.Append(
     2271            226, 'Enable Center Lines', 'Draw center lines', kind=wx.ITEM_CHECK)
     2272        self.Bind(wx.EVT_MENU, self.OnEnableCenterLines, id=226)
     2273        menu.Append(
     2274            227, 'Enable Diagonal Lines', 'Draw diagonal lines', kind=wx.ITEM_CHECK)
     2275        self.Bind(wx.EVT_MENU, self.OnEnableDiagonals, id=227)
     2276
     2277        menu.Append(
     2278            231, 'Set Gray Background', 'Change background colour to gray')
     2279        self.Bind(wx.EVT_MENU, self.OnBackgroundGray, id=231)
     2280        menu.Append(
     2281            232, 'Set &White Background', 'Change background colour to white')
     2282        self.Bind(wx.EVT_MENU, self.OnBackgroundWhite, id=232)
     2283        menu.Append(
     2284            233, 'Set Red Label Text', 'Change label text colour to red')
     2285        self.Bind(wx.EVT_MENU, self.OnForegroundRed, id=233)
     2286        menu.Append(
     2287            234, 'Set &Black Label Text', 'Change label text colour to black')
     2288        self.Bind(wx.EVT_MENU, self.OnForegroundBlack, id=234)
     2289
    21892290        menu.Append(225, 'Scroll Up 1', 'Move View Up 1 Unit')
    2190         self.Bind(wx.EVT_MENU,self.OnScrUp, id=225)
     2291        self.Bind(wx.EVT_MENU, self.OnScrUp, id=225)
    21912292        menu.Append(230, 'Scroll Rt 2', 'Move View Right 2 Units')
    2192         self.Bind(wx.EVT_MENU,self.OnScrRt, id=230)
     2293        self.Bind(wx.EVT_MENU, self.OnScrRt, id=230)
    21932294        menu.Append(235, '&Plot Reset', 'Reset to original plot')
    2194         self.Bind(wx.EVT_MENU,self.OnReset, id=235)
     2295        self.Bind(wx.EVT_MENU, self.OnReset, id=235)
    21952296
    21962297        self.mainmenu.Append(menu, '&Plot')
    21972298
     
    22042305
    22052306        # A status bar to tell people what's happening
    22062307        self.CreateStatusBar(1)
    2207        
     2308
    22082309        self.client = PlotCanvas(self)
    2209         #define the function for drawing pointLabels
     2310        # define the function for drawing pointLabels
    22102311        self.client.SetPointLabelFunc(self.DrawPointLabel)
    22112312        # Create mouse event for showing cursor coords in status bar
    22122313        self.client.canvas.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
     
    22262327        """
    22272328        # ----------
    22282329        dc.SetPen(wx.Pen(wx.BLACK))
    2229         dc.SetBrush(wx.Brush( wx.BLACK, wx.SOLID ) )
    2230        
    2231         sx, sy = mDataDict["scaledXY"] #scaled x,y of closest point
    2232         dc.DrawRectangle( sx-5,sy-5, 10, 10)  #10by10 square centered on point
    2233         px,py = mDataDict["pointXY"]
     2330        dc.SetBrush(wx.Brush(wx.BLACK, wx.BRUSHSTYLE_SOLID))
     2331
     2332        sx, sy = mDataDict["scaledXY"]  # scaled x,y of closest point
     2333        # 10by10 square centered on point
     2334        dc.DrawRectangle(sx - 5, sy - 5, 10, 10)
     2335        px, py = mDataDict["pointXY"]
    22342336        cNum = mDataDict["curveNum"]
    22352337        pntIn = mDataDict["pIndex"]
    22362338        legend = mDataDict["legend"]
    2237         #make a string to display
    2238         s = "Crv# %i, '%s', Pt. (%.2f,%.2f), PtInd %i" %(cNum, legend, px, py, pntIn)
    2239         dc.DrawText(s, sx , sy+1)
     2339        # make a string to display
     2340        s = "Crv# %i, '%s', Pt. (%.2f,%.2f), PtInd %i" % (
     2341            cNum, legend, px, py, pntIn)
     2342        dc.DrawText(s, sx, sy + 1)
    22402343        # -----------
    22412344
    2242     def OnMouseLeftDown(self,event):
    2243         s= "Left Mouse Down at Point: (%.4f, %.4f)" % self.client._getXY(event)
     2345    def OnMouseLeftDown(self, event):
     2346        s = "Left Mouse Down at Point: (%.4f, %.4f)" % self.client._getXY(
     2347            event)
    22442348        self.SetStatusText(s)
    2245         event.Skip()            #allows plotCanvas OnMouseLeftDown to be called
     2349        event.Skip()  # allows plotCanvas OnMouseLeftDown to be called
    22462350
    22472351    def OnMotion(self, event):
    2248         #show closest point (when enbled)
     2352        # show closest point (when enbled)
    22492353        if self.client.GetEnablePointLabel() == True:
    2250             #make up dict with info for the pointLabel
    2251             #I've decided to mark the closest point on the closest curve
    2252             dlst= self.client.GetClosestPoint( self.client._getXY(event), pointScaled= True)
    2253             if dlst != []:    #returns [] if none
     2354            # make up dict with info for the pointLabel
     2355            # I've decided to mark the closest point on the closest curve
     2356            dlst = self.client.GetClosestPoint(
     2357                self.client._getXY(event), pointScaled=True)
     2358            if dlst != []:  # returns [] if none
    22542359                curveNum, legend, pIndex, pointXY, scaledXY, distance = dlst
    2255                 #make up dictionary to pass to my user function (see DrawPointLabel)
    2256                 mDataDict= {"curveNum":curveNum, "legend":legend, "pIndex":pIndex,\
    2257                             "pointXY":pointXY, "scaledXY":scaledXY}
    2258                 #pass dict to update the pointLabel
     2360                # make up dictionary to pass to my user function (see
     2361                # DrawPointLabel)
     2362                mDataDict = {"curveNum": curveNum, "legend": legend, "pIndex": pIndex,
     2363                             "pointXY": pointXY, "scaledXY": scaledXY}
     2364                # pass dict to update the pointLabel
    22592365                self.client.UpdatePointLabel(mDataDict)
    2260         event.Skip()           #go to next handler
     2366        event.Skip()  # go to next handler
    22612367
    22622368    def OnFilePageSetup(self, event):
    22632369        self.client.PageSetup()
    2264        
     2370
    22652371    def OnFilePrintPreview(self, event):
    22662372        self.client.PrintPreview()
    2267        
     2373
    22682374    def OnFilePrint(self, event):
    22692375        self.client.Printout()
    2270        
     2376
    22712377    def OnSaveFile(self, event):
    22722378        self.client.SaveFile()
    22732379
     
    22772383    def OnPlotDraw1(self, event):
    22782384        self.resetDefaults()
    22792385        self.client.Draw(_draw1Objects())
    2280    
     2386
    22812387    def OnPlotDraw2(self, event):
    22822388        self.resetDefaults()
    22832389        self.client.Draw(_draw2Objects())
    2284    
     2390
    22852391    def OnPlotDraw3(self, event):
    22862392        self.resetDefaults()
    2287         self.client.SetFont(wx.Font(10,wx.SCRIPT,wx.NORMAL,wx.NORMAL))
     2393        self.client.SetFont(
     2394            wx.Font(10, wx.FONTFAMILY_SCRIPT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
    22882395        self.client.SetFontSizeAxis(20)
    22892396        self.client.SetFontSizeLegend(12)
    22902397        self.client.SetXSpec('min')
     
    22932400
    22942401    def OnPlotDraw4(self, event):
    22952402        self.resetDefaults()
    2296         drawObj= _draw4Objects()
     2403        drawObj = _draw4Objects()
    22972404        self.client.Draw(drawObj)
    2298 ##        # profile
    2299 ##        start = _time.clock()           
    2300 ##        for x in range(10):
    2301 ##            self.client.Draw(drawObj)
    2302 ##        print "10 plots of Draw4 took: %f sec."%(_time.clock() - start)
    2303 ##        # profile end
     2405# profile
     2406##        start = _time.clock()
     2407# for x in range(10):
     2408# self.client.Draw(drawObj)
     2409##        print("10 plots of Draw4 took: %f sec."%(_time.clock() - start))
     2410# profile end
    23042411
    23052412    def OnPlotDraw5(self, event):
    23062413        # Empty plot with just axes
    23072414        self.resetDefaults()
    2308         drawObj= _draw5Objects()
     2415        drawObj = _draw5Objects()
    23092416        # make the axis X= (0,5), Y=(0,10)
    23102417        # (default with None is X= (-1,1), Y= (-1,1))
    2311         self.client.Draw(drawObj, xAxis= (0,5), yAxis= (0,10))
     2418        self.client.Draw(drawObj, xAxis=(0, 5), yAxis= (0, 10))
    23122419
    23132420    def OnPlotDraw6(self, event):
    2314         #Bar Graph Example
     2421        # Bar Graph Example
    23152422        self.resetDefaults()
    2316         #self.client.SetEnableLegend(True)   #turn on Legend
    2317         #self.client.SetEnableGrid(True)     #turn on Grid
    2318         self.client.SetXSpec('none')        #turns off x-axis scale
     2423        # self.client.SetEnableLegend(True)   #turn on Legend
     2424        # self.client.SetEnableGrid(True)     #turn on Grid
     2425        self.client.SetXSpec('none')  # turns off x-axis scale
    23192426        self.client.SetYSpec('auto')
    2320         self.client.Draw(_draw6Objects(), xAxis= (0,7))
     2427        self.client.Draw(_draw6Objects(), xAxis=(0, 7))
    23212428
    23222429    def OnPlotDraw7(self, event):
    2323         #log scale example
     2430        # log scale example
    23242431        self.resetDefaults()
    2325         self.client.setLogScale((True,True))
     2432        self.client.setLogScale((True, True))
    23262433        self.client.Draw(_draw7Objects())
    23272434
    2328     def OnPlotRedraw(self,event):
     2435    def OnPlotRedraw(self, event):
    23292436        self.client.Redraw()
    23302437
    2331     def OnPlotClear(self,event):
     2438    def OnPlotClear(self, event):
    23322439        self.client.Clear()
    2333        
     2440
    23342441    def OnPlotScale(self, event):
    23352442        if self.client.last_draw != None:
    2336             graphics, xAxis, yAxis= self.client.last_draw
    2337             self.client.Draw(graphics,(1,3.05),(0,1))
     2443            graphics, xAxis, yAxis = self.client.last_draw
     2444            self.client.Draw(graphics, (1, 3.05), (0, 1))
    23382445
    23392446    def OnEnableZoom(self, event):
    23402447        self.client.SetEnableZoom(event.IsChecked())
    23412448        self.mainmenu.Check(217, not event.IsChecked())
    2342        
     2449
    23432450    def OnEnableGrid(self, event):
    23442451        self.client.SetEnableGrid(event.IsChecked())
    2345        
     2452
    23462453    def OnEnableDrag(self, event):
    23472454        self.client.SetEnableDrag(event.IsChecked())
    23482455        self.mainmenu.Check(214, not event.IsChecked())
    2349        
     2456
    23502457    def OnEnableLegend(self, event):
    23512458        self.client.SetEnableLegend(event.IsChecked())
    23522459
     
    23642471
    23652472    def OnEnableDiagonals(self, event):
    23662473        self.client.SetEnableDiagonals(event.IsChecked())
    2367    
     2474
    23682475    def OnBackgroundGray(self, event):
    23692476        self.client.SetBackgroundColour("#CCCCCC")
    23702477        self.client.Redraw()
    2371    
     2478
    23722479    def OnBackgroundWhite(self, event):
    23732480        self.client.SetBackgroundColour("white")
    23742481        self.client.Redraw()
    2375    
     2482
    23762483    def OnForegroundRed(self, event):
    23772484        self.client.SetForegroundColour("red")
    23782485        self.client.Redraw()
     
    23832490
    23842491    def OnScrUp(self, event):
    23852492        self.client.ScrollUp(1)
    2386        
    2387     def OnScrRt(self,event):
     2493
     2494    def OnScrRt(self, event):
    23882495        self.client.ScrollRight(2)
    23892496
    2390     def OnReset(self,event):
     2497    def OnReset(self, event):
    23912498        self.client.Reset()
    23922499
    23932500    def OnHelpAbout(self, event):
     
    23972504
    23982505    def resetDefaults(self):
    23992506        """Just to reset the fonts back to the PlotCanvas defaults"""
    2400         self.client.SetFont(wx.Font(10,wx.SWISS,wx.NORMAL,wx.NORMAL))
     2507        self.client.SetFont(
     2508            wx.Font(10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
    24012509        self.client.SetFontSizeAxis(10)
    24022510        self.client.SetFontSizeLegend(7)
    2403         self.client.setLogScale((False,False))
     2511        self.client.setLogScale((False, False))
    24042512        self.client.SetXSpec('auto')
    24052513        self.client.SetYSpec('auto')
    2406        
    2407        
    24082514
     2515
    24092516def __test():
    24102517
    24112518    class MyApp(wx.App):
     2519
    24122520        def OnInit(self):
    24132521            wx.InitAllImageHandlers()
    24142522            frame = TestFrame(None, -1, "PlotCanvas")
    2415             #frame.Show(True)
     2523            # frame.Show(True)
    24162524            self.SetTopWindow(frame)
    24172525            return True
    24182526
    2419 
    24202527    app = MyApp(0)
    24212528    app.MainLoop()
    24222529