+++ /dev/null
-import wx
-
-from Numeric import array,Float,cos,pi,sum,minimum,maximum,Int32
-from time import clock, sleep
-import types
-import os
-
-ID_ZOOM_IN_BUTTON = wx.NewId()
-ID_ZOOM_OUT_BUTTON = wx.NewId()
-ID_ZOOM_TO_FIT_BUTTON = wx.NewId()
-ID_MOVE_MODE_BUTTON = wx.NewId()
-ID_TEST_BUTTON = wx.NewId()
-
-ID_ABOUT_MENU = wx.NewId()
-ID_EXIT_MENU = wx.NewId()
-ID_ZOOM_TO_FIT_MENU = wx.NewId()
-ID_DRAWTEST_MENU = wx.NewId()
-ID_DRAWMAP_MENU = wx.NewId()
-ID_CLEAR_MENU = wx.NewId()
-
-ID_TEST = wx.NewId()
-
-
-### These are some functions for bitmaps of icons.
-import cPickle, zlib
-
-def GetHandData():
- return cPickle.loads(zlib.decompress(
-'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
-\x01\xc8S\xb6t\x06A(\x1f\x0b\xa0\xa9\x8c\x9e\x1e6\x19\xa0\xa8\x1e\x88\xd4C\
-\x97\xd1\x83\xe8\x80 \x9c2zh\xa6\xc1\x11X\n\xab\x8c\x02\x8a\x0cD!\x92\x12\
-\x98\x8c\x1e\x8a\x8b\xd1d\x14\xf4\x90%\x90LC\xf6\xbf\x1e\xba\xab\x91%\xd0\
-\xdc\x86C\x06\xd9m\xe8!\xaa\x87S\x86\x1a1\xa7\x07\x00v\x0f[\x17' ))
-
-def GetHandBitmap():
- return wx.BitmapFromXPMData(GetHandData())
-
-#----------------------------------------------------------------------
-def GetPlusData():
- return cPickle.loads(zlib.decompress(
-'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
-\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=l2`\r\
-\xe82HF\xe9a\xc8\xe8\xe9A\x9c@\x8a\x0c\x0e\xd3p\xbb\x00\x8f\xab\xe1>\xd5\xd3\
-\xc3\x15:P)l!\n\x91\xc2\x1a\xd6`)\xec\xb1\x00\x92\xc2\x11?\xb8e\x88\x8fSt\
-\x19=\x00\x82\x16[\xf7' ))
-
-def GetPlusBitmap():
- return wx.BitmapFromXPMData(GetPlusData())
-
-#----------------------------------------------------------------------
-def GetMinusData():
- return cPickle.loads(zlib.decompress(
-'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
-\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=\xa2e\
-\x10\x16@\x99\xc82zz\x10\'\x90"\x83\xc34r\xdc\x86\xf0\xa9\x9e\x1e\xae\xd0\
-\x81Ja\x0bQ\x88\x14\xd6\xb0\x06Ka\x8f\x05\x90\x14\x8e\xf8\xc1-C|\x9c\xa2\xcb\
-\xe8\x01\x00\xed\x0f[\x87' ))
-
-def GetMinusBitmap():
- return wx.BitmapFromXPMData(GetMinusData())
-
-## This is a bunch of stuff for implimenting interactive use: catching
-## when objects are clicked on by the mouse, etc. I've made a start, so if
-## you are interesed in making that work, let me know, I may have gotten
-## it going by then
-
-#### I probably want a full set of events someday:
-## #### mouse over, right click, left click mouse up etc, etc.
-## ##FLOATCANVAS_EVENT_LEFT_DOWN = wx.NewEventType()
-## ##FLOATCANVAS_EVENT_LEFT_UP = wx.NewEventType()
-## ##FLOATCANVAS_EVENT_RIGHT_DOWN = wx.NewEventType()
-## ##FLOATCANVAS_EVENT_RIGHT_UP = wx.NewEventType()
-## ##FLOATCANVAS_EVENT_MOUSE_OVER = wx.NewEventType()
-
-##WXFLOATCANVASEVENT = wx.NewEventType()
-
-##def EVT_WXFLOATCANVASEVENT( window, function ):
-
-## """Your documentation here"""
-
-## window.Connect( -1, -1, WXFLOATCANVASEVENT, function )
-
-##class wxFloatCanvasObjectEvent(wx.PyCommandEvent):
-## def __init__(self, WindowID,Object):
-## wx.PyCommandEvent.__init__(self, WXFLOATCANVASEVENT, WindowID)
-## self.Object = Object
-
-## def Clone( self ):
-## self.__class__( self.GetId() )
-
-##class ColorGenerator:
-
-## """ An instance of this class generates a unique color each time
-## GetNextColor() is called. Someday I will use a proper Python
-## generator for this class.
-
-## The point of this generator is for the hit-test bitmap, each object
-## needs to be a unique color. Also, each system can be running a
-## different number of colors, and it doesn't appear to be possible to
-## have a wxMemDC with a different colordepth as the screen so this
-## generates colors far enough apart that they can be distinguished on
-## a 16bit screen. Anything less than 16bits won't work.
-## """
-
-## def __init__(self,depth = 16):
-## self.r = 0
-## self.g = 0
-## self.b = 0
-## if depth == 16:
-## self.step = 8
-## elif depth >= 24:
-## self.step = 1
-## else:
-## raise "ColorGenerator does not work with depth = %s"%depth
-
-## def GetNextColor(self):
-## step = self.step
-## ##r,g,b = self.r,self.g,self.b
-## self.r += step
-## if self.r > 255:
-## self.r = step
-## self.g += step
-## if self.g > 255:
-## self.g = step
-## self.b += step
-## if self.b > 255:
-## ## fixme: this should be a derived exception
-## raise "Too many objects for HitTest"
-## return (self.r,self.g,self.b)
-
-
-class draw_object:
- """
- This is the base class for all the objects that can be drawn.
-
- each object has the following properties; (incomplete)
-
- BoundingBox : is of the form: array((min_x,min_y),(max_x,max_y))
- Pen
- Brush
-
- """
-
- def __init__(self,Foreground = 0):
- self.Foreground = Foreground
-
- self._Canvas = None
-
- # I pre-define all these as class variables to provide an easier
- # interface, and perhaps speed things up by caching all the Pens
- # and Brushes, although that may not help, as I think wx now
- # does that on it's own. Send me a note if you know!
-
- BrushList = {
- ( None,"Transparent") : wx.TRANSPARENT_BRUSH,
- ("Blue","Solid") : wx.BLUE_BRUSH,
- ("Green","Solid") : wx.GREEN_BRUSH,
- ("White","Solid") : wx.WHITE_BRUSH,
- ("Black","Solid") : wx.BLACK_BRUSH,
- ("Grey","Solid") : wx.GREY_BRUSH,
- ("MediumGrey","Solid") : wx.MEDIUM_GREY_BRUSH,
- ("LightGrey","Solid") : wx.LIGHT_GREY_BRUSH,
- ("Cyan","Solid") : wx.CYAN_BRUSH,
- ("Red","Solid") : wx.RED_BRUSH
- }
- PenList = {
- (None,"Transparent",1) : wx.TRANSPARENT_PEN,
- ("Green","Solid",1) : wx.GREEN_PEN,
- ("White","Solid",1) : wx.WHITE_PEN,
- ("Black","Solid",1) : wx.BLACK_PEN,
- ("Grey","Solid",1) : wx.GREY_PEN,
- ("MediumGrey","Solid",1) : wx.MEDIUM_GREY_PEN,
- ("LightGrey","Solid",1) : wx.LIGHT_GREY_PEN,
- ("Cyan","Solid",1) : wx.CYAN_PEN,
- ("Red","Solid",1) : wx.RED_PEN
- }
-
- FillStyleList = {
- "Transparent" : wx.TRANSPARENT,
- "Solid" : wx.SOLID,
- "BiDiagonalHatch": wx.BDIAGONAL_HATCH,
- "CrossDiagHatch" : wx.CROSSDIAG_HATCH,
- "FDiagonal_Hatch": wx.FDIAGONAL_HATCH,
- "CrossHatch" : wx.CROSS_HATCH,
- "HorizontalHatch": wx.HORIZONTAL_HATCH,
- "VerticalHatch" : wx.VERTICAL_HATCH
- }
-
- LineStyleList = {
- "Solid" : wx.SOLID,
- "Transparent": wx.TRANSPARENT,
- "Dot" : wx.DOT,
- "LongDash" : wx.LONG_DASH,
- "ShortDash" : wx.SHORT_DASH,
- "DotDash" : wx.DOT_DASH,
- }
-
- def SetBrush(self,FillColor,FillStyle):
- if FillColor is None or FillStyle is None:
- self.Brush = wx.TRANSPARENT_BRUSH
- self.FillStyle = "Transparent"
- else:
- if not self.BrushList.has_key((FillColor,FillStyle)):
- self.BrushList[(FillColor,FillStyle)] = wx.Brush(FillColor,self.FillStyleList[FillStyle])
- self.Brush = self.BrushList[(FillColor,FillStyle)]
-
- def SetPen(self,LineColor,LineStyle,LineWidth):
- if (LineColor is None) or (LineStyle is None):
- self.Pen = wx.TRANSPARENT_PEN
- self.LineStyle = 'Transparent'
- else:
- if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
- self.PenList[(LineColor,LineStyle,LineWidth)] = wx.Pen(LineColor,LineWidth,self.LineStyleList[LineStyle])
- self.Pen = self.PenList[(LineColor,LineStyle,LineWidth)]
-
- def SetPens(self,LineColors,LineStyles,LineWidths):
- """
- This method used when an object could have a list of pens, rather than just one
- It is used for LineSet, and perhaps others in the future.
-
- fixme: this is really kludgy, there has got to be a better way!
-
- """
-
- length = 1
- if type(LineColors) == types.ListType:
- length = len(LineColors)
- else:
- LineColors = [LineColors]
-
- if type(LineStyles) == types.ListType:
- length = len(LineStyles)
- else:
- LineStyles = [LineStyles]
-
- if type(LineWidths) == types.ListType:
- length = len(LineWidths)
- else:
- LineWidths = [LineWidths]
-
- if length > 1:
- if len(LineColors) == 1:
- LineColors = LineColors*length
- if len(LineStyles) == 1:
- LineStyles = LineStyles*length
- if len(LineWidths) == 1:
- LineWidths = LineWidths*length
-
- self.Pens = []
- for (LineColor,LineStyle,LineWidth) in zip(LineColors,LineStyles,LineWidths):
- if LineColor is None or LineStyle is None:
- self.Pens.append(wx.TRANSPARENT_PEN)
- # what's this for?> self.LineStyle = 'Transparent'
- if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
- Pen = wx.Pen(LineColor,LineWidth,self.LineStyleList[LineStyle])
- self.Pens.append(Pen)
- else:
- self.Pens.append(self.PenList[(LineColor,LineStyle,LineWidth)])
- if length == 1:
- self.Pens = self.Pens[0]
-
- def PutInBackground(self):
- if self._Canvas and self.Foreground:
- self._Canvas._TopDrawList.remove(self)
- self._Canvas._DrawList.append(self)
- self._Canvas._BackgroundDirty = 1
- self.Foreground = 0
-
- def PutInForeground(self):
- if self._Canvas and (not self.Foreground):
- self._Canvas._TopDrawList.append(self)
- self._Canvas._DrawList.remove(self)
- self._Canvas._BackgroundDirty = 1
- self.Foreground = 1
-
-
-class Polygon(draw_object):
-
- """
-
- The Polygon class takes a list of 2-tuples, or a NX2 NumPy array of
- point coordinates. so that Points[N][0] is the x-coordinate of
- point N and Points[N][1] is the y-coordinate or Points[N,0] is the
- x-coordinate of point N and Points[N,1] is the y-coordinate for
- arrays.
-
- """
- def __init__(self,Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
- draw_object.__init__(self,Foreground)
- self.Points = array(Points,Float)
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
-
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
- self.FillColor = FillColor
- self.FillStyle = FillStyle
-
- self.SetPen(LineColor,LineStyle,LineWidth)
- self.SetBrush(FillColor,FillStyle)
-
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- Points = WorldToPixel(self.Points)
- dc.SetPen(self.Pen)
- dc.SetBrush(self.Brush)
- #dc.DrawPolygon(map(lambda x: (x[0],x[1]), Points.tolist()))
- dc.DrawPolygon(Points)
-
-class PolygonSet(draw_object):
- """
- The PolygonSet class takes a Geometry.Polygon object.
- so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
-
- it creates a set of line segments, from (x1,y1) to (x2,y2)
-
- """
-
- def __init__(self,PolySet,LineColors,LineStyles,LineWidths,FillColors,FillStyles,Foreground = 0):
- draw_object.__init__(self, Foreground)
-
- ##fixme: there should be some error checking for everything being the right length.
-
-
- self.Points = array(Points,Float)
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
-
- self.LineColors = LineColors
- self.LineStyles = LineStyles
- self.LineWidths = LineWidths
- self.FillColors = FillColors
- self.FillStyles = FillStyles
-
- self.SetPens(LineColors,LineStyles,LineWidths)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- Points = WorldToPixel(self.Points)
- Points.shape = (-1,4)
- dc.DrawLineList(Points,self.Pens)
-
-
-class Line(draw_object):
- """
- The Line class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
- so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
- or Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
-
- It will draw a straight line if there are two points, and a polyline if there are more than two.
-
- """
- def __init__(self,Points,LineColor,LineStyle,LineWidth,Foreground = 0):
- draw_object.__init__(self, Foreground)
-
- self.Points = array(Points,Float)
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
-
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
-
- self.SetPen(LineColor,LineStyle,LineWidth)
-
- def SetPoints(self,Points):
- self.Points = Points
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
- if self._Canvas:
- # It looks like this shouldn't be private
- self._Canvas.BoundingBoxDirty = 1
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- Points = WorldToPixel(self.Points)
- dc.SetPen(self.Pen)
- #dc.DrawLines(map(lambda x: (x[0],x[1]), Points.tolist()))
- dc.DrawLines(Points)
-
-
-class LineSet(draw_object):
- """
- The LineSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
- so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
-
- it creates a set of line segments, from (x1,y1) to (x2,y2)
-
- """
-
- def __init__(self,Points,LineColors,LineStyles,LineWidths,Foreground = 0):
- draw_object.__init__(self, Foreground)
-
- NumLines = len(Points) / 2
- ##fixme: there should be some error checking for everything being the right length.
-
-
- self.Points = array(Points,Float)
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
-
- self.LineColors = LineColors
- self.LineStyles = LineStyles
- self.LineWidths = LineWidths
-
- self.SetPens(LineColors,LineStyles,LineWidths)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- Points = WorldToPixel(self.Points)
- Points.shape = (-1,4)
- dc.DrawLineList(Points,self.Pens)
-
-
-class PointSet(draw_object):
- """
- The PointSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
- so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
- or Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
-
- Each point will be drawn the same color and Diameter. The Diameter is in screen points,
- not world coordinates.
-
- """
- def __init__(self,Points,Color,Diameter,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.Points = array(Points,Float)
- self.Points.shape = (-1,2) # Make sure it is a NX2 array, even if there is only one point
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
-
- self.Color = Color
- self.Diameter = Diameter
-
- self.SetPen(Color,"Solid",1)
- self.SetBrush(Color,"Solid")
-
- def SetPoints(self,Points):
- self.Points = Points
- self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
- if self._Canvas:
- # It looks like this shouldn't be private
- self._Canvas.BoundingBoxDirty = 1
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- dc.SetPen(self.Pen)
- Points = WorldToPixel(self.Points)
- if self.Diameter <= 1:
- dc.DrawPointList(Points)
- elif self.Diameter <= 2:
- # A Little optimization for a diameter2 - point
- dc.DrawPointList(Points)
- dc.DrawPointList(Points + (1,0))
- dc.DrawPointList(Points + (0,1))
- dc.DrawPointList(Points + (1,1))
- else:
- dc.SetBrush(self.Brush)
- radius = int(round(self.Diameter/2))
- for (x,y) in Points:
- dc.DrawEllipse((x - radius), (y - radius), self.Diameter, self.Diameter)
-
-
-
-class Dot(draw_object):
- """
- The Dot class takes an x.y coordinate pair, and the Diameter of the circle.
- The Diameter is in pixels, so it won't change with zoom.
-
- Also Fill and line data
-
- """
- def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.X = x
- self.Y = y
- self.Diameter = Diameter
- # NOTE: the bounding box does not include the diameter of the dot, as that is in pixel coords.
- # If this is a problem, perhaps you should use a circle, instead!
- self.BoundingBox = array(((x,y),(x,y)),Float)
-
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
- self.FillColor = FillColor
- self.FillStyle = FillStyle
-
- self.SetPen(LineColor,LineStyle,LineWidth)
- self.SetBrush(FillColor,FillStyle)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- dc.SetPen(self.Pen)
- dc.SetBrush(self.Brush)
- radius = int(round(self.Diameter/2))
- (X,Y) = WorldToPixel((self.X,self.Y))
- dc.DrawEllipse((X - radius), (Y - radius), self.Diameter, self.Diameter)
-
-
-class Rectangle(draw_object):
- def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.X = x
- self.Y = y
- self.Width = width
- self.Height = height
- self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
- self.FillColor = FillColor
- self.FillStyle = FillStyle
-
- self.SetPen(LineColor,LineStyle,LineWidth)
- self.SetBrush(FillColor,FillStyle)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- (X,Y) = WorldToPixel((self.X,self.Y))
- (Width,Height) = ScaleFunction((self.Width,self.Height))
-
- dc.SetPen(self.Pen)
- dc.SetBrush(self.Brush)
- dc.DrawRectangle(X,Y, Width,Height)
-
-class Ellipse(draw_object):
- def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.X = x
- self.Y = y
- self.Width = width
- self.Height = height
- self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
- self.FillColor = FillColor
- self.FillStyle = FillStyle
-
- self.SetPen(LineColor,LineStyle,LineWidth)
- self.SetBrush(FillColor,FillStyle)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- (X,Y) = WorldToPixel((self.X,self.Y))
- (Width,Height) = ScaleFunction((self.Width,self.Height))
-
- dc.SetPen(self.Pen)
- dc.SetBrush(self.Brush)
- dc.DrawEllipse(X,Y, Width,Height)
-
-class Circle(draw_object):
- def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.X = x
- self.Y = y
- self.Diameter = Diameter
- self.BoundingBox = array(((x-Diameter/2,y-Diameter/2),(x+Diameter/2,y+Diameter/2)),Float)
- self.LineColor = LineColor
- self.LineStyle = LineStyle
- self.LineWidth = LineWidth
- self.FillColor = FillColor
- self.FillStyle = FillStyle
-
- self.SetPen(LineColor,LineStyle,LineWidth)
- self.SetBrush(FillColor,FillStyle)
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- (X,Y) = WorldToPixel((self.X,self.Y))
- (Diameter,dummy) = ScaleFunction((self.Diameter,self.Diameter))
-
- dc.SetPen(self.Pen)
- dc.SetBrush(self.Brush)
- dc.DrawEllipse(X-Diameter/2,Y-Diameter/2, Diameter,Diameter)
-
-class Text(draw_object):
- """
-
- This class creates a text object, placed at the coordinates,
- x,y. the "Position" argument is a two charactor string, indicating
- where in relation to the coordinates the string should be oriented.
-
- The first letter is: t, c, or b, for top, center and bottom
- The second letter is: l, c, or r, for left, center and right
-
- I've provided arguments for Family, Style, and Weight of font, but
- have not yet implimented them, so all text is: wx.SWISS, wx.NORMAL, wx.NORMAL.
- I'd love it if someone would impliment that!
-
- The size is fixed, and does not scale with the drawing.
-
- """
-
- def __init__(self,String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground = 0):
- draw_object.__init__(self,Foreground)
-
- self.String = String
- self.Size = Size
-
- self.ForeGround = ForeGround
- if BackGround is None:
- self.BackGround = None
- else:
- self.BackGround = BackGround
- self.Family = Family
- self.Style = Style
- self.Weight = Weight
- self.Underline = Underline
- self.Position = Position
- # fixme: this should use the passed in parameters!
- self.Font = wx.Font(Size, wx.MODERN, wx.NORMAL, wx.NORMAL, Underline, )
-
- self.BoundingBox = array(((x,y),(x,y)),Float)
-
- self.X = x
- self.Y = y
- self.x_shift = None
- self.y_shift = None
-
- def _Draw(self,dc,WorldToPixel,ScaleFunction):
- (X,Y) = WorldToPixel((self.X,self.Y))
- dc.SetFont(self.Font)
- dc.SetTextForeground(self.ForeGround)
- if self.BackGround:
- dc.SetBackgroundMode(wx.SOLID)
- dc.SetTextBackground(self.BackGround)
- else:
- dc.SetBackgroundMode(wx.TRANSPARENT)
-
- # compute the shift, and adjust the coordinates, if neccesary
- # This had to be put in here, becsuse there is no wx.DC during __init__
- if self.x_shift is None or self.y_shift is None:
- if self.Position == 'tl':
- x_shift,y_shift = 0,0
- else:
- (w,h) = dc.GetTextExtent(self.String)
- if self.Position[0] == 't':
- y_shift = 0
- elif self.Position[0] == 'c':
- y_shift = h/2
- elif self.Position[0] == 'b':
- y_shift = h
- else:
- ##fixme: this should be a real derived exception
- raise "Invalid value for Text Object Position Attribute"
- if self.Position[1] == 'l':
- x_shift = 0
- elif self.Position[1] == 'c':
- x_shift = w/2
- elif self.Position[1] == 'r':
- x_shift = w
- else:
- ##fixme: this should be a real derived exception
- raise "Invalid value for Text Object Position Attribute"
- self.x_shift = x_shift
- self.y_shift = y_shift
- dc.DrawText(self.String, X-self.x_shift, Y-self.y_shift)
-
-
-#---------------------------------------------------------------------------
-
-class FloatCanvas(wx.Panel):
- """
- FloatCanvas.py
-
- This is a high level window for drawing maps and anything else in an
- arbitrary coordinate system.
-
- The goal is to provide a convenient way to draw stuff on the screen
- without having to deal with handling OnPaint events, converting to pixel
- coordinates, knowing about wxWindows brushes, pens, and colors, etc. It
- also provides virtually unlimited zooming and scrolling
-
- I am using it for two things:
- 1) general purpose drawing in floating point coordinates
- 2) displaying map data in Lat-long coordinates
-
- If the projection is set to None, it will draw in general purpose
- floating point coordinates. If the projection is set to 'FlatEarth', it
- will draw a FlatEarth projection, centered on the part of the map that
- you are viewing. You can also pass in your own projection function.
-
- It is double buffered, so re-draws after the window is uncovered by something
- else are very quick.
-
- It relies on NumPy, which is needed for speed
-
- Bugs and Limitations:
- Lots: patches, fixes welcome
-
- For Map drawing: It ignores the fact that the world is, in fact, a
- sphere, so it will do strange things if you are looking at stuff near
- the poles or the date line. so far I don't have a need to do that, so I
- havn't bothered to add any checks for that yet.
-
- Zooming:
- I have set no zoom limits. What this means is that if you zoom in really
- far, you can get integer overflows, and get wierd results. It
- doesn't seem to actually cause any problems other than wierd output, at
- least when I have run it.
-
- Speed:
- I have done a couple of things to improve speed in this app. The one
- thing I have done is used NumPy Arrays to store the coordinates of the
- points of the objects. This allowed me to use array oriented functions
- when doing transformations, and should provide some speed improvement
- for objects with a lot of points (big polygons, polylines, pointsets).
-
- The real slowdown comes when you have to draw a lot of objects, because
- you have to call the wx.DC.DrawSomething call each time. This is plenty
- fast for tens of objects, OK for hundreds of objects, but pretty darn
- slow for thousands of objects.
-
- The solution is to be able to pass some sort of object set to the DC
- directly. I've used DC.DrawPointList(Points), and it helped a lot with
- drawing lots of points. I havn't got a LineSet type object, so I havn't
- used DC.DrawLineList yet. I'd like to get a full set of DrawStuffList()
- methods implimented, and then I'd also have a full set of Object sets
- that could take advantage of them. I hope to get to it some day.
-
- Copyright: Christopher Barker
-
- License: Same as wxPython
-
- Please let me know if you're using this!!!
-
- Contact me at:
-
- Chris.Barker@noaa.gov
-
- """
-
- def __init__(self, parent, id = -1,
- size = wx.DefaultSize,
- ProjectionFun = None,
- BackgroundColor = "WHITE",
- Debug = 0,
- EnclosingFrame = None,
- UseToolbar = 1,
- UseBackground = 0,
- UseHitTest = 0):
-
- wx.Panel.__init__( self, parent, id, wx.DefaultPosition, size)
-
- if ProjectionFun == 'FlatEarth':
- self.ProjectionFun = self.FlatEarthProjection
- elif type(ProjectionFun) == types.FunctionType:
- self.ProjectionFun = ProjectionFun
- elif ProjectionFun is None:
- self.ProjectionFun = lambda x=None: array( (1,1), Float)
- else:
- raise('Projectionfun must be either: "FlatEarth", None, or a function that takes the ViewPortCenter and returns a MapProjectionVector')
-
- self.UseBackground = UseBackground
- self.UseHitTest = UseHitTest
-
- self.NumBetweenBlits = 40
-
- ## you can have a toolbar with buttons for zoom-in, zoom-out and
- ## move. If you don't use the toolbar, you should provide your
- ## own way of navigating the canvas
- if UseToolbar:
- ## Create the vertical sizer for the toolbar and Panel
- box = wx.BoxSizer(wx.VERTICAL)
- box.Add(self.BuildToolbar(), 0, wx.ALL | wx.ALIGN_LEFT | wx.GROW, 4)
-
- self.DrawPanel = wx.Window(self,-1,wx.DefaultPosition,wx.DefaultSize,wx.SUNKEN_BORDER)
- box.Add(self.DrawPanel,1,wx.GROW)
-
- box.Fit(self)
- self.SetAutoLayout(True)
- self.SetSizer(box)
- else:
- self.DrawPanel = self
-
- self.DrawPanel.BackgroundBrush = wx.Brush(BackgroundColor,wx.SOLID)
-
- self.Debug = Debug
-
- self.EnclosingFrame = EnclosingFrame
-
- wx.EVT_PAINT(self.DrawPanel, self.OnPaint)
- wx.EVT_SIZE(self.DrawPanel, self.OnSize)
-
- wx.EVT_LEFT_DOWN(self.DrawPanel, self.LeftButtonEvent)
- wx.EVT_LEFT_UP(self.DrawPanel, self.LeftButtonEvent)
- wx.EVT_RIGHT_DOWN(self.DrawPanel, self.RightButtonEvent)
- wx.EVT_MOTION(self.DrawPanel, self.LeftButtonEvent)
-
-
- self._DrawList = []
- if self.UseBackground:
- self._TopDrawList = []
- self.BoundingBox = None
- self.BoundingBoxDirty = 0
- self.ViewPortCenter= array( (0,0), Float)
-
- self.MapProjectionVector = array( (1,1), Float) # No Projection to start!
- self.TransformVector = array( (1,-1), Float) # default Transformation
-
- self.Scale = 1
-
- self.GUIMode = None
- self.StartRBBox = None
- self.PrevRBBox = None
- self.StartMove = None
- self.PrevMoveBox = None
- # called just to make sure everything is initialized
- if wx.Platform != "__WXMAC__":
- self.OnSize(None)
-
-
- def BuildToolbar(self):
- tb = wx.ToolBar(self,-1)
- self.ToolBar = tb
-
- tb.SetToolBitmapSize((23,23))
-
- tb.AddTool(ID_ZOOM_IN_BUTTON, GetPlusBitmap(), isToggle=True,shortHelpString = "Zoom In")
- wx.EVT_TOOL(self, ID_ZOOM_IN_BUTTON, self.SetMode)
-
- tb.AddTool(ID_ZOOM_OUT_BUTTON, GetMinusBitmap(), isToggle=True,shortHelpString = "Zoom Out")
- wx.EVT_TOOL(self, ID_ZOOM_OUT_BUTTON, self.SetMode)
-
- tb.AddTool(ID_MOVE_MODE_BUTTON, GetHandBitmap(), isToggle=True,shortHelpString = "Move")
- wx.EVT_TOOL(self, ID_MOVE_MODE_BUTTON, self.SetMode)
-
- tb.AddSeparator()
-
- tb.AddControl(wx.Button(tb, ID_ZOOM_TO_FIT_BUTTON, "Zoom To Fit",wx.DefaultPosition, wx.DefaultSize))
- wx.EVT_BUTTON(self, ID_ZOOM_TO_FIT_BUTTON, self.ZoomToFit)
-
- tb.Realize()
- return tb
-
- def SetMode(self,event):
- for id in [ID_ZOOM_IN_BUTTON,ID_ZOOM_OUT_BUTTON,ID_MOVE_MODE_BUTTON]:
- self.ToolBar.ToggleTool(id,0)
- self.ToolBar.ToggleTool(event.GetId(),1)
- if event.GetId() == ID_ZOOM_IN_BUTTON:
- self.SetGUIMode("ZoomIn")
- elif event.GetId() == ID_ZOOM_OUT_BUTTON:
- self.SetGUIMode("ZoomOut")
- elif event.GetId() == ID_MOVE_MODE_BUTTON:
- self.SetGUIMode("Move")
-
-
- def SetGUIMode(self,Mode):
- if Mode in ["ZoomIn","ZoomOut","Move",None]:
- self.GUIMode = Mode
- else:
- raise "Not a valid Mode"
-
- def FlatEarthProjection(self,CenterPoint):
- return array((cos(pi*CenterPoint[1]/180),1),Float)
-
- def LeftButtonEvent(self,event):
- if self.EnclosingFrame:
- if event.Moving:
- position = self.PixelToWorld((event.GetX(),event.GetY()))
- self.EnclosingFrame.SetStatusText("%8.3f, %8.3f"%tuple(position))
- if self.GUIMode:
- if self.GUIMode == "ZoomIn":
- if event.LeftDown():
- self.StartRBBox = (event.GetX(),event.GetY())
- self.PrevRBBox = None
- elif event.Dragging() and event.LeftIsDown() and self.StartRBBox:
- x0,y0 = self.StartRBBox
- x1,y1 = event.GetX(),event.GetY()
- w, h = abs(x1-x0),abs(y1-y0)
- w = max(w,int(h*self.AspectRatio))
- h = int(w/self.AspectRatio)
- x_c, y_c = (x0+x1)/2 , (y0+y1)/2
- dc = wx.ClientDC(self.DrawPanel)
- dc.BeginDrawing()
- dc.SetPen(wx.Pen('WHITE', 2,wx.SHORT_DASH))
- dc.SetBrush(wx.TRANSPARENT_BRUSH)
- dc.SetLogicalFunction(wx.XOR)
- if self.PrevRBBox:
- dc.DrawRectangle(*self.PrevRBBox)
- dc.DrawRectangle(x_c-w/2,y_c-h/2,w,h)
- self.PrevRBBox = (x_c-w/2,y_c-h/2,w,h)
- dc.EndDrawing()
-
- elif event.LeftUp() and self.StartRBBox :
- self.PrevRBBox = None
- EndRBBox = (event.GetX(),event.GetY())
- StartRBBox = self.StartRBBox
- # if mouse has moved less that ten pixels, don't use the box.
- if abs(StartRBBox[0] - EndRBBox[0]) > 10 and abs(StartRBBox[1] - EndRBBox[1]) > 10:
- EndRBBox = self.PixelToWorld(EndRBBox)
- StartRBBox = self.PixelToWorld(StartRBBox)
- BB = array(((min(EndRBBox[0],StartRBBox[0]), min(EndRBBox[1],StartRBBox[1])),
- (max(EndRBBox[0],StartRBBox[0]), max(EndRBBox[1],StartRBBox[1]))),Float)
- self.ZoomToBB(BB)
- else:
- Center = self.PixelToWorld(StartRBBox)
- self.Zoom(1.5,Center)
- self.StartRBBox = None
-
- if self.GUIMode == "ZoomOut":
- if event.LeftDown():
- Center = self.PixelToWorld((event.GetX(),event.GetY()))
- self.Zoom(1/1.5,Center)
- elif self.GUIMode == "Move":
- if event.LeftDown():
- self.StartMove = array((event.GetX(),event.GetY()))
- self.PrevMoveBox = None
- elif event.Dragging() and event.LeftIsDown() and self.StartMove:
- x_1,y_1 = event.GetX(),event.GetY()
- w, h = self.PanelSize
- x_tl, y_tl = x_1 - self.StartMove[0], y_1 - self.StartMove[1]
- dc = wx.ClientDC(self.DrawPanel)
- dc.BeginDrawing()
- dc.SetPen(wx.Pen('WHITE', 1,))
- dc.SetBrush(wx.TRANSPARENT_BRUSH)
- dc.SetLogicalFunction(wx.XOR)
- if self.PrevMoveBox:
- dc.DrawRectangle(*self.PrevMoveBox)
- dc.DrawRectangle(x_tl,y_tl,w,h)
- self.PrevMoveBox = (x_tl,y_tl,w,h)
- dc.EndDrawing()
-
- elif event.LeftUp() and self.StartMove:
- self.PrevMoveBox = None
- StartMove = self.StartMove
- EndMove = array((event.GetX(),event.GetY()))
- if sum((StartMove-EndMove)**2) > 16:
- self.Move(StartMove-EndMove,'Pixel')
- self.StartMove = None
-
- def RightButtonEvent(self,event):
- if self.GUIMode:
- if self.GUIMode == "ZoomIn":
- Center = self.PixelToWorld((event.GetX(),event.GetY()))
- self.Zoom(1/1.5,Center)
- elif self.GUIMode == "ZoomOut":
- Center = self.PixelToWorld((event.GetX(),event.GetY()))
- self.Zoom(1.5,Center)
- else:
- event.Skip()
- event.Skip()
-
- def MakeNewBuffers(self):
- # Make new offscreen bitmap:
- self._Buffer = wx.EmptyBitmap(self.PanelSize[0],self.PanelSize[1])
- if self.UseBackground:
- self._BackBuffer = wx.EmptyBitmap(self.PanelSize[0],self.PanelSize[1])
- self._BackgroundDirty = 1
- else:
- pass
-
- def OnSize(self,event):
- self.PanelSize = array(self.DrawPanel.GetClientSizeTuple(),Int32)
- try:
- self.AspectRatio = self.PanelSize[0]/self.PanelSize[1]
- except ZeroDivisionError:
- self.AspectRatio = 1.0
- self.MakeNewBuffers()
- self.Draw()
-
- def OnPaint(self, event):
- #dc = wx.BufferedPaintDC(self.DrawPanel, self._Buffer)
- dc = wx.PaintDC(self.DrawPanel)
- dc.DrawBitmap(self._Buffer, 0,0)
-
- def Draw(self):
- """
- The Draw method gets pretty complicated because of all the buffers
-
- There is a main buffer set up to double buffer the screen, so
- you can get quick re-draws when the window gets uncovered.
-
- If self.UseBackground is set, and an object is set up with the
- "ForeGround" flag, then it gets drawn to the screen after blitting
- the background. This is done so that you can have a complicated
- background, but have something changing on the foreground,
- without having to wait for the background to get re-drawn. This
- can be used to support simple animation, for instance.
-
- """
- if self.Debug: start = clock()
- ScreenDC = wx.ClientDC(self.DrawPanel)
- ViewPortWorld = ( self.PixelToWorld((0,0)), self.PixelToWorld(self.PanelSize) )
- ViewPortBB = array( ( minimum.reduce(ViewPortWorld), maximum.reduce(ViewPortWorld) ) )
- if self.UseBackground:
- dc = wx.MemoryDC()
- dc.SelectObject(self._BackBuffer)
- dc.SetBackground(self.DrawPanel.BackgroundBrush)
- if self._DrawList:
- if self._BackgroundDirty:
- dc.BeginDrawing()
- dc.Clear()
- i = 0
- for Object in self._DrawList:
- if self.BBCheck(Object.BoundingBox,ViewPortBB):
- #print "object is in Bounding Box"
- i+=1
- Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
- if i % self.NumBetweenBlits == 0:
- w,h = self.PanelSize
- ScreenDC.Blit(0, 0, w,h, dc, 0, 0)
- dc.EndDrawing()
- else:
- dc.Clear()
- self._BackgroundDirty = 0
- dc.SelectObject(self._Buffer)
- dc.BeginDrawing()
- ##Draw Background on Main Buffer:
- dc.DrawBitmap(self._BackBuffer,0,0)
- #Draw the OnTop stuff
- i = 0
- for Object in self._TopDrawList:
- i+=1
- Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
- if i % self.NumBetweenBlits == 0:
- w, h = self.PanelSize
- ScreenDC.Blit(0, 0, w,h, dc, 0, 0)
- dc.EndDrawing()
- else: # not using a Background DC
- dc = wx.MemoryDC()
- dc.SelectObject(self._Buffer)
- dc.SetBackground(self.DrawPanel.BackgroundBrush)
- if self._DrawList:
- dc.BeginDrawing()
- dc.Clear()
- i = 0
- for Object in self._DrawList:
- if self.BBCheck(Object.BoundingBox,ViewPortBB):
- #print "object is in Bounding Box"
- i+=1
- Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
- if i % self.NumBetweenBlits == 0:
- w, h = self.PanelSize
- ScreenDC.Blit(0, 0, w, h, dc, 0, 0)
- dc.EndDrawing()
- else:
- dc.Clear()
- # now refresh the screen
- #ScreenDC.DrawBitmap(self._Buffer,0,0) #NOTE: uisng DrawBitmap didn't work right on MSW
- w, h = self.PanelSize
- ScreenDC.Blit(0, 0, w, h, dc, 0, 0)
-
- # If the canvas is in the middle of a zoom or move, the Rubber Band box needs to be re-drawn
- if self.PrevRBBox:
- ScreenDC.SetPen(wx.Pen('WHITE', 2,wx.SHORT_DASH))
- ScreenDC.SetBrush(wx.TRANSPARENT_BRUSH)
- ScreenDC.SetLogicalFunction(wx.XOR)
- ScreenDC.DrawRectangle(*self.PrevRBBox)
- elif self.PrevMoveBox:
- ScreenDC.SetPen(wx.Pen('WHITE', 1,))
- ScreenDC.SetBrush(wx.TRANSPARENT_BRUSH)
- ScreenDC.SetLogicalFunction(wx.XOR)
- ScreenDC.DrawRectangle(*self.PrevMoveBox)
- if self.Debug: print "Drawing took %f seconds of CPU time"%(clock()-start)
-
- def BBCheck(self, BB1, BB2):
- """
-
- BBCheck(BB1, BB2) returns True is the Bounding boxes intesect, False otherwise
-
- """
- if ( (BB1[1,0] > BB2[0,0]) and (BB1[0,0] < BB2[1,0]) and
- (BB1[1,1] > BB2[0,1]) and (BB1[0,1] < BB2[1,1]) ):
- return True
- else:
- return False
-
- def Move(self,shift,CoordType):
- """
- move the image in the window.
-
- shift is an (x,y) tuple, specifying the amount to shift in each direction
-
- It can be in any of three coordinates: Panel, Pixel, World,
- specified by the CoordType parameter
-
- Panel coordinates means you want to shift the image by some
- fraction of the size of the displaed image
-
- Pixel coordinates means you want to shift the image by some number of pixels
-
- World coordinates meand you want to shift the image by an amount
- in Floating point world coordinates
-
- """
-
- shift = array(shift,Float)
- if CoordType == 'Panel':# convert from panel coordinates
- shift = shift * array((-1,1),Float) *self.PanelSize/self.TransformVector
- elif CoordType == 'Pixel': # convert from pixel coordinates
- shift = shift/self.TransformVector
- elif CoordType == 'World': # No conversion
- pass
- else:
- raise 'CoordType must be either "Panel", "Pixel", or "World"'
-
- self.ViewPortCenter = self.ViewPortCenter + shift
- self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
- self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
- self._BackgroundDirty = 1
- self.Draw()
-
- def Zoom(self,factor,center = None):
-
- """
- Zoom(factor, center) changes the amount of zoom of the image by factor.
- If factor is greater than one, the image gets larger.
- If factor is less than one, the image gets smaller.
-
- Center is a tuple of (x,y) coordinates of the center of the viewport, after zooming.
- If center is not given, the center will stay the same.
-
- """
- self.Scale = self.Scale*factor
- if center:
- self.ViewPortCenter = array(center,Float)
- self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
- self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
- self._BackgroundDirty = 1
- self.Draw()
-
- def ZoomToFit(self,event):
- self.ZoomToBB()
-
- def ZoomToBB(self,NewBB = None,DrawFlag = 1):
-
- """
-
- Zooms the image to the bounding box given, or to the bounding
- box of all the objects on the canvas, if none is given.
-
- """
-
- if NewBB:
- BoundingBox = NewBB
- else:
- if self.BoundingBoxDirty:
- self._ResetBoundingBox()
- BoundingBox = self.BoundingBox
- if BoundingBox:
- self.ViewPortCenter = array(((BoundingBox[0,0]+BoundingBox[1,0])/2,
- (BoundingBox[0,1]+BoundingBox[1,1])/2 ),Float)
- self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
- # Compute the new Scale
- BoundingBox = BoundingBox * self.MapProjectionVector
- try:
- self.Scale = min((self.PanelSize[0] / (BoundingBox[1,0]-BoundingBox[0,0])),
- (self.PanelSize[1] / (BoundingBox[1,1]-BoundingBox[0,1])))*0.95
- except ZeroDivisionError: # this will happen if the BB has zero width or height
- try: #width
- self.Scale = (self.PanelSize[0] / (BoundingBox[1,0]-BoundingBox[0,0]))*0.95
- except ZeroDivisionError:
- try: # height
- self.Scale = (self.PanelSize[1] / (BoundingBox[1,1]-BoundingBox[0,1]))*0.95
- except ZeroDivisionError: #zero size! (must be a single point)
- self.Scale = 1
-
- self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
- if DrawFlag:
- self._BackgroundDirty = 1
- self.Draw()
-
- def RemoveObjects(self,Objects):
- for Object in Objects:
- self.RemoveObject(Object,ResetBB = 0)
- self.BoundingBoxDirty = 1
-
- def RemoveObject(self,Object,ResetBB = 1):
- if Object.Foreground:
- self._TopDrawList.remove(Object)
- else:
- self._DrawList.remove(Object)
- self._BackgroundDirty = 1
-
- if ResetBB:
- self.BoundingBoxDirty = 1
-
- def Clear(self, ResetBB = True):
- self._DrawList = []
- if self.UseBackground:
- self._TopDrawList = []
- self._BackgroundDirty = 1
- if ResetBB:
- self._ResetBoundingBox()
-
- def _AddBoundingBox(self,NewBB):
- if self.BoundingBox is None:
- self.BoundingBox = NewBB
- self.ZoomToBB(NewBB,DrawFlag = 0)
- else:
- self.BoundingBox = array(((min(self.BoundingBox[0,0],NewBB[0,0]),
- min(self.BoundingBox[0,1],NewBB[0,1])),
- (max(self.BoundingBox[1,0],NewBB[1,0]),
- max(self.BoundingBox[1,1],NewBB[1,1]))),Float)
- def _ResetBoundingBox(self):
- # NOTE: could you remove an item without recomputing the entire bounding box?
- self.BoundingBox = None
- if self._DrawList:
- self.BoundingBox = self._DrawList[0].BoundingBox
- for Object in self._DrawList[1:]:
- self._AddBoundingBox(Object.BoundingBox)
- if self.UseBackground:
- for Object in self._TopDrawList:
- self._AddBoundingBox(Object.BoundingBox)
- if self.BoundingBox is None:
- self.ViewPortCenter= array( (0,0), Float)
- self.TransformVector = array( (1,-1), Float)
- self.MapProjectionVector = array( (1,1), Float)
- self.Scale = 1
- self.BoundingBoxDirty = 0
-
- def PixelToWorld(self,Points):
- """
- Converts coordinates from Pixel coordinates to world coordinates.
-
- Points is a tuple of (x,y) coordinates, or a list of such tuples, or a NX2 Numpy array of x,y coordinates.
-
- """
- return (((array(Points,Float) - (self.PanelSize/2))/self.TransformVector) + self.ViewPortCenter)
-
- def WorldToPixel(self,Coordinates):
- """
- This function will get passed to the drawing functions of the objects,
- to transform from world to pixel coordinates.
- Coordinates should be a NX2 array of (x,y) coordinates, or
- a 2-tuple, or sequence of 2-tuples.
- """
- return (((array(Coordinates,Float) - self.ViewPortCenter)*self.TransformVector)+(self.PanelSize/2)).astype('i')
-
- def ScaleFunction(self,Lengths):
- """
- This function will get passed to the drawing functions of the objects,
- to Change a length from world to pixel coordinates.
-
- Lengths should be a NX2 array of (x,y) coordinates, or
- a 2-tuple, or sequence of 2-tuples.
- """
- return (array(Lengths,Float)*self.TransformVector).astype('i')
-
-
- ## This is a set of methods that add objects to the Canvas. It kind
- ## of seems like a lot of duplication, but I wanted to be able to
- ## instantiate the draw objects separatley form adding them, but
- ## also to be able to do add one oin one step. I'm open to better
- ## ideas...
- def AddRectangle(self,x,y,width,height,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- FillColor = None,
- FillStyle = "Solid",
- Foreground = 0):
- Object = Rectangle(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddEllipse(self,x,y,width,height,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- FillColor = None,
- FillStyle = "Solid",
- Foreground = 0):
- Object = Ellipse(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddCircle(self,x,y,Diameter,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- FillColor = None,
- FillStyle = "Solid",
- Foreground = 0):
- Object = Circle(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddDot(self,x,y,Diameter,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- FillColor = None,
- FillStyle = "Solid",
- Foreground = 0):
- Object = Dot(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddPolygon(self,Points,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- FillColor = None,
- FillStyle = "Solid",
- Foreground = 0):
-
- Object = Polygon(Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddLine(self,Points,
- LineColor = "Black",
- LineStyle = "Solid",
- LineWidth = 1,
- Foreground = 0):
-
- Object = Line(Points,LineColor,LineStyle,LineWidth,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddLineSet(self,Points,
- LineColors = "Black",
- LineStyles = "Solid",
- LineWidths = 1,
- Foreground = 0):
-
- Object = LineSet(Points,LineColors,LineStyles,LineWidths,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddPointSet(self,Points,
- Color = "Black",
- Diameter = 1,
- Foreground = 0):
-
- Object = PointSet(Points,Color,Diameter,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddText(self,String,x,y,
- Size = 20,
- ForeGround = 'Black',
- BackGround = None,
- Family = 'Swiss',
- Style = 'Normal',
- Weight = 'Normal',
- Underline = 0,
- Position = 'tl',
- Foreground = 0):
- Object = Text(String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground)
- self.AddObject(Object)
- return Object
-
- def AddObject(self,obj):
- # put in a reference to the Canvas, so remove and other stuff can work
- obj._Canvas = self
- if obj.Foreground and self.UseBackground:
- self._TopDrawList.append(obj)
- else:
- self._DrawList.append(obj)
- self._backgrounddirty = 1
- self._AddBoundingBox(obj.BoundingBox)
- return None
-
-
-
-
-
-
-
projects / wxWidgets.git / blobdiff