+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
+
+
+
+
+
-"""Renamer stub: provides a way to drop the wx prefix from wxPython objects."""
-from wx import _rename
-from wxPython.lib import floatcanvas
-_rename(globals(), floatcanvas.__dict__, modulename='lib.floatcanvas')
-del floatcanvas
-del _rename
projects / wxWidgets.git / blobdiff