Ticket #16590: phoenix-plot.py.patch

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

phoenix branch

  • wx/lib/plot.py

     
    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
     
    126126    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)
    147147        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
    151152
    152153    def setLogScale(self, logscale):
     
    154155
    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]:
     
    167168            raise AttributeError(name)
    168169
    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
    195196
    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]
    218219
    219220
    220221class PolyLine(PolyPoints):
     222
    221223    """Class to define line type and style
    222224        - All methods except __init__ are private.
    223225    """
     
    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):
    252254            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    """
     
    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):
    300304            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    """
     
    350356
    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]
     
    365371
    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))
     423        dc.DrawPolygonList(poly.astype(np.int32))
    416424
    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]:
     451        if type(objects) not in [list, tuple]:
    442452            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:
     
    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
     490        self.yLabel = yLabel
    480491
    481     def setTitle(self, title= ''):
     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
     
    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
    514525
    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
    521532
    522533    def __len__(self):
     
    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
     
    542554
    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))
     567        sizer.Add((0, 0))
    556568
    557569        sizer.AddGrowableRow(0, 1)
    558570        sizer.AddGrowableCol(0, 1)
     
    563575        self.SetSizer(sizer)
    564576        self.Fit()
    565577
    566         self.border = (1,1)
     578        self.border = (1, 1)
    567579
    568580        self.SetBackgroundColour("white")
    569581
     
    589601
    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
     
    602614        self._sb_yunit = 0
    603615
    604616        self._dragEnabled = False
    605         self._screenCoordinates = _Numeric.array([0.0, 0.0])
     617        self._screenCoordinates = np.array([0.0, 0.0])
    606618
    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
     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
    616628
    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
    628640
    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
    646659
     
    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
    659672        self._gridColour = wx.BLACK
    660673
     
    670683        else:
    671684            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.
     
    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(
    708721                    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()
    760775
     
    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):
     
    776792        printout2 = PlotPrintout(self)
    777793        self.preview = wx.PrintPreview(printout, printout2, self.print_data)
    778794        if not self.preview.IsOk():
    779             wx.MessageDialog(self, "Print Preview failed.\n" \
    780                                "Check that default printer is configured\n", \
    781                                "Print error", wx.OK|wx.CENTRE).ShowModal()
     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')
     
    805822    def getLogScale(self):
    806823        return self._logscale
    807824
    808     def SetFontSizeAxis(self, point= 10):
     825    def SetFontSizeAxis(self, point=10):
    809826        """Set the tick and axis label font size (default is 10 point)"""
    810         self._fontSizeAxis= point
     827        self._fontSizeAxis = point
    811828
    812829    def GetFontSizeAxis(self):
    813830        """Get current tick and axis label font size in points"""
    814831        return self._fontSizeAxis
    815832
    816     def SetFontSizeTitle(self, point= 15):
     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
    823840
    824     def SetFontSizeLegend(self, point= 7):
     841    def SetFontSizeLegend(self, point=7):
    825842        """Set Legend font size (default is 7 point)"""
    826         self._fontSizeLegend= point
     843        self._fontSizeLegend = point
    827844
    828845    def GetFontSizeLegend(self):
    829846        """Get current Legend font size in points"""
     
    831848
    832849    def SetShowScrollbars(self, value):
    833850        """Set True to show scrollbars"""
    834         if value not in [True,False]:
     851        if value not in [True, False]:
    835852            raise TypeError("Value should be True or False")
    836853        if value == self.GetShowScrollbars():
    837854            return
     
    867884
    868885    def SetEnableDrag(self, value):
    869886        """Set True to enable drag."""
    870         if value not in [True,False]:
     887        if value not in [True, False]:
    871888            raise TypeError("Value should be True or False")
    872889        if value:
    873890            if self.GetEnableZoom():
     
    882899
    883900    def SetEnableZoom(self, value):
    884901        """Set True to enable zooming."""
    885         if value not in [True,False]:
     902        if value not in [True, False]:
    886903            raise TypeError("Value should be True or False")
    887904        if value:
    888905            if self.GetEnableDrag():
     
    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):
     
    921940    def SetEnableDiagonals(self, value):
    922941        """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]:
     955        if value not in [True, False]:
    936956            raise TypeError("Value should be True or False")
    937         self._legendEnabled= value
     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]:
     966        if value not in [True, False]:
    947967            raise TypeError("Value should be True or False")
    948         self._titleEnabled= value
     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]:
     977        if value not in [True, False]:
    958978            raise TypeError("Value should be True or False")
    959         self._pointLabelEnabled= value
    960         self.Redraw()  #will erase existing pointLabel if present
     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])
    9821002
    9831003    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
     1025            y = np.power(10, y)
     1026        return x, y
    10071027
    1008     def _getXY(self,event):
     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
     1035        userPos = np.array(pntXY)
     1036        x, y = userPos * self._pointScale + self._pointShift
     1037        return x, y
    10181038
    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
     1041        screenPos = np.array(pntXY)
     1042        x, y = (screenPos - self._pointShift) / self._pointScale
     1043        return x, y
    10241044
    1025     def SetXSpec(self, type= 'auto'):
     1045    def SetXSpec(self, type='auto'):
    10261046        """xSpec- defines x axis type. Can be 'none', 'min' or 'auto'
    10271047        where:
    10281048
     
    10311051        * 'auto' - rounds axis range to sensible values
    10321052        * <number> - like 'min', but with <number> tick marks
    10331053        """
    1034         self._xSpec= type
     1054        self._xSpec = type
    10351055
    1036     def SetYSpec(self, type= 'auto'):
     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"""
     
    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):
     
    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"""
    11031123
    11041124        graphics.setLogScale(self.getLogScale())
    11051125
    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)))
     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)))
    11111133
    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)
    11241146
    1125     def _Draw(self, graphics, xAxis = None, yAxis = None, dc = None):
     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
     
    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
    11641190
    11651191        dc.SetTextForeground(self.GetForegroundColour())
     
    11701196        # set font size for every thing but title and legend
    11711197        dc.SetFont(self._getFont(self._fontSizeAxis))
    11721198
    1173         # 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
    11741201        if xAxis == None or yAxis == None:
    11751202            # One or both axis not specified in Draw
    11761203            p1, p2 = graphics.boundingBox()     # min, max points of graphics
    11771204            if xAxis == None:
    1178                 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
    11791207            if yAxis == None:
    11801208                yAxis = self._axisInterval(self._ySpec, p1[1], p2[1])
    11811209            # Adjust bounding box for axis spec
    1182             p1[0],p1[1] = xAxis[0], yAxis[0]     # lower left corner user scale (xmin,ymin)
    1183             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]
    11841214        else:
    11851215            # Both axis specified in Draw
    1186             p1= _Numeric.array([xAxis[0], yAxis[0]])    # lower left corner user scale (xmin,ymin)
    1187             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]])
    11881220
    1189         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))
    11901223
    11911224        # Get ticks and textExtents for axis if required
    11921225        if self._xSpec is not 'none':
    11931226            xticks = self._xticks(xAxis[0], xAxis[1])
    1194             xTextExtent = dc.GetTextExtent(xticks[-1][1])# w h of x axis text last number on axis
    11951227        else:
    11961228            xticks = None
    1197             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
    11981234        if self._ySpec is not 'none':
    11991235            yticks = self._yticks(yAxis[0], yAxis[1])
     1236        else:
     1237            yticks = None
     1238        if yticks:
    12001239            if self.getLogScale()[1]:
    12011240                yTextExtent = dc.GetTextExtent('-2e-2')
    12021241            else:
    12031242                yTextExtentBottom = dc.GetTextExtent(yticks[0][1])
    12041243                yTextExtentTop = dc.GetTextExtent(yticks[-1][1])
    1205                 yTextExtent= (max(yTextExtentBottom[0],yTextExtentTop[0]),
    1206                               max(yTextExtentBottom[1],yTextExtentTop[1]))
     1244                yTextExtent = (max(yTextExtentBottom[0], yTextExtentTop[0]),
     1245                               max(yTextExtentBottom[1], yTextExtentTop[1]))
    12071246        else:
    12081247            yticks = None
    1209             yTextExtent= (0,0) # No text for ticks
     1248            yTextExtent = (0, 0) # No text for ticks
    12101249
    12111250        # TextExtents for Title and Axis Labels
    1212         titleWH, xLabelWH, yLabelWH= self._titleLablesWH(dc, graphics)
     1251        titleWH, xLabelWH, yLabelWH = self._titleLablesWH(dc, graphics)
    12131252
    12141253        # TextExtents for Legend
    12151254        legendBoxWH, legendSymExt, legendTextExt = self._legendWH(dc, graphics)
    12161255
    12171256        # room around graph area
    1218         rhsW= max(xTextExtent[0], legendBoxWH[0])+5*self._pointSize[0] # use larger of number width or legend width
    1219         lhsW= yTextExtent[0]+ yLabelWH[1] + 3*self._pointSize[0]
    1220         bottomH= max(xTextExtent[1], yTextExtent[1]/2.)+ xLabelWH[1] + 2*self._pointSize[1]
    1221         topH= yTextExtent[1]/2. + titleWH[1]
    1222         textSize_scale= _Numeric.array([rhsW+lhsW,bottomH+topH]) # make plot area smaller by text size
    1223         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])
    12241267
    12251268        # draw title if requested
    12261269        if self._titleEnabled:
    12271270            dc.SetFont(self._getFont(self._fontSizeTitle))
    1228             titlePos= (self.plotbox_origin[0]+ lhsW + (self.plotbox_size[0]-lhsW-rhsW)/2.- titleWH[0]/2.,
    1229                        self.plotbox_origin[1]- self.plotbox_size[1])
    1230             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])
    12311274
    12321275        # draw label text
    12331276        dc.SetFont(self._getFont(self._fontSizeAxis))
    1234         xLabelPos= (self.plotbox_origin[0]+ lhsW + (self.plotbox_size[0]-lhsW-rhsW)/2.- xLabelWH[0]/2.,
    1235                  self.plotbox_origin[1]- xLabelWH[1])
    1236         dc.DrawText(graphics.getXLabel(),xLabelPos[0],xLabelPos[1])
    1237         yLabelPos= (self.plotbox_origin[0] - 3*self._pointSize[0],
    1238                  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.)
    12391282        if graphics.getYLabel():  # bug fix for Linux
    1240             dc.DrawRotatedText(graphics.getYLabel(),yLabelPos[0],yLabelPos[1],90)
     1283            dc.DrawRotatedText(
     1284                graphics.getYLabel(), yLabelPos[0], yLabelPos[1], 90)
    12411285
    12421286        # drawing legend makers and text
    12431287        if self._legendEnabled:
    1244             self._drawLegend(dc,graphics,rhsW,topH,legendBoxWH, legendSymExt, legendTextExt)
     1288            self._drawLegend(
     1289                dc, graphics, rhsW, topH, legendBoxWH, legendSymExt, legendTextExt)
    12451290
    12461291        # allow for scaling and shifting plotted points
    1247         scale = (self.plotbox_size-textSize_scale) / (p2-p1)* _Numeric.array((1,-1))
    1248         shift = -p1*scale + self.plotbox_origin + textSize_shift * _Numeric.array((1,-1))
    1249         self._pointScale= scale / self._pointSize  # make available for mouse events
    1250         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
    12511299        self._drawAxes(dc, p1, p2, scale, shift, xticks, yticks)
    12521300
    12531301        graphics.scaleAndShift(scale, shift)
    1254         graphics.setPrinterScale(self.printerScale)  # thicken up lines and markers if printing
     1302        # thicken up lines and markers if printing
     1303        graphics.setPrinterScale(self.printerScale)
    12551304
    12561305        # set clipping area so drawing does not occur outside axis box
    1257         ptx,pty,rectWidth,rectHeight= self._point2ClientCoord(p1, p2)
     1306        ptx, pty, rectWidth, rectHeight = self._point2ClientCoord(p1, p2)
    12581307        # allow graph to overlap axis lines by adding units to width and height
    1259         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)
    12601310        # Draw the lines and markers
    12611311        #start = _time.clock()
    12621312        graphics.draw(dc)
     
    12691319    def Redraw(self, dc=None):
    12701320        """Redraw the existing plot."""
    12711321        if self.last_draw is not None:
    1272             graphics, xAxis, yAxis= self.last_draw
    1273             self._Draw(graphics,xAxis,yAxis,dc)
     1322            graphics, xAxis, yAxis = self.last_draw
     1323            self._Draw(graphics, xAxis, yAxis, dc)
    12741324
    12751325    def Clear(self):
    12761326        """Erase the window."""
    1277         self.last_PointLabel = None        #reset pointLabel
     1327        self.last_PointLabel = None  # reset pointLabel
    12781328        dc = wx.BufferedDC(wx.ClientDC(self.canvas), self._Buffer)
    12791329        bbr = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
    12801330        dc.SetBackground(bbr)
     
    12941344            Centers on the X,Y coords given in Center
    12951345            Zooms by the Ratio = (Xratio, Yratio) given
    12961346        """
    1297         self.last_PointLabel = None   #reset maker
    1298         x,y = Center
     1347        self.last_PointLabel = None  # reset maker
     1348        x, y = Center
    12991349        if self.last_draw != None:
    13001350            (graphics, xAxis, yAxis) = self.last_draw
    13011351            w = (xAxis[1] - xAxis[0]) * Ratio[0]
    13021352            h = (yAxis[1] - yAxis[0]) * Ratio[1]
    1303             xAxis = ( x - w/2, x + w/2 )
    1304             yAxis = ( y - h/2, y + h/2 )
     1353            xAxis = (x - w / 2, x + w / 2)
     1354            yAxis = (y - h / 2, y + h / 2)
    13051355            self._Draw(graphics, xAxis, yAxis)
    13061356
    1307     def GetClosestPoints(self, pntXY, pointScaled= True):
     1357    def GetClosestPoints(self, pntXY, pointScaled=True):
    13081358        """Returns list with
    13091359            [curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    13101360            list for each curve.
     
    13151365            if pointScaled == False based on user coords
    13161366        """
    13171367        if self.last_draw == None:
    1318             #no graph available
     1368            # no graph available
    13191369            return []
    1320         graphics, xAxis, yAxis= self.last_draw
     1370        graphics, xAxis, yAxis = self.last_draw
    13211371        l = []
    1322         for curveNum,obj in enumerate(graphics):
    1323             #check there are points in the curve
     1372        for curveNum, obj in enumerate(graphics):
     1373            # check there are points in the curve
    13241374            if len(obj.points) == 0:
    1325                 continue  #go to next obj
     1375                continue  # go to next obj
    13261376            #[curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    1327             cn = [curveNum]+ [obj.getLegend()]+ obj.getClosestPoint( pntXY, pointScaled)
     1377            cn = [curveNum] + \
     1378                [obj.getLegend()] + obj.getClosestPoint(pntXY, pointScaled)
    13281379            l.append(cn)
    13291380        return l
    13301381
    1331     def GetClosestPoint(self, pntXY, pointScaled= True):
     1382    def GetClosestPoint(self, pntXY, pointScaled=True):
    13321383        """Returns list with
    13331384            [curveNumber, legend, index of closest point, pointXY, scaledXY, distance]
    13341385            list for only the closest curve.
     
    13381389            if pointScaled == True based on screen coords
    13391390            if pointScaled == False based on user coords
    13401391        """
    1341         #closest points on screen based on screen scaling (pointScaled= True)
    1342         #list [curveNumber, index, pointXY, scaledXY, distance] for each curve
    1343         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)
    13441395        if closestPts == []:
    1345             return []  #no graph present
    1346         #find one with least distance
     1396            return []  # no graph present
     1397        # find one with least distance
    13471398        dists = [c[-1] for c in closestPts]
    1348         mdist = min(dists)  #Min dist
    1349         i = dists.index(mdist)  #index for min dist
    1350         return closestPts[i]  #this is the closest point on closest curve
     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
    13511402
    13521403    GetClosetPoint = GetClosestPoint
    13531404
     
    13641415            onMotion events etc.
    13651416        """
    13661417        if self.last_PointLabel != None:
    1367             #compare pointXY
    1368             if _Numeric.sometrue(mDataDict["pointXY"] != self.last_PointLabel["pointXY"]):
    1369                 #closest changed
    1370                 self._drawPointLabel(self.last_PointLabel) #erase old
    1371                 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
    13721423        else:
    1373             #just plot new with no erase
    1374             self._drawPointLabel(mDataDict) #plot new
    1375         #save for next erase
     1424            # just plot new with no erase
     1425            self._drawPointLabel(mDataDict)  # plot new
     1426        # save for next erase
    13761427        self.last_PointLabel = mDataDict
    13771428
    13781429    # event handlers **********************************
     
    13791430    def OnMotion(self, event):
    13801431        if self._zoomEnabled and event.LeftIsDown():
    13811432            if self._hasDragged:
    1382                 self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # remove old
     1433                self._drawRubberBand(
     1434                    self._zoomCorner1, self._zoomCorner2)  # remove old
    13831435            else:
    1384                 self._hasDragged= True
     1436                self._hasDragged = True
    13851437            self._zoomCorner2[0], self._zoomCorner2[1] = self._getXY(event)
    1386             self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # add new
     1438            self._drawRubberBand(
     1439                self._zoomCorner1, self._zoomCorner2)  # add new
    13871440        elif self._dragEnabled and event.LeftIsDown():
    13881441            coordinates = event.GetPosition()
    1389             newpos, oldpos = map(_Numeric.array, map(self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
    1390             dist = newpos-oldpos
     1442            newpos, oldpos = map(np.array, map(
     1443                self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
     1444            dist = newpos - oldpos
    13911445            self._screenCoordinates = coordinates
    13921446
    13931447            if self.last_draw is not None:
    1394                 graphics, xAxis, yAxis= self.last_draw
     1448                graphics, xAxis, yAxis = self.last_draw
    13951449                yAxis -= dist[1]
    13961450                xAxis -= dist[0]
    1397                 self._Draw(graphics,xAxis,yAxis)
     1451                self._Draw(graphics, xAxis, yAxis)
    13981452
    1399     def OnMouseLeftDown(self,event):
    1400         self._zoomCorner1[0], self._zoomCorner1[1]= self._getXY(event)
    1401         self._screenCoordinates = _Numeric.array(event.GetPosition())
     1453    def OnMouseLeftDown(self, event):
     1454        self._zoomCorner1[0], self._zoomCorner1[1] = self._getXY(event)
     1455        self._screenCoordinates = np.array(event.GetPosition())
    14021456        if self._dragEnabled:
    14031457            self.SetCursor(self.GrabHandCursor)
    14041458            self.canvas.CaptureMouse()
     
    14061460    def OnMouseLeftUp(self, event):
    14071461        if self._zoomEnabled:
    14081462            if self._hasDragged == True:
    1409                 self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # remove old
    1410                 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)
    14111466                self._hasDragged = False  # reset flag
    1412                 minX, minY= _Numeric.minimum( self._zoomCorner1, self._zoomCorner2)
    1413                 maxX, maxY= _Numeric.maximum( self._zoomCorner1, self._zoomCorner2)
    1414                 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
    14151470                if self.last_draw != None:
    1416                     self._Draw(self.last_draw[0], xAxis = (minX,maxX), yAxis = (minY,maxY), dc = None)
    1417             #else: # A box has not been drawn, zoom in on a point
    1418             ## 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.
    14191475            #    X,Y = self._getXY(event)
    14201476            #    self.Zoom( (X,Y), (self._zoomInFactor,self._zoomInFactor) )
    14211477        if self._dragEnabled:
     
    14231479            if self.canvas.HasCapture():
    14241480                self.canvas.ReleaseMouse()
    14251481
    1426     def OnMouseDoubleClick(self,event):
     1482    def OnMouseDoubleClick(self, event):
    14271483        if self._zoomEnabled:
    14281484            # Give a little time for the click to be totally finished
    14291485            # before (possibly) removing the scrollbars and trigering
    14301486            # size events, etc.
    1431             wx.CallLater(200,self.Reset)
     1487            wx.CallLater(200, self.Reset)
    14321488
    1433     def OnMouseRightDown(self,event):
     1489    def OnMouseRightDown(self, event):
    14341490        if self._zoomEnabled:
    1435             X,Y = self._getXY(event)
    1436             self.Zoom( (X,Y), (self._zoomOutFactor, self._zoomOutFactor) )
     1491            X, Y = self._getXY(event)
     1492            self.Zoom((X, Y), (self._zoomOutFactor, self._zoomOutFactor))
    14371493
    14381494    def OnPaint(self, event):
    14391495        # All that is needed here is to draw the buffer to screen
    14401496        if self.last_PointLabel != None:
    1441             self._drawPointLabel(self.last_PointLabel) #erase old
     1497            self._drawPointLabel(self.last_PointLabel)  # erase old
    14421498            self.last_PointLabel = None
    14431499        dc = wx.BufferedPaintDC(self.canvas, self._Buffer)
    14441500        if self._antiAliasingEnabled:
     
    14471503            except Exception:
    14481504                pass
    14491505
    1450     def OnSize(self,event):
     1506    def OnSize(self, event):
    14511507        # The Buffer init is done here, to make sure the buffer is always
    14521508        # the same size as the Window
    1453         Size  = self.canvas.GetClientSize()
     1509        Size = self.canvas.GetClientSize()
    14541510        Size.width = max(1, Size.width)
    14551511        Size.height = max(1, Size.height)
    14561512
     
    14601516        self._Buffer = wx.Bitmap(Size.width, Size.height)
    14611517        self._setSize()
    14621518
    1463         self.last_PointLabel = None        #reset pointLabel
     1519        self.last_PointLabel = None  # reset pointLabel
    14641520
    14651521        if self.last_draw is None:
    14661522            self.Clear()
    14671523        else:
    14681524            graphics, xSpec, ySpec = self.last_draw
    1469             self._Draw(graphics,xSpec,ySpec)
     1525            self._Draw(graphics, xSpec, ySpec)
    14701526
    14711527    def OnLeave(self, event):
    14721528        """Used to erase pointLabel when mouse outside window"""
    14731529        if self.last_PointLabel != None:
    1474             self._drawPointLabel(self.last_PointLabel) #erase old
     1530            self._drawPointLabel(self.last_PointLabel)  # erase old
    14751531            self.last_PointLabel = None
    14761532
    14771533    def OnScroll(self, evt):
     
    14801536            sbpos = evt.GetPosition()
    14811537
    14821538            if evt.GetOrientation() == wx.VERTICAL:
    1483                 fullrange,pagesize = self.sb_vert.GetRange(),self.sb_vert.GetPageSize()
    1484                 sbpos = fullrange-pagesize-sbpos
    1485                 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)
    14861544                self.ScrollUp(dist)
    14871545
    14881546            if evt.GetOrientation() == wx.HORIZONTAL:
    1489                 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])
    14901549                self.ScrollRight(dist)
    14911550
    14921551    # Private Methods **************************************************
     
    14931552    def _setSize(self, width=None, height=None):
    14941553        """DC width and height."""
    14951554        if width == None:
    1496             (self.width,self.height) = self.canvas.GetClientSize()
     1555            (self.width, self.height) = self.canvas.GetClientSize()
    14971556        else:
    1498             self.width, self.height= width,height
    1499         self.width *= self._pointSize[0] # high precision
    1500         self.height *= self._pointSize[1] # high precision
    1501         self.plotbox_size = 0.97*_Numeric.array([self.width, self.height])
    1502         xo = 0.5*(self.width-self.plotbox_size[0])
    1503         yo = self.height-0.5*(self.height-self.plotbox_size[1])
    1504         self.plotbox_origin = _Numeric.array([xo, yo])
     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])
    15051564
    15061565    def _setPrinterScale(self, scale):
    15071566        """Used to thicken lines and increase marker size for print out."""
    15081567        # line thickness on printer is very thin at 600 dot/in. Markers small
    1509         self.printerScale= scale
     1568        self.printerScale = scale
    15101569
    15111570    def _printDraw(self, printDC):
    15121571        """Used for printing."""
    15131572        if self.last_draw != None:
    1514             graphics, xSpec, ySpec= self.last_draw
    1515             self._Draw(graphics,xSpec,ySpec,printDC)
     1573            graphics, xSpec, ySpec = self.last_draw
     1574            self._Draw(graphics, xSpec, ySpec, printDC)
    15161575
    15171576    def _drawPointLabel(self, mDataDict):
    15181577        """Draws and erases pointLabels"""
     
    15191578        width = self._Buffer.GetWidth()
    15201579        height = self._Buffer.GetHeight()
    15211580        if sys.platform != "darwin":
    1522             tmp_Buffer = wx.Bitmap(width,height)
     1581            tmp_Buffer = wx.Bitmap(width, height)
    15231582            dcs = wx.MemoryDC()
    15241583            dcs.SelectObject(tmp_Buffer)
    15251584            dcs.Clear()
     
    15261585        else:
    15271586            tmp_Buffer = self._Buffer.GetSubBitmap((0, 0, width, height))
    15281587            dcs = wx.MemoryDC(self._Buffer)
    1529         self._pointLabelFunc(dcs,mDataDict)  #custom user pointLabel function
     1588        self._pointLabelFunc(dcs, mDataDict)  # custom user pointLabel function
    15301589
    1531         dc = wx.ClientDC( self.canvas )
    1532         #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
    15331593        dc.Blit(0, 0, width, height, dcs, 0, 0, self._logicalFunction)
    15341594        if sys.platform == "darwin":
    15351595            self._Buffer = tmp_Buffer
    15361596
    1537 
    1538     def _drawLegend(self,dc,graphics,rhsW,topH,legendBoxWH, legendSymExt, legendTextExt):
     1597    def _drawLegend(self, dc, graphics, rhsW, topH, legendBoxWH, legendSymExt, legendTextExt):
    15391598        """Draws legend symbols and text"""
    15401599        # top right hand corner of graph box is ref corner
    1541         trhc= self.plotbox_origin+ (self.plotbox_size-[rhsW,topH])*[1,-1]
    1542         legendLHS= .091* legendBoxWH[0]  # border space between legend sym and graph box
    1543         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
    15441606        dc.SetFont(self._getFont(self._fontSizeLegend))
    15451607        for i in range(len(graphics)):
    15461608            o = graphics[i]
    1547             s= i*lineHeight
    1548             if isinstance(o,PolyMarker):
     1609            s = i * lineHeight
     1610            if isinstance(o, PolyMarker):
    15491611                # draw marker with legend
    1550                 pnt= (trhc[0]+legendLHS+legendSymExt[0]/2., trhc[1]+s+lineHeight/2.)
    1551                 o.draw(dc, self.printerScale, coord= _Numeric.array([pnt]))
    1552             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):
    15531616                # draw line with legend
    1554                 pnt1= (trhc[0]+legendLHS, trhc[1]+s+lineHeight/2.)
    1555                 pnt2= (trhc[0]+legendLHS+legendSymExt[0], trhc[1]+s+lineHeight/2.)
    1556                 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]))
    15571621            else:
    1558                 raise TypeError("object is neither PolyMarker or PolyLine instance")
     1622                raise TypeError(
     1623                    "object is neither PolyMarker or PolyLine instance")
    15591624            # draw legend txt
    1560             pnt= (trhc[0]+legendLHS+legendSymExt[0]+5*self._pointSize[0], trhc[1]+s+lineHeight/2.-legendTextExt[1]/2)
    1561             dc.DrawText(o.getLegend(),pnt[0],pnt[1])
    1562         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
    15631629
    15641630    def _titleLablesWH(self, dc, graphics):
    15651631        """Draws Title and labels and returns width and height for each"""
     
    15661632        # TextExtents for Title and Axis Labels
    15671633        dc.SetFont(self._getFont(self._fontSizeTitle))
    15681634        if self._titleEnabled:
    1569             title= graphics.getTitle()
    1570             titleWH= dc.GetTextExtent(title)
     1635            title = graphics.getTitle()
     1636            titleWH = dc.GetTextExtent(title)
    15711637        else:
    1572             titleWH= (0,0)
     1638            titleWH = (0, 0)
    15731639        dc.SetFont(self._getFont(self._fontSizeAxis))
    1574         xLabel, yLabel= graphics.getXLabel(),graphics.getYLabel()
    1575         xLabelWH= dc.GetTextExtent(xLabel)
    1576         yLabelWH= dc.GetTextExtent(yLabel)
     1640        xLabel, yLabel = graphics.getXLabel(), graphics.getYLabel()
     1641        xLabelWH = dc.GetTextExtent(xLabel)
     1642        yLabelWH = dc.GetTextExtent(yLabel)
    15771643        return titleWH, xLabelWH, yLabelWH
    15781644
    15791645    def _legendWH(self, dc, graphics):
    15801646        """Returns the size in screen units for legend box"""
    15811647        if self._legendEnabled != True:
    1582             legendBoxWH= symExt= txtExt= (0,0)
     1648            legendBoxWH = symExt = txtExt = (0, 0)
    15831649        else:
    15841650            # find max symbol size
    1585             symExt= graphics.getSymExtent(self.printerScale)
     1651            symExt = graphics.getSymExtent(self.printerScale)
    15861652            # find max legend text extent
    15871653            dc.SetFont(self._getFont(self._fontSizeLegend))
    1588             txtList= graphics.getLegendNames()
    1589             txtExt= dc.GetTextExtent(txtList[0])
     1654            txtList = graphics.getLegendNames()
     1655            txtExt = dc.GetTextExtent(txtList[0])
    15901656            for txt in graphics.getLegendNames()[1:]:
    1591                 txtExt= _Numeric.maximum(txtExt,dc.GetTextExtent(txt))
    1592             maxW= symExt[0]+txtExt[0]
    1593             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])
    15941660            # padding .1 for lhs of legend box and space between lines
    1595             maxW= maxW* 1.1
    1596             maxH= maxH* 1.1 * len(txtList)
     1661            maxW = maxW * 1.1
     1662            maxH = maxH * 1.1 * len(txtList)
    15971663            dc.SetFont(self._getFont(self._fontSizeAxis))
    1598             legendBoxWH= (maxW,maxH)
     1664            legendBoxWH = (maxW, maxH)
    15991665        return (legendBoxWH, symExt, txtExt)
    16001666
    16011667    def _drawRubberBand(self, corner1, corner2):
    16021668        """Draws/erases rect box from corner1 to corner2"""
    1603         ptx,pty,rectWidth,rectHeight= self._point2ClientCoord(corner1, corner2)
     1669        ptx, pty, rectWidth, rectHeight = self._point2ClientCoord(
     1670            corner1, corner2)
    16041671        # draw rectangle
    1605         dc = wx.ClientDC( self.canvas )
     1672        dc = wx.ClientDC(self.canvas)
    16061673        dc.SetPen(wx.Pen(wx.BLACK))
    1607         dc.SetBrush(wx.Brush( wx.WHITE, wx.BRUSHSTYLE_TRANSPARENT ) )
     1674        dc.SetBrush(wx.Brush(wx.WHITE, wx.BRUSHSTYLE_TRANSPARENT))
    16081675        dc.SetLogicalFunction(wx.INVERT)
    1609         dc.DrawRectangle( ptx,pty, rectWidth,rectHeight)
     1676        dc.DrawRectangle(ptx, pty, rectWidth, rectHeight)
    16101677        dc.SetLogicalFunction(wx.COPY)
    16111678
    1612     def _getFont(self,size):
     1679    def _getFont(self, size):
    16131680        """Take font size, adjusts if printing and returns wx.Font"""
    1614         s = size*self.printerScale*self._fontScale
     1681        s = size * self.printerScale * self._fontScale
    16151682        of = self.GetFont()
    16161683        # Linux speed up to get font from cache rather than X font server
    1617         key = (int(s), of.GetFamily (), of.GetStyle (), of.GetWeight ())
    1618         font = self._fontCache.get (key, None)
     1684        key = (int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
     1685        font = self._fontCache.get(key, None)
    16191686        if font:
    16201687            return font                 # yeah! cache hit
    16211688        else:
    1622             font =  wx.Font(int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
     1689            font = wx.Font(
     1690                int(s), of.GetFamily(), of.GetStyle(), of.GetWeight())
    16231691            self._fontCache[key] = font
    16241692            return font
    16251693
    1626 
    16271694    def _point2ClientCoord(self, corner1, corner2):
    16281695        """Converts user point coords to client screen int coords x,y,width,height"""
    1629         c1= _Numeric.array(corner1)
    1630         c2= _Numeric.array(corner2)
     1696        c1 = np.array(corner1)
     1697        c2 = np.array(corner2)
    16311698        # convert to screen coords
    1632         pt1= c1*self._pointScale+self._pointShift
    1633         pt2= c2*self._pointScale+self._pointShift
     1699        pt1 = c1 * self._pointScale + self._pointShift
     1700        pt2 = c2 * self._pointScale + self._pointShift
    16341701        # make height and width positive
    1635         pul= _Numeric.minimum(pt1,pt2) # Upper left corner
    1636         plr= _Numeric.maximum(pt1,pt2) # Lower right corner
    1637         rectWidth, rectHeight= plr-pul
    1638         ptx,pty= pul
     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
    16391706        return ptx, pty, rectWidth, rectHeight
    16401707
    16411708    def _axisInterval(self, spec, lower, upper):
     
    16421709        """Returns sensible axis range for given spec"""
    16431710        if spec == 'none' or spec == 'min' or isinstance(spec, (float, int)):
    16441711            if lower == upper:
    1645                 return lower-0.5, upper+0.5
     1712                return lower - 0.5, upper + 0.5
    16461713            else:
    16471714                return lower, upper
    16481715        elif spec == 'auto':
    1649             range = upper-lower
     1716            range = upper - lower
    16501717            if range == 0.:
    1651                 return lower-0.5, upper+0.5
    1652             log = _Numeric.log10(range)
    1653             power = _Numeric.floor(log)
    1654             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
    16551722            if fraction <= 0.05:
    1656                 power = power-1
    1657             grid = 10.**power
     1723                power = power - 1
     1724            grid = 10. ** power
    16581725            lower = lower - lower % grid
    16591726            mod = upper % grid
    16601727            if mod != 0:
     
    16711738
    16721739    def _drawAxes(self, dc, p1, p2, scale, shift, xticks, yticks):
    16731740
    1674         penWidth= self.printerScale * self._pointSize[0]        # increases thickness for printing only
     1741        # increases thickness for printing only
     1742        penWidth = self.printerScale * self._pointSize[0]
    16751743        dc.SetPen(wx.Pen(self._gridColour, penWidth))
    16761744
    16771745        # set length of tick marks--long ones make grid
    16781746        if self._gridEnabled:
    1679             x,y,width,height= self._point2ClientCoord(p1,p2)
     1747            x, y, width, height = self._point2ClientCoord(p1, p2)
    16801748            if self._gridEnabled == 'Horizontal':
    1681                 yTickLength= (width/2.0 +1) * self._pointSize[1]
    1682                 xTickLength= 3 * self.printerScale * self._pointSize[0]
     1749                yTickLength = (width / 2.0 + 1) * self._pointSize[1]
     1750                xTickLength = 3 * self.printerScale * self._pointSize[0]
    16831751            elif self._gridEnabled == 'Vertical':
    1684                 yTickLength= 3 * self.printerScale * self._pointSize[1]
    1685                 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]
    16861754            else:
    1687                 yTickLength= (width/2.0 +1) * self._pointSize[1]
    1688                 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]
    16891757        else:
    1690             yTickLength= 3 * self.printerScale * self._pointSize[1]  # lengthens lines for printing
    1691             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]
    16921761
    16931762        if self._xSpec is not 'none':
    1694             lower, upper = p1[0],p2[0]
     1763            lower, upper = p1[0], p2[0]
    16951764            text = 1
    1696             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)]:
    16971767                for x, label in xticks:
    1698                     pt = scale*_Numeric.array([x, y])+shift
    1699                     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)
    17001771                    if text:
    1701                         dc.DrawText(label,pt[0],pt[1]+2*self._pointSize[1])
    1702                 a1 = scale*_Numeric.array([lower, y])+shift
    1703                 a2 = scale*_Numeric.array([upper, y])+shift
    1704                 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])
    17051778                text = 0  # axis values not drawn on top side
    17061779
    17071780        if self._ySpec is not 'none':
    1708             lower, upper = p1[1],p2[1]
     1781            lower, upper = p1[1], p2[1]
    17091782            text = 1
    17101783            h = dc.GetCharHeight()
    17111784            for x, d in [(p1[0], -yTickLength), (p2[0], yTickLength)]:
    17121785                for y, label in yticks:
    1713                     pt = scale*_Numeric.array([x, y])+shift
    1714                     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])
    17151788                    if text:
    1716                         dc.DrawText(label,pt[0]-dc.GetTextExtent(label)[0]-3*self._pointSize[0],
    1717                                     pt[1]-0.75*h)
    1718                 a1 = scale*_Numeric.array([x, lower])+shift
    1719                 a2 = scale*_Numeric.array([x, upper])+shift
    1720                 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])
    17211794                text = 0    # axis values not drawn on right side
    17221795
    17231796        if self._centerLinesEnabled:
    17241797            if self._centerLinesEnabled in ('Horizontal', True):
    1725                 y1 = scale[1]*p1[1]+shift[1]
    1726                 y2 = scale[1]*p2[1]+shift[1]
     1798                y1 = scale[1] * p1[1] + shift[1]
     1799                y2 = scale[1] * p2[1] + shift[1]
    17271800                y = (y1 - y2) / 2.0 + y2
    1728                 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)
    17291803            if self._centerLinesEnabled in ('Vertical', True):
    1730                 x1 = scale[0]*p1[0]+shift[0]
    1731                 x2 = scale[0]*p2[0]+shift[0]
     1804                x1 = scale[0] * p1[0] + shift[0]
     1805                x2 = scale[0] * p2[0] + shift[0]
    17321806                x = (x1 - x2) / 2.0 + x2
    1733                 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])
    17341809
    17351810        if self._diagonalsEnabled:
    17361811            if self._diagonalsEnabled in ('Bottomleft-Topright', True):
    1737                 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])
    17381814            if self._diagonalsEnabled in ('Bottomright-Topleft', True):
    1739                 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])
    17401817
    17411818    def _xticks(self, *args):
    17421819        if self._logscale[0]:
     
    17531830            return self._ticks(*args, **attr)
    17541831
    17551832    def _logticks(self, lower, upper):
    1756         #lower,upper = map(_Numeric.log10,[lower,upper])
    1757         #print('logticks',lower,upper)
     1833        #lower,upper = map(np.log10,[lower,upper])
     1834        # print('logticks',lower,upper)
    17581835        ticks = []
    1759         mag = _Numeric.power(10,_Numeric.floor(lower))
    1760         if upper-lower > 6:
    1761             t = _Numeric.power(10,_Numeric.ceil(lower))
    1762             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
    17631841            def inc(t):
    1764                 return t*base-t
     1842                return t * base - t
    17651843        else:
    1766             t = _Numeric.ceil(_Numeric.power(10,lower)/mag)*mag
     1844            t = np.ceil(np.power(10, lower) / mag) * mag
     1845
    17671846            def inc(t):
    1768                 return 10**int(_Numeric.floor(_Numeric.log10(t)+1e-16))
    1769         majortick = int(_Numeric.log10(mag))
    1770         while t <= pow(10,upper):
    1771             if majortick != int(_Numeric.floor(_Numeric.log10(t)+1e-16)):
    1772                 majortick = int(_Numeric.floor(_Numeric.log10(t)+1e-16))
    1773                 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
    17741853            else:
    1775                 if upper-lower < 2:
    1776                     minortick = int(t/pow(10,majortick)+.5)
    1777                     ticklabel = '%de%d'%(minortick,majortick)
     1854                if upper - lower < 2:
     1855                    minortick = int(t / pow(10, majortick) + .5)
     1856                    ticklabel = '%de%d' % (minortick, majortick)
    17781857                else:
    17791858                    ticklabel = ''
    1780             ticks.append((_Numeric.log10(t), ticklabel))
     1859            ticks.append((np.log10(t), ticklabel))
    17811860            t += inc(t)
    17821861        if len(ticks) == 0:
    1783             ticks = [(0,'')]
     1862            ticks = [(0, '')]
    17841863        return ticks
    17851864
    17861865    def _ticks(self, lower, upper, numticks=None):
    17871866        if isinstance(numticks, (float, int)):
    1788             ideal = (upper-lower)/float(numticks)
     1867            ideal = (upper - lower) / float(numticks)
    17891868        else:
    1790             ideal = (upper-lower)/7.
    1791         log = _Numeric.log10(ideal)
    1792         power = _Numeric.floor(log)
     1869            ideal = (upper - lower) / 7.
     1870        log = np.log10(ideal)
     1871        power = np.floor(log)
    17931872        if isinstance(numticks, (float, int)):
    17941873            grid = ideal
    17951874        else:
    1796             fraction = log-power
     1875            fraction = log - power
    17971876            factor = 1.
    17981877            error = fraction
    17991878            for f, lf in self._multiples:
    1800                 e = _Numeric.fabs(fraction-lf)
     1879                e = np.fabs(fraction - lf)
    18011880                if e < error:
    18021881                    error = e
    18031882                    factor = f
    1804             grid = factor * 10.**power
     1883            grid = factor * 10. ** power
    18051884        if self._useScientificNotation and (power > 4 or power < -4):
    18061885            format = '%+7.1e'
    18071886        elif power >= 0:
     
    18091888            format = '%' + repr(digits) + '.0f'
    18101889        else:
    18111890            digits = -int(power)
    1812             format = '%' + repr(digits+2) + '.' + repr(digits) + 'f'
     1891            format = '%' + repr(digits + 2) + '.' + repr(digits) + 'f'
    18131892        ticks = []
    1814         t = -grid*_Numeric.floor(-lower/grid)
     1893        t = -grid * np.floor(-lower / grid)
    18151894        while t <= upper:
    18161895            if t == -0:
    18171896                t = 0
    1818             ticks.append( (t, format % (t,)) )
     1897            ticks.append((t, format % (t,)))
    18191898            t = t + grid
    18201899        return ticks
    18211900
    1822     _multiples = [(2., _Numeric.log10(2.)), (5., _Numeric.log10(5.))]
     1901    _multiples = [(2., np.log10(2.)), (5., np.log10(5.))]
    18231902
    1824 
    18251903    def _adjustScrollbars(self):
    18261904        if self._sb_ignore:
    18271905            self._sb_ignore = False
     
    18381916        r_max = list(self._getXMaxRange())
    18391917        sbfullrange = float(self.sb_hor.GetRange())
    18401918
    1841         r_max[0] = min(r_max[0],r_current[0])
    1842         r_max[1] = max(r_max[1],r_current[1])
     1919        r_max[0] = min(r_max[0], r_current[0])
     1920        r_max[1] = max(r_max[1], r_current[1])
    18431921
    18441922        self._sb_xfullrange = r_max
    18451923
    1846         unit = (r_max[1]-r_max[0])/float(self.sb_hor.GetRange())
    1847         pos = int((r_current[0]-r_max[0])/unit)
     1924        unit = (r_max[1] - r_max[0]) / float(self.sb_hor.GetRange())
     1925        pos = int((r_current[0] - r_max[0]) / unit)
    18481926
    18491927        if pos >= 0:
    1850             pagesize = int((r_current[1]-r_current[0])/unit)
     1928            pagesize = int((r_current[1] - r_current[0]) / unit)
    18511929
    18521930            self.sb_hor.SetScrollbar(pos, pagesize, sbfullrange, pagesize)
    18531931            self._sb_xunit = unit
     
    18601938        r_max = list(self._getYMaxRange())
    18611939        sbfullrange = float(self.sb_vert.GetRange())
    18621940
    1863         r_max[0] = min(r_max[0],r_current[0])
    1864         r_max[1] = max(r_max[1],r_current[1])
     1941        r_max[0] = min(r_max[0], r_current[0])
     1942        r_max[1] = max(r_max[1], r_current[1])
    18651943
    18661944        self._sb_yfullrange = r_max
    18671945
    1868         unit = (r_max[1]-r_max[0])/sbfullrange
    1869         pos = int((r_current[0]-r_max[0])/unit)
     1946        unit = (r_max[1] - r_max[0]) / sbfullrange
     1947        pos = int((r_current[0] - r_max[0]) / unit)
    18701948
    18711949        if pos >= 0:
    1872             pagesize = int((r_current[1]-r_current[0])/unit)
    1873             pos = (sbfullrange-1-pos-pagesize)
     1950            pagesize = int((r_current[1] - r_current[0]) / unit)
     1951            pos = (sbfullrange - 1 - pos - pagesize)
    18741952            self.sb_vert.SetScrollbar(pos, pagesize, sbfullrange, pagesize)
    18751953            self._sb_yunit = unit
    18761954            needScrollbars = needScrollbars or (pagesize != sbfullrange)
     
    18801958        self.SetShowScrollbars(needScrollbars)
    18811959        self._adjustingSB = False
    18821960
    1883 #-------------------------------------------------------------------------------
     1961#-------------------------------------------------------------------------
    18841962# Used to layout the printer page
    18851963
     1964
    18861965class PlotPrintout(wx.Printout):
     1966
    18871967    """Controls how the plot is made in printing and previewing"""
    18881968    # Do not change method names in this class,
    18891969    # we have to override wx.Printout methods here!
     1970
    18901971    def __init__(self, graph):
    18911972        """graph is instance of plotCanvas to be printed or previewed"""
    18921973        wx.Printout.__init__(self)
     
    19091990##        print("GetPageSizePixels", self.GetPageSizePixels())
    19101991        # Note PPIScreen does not give the correct number
    19111992        # Calulate everything for printer and then scale for preview
    1912         PPIPrinter= self.GetPPIPrinter()        # printer dots/inch (w,h)
    1913         #PPIScreen= self.GetPPIScreen()          # screen dots/inch (w,h)
    1914         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
    19151996        if self.graph._antiAliasingEnabled and not isinstance(dc, wx.GCDC):
    19161997            try:
    19171998                dc = wx.GCDC(dc)
     
    19192000                pass
    19202001            else:
    19212002                if self.graph._hiResEnabled:
    1922                     dc.SetMapMode(wx.MM_TWIPS) # high precision - each logical unit is 1/20 of a point
    1923         pageSize= self.GetPageSizePixels() # page size in terms of pixcels
    1924         clientDcSize= self.graph.GetClientSize()
     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()
    19252007
    19262008        # find what the margins are (mm)
    1927         margLeftSize,margTopSize= self.graph.pageSetupData.GetMarginTopLeft()
    1928         margRightSize, margBottomSize= self.graph.pageSetupData.GetMarginBottomRight()
     2009        margLeftSize, margTopSize = self.graph.pageSetupData.GetMarginTopLeft()
     2010        margRightSize, margBottomSize = self.graph.pageSetupData.GetMarginBottomRight()
    19292011
    19302012        # calculate offset and scale for dc
    1931         pixLeft= margLeftSize*PPIPrinter[0]/25.4  # mm*(dots/in)/(mm/in)
    1932         pixRight= margRightSize*PPIPrinter[0]/25.4
    1933         pixTop= margTopSize*PPIPrinter[1]/25.4
    1934         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
    19352017
    1936         plotAreaW= pageSize[0]-(pixLeft+pixRight)
    1937         plotAreaH= pageSize[1]-(pixTop+pixBottom)
     2018        plotAreaW = pageSize[0] - (pixLeft + pixRight)
     2019        plotAreaH = pageSize[1] - (pixTop + pixBottom)
    19382020
    19392021        # ratio offset and scale to screen size if preview
    19402022        if self.IsPreview():
    1941             ratioW= float(dcSize[0])/pageSize[0]
    1942             ratioH= float(dcSize[1])/pageSize[1]
     2023            ratioW = float(dcSize[0]) / pageSize[0]
     2024            ratioH = float(dcSize[1]) / pageSize[1]
    19432025            pixLeft *= ratioW
    19442026            pixTop *= ratioH
    19452027            plotAreaW *= ratioW
     
    19462028            plotAreaH *= ratioH
    19472029
    19482030        # rescale plot to page or preview plot area
    1949         self.graph._setSize(plotAreaW,plotAreaH)
     2031        self.graph._setSize(plotAreaW, plotAreaH)
    19502032
    19512033        # Set offset and scale
    1952         dc.SetDeviceOrigin(pixLeft,pixTop)
     2034        dc.SetDeviceOrigin(pixLeft, pixTop)
    19532035
    19542036        # Thicken up pens and increase marker size for printing
    1955         ratioW= float(plotAreaW)/clientDcSize[0]
    1956         ratioH= float(plotAreaH)/clientDcSize[1]
    1957         aveScale= (ratioW+ratioH)/2
     2037        ratioW = float(plotAreaW) / clientDcSize[0]
     2038        ratioH = float(plotAreaH) / clientDcSize[1]
     2039        aveScale = (ratioW + ratioH) / 2
    19582040        if self.graph._antiAliasingEnabled and not self.IsPreview():
    19592041            scale = dc.GetUserScale()
    1960             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])
    19612044        self.graph._setPrinterScale(aveScale)  # tickens up pens for printing
    19622045
    19632046        self.graph._printDraw(dc)
     
    19642047        # rescale back to original
    19652048        self.graph._setSize()
    19662049        self.graph._setPrinterScale(1)
    1967         self.graph.Redraw()     #to get point label scale and shift correct
     2050        self.graph.Redraw()  # to get point label scale and shift correct
    19682051
    19692052        return True
    19702053
     
    20042087#     ...a sample implementation using the above
    20052088#
    20062089
     2090
    20072091def _draw1Objects():
    20082092    # 100 points sin function, plotted as green circles
    2009     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2093    data1 = 2. * np.pi * np.arange(200) / 200.
    20102094    data1.shape = (100, 2)
    2011     data1[:,1] = _Numeric.sin(data1[:,0])
    2012     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)
    20132098
    20142099    # 50 points cos function, plotted as red line
    2015     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
    2016     data1.shape = (50,2)
    2017     data1[:,1] = _Numeric.cos(data1[:,0])
    2018     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')
    20192104
    20202105    # A few more points...
    2021     pi = _Numeric.pi
    2022     markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    2023                           (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',
    20242109                          marker='cross')
    20252110
    2026     return PlotGraphics([markers1, lines, markers2],"Graph Title", "X Axis", "Y Axis")
     2111    return PlotGraphics([markers1, lines, markers2], "Graph Title", "X Axis", "Y Axis")
    20272112
     2113
    20282114def _draw2Objects():
    20292115    # 100 points sin function, plotted as green dots
    2030     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2116    data1 = 2. * np.pi * np.arange(200) / 200.
    20312117    data1.shape = (100, 2)
    2032     data1[:,1] = _Numeric.sin(data1[:,0])
    2033     line1 = PolySpline(data1, legend='Green Line', colour='green', width=6, style=wx.PENSTYLE_DOT)
     2118    data1[:, 1] = np.sin(data1[:, 0])
     2119    line1 = PolySpline(
     2120        data1, legend='Green Line', colour='green', width=6, style=wx.PENSTYLE_DOT)
    20342121
    20352122    # 50 points cos function, plotted as red dot-dash
    2036     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
    2037     data1.shape = (50,2)
    2038     data1[:,1] = _Numeric.cos(data1[:,0])
    2039     line2 = PolySpline(data1, legend='Red Line', colour='red', width=3, style= wx.PENSTYLE_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)
    20402128
    20412129    # A few more points...
    2042     pi = _Numeric.pi
    2043     markers1 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    2044                           (3.*pi/4., -1)], legend='Cross Hatch Square', colour='blue', width= 3, size= 6,
    2045                           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,
    20462134                          marker='square')
    20472135
    20482136    return PlotGraphics([markers1, line1, line2], "Big Markers with Different Line Styles")
    20492137
     2138
    20502139def _draw3Objects():
    2051     markerList= ['circle', 'dot', 'square', 'triangle', 'triangle_down',
    2052                 'cross', 'plus', 'circle']
    2053     m=[]
     2140    markerList = ['circle', 'dot', 'square', 'triangle', 'triangle_down',
     2141                  'cross', 'plus', 'circle']
     2142    m = []
    20542143    for i in range(len(markerList)):
    2055         m.append(PolyMarker([(2*i+.5,i+.5)], legend=markerList[i], colour='blue',
    2056                           marker=markerList[i]))
     2144        m.append(PolyMarker([(2 * i + .5, i + .5)], legend=markerList[i], colour='blue',
     2145                            marker=markerList[i]))
    20572146    return PlotGraphics(m, "Selection of Markers", "Minimal Axis", "No Axis")
    20582147
     2148
    20592149def _draw4Objects():
    20602150    # 25,000 point line
    2061     data1 = _Numeric.arange(5e5,1e6,10)
     2151    data1 = np.arange(5e5, 1e6, 10)
    20622152    data1.shape = (25000, 2)
    20632153    line1 = PolyLine(data1, legend='Wide Line', colour='green', width=5)
    20642154
     
    20672157                          marker='square')
    20682158    return PlotGraphics([line1, markers2], "25,000 Points", "Value X", "")
    20692159
     2160
    20702161def _draw5Objects():
    20712162    # Empty graph with axis defined but no points/lines
    2072     points=[]
     2163    points = []
    20732164    line1 = PolyLine(points, legend='Wide Line', colour='green', width=5)
    20742165    return PlotGraphics([line1], "Empty Plot With Just Axes", "Value X", "Value Y")
    20752166
     2167
    20762168def _draw6Objects():
    20772169    # Bar graph
    2078     points1=[(1,0), (1,10)]
     2170    points1 = [(1, 0), (1, 10)]
    20792171    line1 = PolyLine(points1, colour='green', legend='Feb.', width=10)
    2080     points1g=[(2,0), (2,4)]
     2172    points1g = [(2, 0), (2, 4)]
    20812173    line1g = PolyLine(points1g, colour='red', legend='Mar.', width=10)
    2082     points1b=[(3,0), (3,6)]
     2174    points1b = [(3, 0), (3, 6)]
    20832175    line1b = PolyLine(points1b, colour='blue', legend='Apr.', width=10)
    20842176
    2085     points2=[(4,0), (4,12)]
     2177    points2 = [(4, 0), (4, 12)]
    20862178    line2 = PolyLine(points2, colour='Yellow', legend='May', width=10)
    2087     points2g=[(5,0), (5,8)]
     2179    points2g = [(5, 0), (5, 8)]
    20882180    line2g = PolyLine(points2g, colour='orange', legend='June', width=10)
    2089     points2b=[(6,0), (6,4)]
     2181    points2b = [(6, 0), (6, 4)]
    20902182    line2b = PolyLine(points2b, colour='brown', legend='July', width=10)
    20912183
    20922184    return PlotGraphics([line1, line1g, line1b, line2, line2g, line2b],
    20932185                        "Bar Graph - (Turn on Grid, Legend)", "Months", "Number of Students")
     2186
     2187
    20942188def _draw7Objects():
    20952189    # Empty graph with axis defined but no points/lines
    2096     x = _Numeric.arange(1,1000,1)
    2097     y1 = 4.5*x**2
    2098     y2 = 2.2*x**3
    2099     points1 = _Numeric.transpose([x,y1])
    2100     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])
    21012195    line1 = PolyLine(points1, legend='quadratic', colour='blue', width=1)
    21022196    line2 = PolyLine(points2, legend='cubic', colour='red', width=1)
    2103     return PlotGraphics([line1,line2], "double log plot", "Value X", "Value Y")
     2197    return PlotGraphics([line1, line2], "double log plot", "Value X", "Value Y")
    21042198
    21052199
    21062200class TestFrame(wx.Frame):
     2201
    21072202    def __init__(self, parent, id, title):
    21082203        wx.Frame.__init__(self, parent, id, title,
    21092204                          wx.DefaultPosition, (600, 400))
     
    21302225
    21312226        menu = wx.Menu()
    21322227        menu.Append(206, 'Draw1', 'Draw plots1')
    2133         self.Bind(wx.EVT_MENU,self.OnPlotDraw1, id=206)
     2228        self.Bind(wx.EVT_MENU, self.OnPlotDraw1, id=206)
    21342229        menu.Append(207, 'Draw2', 'Draw plots2')
    2135         self.Bind(wx.EVT_MENU,self.OnPlotDraw2, id=207)
     2230        self.Bind(wx.EVT_MENU, self.OnPlotDraw2, id=207)
    21362231        menu.Append(208, 'Draw3', 'Draw plots3')
    2137         self.Bind(wx.EVT_MENU,self.OnPlotDraw3, id=208)
     2232        self.Bind(wx.EVT_MENU, self.OnPlotDraw3, id=208)
    21382233        menu.Append(209, 'Draw4', 'Draw plots4')
    2139         self.Bind(wx.EVT_MENU,self.OnPlotDraw4, id=209)
     2234        self.Bind(wx.EVT_MENU, self.OnPlotDraw4, id=209)
    21402235        menu.Append(210, 'Draw5', 'Draw plots5')
    2141         self.Bind(wx.EVT_MENU,self.OnPlotDraw5, id=210)
     2236        self.Bind(wx.EVT_MENU, self.OnPlotDraw5, id=210)
    21422237        menu.Append(260, 'Draw6', 'Draw plots6')
    2143         self.Bind(wx.EVT_MENU,self.OnPlotDraw6, id=260)
     2238        self.Bind(wx.EVT_MENU, self.OnPlotDraw6, id=260)
    21442239        menu.Append(261, 'Draw7', 'Draw plots7')
    2145         self.Bind(wx.EVT_MENU,self.OnPlotDraw7, id=261)
     2240        self.Bind(wx.EVT_MENU, self.OnPlotDraw7, id=261)
    21462241
    21472242        menu.Append(211, '&Redraw', 'Redraw plots')
    2148         self.Bind(wx.EVT_MENU,self.OnPlotRedraw, id=211)
     2243        self.Bind(wx.EVT_MENU, self.OnPlotRedraw, id=211)
    21492244        menu.Append(212, '&Clear', 'Clear canvas')
    2150         self.Bind(wx.EVT_MENU,self.OnPlotClear, id=212)
     2245        self.Bind(wx.EVT_MENU, self.OnPlotClear, id=212)
    21512246        menu.Append(213, '&Scale', 'Scale canvas')
    2152         self.Bind(wx.EVT_MENU,self.OnPlotScale, id=213)
    2153         menu.Append(214, 'Enable &Zoom', 'Enable Mouse Zoom', kind=wx.ITEM_CHECK)
    2154         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)
    21552251        menu.Append(215, 'Enable &Grid', 'Turn on Grid', kind=wx.ITEM_CHECK)
    2156         self.Bind(wx.EVT_MENU,self.OnEnableGrid, id=215)
    2157         menu.Append(217, 'Enable &Drag', 'Activates dragging mode', kind=wx.ITEM_CHECK)
    2158         self.Bind(wx.EVT_MENU,self.OnEnableDrag, id=217)
    2159         menu.Append(220, 'Enable &Legend', 'Turn on Legend', kind=wx.ITEM_CHECK)
    2160         self.Bind(wx.EVT_MENU,self.OnEnableLegend, id=220)
    2161         menu.Append(222, 'Enable &Point Label', 'Show Closest Point', kind=wx.ITEM_CHECK)
    2162         self.Bind(wx.EVT_MENU,self.OnEnablePointLabel, id=222)
     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)
    21632262
    2164         menu.Append(223, 'Enable &Anti-Aliasing', 'Smooth output', kind=wx.ITEM_CHECK)
    2165         self.Bind(wx.EVT_MENU,self.OnEnableAntiAliasing, id=223)
    2166         menu.Append(224, 'Enable &High-Resolution AA', 'Draw in higher resolution', kind=wx.ITEM_CHECK)
    2167         self.Bind(wx.EVT_MENU,self.OnEnableHiRes, id=224)
     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)
    21682269
    2169         menu.Append(226, 'Enable Center Lines', 'Draw center lines', kind=wx.ITEM_CHECK)
    2170         self.Bind(wx.EVT_MENU,self.OnEnableCenterLines, id=226)
    2171         menu.Append(227, 'Enable Diagonal Lines', 'Draw diagonal lines', kind=wx.ITEM_CHECK)
    2172         self.Bind(wx.EVT_MENU,self.OnEnableDiagonals, id=227)
     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)
    21732276
    2174         menu.Append(231, 'Set Gray Background', 'Change background colour to gray')
    2175         self.Bind(wx.EVT_MENU,self.OnBackgroundGray, id=231)
    2176         menu.Append(232, 'Set &White Background', 'Change background colour to white')
    2177         self.Bind(wx.EVT_MENU,self.OnBackgroundWhite, id=232)
    2178         menu.Append(233, 'Set Red Label Text', 'Change label text colour to red')
    2179         self.Bind(wx.EVT_MENU,self.OnForegroundRed, id=233)
    2180         menu.Append(234, 'Set &Black Label Text', 'Change label text colour to black')
    2181         self.Bind(wx.EVT_MENU,self.OnForegroundBlack, id=234)
     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)
    21822289
    21832290        menu.Append(225, 'Scroll Up 1', 'Move View Up 1 Unit')
    2184         self.Bind(wx.EVT_MENU,self.OnScrUp, id=225)
     2291        self.Bind(wx.EVT_MENU, self.OnScrUp, id=225)
    21852292        menu.Append(230, 'Scroll Rt 2', 'Move View Right 2 Units')
    2186         self.Bind(wx.EVT_MENU,self.OnScrRt, id=230)
     2293        self.Bind(wx.EVT_MENU, self.OnScrRt, id=230)
    21872294        menu.Append(235, '&Plot Reset', 'Reset to original plot')
    2188         self.Bind(wx.EVT_MENU,self.OnReset, id=235)
     2295        self.Bind(wx.EVT_MENU, self.OnReset, id=235)
    21892296
    21902297        self.mainmenu.Append(menu, '&Plot')
    21912298
     
    22002307        self.CreateStatusBar(1)
    22012308
    22022309        self.client = PlotCanvas(self)
    2203         #define the function for drawing pointLabels
     2310        # define the function for drawing pointLabels
    22042311        self.client.SetPointLabelFunc(self.DrawPointLabel)
    22052312        # Create mouse event for showing cursor coords in status bar
    22062313        self.client.canvas.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown)
     
    22202327        """
    22212328        # ----------
    22222329        dc.SetPen(wx.Pen(wx.BLACK))
    2223         dc.SetBrush(wx.Brush( wx.BLACK, wx.BRUSHSTYLE_SOLID ) )
     2330        dc.SetBrush(wx.Brush(wx.BLACK, wx.BRUSHSTYLE_SOLID))
    22242331
    2225         sx, sy = mDataDict["scaledXY"] #scaled x,y of closest point
    2226         dc.DrawRectangle( sx-5,sy-5, 10, 10)  #10by10 square centered on point
    2227         px,py = mDataDict["pointXY"]
     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"]
    22282336        cNum = mDataDict["curveNum"]
    22292337        pntIn = mDataDict["pIndex"]
    22302338        legend = mDataDict["legend"]
    2231         #make a string to display
    2232         s = "Crv# %i, '%s', Pt. (%.2f,%.2f), PtInd %i" %(cNum, legend, px, py, pntIn)
    2233         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)
    22342343        # -----------
    22352344
    2236     def OnMouseLeftDown(self,event):
    2237         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)
    22382348        self.SetStatusText(s)
    2239         event.Skip()            #allows plotCanvas OnMouseLeftDown to be called
     2349        event.Skip()  # allows plotCanvas OnMouseLeftDown to be called
    22402350
    22412351    def OnMotion(self, event):
    2242         #show closest point (when enbled)
     2352        # show closest point (when enbled)
    22432353        if self.client.GetEnablePointLabel() == True:
    2244             #make up dict with info for the pointLabel
    2245             #I've decided to mark the closest point on the closest curve
    2246             dlst= self.client.GetClosestPoint( self.client._getXY(event), pointScaled= True)
    2247             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
    22482359                curveNum, legend, pIndex, pointXY, scaledXY, distance = dlst
    2249                 #make up dictionary to pass to my user function (see DrawPointLabel)
    2250                 mDataDict= {"curveNum":curveNum, "legend":legend, "pIndex":pIndex,\
    2251                             "pointXY":pointXY, "scaledXY":scaledXY}
    2252                 #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
    22532365                self.client.UpdatePointLabel(mDataDict)
    2254         event.Skip()           #go to next handler
     2366        event.Skip()  # go to next handler
    22552367
    22562368    def OnFilePageSetup(self, event):
    22572369        self.client.PageSetup()
     
    22782390
    22792391    def OnPlotDraw3(self, event):
    22802392        self.resetDefaults()
    2281         self.client.SetFont(wx.Font(10,wx.FONTFAMILY_SCRIPT,wx.FONTSTYLE_NORMAL,wx.FONTWEIGHT_NORMAL))
     2393        self.client.SetFont(
     2394            wx.Font(10, wx.FONTFAMILY_SCRIPT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
    22822395        self.client.SetFontSizeAxis(20)
    22832396        self.client.SetFontSizeLegend(12)
    22842397        self.client.SetXSpec('min')
     
    22872400
    22882401    def OnPlotDraw4(self, event):
    22892402        self.resetDefaults()
    2290         drawObj= _draw4Objects()
     2403        drawObj = _draw4Objects()
    22912404        self.client.Draw(drawObj)
    2292 ##        # profile
     2405# profile
    22932406##        start = _time.clock()
    2294 ##        for x in range(10):
    2295 ##            self.client.Draw(drawObj)
     2407# for x in range(10):
     2408# self.client.Draw(drawObj)
    22962409##        print("10 plots of Draw4 took: %f sec."%(_time.clock() - start))
    2297 ##        # profile end
     2410# profile end
    22982411
    22992412    def OnPlotDraw5(self, event):
    23002413        # Empty plot with just axes
    23012414        self.resetDefaults()
    2302         drawObj= _draw5Objects()
     2415        drawObj = _draw5Objects()
    23032416        # make the axis X= (0,5), Y=(0,10)
    23042417        # (default with None is X= (-1,1), Y= (-1,1))
    2305         self.client.Draw(drawObj, xAxis= (0,5), yAxis= (0,10))
     2418        self.client.Draw(drawObj, xAxis=(0, 5), yAxis= (0, 10))
    23062419
    23072420    def OnPlotDraw6(self, event):
    2308         #Bar Graph Example
     2421        # Bar Graph Example
    23092422        self.resetDefaults()
    2310         #self.client.SetEnableLegend(True)   #turn on Legend
    2311         #self.client.SetEnableGrid(True)     #turn on Grid
    2312         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
    23132426        self.client.SetYSpec('auto')
    2314         self.client.Draw(_draw6Objects(), xAxis= (0,7))
     2427        self.client.Draw(_draw6Objects(), xAxis=(0, 7))
    23152428
    23162429    def OnPlotDraw7(self, event):
    2317         #log scale example
     2430        # log scale example
    23182431        self.resetDefaults()
    2319         self.client.setLogScale((True,True))
     2432        self.client.setLogScale((True, True))
    23202433        self.client.Draw(_draw7Objects())
    23212434
    2322     def OnPlotRedraw(self,event):
     2435    def OnPlotRedraw(self, event):
    23232436        self.client.Redraw()
    23242437
    2325     def OnPlotClear(self,event):
     2438    def OnPlotClear(self, event):
    23262439        self.client.Clear()
    23272440
    23282441    def OnPlotScale(self, event):
    23292442        if self.client.last_draw != None:
    2330             graphics, xAxis, yAxis= self.client.last_draw
    2331             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))
    23322445
    23332446    def OnEnableZoom(self, event):
    23342447        self.client.SetEnableZoom(event.IsChecked())
     
    23782491    def OnScrUp(self, event):
    23792492        self.client.ScrollUp(1)
    23802493
    2381     def OnScrRt(self,event):
     2494    def OnScrRt(self, event):
    23822495        self.client.ScrollRight(2)
    23832496
    2384     def OnReset(self,event):
     2497    def OnReset(self, event):
    23852498        self.client.Reset()
    23862499
    23872500    def OnHelpAbout(self, event):
     
    23912504
    23922505    def resetDefaults(self):
    23932506        """Just to reset the fonts back to the PlotCanvas defaults"""
    2394         self.client.SetFont(wx.Font(10,wx.FONTFAMILY_SWISS,wx.FONTSTYLE_NORMAL,wx.FONTWEIGHT_NORMAL))
     2507        self.client.SetFont(
     2508            wx.Font(10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL))
    23952509        self.client.SetFontSizeAxis(10)
    23962510        self.client.SetFontSizeLegend(7)
    2397         self.client.setLogScale((False,False))
     2511        self.client.setLogScale((False, False))
    23982512        self.client.SetXSpec('auto')
    23992513        self.client.SetYSpec('auto')
    24002514
    24012515
    2402 
    24032516def __test():
    24042517
    24052518    class MyApp(wx.App):
     2519
    24062520        def OnInit(self):
    24072521            wx.InitAllImageHandlers()
    24082522            frame = TestFrame(None, -1, "PlotCanvas")
    2409             #frame.Show(True)
     2523            # frame.Show(True)
    24102524            self.SetTopWindow(frame)
    24112525            return True
    24122526
    2413 
    24142527    app = MyApp(0)
    24152528    app.MainLoop()
    24162529