Ticket #16590: plot.py.patch

File plot.py.patch, 24.2 KB (added by ryexander, 6 years ago)
  • wx/lib/plot.py

     
    115115
    116116# Needs NumPy
    117117try:
    118     import numpy.oldnumeric as _Numeric
     118    import numpy as np
    119119except:
    120120    msg= """
    121121    This module requires the NumPy module, which could not be
     
    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)
    142142        self.currentScale= (1,1)
     
    155155    def __getattr__(self, name):
    156156        if name == 'points':
    157157            if len(self._points)>0:
    158                 data = _Numeric.array(self._points,copy=True)
     158                data = np.array(self._points,copy=True)
    159159                if self._logscale[0]:
    160160                    data = self.log10(data, 0)
    161161                if self._logscale[1]:
     
    167167            raise AttributeError(name)
    168168
    169169    def log10(self, data, ind):
    170         data = _Numeric.compress(data[:,ind]>0,data,0)
    171         data[:,ind] = _Numeric.log10(data[:,ind])
     170        data = np.compress(data[:,ind]>0,data,0)
     171        data[:,ind] = np.log10(data[:,ind])
    172172        return data
    173173
    174174    def boundingBox(self):
    175175        if len(self.points) == 0:
    176176            # no curves to draw
    177177            # 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])
     178            minXY= np.array([-1.0,-1.0])
     179            maxXY= np.array([ 1.0, 1.0])
    180180        else:
    181             minXY= _Numeric.minimum.reduce(self.points)
    182             maxXY= _Numeric.maximum.reduce(self.points)
     181            minXY= np.minimum.reduce(self.points)
     182            maxXY= np.maximum.reduce(self.points)
    183183        return minXY, maxXY
    184184
    185185    def scaleAndShift(self, scale=(1,1), shift=(0,0)):
     
    205205        if pointScaled == True:
    206206            #Using screen coords
    207207            p = self.scaled
    208             pxy = self.currentScale * _Numeric.array(pntXY)+ self.currentShift
     208            pxy = self.currentScale * np.array(pntXY)+ self.currentShift
    209209        else:
    210210            #Using user coords
    211211            p = self.points
    212             pxy = _Numeric.array(pntXY)
     212            pxy = np.array(pntXY)
    213213        #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)
     214        d= np.sqrt(np.add.reduce((p-pxy)**2,1)) #sqrt(dx^2+dy^2)
     215        pntIndex = np.argmin(d)
    216216        dist = d[pntIndex]
    217217        return [pntIndex, self.points[pntIndex], self.scaled[pntIndex] / self._pointSize, dist]
    218218
     
    386386    def _circle(self, dc, coords, size=1):
    387387        fact= 2.5*size
    388388        wh= 5.0*size
    389         rect= _Numeric.zeros((len(coords),4),_Numeric.Float)+[0.0,0.0,wh,wh]
     389        rect= np.zeros((len(coords),4),np.float)+[0.0,0.0,wh,wh]
    390390        rect[:,0:2]= coords-[fact,fact]
    391         dc.DrawEllipseList(rect.astype(_Numeric.Int32))
     391        dc.DrawEllipseList(rect.astype(np.int32))
    392392
    393393    def _dot(self, dc, coords, size=1):
    394394        dc.DrawPointList(coords)
     
    396396    def _square(self, dc, coords, size=1):
    397397        fact= 2.5*size
    398398        wh= 5.0*size
    399         rect= _Numeric.zeros((len(coords),4),_Numeric.Float)+[0.0,0.0,wh,wh]
     399        rect= np.zeros((len(coords),4),np.float)+[0.0,0.0,wh,wh]
    400400        rect[:,0:2]= coords-[fact,fact]
    401         dc.DrawRectangleList(rect.astype(_Numeric.Int32))
     401        dc.DrawRectangleList(rect.astype(np.int32))
    402402
    403403    def _triangle(self, dc, coords, size=1):
    404404        shape= [(-2.5*size,1.44*size), (2.5*size,1.44*size), (0.0,-2.88*size)]
    405         poly= _Numeric.repeat(coords,3)
     405        poly= np.repeat(coords,3)
    406406        poly.shape= (len(coords),3,2)
    407407        poly += shape
    408         dc.DrawPolygonList(poly.astype(_Numeric.Int32))
     408        dc.DrawPolygonList(poly.astype(np.int32))
    409409
    410410    def _triangle_down(self, dc, coords, size=1):
    411411        shape= [(-2.5*size,-1.44*size), (2.5*size,-1.44*size), (0.0,2.88*size)]
    412         poly= _Numeric.repeat(coords,3)
     412        poly= np.repeat(coords,3)
    413413        poly.shape= (len(coords),3,2)
    414414        poly += shape
    415         dc.DrawPolygonList(poly.astype(_Numeric.Int32))
     415        dc.DrawPolygonList(poly.astype(np.int32))
    416416
    417417    def _cross(self, dc, coords, size=1):
    418418        fact= 2.5*size
    419419        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))
     420            lines= np.concatenate((coords,coords),axis=1)+f
     421            dc.DrawLineList(lines.astype(np.int32))
    422422
    423423    def _plus(self, dc, coords, size=1):
    424424        fact= 2.5*size
    425425        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))
     426            lines= np.concatenate((coords,coords),axis=1)+f
     427            dc.DrawLineList(lines.astype(np.int32))
    428428
    429429class PlotGraphics:
    430430    """Container to hold PolyXXX objects and graph labels
     
    458458        p1, p2 = self.objects[0].boundingBox()
    459459        for o in self.objects[1:]:
    460460            p1o, p2o = o.boundingBox()
    461             p1 = _Numeric.minimum(p1, p1o)
    462             p2 = _Numeric.maximum(p2, p2o)
     461            p1 = np.minimum(p1, p1o)
     462            p2 = np.maximum(p2, p2o)
    463463        return p1, p2
    464464
    465465    def scaleAndShift(self, scale=(1,1), shift=(0,0)):
     
    509509        for o in self.objects[1:]:
    510510            o._pointSize = self._pointSize
    511511            oSymExt = o.getSymExtent(printerScale)
    512             symExt = _Numeric.maximum(symExt, oSymExt)
     512            symExt = np.maximum(symExt, oSymExt)
    513513        return symExt
    514514
    515515    def getLegendNames(self):
     
    602602        self._sb_yunit = 0
    603603
    604604        self._dragEnabled = False
    605         self._screenCoordinates = _Numeric.array([0.0, 0.0])
     605        self._screenCoordinates = np.array([0.0, 0.0])
    606606
    607607        self._logscale = (False, False)
    608608
    609609        # Zooming variables
    610610        self._zoomInFactor =  0.5
    611611        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
     612        self._zoomCorner1= np.array([0.0, 0.0]) # left mouse down corner
     613        self._zoomCorner2= np.array([0.0, 0.0])   # left mouse up corner
    614614        self._zoomEnabled= False
    615615        self._hasDragged= False
    616616
     
    10001000        """Wrapper around _getXY, which handles log scales"""
    10011001        x,y = self._getXY(event)
    10021002        if self.getLogScale()[0]:
    1003             x = _Numeric.power(10,x)
     1003            x = np.power(10,x)
    10041004        if self.getLogScale()[1]:
    1005             y = _Numeric.power(10,y)
     1005            y = np.power(10,y)
    10061006        return x,y
    10071007
    10081008    def _getXY(self,event):
     
    10121012
    10131013    def PositionUserToScreen(self, pntXY):
    10141014        """Converts User position to Screen Coordinates"""
    1015         userPos= _Numeric.array(pntXY)
     1015        userPos= np.array(pntXY)
    10161016        x,y= userPos * self._pointScale + self._pointShift
    10171017        return x,y
    10181018
    10191019    def PositionScreenToUser(self, pntXY):
    10201020        """Converts Screen position to User Coordinates"""
    1021         screenPos= _Numeric.array(pntXY)
     1021        screenPos= np.array(pntXY)
    10221022        x,y= (screenPos-self._pointShift)/self._pointScale
    10231023        return x,y
    10241024
     
    10551055    def GetXMaxRange(self):
    10561056        xAxis = self._getXMaxRange()
    10571057        if self.getLogScale()[0]:
    1058             xAxis = _Numeric.power(10,xAxis)
     1058            xAxis = np.power(10,xAxis)
    10591059        return xAxis
    10601060
    10611061    def _getXMaxRange(self):
     
    10681068    def GetYMaxRange(self):
    10691069        yAxis = self._getYMaxRange()
    10701070        if self.getLogScale()[1]:
    1071             yAxis = _Numeric.power(10,yAxis)
     1071            yAxis = np.power(10,yAxis)
    10721072        return yAxis
    10731073
    10741074    def _getYMaxRange(self):
     
    10811081    def GetXCurrentRange(self):
    10821082        xAxis = self._getXCurrentRange()
    10831083        if self.getLogScale()[0]:
    1084             xAxis = _Numeric.power(10,xAxis)
     1084            xAxis = np.power(10,xAxis)
    10851085        return xAxis
    10861086
    10871087    def _getXCurrentRange(self):
     
    10911091    def GetYCurrentRange(self):
    10921092        yAxis = self._getYCurrentRange()
    10931093        if self.getLogScale()[1]:
    1094             yAxis = _Numeric.power(10,yAxis)
     1094            yAxis = np.power(10,yAxis)
    10951095        return yAxis
    10961096
    10971097    def _getYCurrentRange(self):
     
    11141114            if xAxis[0] == xAxis[1]:
    11151115                return
    11161116            if self.getLogScale()[0]:
    1117                 xAxis = _Numeric.log10(xAxis)
     1117                xAxis = np.log10(xAxis)
    11181118        if yAxis != None:
    11191119            if yAxis[0] == yAxis[1]:
    11201120                return
    11211121            if self.getLogScale()[1]:
    1122                 yAxis = _Numeric.log10(yAxis)
     1122                yAxis = np.log10(yAxis)
    11231123        self._Draw(graphics, xAxis, yAxis, dc)
    11241124
    11251125    def _Draw(self, graphics, xAxis = None, yAxis = None, dc = None):
     
    11831183            p2[0],p2[1] = xAxis[1], yAxis[1]     # upper right corner user scale (xmax,ymax)
    11841184        else:
    11851185            # 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)
     1186            p1= np.array([xAxis[0], yAxis[0]])    # lower left corner user scale (xmin,ymin)
     1187            p2= np.array([xAxis[1], yAxis[1]])     # upper right corner user scale (xmax,ymax)
    11881188
    1189         self.last_draw = (graphics, _Numeric.array(xAxis), _Numeric.array(yAxis))       # saves most recient values
     1189        self.last_draw = (graphics, np.array(xAxis), np.array(yAxis))       # saves most recient values
    11901190
    11911191        # Get ticks and textExtents for axis if required
    11921192        if self._xSpec is not 'none':
     
    12191219        lhsW= yTextExtent[0]+ yLabelWH[1] + 3*self._pointSize[0]
    12201220        bottomH= max(xTextExtent[1], yTextExtent[1]/2.)+ xLabelWH[1] + 2*self._pointSize[1]
    12211221        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
     1222        textSize_scale= np.array([rhsW+lhsW,bottomH+topH]) # make plot area smaller by text size
     1223        textSize_shift= np.array([lhsW, bottomH])          # shift plot area by this amount
    12241224
    12251225        # draw title if requested
    12261226        if self._titleEnabled:
     
    12441244            self._drawLegend(dc,graphics,rhsW,topH,legendBoxWH, legendSymExt, legendTextExt)
    12451245
    12461246        # 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))
     1247        scale = (self.plotbox_size-textSize_scale) / (p2-p1)* np.array((1,-1))
     1248        shift = -p1*scale + self.plotbox_origin + textSize_shift * np.array((1,-1))
    12491249        self._pointScale= scale / self._pointSize  # make available for mouse events
    12501250        self._pointShift= shift / self._pointSize
    12511251        self._drawAxes(dc, p1, p2, scale, shift, xticks, yticks)
     
    13651365        """
    13661366        if self.last_PointLabel != None:
    13671367            #compare pointXY
    1368             if _Numeric.sometrue(mDataDict["pointXY"] != self.last_PointLabel["pointXY"]):
     1368            if np.sometrue(mDataDict["pointXY"] != self.last_PointLabel["pointXY"]):
    13691369                #closest changed
    13701370                self._drawPointLabel(self.last_PointLabel) #erase old
    13711371                self._drawPointLabel(mDataDict) #plot new
     
    13861386            self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # add new
    13871387        elif self._dragEnabled and event.LeftIsDown():
    13881388            coordinates = event.GetPosition()
    1389             newpos, oldpos = map(_Numeric.array, map(self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
     1389            newpos, oldpos = map(np.array, map(self.PositionScreenToUser, [coordinates, self._screenCoordinates]))
    13901390            dist = newpos-oldpos
    13911391            self._screenCoordinates = coordinates
    13921392
     
    13981398
    13991399    def OnMouseLeftDown(self,event):
    14001400        self._zoomCorner1[0], self._zoomCorner1[1]= self._getXY(event)
    1401         self._screenCoordinates = _Numeric.array(event.GetPosition())
     1401        self._screenCoordinates = np.array(event.GetPosition())
    14021402        if self._dragEnabled:
    14031403            self.SetCursor(self.GrabHandCursor)
    14041404            self.canvas.CaptureMouse()
     
    14091409                self._drawRubberBand(self._zoomCorner1, self._zoomCorner2) # remove old
    14101410                self._zoomCorner2[0], self._zoomCorner2[1]= self._getXY(event)
    14111411                self._hasDragged = False  # reset flag
    1412                 minX, minY= _Numeric.minimum( self._zoomCorner1, self._zoomCorner2)
    1413                 maxX, maxY= _Numeric.maximum( self._zoomCorner1, self._zoomCorner2)
     1412                minX, minY= np.minimum( self._zoomCorner1, self._zoomCorner2)
     1413                maxX, maxY= np.maximum( self._zoomCorner1, self._zoomCorner2)
    14141414                self.last_PointLabel = None        #reset pointLabel
    14151415                if self.last_draw != None:
    14161416                    self._Draw(self.last_draw[0], xAxis = (minX,maxX), yAxis = (minY,maxY), dc = None)
     
    14981498            self.width, self.height= width,height
    14991499        self.width *= self._pointSize[0] # high precision
    15001500        self.height *= self._pointSize[1] # high precision
    1501         self.plotbox_size = 0.97*_Numeric.array([self.width, self.height])
     1501        self.plotbox_size = 0.97*np.array([self.width, self.height])
    15021502        xo = 0.5*(self.width-self.plotbox_size[0])
    15031503        yo = self.height-0.5*(self.height-self.plotbox_size[1])
    1504         self.plotbox_origin = _Numeric.array([xo, yo])
     1504        self.plotbox_origin = np.array([xo, yo])
    15051505
    15061506    def _setPrinterScale(self, scale):
    15071507        """Used to thicken lines and increase marker size for print out."""
     
    15481548            if isinstance(o,PolyMarker):
    15491549                # draw marker with legend
    15501550                pnt= (trhc[0]+legendLHS+legendSymExt[0]/2., trhc[1]+s+lineHeight/2.)
    1551                 o.draw(dc, self.printerScale, coord= _Numeric.array([pnt]))
     1551                o.draw(dc, self.printerScale, coord= np.array([pnt]))
    15521552            elif isinstance(o,PolyLine):
    15531553                # draw line with legend
    15541554                pnt1= (trhc[0]+legendLHS, trhc[1]+s+lineHeight/2.)
    15551555                pnt2= (trhc[0]+legendLHS+legendSymExt[0], trhc[1]+s+lineHeight/2.)
    1556                 o.draw(dc, self.printerScale, coord= _Numeric.array([pnt1,pnt2]))
     1556                o.draw(dc, self.printerScale, coord= np.array([pnt1,pnt2]))
    15571557            else:
    15581558                raise TypeError("object is neither PolyMarker or PolyLine instance")
    15591559            # draw legend txt
     
    15881588            txtList= graphics.getLegendNames()
    15891589            txtExt= dc.GetTextExtent(txtList[0])
    15901590            for txt in graphics.getLegendNames()[1:]:
    1591                 txtExt= _Numeric.maximum(txtExt,dc.GetTextExtent(txt))
     1591                txtExt= np.maximum(txtExt,dc.GetTextExtent(txt))
    15921592            maxW= symExt[0]+txtExt[0]
    15931593            maxH= max(symExt[1],txtExt[1])
    15941594            # padding .1 for lhs of legend box and space between lines
     
    16261626
    16271627    def _point2ClientCoord(self, corner1, corner2):
    16281628        """Converts user point coords to client screen int coords x,y,width,height"""
    1629         c1= _Numeric.array(corner1)
    1630         c2= _Numeric.array(corner2)
     1629        c1= np.array(corner1)
     1630        c2= np.array(corner2)
    16311631        # convert to screen coords
    16321632        pt1= c1*self._pointScale+self._pointShift
    16331633        pt2= c2*self._pointScale+self._pointShift
    16341634        # make height and width positive
    1635         pul= _Numeric.minimum(pt1,pt2) # Upper left corner
    1636         plr= _Numeric.maximum(pt1,pt2) # Lower right corner
     1635        pul= np.minimum(pt1,pt2) # Upper left corner
     1636        plr= np.maximum(pt1,pt2) # Lower right corner
    16371637        rectWidth, rectHeight= plr-pul
    16381638        ptx,pty= pul
    16391639        return ptx, pty, rectWidth, rectHeight
     
    16491649            range = upper-lower
    16501650            if range == 0.:
    16511651                return lower-0.5, upper+0.5
    1652             log = _Numeric.log10(range)
    1653             power = _Numeric.floor(log)
     1652            log = np.log10(range)
     1653            power = np.floor(log)
    16541654            fraction = log-power
    16551655            if fraction <= 0.05:
    16561656                power = power-1
     
    16951695            text = 1
    16961696            for y, d in [(p1[1], -xTickLength), (p2[1], xTickLength)]:   # miny, maxy and tick lengths
    16971697                for x, label in xticks:
    1698                     pt = scale*_Numeric.array([x, y])+shift
     1698                    pt = scale*np.array([x, y])+shift
    16991699                    dc.DrawLine(pt[0],pt[1],pt[0],pt[1] + d) # draws tick mark d units
    17001700                    if text:
    17011701                        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
     1702                a1 = scale*np.array([lower, y])+shift
     1703                a2 = scale*np.array([upper, y])+shift
    17041704                dc.DrawLine(a1[0],a1[1],a2[0],a2[1])  # draws upper and lower axis line
    17051705                text = 0  # axis values not drawn on top side
    17061706
     
    17101710            h = dc.GetCharHeight()
    17111711            for x, d in [(p1[0], -yTickLength), (p2[0], yTickLength)]:
    17121712                for y, label in yticks:
    1713                     pt = scale*_Numeric.array([x, y])+shift
     1713                    pt = scale*np.array([x, y])+shift
    17141714                    dc.DrawLine(pt[0],pt[1],pt[0]-d,pt[1])
    17151715                    if text:
    17161716                        dc.DrawText(label,pt[0]-dc.GetTextExtent(label)[0]-3*self._pointSize[0],
    17171717                                    pt[1]-0.75*h)
    1718                 a1 = scale*_Numeric.array([x, lower])+shift
    1719                 a2 = scale*_Numeric.array([x, upper])+shift
     1718                a1 = scale*np.array([x, lower])+shift
     1719                a2 = scale*np.array([x, upper])+shift
    17201720                dc.DrawLine(a1[0],a1[1],a2[0],a2[1])
    17211721                text = 0    # axis values not drawn on right side
    17221722
     
    17531753            return self._ticks(*args, **attr)
    17541754
    17551755    def _logticks(self, lower, upper):
    1756         #lower,upper = map(_Numeric.log10,[lower,upper])
     1756        #lower,upper = map(np.log10,[lower,upper])
    17571757        #print('logticks',lower,upper)
    17581758        ticks = []
    1759         mag = _Numeric.power(10,_Numeric.floor(lower))
     1759        mag = np.power(10,np.floor(lower))
    17601760        if upper-lower > 6:
    1761             t = _Numeric.power(10,_Numeric.ceil(lower))
    1762             base = _Numeric.power(10,_Numeric.floor((upper-lower)/6))
     1761            t = np.power(10,np.ceil(lower))
     1762            base = np.power(10,np.floor((upper-lower)/6))
    17631763            def inc(t):
    17641764                return t*base-t
    17651765        else:
    1766             t = _Numeric.ceil(_Numeric.power(10,lower)/mag)*mag
     1766            t = np.ceil(np.power(10,lower)/mag)*mag
    17671767            def inc(t):
    1768                 return 10**int(_Numeric.floor(_Numeric.log10(t)+1e-16))
    1769         majortick = int(_Numeric.log10(mag))
     1768                return 10**int(np.floor(np.log10(t)+1e-16))
     1769        majortick = int(np.log10(mag))
    17701770        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))
     1771            if majortick != int(np.floor(np.log10(t)+1e-16)):
     1772                majortick = int(np.floor(np.log10(t)+1e-16))
    17731773                ticklabel = '1e%d'%majortick
    17741774            else:
    17751775                if upper-lower < 2:
     
    17771777                    ticklabel = '%de%d'%(minortick,majortick)
    17781778                else:
    17791779                    ticklabel = ''
    1780             ticks.append((_Numeric.log10(t), ticklabel))
     1780            ticks.append((np.log10(t), ticklabel))
    17811781            t += inc(t)
    17821782        if len(ticks) == 0:
    17831783            ticks = [(0,'')]
     
    17881788            ideal = (upper-lower)/float(numticks)
    17891789        else:
    17901790            ideal = (upper-lower)/7.
    1791         log = _Numeric.log10(ideal)
    1792         power = _Numeric.floor(log)
     1791        log = np.log10(ideal)
     1792        power = np.floor(log)
    17931793        if isinstance(numticks, (float, int)):
    17941794            grid = ideal
    17951795        else:
     
    17971797            factor = 1.
    17981798            error = fraction
    17991799            for f, lf in self._multiples:
    1800                 e = _Numeric.fabs(fraction-lf)
     1800                e = np.fabs(fraction-lf)
    18011801                if e < error:
    18021802                    error = e
    18031803                    factor = f
     
    18111811            digits = -int(power)
    18121812            format = '%' + repr(digits+2) + '.' + repr(digits) + 'f'
    18131813        ticks = []
    1814         t = -grid*_Numeric.floor(-lower/grid)
     1814        t = -grid*np.floor(-lower/grid)
    18151815        while t <= upper:
    18161816            if t == -0:
    18171817                t = 0
     
    18191819            t = t + grid
    18201820        return ticks
    18211821
    1822     _multiples = [(2., _Numeric.log10(2.)), (5., _Numeric.log10(5.))]
     1822    _multiples = [(2., np.log10(2.)), (5., np.log10(5.))]
    18231823
    18241824
    18251825    def _adjustScrollbars(self):
     
    20062006
    20072007def _draw1Objects():
    20082008    # 100 points sin function, plotted as green circles
    2009     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2009    data1 = 2.*np.pi*np.arange(200)/200.
    20102010    data1.shape = (100, 2)
    2011     data1[:,1] = _Numeric.sin(data1[:,0])
     2011    data1[:,1] = np.sin(data1[:,0])
    20122012    markers1 = PolyMarker(data1, legend='Green Markers', colour='green', marker='circle',size=1)
    20132013
    20142014    # 50 points cos function, plotted as red line
    2015     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
     2015    data1 = 2.*np.pi*np.arange(100)/100.
    20162016    data1.shape = (50,2)
    2017     data1[:,1] = _Numeric.cos(data1[:,0])
     2017    data1[:,1] = np.cos(data1[:,0])
    20182018    lines = PolySpline(data1, legend= 'Red Line', colour='red')
    20192019
    20202020    # A few more points...
    2021     pi = _Numeric.pi
     2021    pi = np.pi
    20222022    markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    20232023                          (3.*pi/4., -1)], legend='Cross Legend', colour='blue',
    20242024                          marker='cross')
     
    20272027
    20282028def _draw2Objects():
    20292029    # 100 points sin function, plotted as green dots
    2030     data1 = 2.*_Numeric.pi*_Numeric.arange(200)/200.
     2030    data1 = 2.*np.pi*np.arange(200)/200.
    20312031    data1.shape = (100, 2)
    2032     data1[:,1] = _Numeric.sin(data1[:,0])
     2032    data1[:,1] = np.sin(data1[:,0])
    20332033    line1 = PolySpline(data1, legend='Green Line', colour='green', width=6, style=wx.PENSTYLE_DOT)
    20342034
    20352035    # 50 points cos function, plotted as red dot-dash
    2036     data1 = 2.*_Numeric.pi*_Numeric.arange(100)/100.
     2036    data1 = 2.*np.pi*np.arange(100)/100.
    20372037    data1.shape = (50,2)
    2038     data1[:,1] = _Numeric.cos(data1[:,0])
     2038    data1[:,1] = np.cos(data1[:,0])
    20392039    line2 = PolySpline(data1, legend='Red Line', colour='red', width=3, style= wx.PENSTYLE_DOT_DASH)
    20402040
    20412041    # A few more points...
    2042     pi = _Numeric.pi
     2042    pi = np.pi
    20432043    markers1 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
    20442044                          (3.*pi/4., -1)], legend='Cross Hatch Square', colour='blue', width= 3, size= 6,
    20452045                          fillcolour= 'red', fillstyle= wx.CROSSDIAG_HATCH,
     
    20582058
    20592059def _draw4Objects():
    20602060    # 25,000 point line
    2061     data1 = _Numeric.arange(5e5,1e6,10)
     2061    data1 = np.arange(5e5,1e6,10)
    20622062    data1.shape = (25000, 2)
    20632063    line1 = PolyLine(data1, legend='Wide Line', colour='green', width=5)
    20642064
     
    20932093                        "Bar Graph - (Turn on Grid, Legend)", "Months", "Number of Students")
    20942094def _draw7Objects():
    20952095    # Empty graph with axis defined but no points/lines
    2096     x = _Numeric.arange(1,1000,1)
     2096    x = np.arange(1,1000,1)
    20972097    y1 = 4.5*x**2
    20982098    y2 = 2.2*x**3
    2099     points1 = _Numeric.transpose([x,y1])
    2100     points2 = _Numeric.transpose([x,y2])
     2099    points1 = np.transpose([x,y1])
     2100    points2 = np.transpose([x,y2])
    21012101    line1 = PolyLine(points1, legend='quadratic', colour='blue', width=1)
    21022102    line2 = PolyLine(points2, legend='cubic', colour='red', width=1)
    21032103    return PlotGraphics([line1,line2], "double log plot", "Value X", "Value Y")