]> git.saurik.com Git - wxWidgets.git/blame - wxPython/wx/lib/floatcanvas.py
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fixed the code to actually work.
[wxWidgets.git] / wxPython / wx / lib / floatcanvas.py
CommitLineData
d14a1e28
RD		 1from Numeric import array,Float,cos,pi,sum,minimum,maximum,Int32
2
3from time import clock, sleep
4from wxPython.wx import *
5import types
6import os
7
8ID_ZOOM_IN_BUTTON = wxNewId()
9ID_ZOOM_OUT_BUTTON = wxNewId()
10ID_ZOOM_TO_FIT_BUTTON = wxNewId()
11ID_MOVE_MODE_BUTTON = wxNewId()
12ID_TEST_BUTTON = wxNewId()
13
14ID_ABOUT_MENU = wxNewId()
15ID_EXIT_MENU = wxNewId()
16ID_ZOOM_TO_FIT_MENU = wxNewId()
17ID_DRAWTEST_MENU = wxNewId()
18ID_DRAWMAP_MENU = wxNewId()
19ID_CLEAR_MENU = wxNewId()
20
21ID_TEST = wxNewId()
22
23
24### These are some functions for bitmaps of icons.
25import cPickle, zlib
26
27def GetHandData():
28 return cPickle.loads(zlib.decompress(
29'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
30\x01\xc8S\xb6t\x06A(\x1f\x0b\xa0\xa9\x8c\x9e\x1e6\x19\xa0\xa8\x1e\x88\xd4C\
31\x97\xd1\x83\xe8\x80 \x9c2zh\xa6\xc1\x11X\n\xab\x8c\x02\x8a\x0cD!\x92\x12\
32\x98\x8c\x1e\x8a\x8b\xd1d\x14\xf4\x90%\x90LC\xf6\xbf\x1e\xba\xab\x91%\xd0\
33\xdc\x86C\x06\xd9m\xe8!\xaa\x87S\x86\x1a1\xa7\x07\x00v\x0f[\x17' ))
34
35def GetHandBitmap():
36 return wxBitmapFromXPMData(GetHandData())
37
38#----------------------------------------------------------------------
39def GetPlusData():
40 return cPickle.loads(zlib.decompress(
41'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
42\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=l2`\r\
43\xe82HF\xe9a\xc8\xe8\xe9A\x9c@\x8a\x0c\x0e\xd3p\xbb\x00\x8f\xab\xe1>\xd5\xd3\
44\xc3\x15:P)l!\n\x91\xc2\x1a\xd6`)\xec\xb1\x00\x92\xc2\x11?\xb8e\x88\x8fSt\
45\x19=\x00\x82\x16[\xf7' ))
46
47def GetPlusBitmap():
48 return wxBitmapFromXPMData(GetPlusData())
49
50#----------------------------------------------------------------------
51def GetMinusData():
52 return cPickle.loads(zlib.decompress(
53'x\xda\xd3\xc8)0\xe4\nV72T\x00!\x05Cu\xae\xc4`u=\x85d\x05\xa7\x9c\xc4\xe4l0O\
54\x01\xc8S\xb6t\x06A(\x1f\x0b RF\x0f\x08\xb0\xc9@D\xe1r\x08\x19\xb8j=\xa2e\
55\x10\x16@\x99\xc82zz\x10\'\x90"\x83\xc34r\xdc\x86\xf0\xa9\x9e\x1e\xae\xd0\
56\x81Ja\x0bQ\x88\x14\xd6\xb0\x06Ka\x8f\x05\x90\x14\x8e\xf8\xc1-C|\x9c\xa2\xcb\
57\xe8\x01\x00\xed\x0f[\x87' ))
58
59def GetMinusBitmap():
60 return wxBitmapFromXPMData(GetMinusData())
61
62## This is a bunch of stuff for implimenting interactive use: catching
63## when objects are clicked on by the mouse, etc. I've made a start, so if
64## you are interesed in making that work, let me know, I may have gotten
65## it going by then
66
67#### I probably want a full set of events someday:
68## #### mouse over, right click, left click mouse up etc, etc.
69## ##FLOATCANVAS_EVENT_LEFT_DOWN = wxNewEventType()
70## ##FLOATCANVAS_EVENT_LEFT_UP = wxNewEventType()
71## ##FLOATCANVAS_EVENT_RIGHT_DOWN = wxNewEventType()
72## ##FLOATCANVAS_EVENT_RIGHT_UP = wxNewEventType()
73## ##FLOATCANVAS_EVENT_MOUSE_OVER = wxNewEventType()
74
75##WXFLOATCANVASEVENT = wxNewEventType()
76
77##def EVT_WXFLOATCANVASEVENT( window, function ):
78
79## """Your documentation here"""
80
81## window.Connect( -1, -1, WXFLOATCANVASEVENT, function )
82
83##class wxFloatCanvasObjectEvent(wxPyCommandEvent):
84## def __init__(self, WindowID,Object):
85## wxPyCommandEvent.__init__(self, WXFLOATCANVASEVENT, WindowID)
86## self.Object = Object
87
88## def Clone( self ):
89## self.__class__( self.GetId() )
90
91##class ColorGenerator:
92
93## """ An instance of this class generates a unique color each time
94## GetNextColor() is called. Someday I will use a proper Python
95## generator for this class.
96
97## The point of this generator is for the hit-test bitmap, each object
98## needs to be a unique color. Also, each system can be running a
99## different number of colors, and it doesn't appear to be possible to
100## have a wxMemDC with a different colordepth as the screen so this
101## generates colors far enough apart that they can be distinguished on
102## a 16bit screen. Anything less than 16bits won't work.
103## """
104
105## def __init__(self,depth = 16):
106## self.r = 0
107## self.g = 0
108## self.b = 0
109## if depth == 16:
110## self.step = 8
111## elif depth >= 24:
112## self.step = 1
113## else:
114## raise "ColorGenerator does not work with depth = %s"%depth
115
116## def GetNextColor(self):
117## step = self.step
118## ##r,g,b = self.r,self.g,self.b
119## self.r += step
120## if self.r > 255:
121## self.r = step
122## self.g += step
123## if self.g > 255:
124## self.g = step
125## self.b += step
126## if self.b > 255:
127## ## fixme: this should be a derived exception
128## raise "Too many objects for HitTest"
129## return (self.r,self.g,self.b)
130
131
132class draw_object:
133 """
134 This is the base class for all the objects that can be drawn.
135
136 each object has the following properties; (incomplete)
137
138 BoundingBox : is of the form: array((min_x,min_y),(max_x,max_y))
139 Pen
140 Brush
141
142 """
143
144 def __init__(self,Foreground = 0):
145 self.Foreground = Foreground
146
147 self._Canvas = None
148
149 # I pre-define all these as class variables to provide an easier
150 # interface, and perhaps speed things up by caching all the Pens
151 # and Brushes, although that may not help, as I think wx now
152 # does that on it's own. Send me a note if you know!
153
154 BrushList = {
155 ( None,"Transparent") : wxTRANSPARENT_BRUSH,
156 ("Blue","Solid") : wxBLUE_BRUSH,
157 ("Green","Solid") : wxGREEN_BRUSH,
158 ("White","Solid") : wxWHITE_BRUSH,
159 ("Black","Solid") : wxBLACK_BRUSH,
160 ("Grey","Solid") : wxGREY_BRUSH,
161 ("MediumGrey","Solid") : wxMEDIUM_GREY_BRUSH,
162 ("LightGrey","Solid") : wxLIGHT_GREY_BRUSH,
163 ("Cyan","Solid") : wxCYAN_BRUSH,
164 ("Red","Solid") : wxRED_BRUSH
165 }
166 PenList = {
167 (None,"Transparent",1) : wxTRANSPARENT_PEN,
168 ("Green","Solid",1) : wxGREEN_PEN,
169 ("White","Solid",1) : wxWHITE_PEN,
170 ("Black","Solid",1) : wxBLACK_PEN,
171 ("Grey","Solid",1) : wxGREY_PEN,
172 ("MediumGrey","Solid",1) : wxMEDIUM_GREY_PEN,
173 ("LightGrey","Solid",1) : wxLIGHT_GREY_PEN,
174 ("Cyan","Solid",1) : wxCYAN_PEN,
175 ("Red","Solid",1) : wxRED_PEN
176 }
177
178 FillStyleList = {
179 "Transparent" : wxTRANSPARENT,
180 "Solid" : wxSOLID,
181 "BiDiagonalHatch": wxBDIAGONAL_HATCH,
182 "CrossDiagHatch" : wxCROSSDIAG_HATCH,
183 "FDiagonal_Hatch": wxFDIAGONAL_HATCH,
184 "CrossHatch" : wxCROSS_HATCH,
185 "HorizontalHatch": wxHORIZONTAL_HATCH,
186 "VerticalHatch" : wxVERTICAL_HATCH
187 }
188
189 LineStyleList = {
190 "Solid" : wxSOLID,
191 "Transparent": wxTRANSPARENT,
192 "Dot" : wxDOT,
193 "LongDash" : wxLONG_DASH,
194 "ShortDash" : wxSHORT_DASH,
195 "DotDash" : wxDOT_DASH,
196 }
197
198 def SetBrush(self,FillColor,FillStyle):
199 if FillColor is None or FillStyle is None:
200 self.Brush = wxTRANSPARENT_BRUSH
201 self.FillStyle = "Transparent"
202 else:
203 if not self.BrushList.has_key((FillColor,FillStyle)):
204 self.BrushList[(FillColor,FillStyle)] = wxBrush(FillColor,self.FillStyleList[FillStyle])
205 self.Brush = self.BrushList[(FillColor,FillStyle)]
206
207 def SetPen(self,LineColor,LineStyle,LineWidth):
208 if (LineColor is None) or (LineStyle is None):
209 self.Pen = wxTRANSPARENT_PEN
210 self.LineStyle = 'Transparent'
211 else:
212 if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
213 self.PenList[(LineColor,LineStyle,LineWidth)] = wxPen(LineColor,LineWidth,self.LineStyleList[LineStyle])
214 self.Pen = self.PenList[(LineColor,LineStyle,LineWidth)]
215
216 def SetPens(self,LineColors,LineStyles,LineWidths):
217 """
218 This method used when an object could have a list of pens, rather than just one
219 It is used for LineSet, and perhaps others in the future.
220
221 fixme: this is really kludgy, there has got to be a better way!
222
223 """
224
225 length = 1
226 if type(LineColors) == types.ListType:
227 length = len(LineColors)
228 else:
229 LineColors = [LineColors]
230
231 if type(LineStyles) == types.ListType:
232 length = len(LineStyles)
233 else:
234 LineStyles = [LineStyles]
235
236 if type(LineWidths) == types.ListType:
237 length = len(LineWidths)
238 else:
239 LineWidths = [LineWidths]
240
241 if length > 1:
242 if len(LineColors) == 1:
243 LineColors = LineColors*length
244 if len(LineStyles) == 1:
245 LineStyles = LineStyles*length
246 if len(LineWidths) == 1:
247 LineWidths = LineWidths*length
248
249 self.Pens = []
250 for (LineColor,LineStyle,LineWidth) in zip(LineColors,LineStyles,LineWidths):
251 if LineColor is None or LineStyle is None:
252 self.Pens.append(wxTRANSPARENT_PEN)
253 # what's this for?> self.LineStyle = 'Transparent'
254 if not self.PenList.has_key((LineColor,LineStyle,LineWidth)):
255 Pen = wxPen(LineColor,LineWidth,self.LineStyleList[LineStyle])
256 self.Pens.append(Pen)
257 else:
258 self.Pens.append(self.PenList[(LineColor,LineStyle,LineWidth)])
259 if length == 1:
260 self.Pens = self.Pens[0]
261
262 def PutInBackground(self):
263 if self._Canvas and self.Foreground:
264 self._Canvas._TopDrawList.remove(self)
265 self._Canvas._DrawList.append(self)
266 self._Canvas._BackgroundDirty = 1
267 self.Foreground = 0
268
269 def PutInForeground(self):
270 if self._Canvas and (not self.Foreground):
271 self._Canvas._TopDrawList.append(self)
272 self._Canvas._DrawList.remove(self)
273 self._Canvas._BackgroundDirty = 1
274 self.Foreground = 1
275
276
277class Polygon(draw_object):
278
279 """
280
281 The Polygon class takes a list of 2-tuples, or a NX2 NumPy array of
282 point coordinates. so that Points[N][0] is the x-coordinate of
283 point N and Points[N][1] is the y-coordinate or Points[N,0] is the
284 x-coordinate of point N and Points[N,1] is the y-coordinate for
285 arrays.
286
287 """
288 def __init__(self,Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
289 draw_object.__init__(self,Foreground)
290 self.Points = array(Points,Float)
291 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
292
293 self.LineColor = LineColor
294 self.LineStyle = LineStyle
295 self.LineWidth = LineWidth
296 self.FillColor = FillColor
297 self.FillStyle = FillStyle
298
299 self.SetPen(LineColor,LineStyle,LineWidth)
300 self.SetBrush(FillColor,FillStyle)
301
302
303 def _Draw(self,dc,WorldToPixel,ScaleFunction):
304 Points = WorldToPixel(self.Points)
305 dc.SetPen(self.Pen)
306 dc.SetBrush(self.Brush)
307 #dc.DrawPolygon(map(lambda x: (x[0],x[1]), Points.tolist()))
308 dc.DrawPolygon(Points)
309
310class PolygonSet(draw_object):
311 """
312 The PolygonSet class takes a Geometry.Polygon object.
313 so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
314
315 it creates a set of line segments, from (x1,y1) to (x2,y2)
316
317 """
318
319 def __init__(self,PolySet,LineColors,LineStyles,LineWidths,FillColors,FillStyles,Foreground = 0):
320 draw_object.__init__(self, Foreground)
321
322 ##fixme: there should be some error checking for everything being the right length.
323
324
325 self.Points = array(Points,Float)
326 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
327
328 self.LineColors = LineColors
329 self.LineStyles = LineStyles
330 self.LineWidths = LineWidths
331 self.FillColors = FillColors
332 self.FillStyles = FillStyles
333
334 self.SetPens(LineColors,LineStyles,LineWidths)
335
336 def _Draw(self,dc,WorldToPixel,ScaleFunction):
337 Points = WorldToPixel(self.Points)
338 Points.shape = (-1,4)
339 dc.DrawLineList(Points,self.Pens)
340
341
342class Line(draw_object):
343 """
344 The Line class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
345 so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
346 or Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
347
348 It will draw a straight line if there are two points, and a polyline if there are more than two.
349
350 """
351 def __init__(self,Points,LineColor,LineStyle,LineWidth,Foreground = 0):
352 draw_object.__init__(self, Foreground)
353
354 self.Points = array(Points,Float)
355 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
356
357 self.LineColor = LineColor
358 self.LineStyle = LineStyle
359 self.LineWidth = LineWidth
360
361 self.SetPen(LineColor,LineStyle,LineWidth)
362
363 def SetPoints(self,Points):
364 self.Points = Points
365 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
366 if self._Canvas:
367 # It looks like this shouldn't be private
368 self._Canvas.BoundingBoxDirty = 1
369
370 def _Draw(self,dc,WorldToPixel,ScaleFunction):
371 Points = WorldToPixel(self.Points)
372 dc.SetPen(self.Pen)
373 #dc.DrawLines(map(lambda x: (x[0],x[1]), Points.tolist()))
374 dc.DrawLines(Points)
375
376
377class LineSet(draw_object):
378 """
379 The LineSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
380 so that Points[N] = (x1,y1) and Points[N+1] = (x2,y2). N must be an even number!
381
382 it creates a set of line segments, from (x1,y1) to (x2,y2)
383
384 """
385
386 def __init__(self,Points,LineColors,LineStyles,LineWidths,Foreground = 0):
387 draw_object.__init__(self, Foreground)
388
389 NumLines = len(Points) / 2
390 ##fixme: there should be some error checking for everything being the right length.
391
392
393 self.Points = array(Points,Float)
394 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
395
396 self.LineColors = LineColors
397 self.LineStyles = LineStyles
398 self.LineWidths = LineWidths
399
400 self.SetPens(LineColors,LineStyles,LineWidths)
401
402 def _Draw(self,dc,WorldToPixel,ScaleFunction):
403 Points = WorldToPixel(self.Points)
404 Points.shape = (-1,4)
405 dc.DrawLineList(Points,self.Pens)
406
407
408class PointSet(draw_object):
409 """
410 The PointSet class takes a list of 2-tuples, or a NX2 NumPy array of point coordinates.
411 so that Points[N][0] is the x-coordinate of point N and Points[N][1] is the y-coordinate
412 or Points[N,0] is the x-coordinate of point N and Points[N,1] is the y-coordinate for arrays.
413
414 Each point will be drawn the same color and Diameter. The Diameter is in screen points,
415 not world coordinates.
416
417 """
418 def __init__(self,Points,Color,Diameter,Foreground = 0):
419 draw_object.__init__(self,Foreground)
420
421 self.Points = array(Points,Float)
422 self.Points.shape = (-1,2) # Make sure it is a NX2 array, even if there is only one point
423 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
424
425 self.Color = Color
426 self.Diameter = Diameter
427
428 self.SetPen(Color,"Solid",1)
429 self.SetBrush(Color,"Solid")
430
431 def SetPoints(self,Points):
432 self.Points = Points
433 self.BoundingBox = array(((min(self.Points[:,0]),min(self.Points[:,1])),(max(self.Points[:,0]),max(self.Points[:,1]))),Float)
434 if self._Canvas:
435 # It looks like this shouldn't be private
436 self._Canvas.BoundingBoxDirty = 1
437
438 def _Draw(self,dc,WorldToPixel,ScaleFunction):
439 dc.SetPen(self.Pen)
440 Points = WorldToPixel(self.Points)
441 if self.Diameter <= 1:
442 dc.DrawPointList(Points)
443 elif self.Diameter <= 2:
444 # A Little optimization for a diameter2 - point
445 dc.DrawPointList(Points)
446 dc.DrawPointList(Points + (1,0))
447 dc.DrawPointList(Points + (0,1))
448 dc.DrawPointList(Points + (1,1))
449 else:
450 dc.SetBrush(self.Brush)
451 radius = int(round(self.Diameter/2))
452 for (x,y) in Points:
453 dc.DrawEllipse((x - radius), (y - radius), self.Diameter, self.Diameter)
454
455
456
457class Dot(draw_object):
458 """
459 The Dot class takes an x.y coordinate pair, and the Diameter of the circle.
460 The Diameter is in pixels, so it won't change with zoom.
461
462 Also Fill and line data
463
464 """
465 def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
466 draw_object.__init__(self,Foreground)
467
468 self.X = x
469 self.Y = y
470 self.Diameter = Diameter
471 # NOTE: the bounding box does not include the diameter of the dot, as that is in pixel coords.
472 # If this is a problem, perhaps you should use a circle, instead!
473 self.BoundingBox = array(((x,y),(x,y)),Float)
474
475 self.LineColor = LineColor
476 self.LineStyle = LineStyle
477 self.LineWidth = LineWidth
478 self.FillColor = FillColor
479 self.FillStyle = FillStyle
480
481 self.SetPen(LineColor,LineStyle,LineWidth)
482 self.SetBrush(FillColor,FillStyle)
483
484 def _Draw(self,dc,WorldToPixel,ScaleFunction):
485 dc.SetPen(self.Pen)
486 dc.SetBrush(self.Brush)
487 radius = int(round(self.Diameter/2))
488 (X,Y) = WorldToPixel((self.X,self.Y))
489 dc.DrawEllipse((X - radius), (Y - radius), self.Diameter, self.Diameter)
490
491
492class Rectangle(draw_object):
493 def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
494 draw_object.__init__(self,Foreground)
495
496 self.X = x
497 self.Y = y
498 self.Width = width
499 self.Height = height
500 self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
501 self.LineColor = LineColor
502 self.LineStyle = LineStyle
503 self.LineWidth = LineWidth
504 self.FillColor = FillColor
505 self.FillStyle = FillStyle
506
507 self.SetPen(LineColor,LineStyle,LineWidth)
508 self.SetBrush(FillColor,FillStyle)
509
510 def _Draw(self,dc,WorldToPixel,ScaleFunction):
511 (X,Y) = WorldToPixel((self.X,self.Y))
512 (Width,Height) = ScaleFunction((self.Width,self.Height))
513
514 dc.SetPen(self.Pen)
515 dc.SetBrush(self.Brush)
516 dc.DrawRectangle(X,Y,Width,Height)
517
518class Ellipse(draw_object):
519 def __init__(self,x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
520 draw_object.__init__(self,Foreground)
521
522 self.X = x
523 self.Y = y
524 self.Width = width
525 self.Height = height
526 self.BoundingBox = array(((x,y),(x+width,y+height)),Float)
527 self.LineColor = LineColor
528 self.LineStyle = LineStyle
529 self.LineWidth = LineWidth
530 self.FillColor = FillColor
531 self.FillStyle = FillStyle
532
533 self.SetPen(LineColor,LineStyle,LineWidth)
534 self.SetBrush(FillColor,FillStyle)
535
536 def _Draw(self,dc,WorldToPixel,ScaleFunction):
537 (X,Y) = WorldToPixel((self.X,self.Y))
538 (Width,Height) = ScaleFunction((self.Width,self.Height))
539
540 dc.SetPen(self.Pen)
541 dc.SetBrush(self.Brush)
542 dc.DrawEllipse(X,Y,Width,Height)
543
544class Circle(draw_object):
545 def __init__(self,x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground = 0):
546 draw_object.__init__(self,Foreground)
547
548 self.X = x
549 self.Y = y
550 self.Diameter = Diameter
551 self.BoundingBox = array(((x-Diameter/2,y-Diameter/2),(x+Diameter/2,y+Diameter/2)),Float)
552 self.LineColor = LineColor
553 self.LineStyle = LineStyle
554 self.LineWidth = LineWidth
555 self.FillColor = FillColor
556 self.FillStyle = FillStyle
557
558 self.SetPen(LineColor,LineStyle,LineWidth)
559 self.SetBrush(FillColor,FillStyle)
560
561 def _Draw(self,dc,WorldToPixel,ScaleFunction):
562 (X,Y) = WorldToPixel((self.X,self.Y))
563 (Diameter,dummy) = ScaleFunction((self.Diameter,self.Diameter))
564
565 dc.SetPen(self.Pen)
566 dc.SetBrush(self.Brush)
567 dc.DrawEllipse(X-Diameter/2,Y-Diameter/2,Diameter,Diameter)
568
569class Text(draw_object):
570 """
571
572 This class creates a text object, placed at the coordinates,
573 x,y. the "Position" argument is a two charactor string, indicating
574 where in relation to the coordinates the string should be oriented.
575
576 The first letter is: t, c, or b, for top, center and bottom
577 The second letter is: l, c, or r, for left, center and right
578
579 I've provided arguments for Family, Style, and Weight of font, but
580 have not yet implimented them, so all text is: wxSWISS, wxNORMAL, wxNORMAL.
581 I'd love it if someone would impliment that!
582
583 The size is fixed, and does not scale with the drawing.
584
585 """
586
587 def __init__(self,String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground = 0):
588 draw_object.__init__(self,Foreground)
589
590 self.String = String
591 self.Size = Size
592
593 self.ForeGround = ForeGround
594 if BackGround is None:
595 self.BackGround = None
596 else:
597 self.BackGround = BackGround
598 self.Family = Family
599 self.Style = Style
600 self.Weight = Weight
601 self.Underline = Underline
602 self.Position = Position
603 # fixme: this should use the passed in parameters!
604 self.Font = wxFont(Size, wxMODERN, wxNORMAL, wxNORMAL, Underline, )
605
606 self.BoundingBox = array(((x,y),(x,y)),Float)
607
608 self.X = x
609 self.Y = y
610 self.x_shift = None
611 self.y_shift = None
612
613 def _Draw(self,dc,WorldToPixel,ScaleFunction):
614 (X,Y) = WorldToPixel((self.X,self.Y))
615 dc.SetFont(self.Font)
616 dc.SetTextForeground(self.ForeGround)
617 if self.BackGround:
618 dc.SetBackgroundMode(wxSOLID)
619 dc.SetTextBackground(self.BackGround)
620 else:
621 dc.SetBackgroundMode(wxTRANSPARENT)
622
623 # compute the shift, and adjust the coordinates, if neccesary
624 # This had to be put in here, becsuse there is no wxDC during __init__
625 if self.x_shift is None or self.y_shift is None:
626 if self.Position == 'tl':
627 x_shift,y_shift = 0,0
628 else:
629 (w,h) = dc.GetTextExtent(self.String)
630 if self.Position[0] == 't':
631 y_shift = 0
632 elif self.Position[0] == 'c':
633 y_shift = h/2
634 elif self.Position[0] == 'b':
635 y_shift = h
636 else:
637 ##fixme: this should be a real derived exception
638 raise "Invalid value for Text Object Position Attribute"
639 if self.Position[1] == 'l':
640 x_shift = 0
641 elif self.Position[1] == 'c':
642 x_shift = w/2
643 elif self.Position[1] == 'r':
644 x_shift = w
645 else:
646 ##fixme: this should be a real derived exception
647 raise "Invalid value for Text Object Position Attribute"
648 self.x_shift = x_shift
649 self.y_shift = y_shift
650 dc.DrawText(self.String, X-self.x_shift, Y-self.y_shift)
651
652
653#---------------------------------------------------------------------------
654
655class FloatCanvas(wxPanel):
656 """
657 FloatCanvas.py
658
659 This is a high level window for drawing maps and anything else in an
660 arbitrary coordinate system.
661
662 The goal is to provide a convenient way to draw stuff on the screen
663 without having to deal with handling OnPaint events, converting to pixel
664 coordinates, knowing about wxWindows brushes, pens, and colors, etc. It
665 also provides virtually unlimited zooming and scrolling
666
667 I am using it for two things:
668 1) general purpose drawing in floating point coordinates
669 2) displaying map data in Lat-long coordinates
670
671 If the projection is set to None, it will draw in general purpose
672 floating point coordinates. If the projection is set to 'FlatEarth', it
673 will draw a FlatEarth projection, centered on the part of the map that
674 you are viewing. You can also pass in your own projection function.
675
676 It is double buffered, so re-draws after the window is uncovered by something
677 else are very quick.
678
679 It relies on NumPy, which is needed for speed
680
681 Bugs and Limitations:
682 Lots: patches, fixes welcome
683
684 For Map drawing: It ignores the fact that the world is, in fact, a
685 sphere, so it will do strange things if you are looking at stuff near
686 the poles or the date line. so far I don't have a need to do that, so I
687 havn't bothered to add any checks for that yet.
688
689 Zooming:
690 I have set no zoom limits. What this means is that if you zoom in really
691 far, you can get integer overflows, and get wierd results. It
692 doesn't seem to actually cause any problems other than wierd output, at
693 least when I have run it.
694
695 Speed:
696 I have done a couple of things to improve speed in this app. The one
697 thing I have done is used NumPy Arrays to store the coordinates of the
698 points of the objects. This allowed me to use array oriented functions
699 when doing transformations, and should provide some speed improvement
700 for objects with a lot of points (big polygons, polylines, pointsets).
701
702 The real slowdown comes when you have to draw a lot of objects, because
703 you have to call the wxDC.DrawSomething call each time. This is plenty
704 fast for tens of objects, OK for hundreds of objects, but pretty darn
705 slow for thousands of objects.
706
707 The solution is to be able to pass some sort of object set to the DC
708 directly. I've used DC.DrawPointList(Points), and it helped a lot with
709 drawing lots of points. I havn't got a LineSet type object, so I havn't
710 used DC.DrawLineList yet. I'd like to get a full set of DrawStuffList()
711 methods implimented, and then I'd also have a full set of Object sets
712 that could take advantage of them. I hope to get to it some day.
713
714 Copyright: Christopher Barker
715
716 License: Same as wxPython
717
718 Please let me know if you're using this!!!
719
720 Contact me at:
721
722 Chris.Barker@noaa.gov
723
724 """
725
726 def __init__(self, parent, id = -1,
727 size = wxDefaultSize,
728 ProjectionFun = None,
729 BackgroundColor = "WHITE",
730 Debug = 0,
731 EnclosingFrame = None,
732 UseToolbar = 1,
733 UseBackground = 0,
734 UseHitTest = 0):
735
736 wxPanel.__init__( self, parent, id, wxDefaultPosition, size)
737
738 if ProjectionFun == 'FlatEarth':
739 self.ProjectionFun = self.FlatEarthProjection
740 elif type(ProjectionFun) == types.FunctionType:
741 self.ProjectionFun = ProjectionFun
742 elif ProjectionFun is None:
743 self.ProjectionFun = lambda x=None: array( (1,1), Float)
744 else:
745 raise('Projectionfun must be either: "FlatEarth", None, or a function that takes the ViewPortCenter and returns a MapProjectionVector')
746
747 self.UseBackground = UseBackground
748 self.UseHitTest = UseHitTest
749
750 self.NumBetweenBlits = 40
751
752 ## you can have a toolbar with buttons for zoom-in, zoom-out and
753 ## move. If you don't use the toolbar, you should provide your
754 ## own way of navigating the canvas
755 if UseToolbar:
756 ## Create the vertical sizer for the toolbar and Panel
757 box = wxBoxSizer(wxVERTICAL)
758 box.Add(self.BuildToolbar(), 0, wxALL | wxALIGN_LEFT | wxGROW, 4)
759
760 self.DrawPanel = wxWindow(self,-1,wxDefaultPosition,wxDefaultSize,wxSUNKEN_BORDER)
761 box.Add(self.DrawPanel,1,wxGROW)
762
763 box.Fit(self)
764 self.SetAutoLayout(True)
765 self.SetSizer(box)
766 else:
767 self.DrawPanel = self
768
769 self.DrawPanel.BackgroundBrush = wxBrush(BackgroundColor,wxSOLID)
770
771 self.Debug = Debug
772
773 self.EnclosingFrame = EnclosingFrame
774
775 EVT_PAINT(self.DrawPanel, self.OnPaint)
776 EVT_SIZE(self.DrawPanel, self.OnSize)
777
778 EVT_LEFT_DOWN(self.DrawPanel, self.LeftButtonEvent)
779 EVT_LEFT_UP(self.DrawPanel, self.LeftButtonEvent)
780 EVT_RIGHT_DOWN(self.DrawPanel, self.RightButtonEvent)
781 EVT_MOTION(self.DrawPanel, self.LeftButtonEvent)
782
783
784 self._DrawList = []
785 if self.UseBackground:
786 self._TopDrawList = []
787 self.BoundingBox = None
788 self.BoundingBoxDirty = 0
789 self.ViewPortCenter= array( (0,0), Float)
790
791 self.MapProjectionVector = array( (1,1), Float) # No Projection to start!
792 self.TransformVector = array( (1,-1), Float) # default Transformation
793
794 self.Scale = 1
795
796 self.GUIMode = None
797 self.StartRBBox = None
798 self.PrevRBBox = None
799 self.StartMove = None
800 self.PrevMoveBox = None
801 # called just to make sure everything is initialized
802 self.OnSize(None)
803
804
805 def BuildToolbar(self):
806 tb = wxToolBar(self,-1)
807 self.ToolBar = tb
808
809 tb.SetToolBitmapSize((23,23))
810
811 tb.AddTool(ID_ZOOM_IN_BUTTON, GetPlusBitmap(), isToggle=true,shortHelpString = "Zoom In")
812 EVT_TOOL(self, ID_ZOOM_IN_BUTTON, self.SetMode)
813
814 tb.AddTool(ID_ZOOM_OUT_BUTTON, GetMinusBitmap(), isToggle=true,shortHelpString = "Zoom Out")
815 EVT_TOOL(self, ID_ZOOM_OUT_BUTTON, self.SetMode)
816
817 tb.AddTool(ID_MOVE_MODE_BUTTON, GetHandBitmap(), isToggle=true,shortHelpString = "Move")
818 EVT_TOOL(self, ID_MOVE_MODE_BUTTON, self.SetMode)
819
820 tb.AddSeparator()
821
822 tb.AddControl(wxButton(tb, ID_ZOOM_TO_FIT_BUTTON, "Zoom To Fit",wxDefaultPosition, wxDefaultSize))
823 EVT_BUTTON(self, ID_ZOOM_TO_FIT_BUTTON, self.ZoomToFit)
824
825 tb.Realize()
826 return tb
827
828 def SetMode(self,event):
829 for id in [ID_ZOOM_IN_BUTTON,ID_ZOOM_OUT_BUTTON,ID_MOVE_MODE_BUTTON]:
830 self.ToolBar.ToggleTool(id,0)
831 self.ToolBar.ToggleTool(event.GetId(),1)
832 if event.GetId() == ID_ZOOM_IN_BUTTON:
833 self.SetGUIMode("ZoomIn")
834 elif event.GetId() == ID_ZOOM_OUT_BUTTON:
835 self.SetGUIMode("ZoomOut")
836 elif event.GetId() == ID_MOVE_MODE_BUTTON:
837 self.SetGUIMode("Move")
838
839
840 def SetGUIMode(self,Mode):
841 if Mode in ["ZoomIn","ZoomOut","Move",None]:
842 self.GUIMode = Mode
843 else:
844 raise "Not a valid Mode"
845
846 def FlatEarthProjection(self,CenterPoint):
847 return array((cos(pi*CenterPoint[1]/180),1),Float)
848
849 def LeftButtonEvent(self,event):
850 if self.EnclosingFrame:
851 if event.Moving:
852 position = self.PixelToWorld((event.GetX(),event.GetY()))
853 self.EnclosingFrame.SetStatusText("%8.3f, %8.3f"%tuple(position))
854 if self.GUIMode:
855 if self.GUIMode == "ZoomIn":
856 if event.LeftDown():
857 self.StartRBBox = (event.GetX(),event.GetY())
858 self.PrevRBBox = None
859 elif event.Dragging() and event.LeftIsDown() and self.StartRBBox:
860 x0,y0 = self.StartRBBox
861 x1,y1 = event.GetX(),event.GetY()
862 w, h = abs(x1-x0),abs(y1-y0)
863 w = max(w,int(h*self.AspectRatio))
864 h = int(w/self.AspectRatio)
865 x_c, y_c = (x0+x1)/2 , (y0+y1)/2
866 dc = wxClientDC(self.DrawPanel)
867 dc.BeginDrawing()
868 dc.SetPen(wxPen('WHITE', 2,wxSHORT_DASH))
869 dc.SetBrush(wxTRANSPARENT_BRUSH)
870 dc.SetLogicalFunction(wxXOR)
871 if self.PrevRBBox:
872 dc.DrawRectangle(*self.PrevRBBox)
873 dc.DrawRectangle(x_c-w/2,y_c-h/2,w,h)
874 self.PrevRBBox = (x_c-w/2,y_c-h/2,w,h)
875 dc.EndDrawing()
876
877 elif event.LeftUp() and self.StartRBBox :
878 self.PrevRBBox = None
879 EndRBBox = (event.GetX(),event.GetY())
880 StartRBBox = self.StartRBBox
881 # if mouse has moved less that ten pixels, don't use the box.
882 if abs(StartRBBox[0] - EndRBBox[0]) > 10 and abs(StartRBBox[1] - EndRBBox[1]) > 10:
883 EndRBBox = self.PixelToWorld(EndRBBox)
884 StartRBBox = self.PixelToWorld(StartRBBox)
885 BB = array(((min(EndRBBox[0],StartRBBox[0]), min(EndRBBox[1],StartRBBox[1])),
886 (max(EndRBBox[0],StartRBBox[0]), max(EndRBBox[1],StartRBBox[1]))),Float)
887 self.ZoomToBB(BB)
888 else:
889 Center = self.PixelToWorld(StartRBBox)
890 self.Zoom(1.5,Center)
891 self.StartRBBox = None
892
893 if self.GUIMode == "ZoomOut":
894 if event.LeftDown():
895 Center = self.PixelToWorld((event.GetX(),event.GetY()))
896 self.Zoom(1/1.5,Center)
897 elif self.GUIMode == "Move":
898 if event.LeftDown():
899 self.StartMove = array((event.GetX(),event.GetY()))
900 self.PrevMoveBox = None
901 elif event.Dragging() and event.LeftIsDown() and self.StartMove:
902 x_1,y_1 = event.GetX(),event.GetY()
903 w, h = self.PanelSize
904 x_tl, y_tl = x_1 - self.StartMove[0], y_1 - self.StartMove[1]
905 dc = wxClientDC(self.DrawPanel)
906 dc.BeginDrawing()
907 dc.SetPen(wxPen('WHITE', 1,))
908 dc.SetBrush(wxTRANSPARENT_BRUSH)
909 dc.SetLogicalFunction(wxXOR)
910 if self.PrevMoveBox:
911 dc.DrawRectangle(*self.PrevMoveBox)
912 dc.DrawRectangle(x_tl,y_tl,w,h)
913 self.PrevMoveBox = (x_tl,y_tl,w,h)
914 dc.EndDrawing()
915
916 elif event.LeftUp() and self.StartMove:
917 self.PrevMoveBox = None
918 StartMove = self.StartMove
919 EndMove = array((event.GetX(),event.GetY()))
920 if sum((StartMove-EndMove)**2) > 16:
921 self.Move(StartMove-EndMove,'Pixel')
922 self.StartMove = None
923
924 def RightButtonEvent(self,event):
925 if self.GUIMode:
926 if self.GUIMode == "ZoomIn":
927 Center = self.PixelToWorld((event.GetX(),event.GetY()))
928 self.Zoom(1/1.5,Center)
929 elif self.GUIMode == "ZoomOut":
930 Center = self.PixelToWorld((event.GetX(),event.GetY()))
931 self.Zoom(1.5,Center)
932 else:
933 event.Skip()
934 event.Skip()
935
936 def MakeNewBuffers(self):
937 # Make new offscreen bitmap:
938 self._Buffer = wxEmptyBitmap(self.PanelSize[0],self.PanelSize[1])
939 if self.UseBackground:
940 self._BackBuffer = wxEmptyBitmap(self.PanelSize[0],self.PanelSize[1])
941 self._BackgroundDirty = 1
942 else:
943 pass
944
945 def OnSize(self,event):
946 self.PanelSize = array(self.DrawPanel.GetClientSizeTuple(),Int32)
947 try:
948 self.AspectRatio = self.PanelSize[0]/self.PanelSize[1]
949 except ZeroDivisionError:
950 self.AspectRatio = 1.0
951 self.MakeNewBuffers()
952 self.Draw()
953
954 def OnPaint(self, event):
955 #dc = wxBufferedPaintDC(self.DrawPanel, self._Buffer)
956 dc = wxPaintDC(self.DrawPanel)
957 dc.DrawBitmap(self._Buffer,0,0)
958
959 def Draw(self):
960 """
961 The Draw method gets pretty complicated because of all the buffers
962
963 There is a main buffer set up to double buffer the screen, so
964 you can get quick re-draws when the window gets uncovered.
965
966 If self.UseBackground is set, and an object is set up with the
967 "ForeGround" flag, then it gets drawn to the screen after blitting
968 the background. This is done so that you can have a complicated
969 background, but have something changing on the foreground,
970 without having to wait for the background to get re-drawn. This
971 can be used to support simple animation, for instance.
972
973 """
974 if self.Debug: start = clock()
975 ScreenDC = wxClientDC(self.DrawPanel)
976 ViewPortWorld = ( self.PixelToWorld((0,0)), self.PixelToWorld(self.PanelSize) )
977 ViewPortBB = array( ( minimum.reduce(ViewPortWorld), maximum.reduce(ViewPortWorld) ) )
978 if self.UseBackground:
979 dc = wxMemoryDC()
980 dc.SelectObject(self._BackBuffer)
981 dc.SetBackground(self.DrawPanel.BackgroundBrush)
982 if self._DrawList:
983 if self._BackgroundDirty:
984 dc.BeginDrawing()
985 dc.Clear()
986 i = 0
987 for Object in self._DrawList:
988 if self.BBCheck(Object.BoundingBox,ViewPortBB):
989 #print "object is in Bounding Box"
990 i+=1
991 Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
992 if i % self.NumBetweenBlits == 0:
993 ScreenDC.Blit(0, 0, self.PanelSize[0],self.PanelSize[1], dc, 0, 0)
994 dc.EndDrawing()
995 else:
996 dc.Clear()
997 self._BackgroundDirty = 0
998 dc.SelectObject(self._Buffer)
999 dc.BeginDrawing()
1000 ##Draw Background on Main Buffer:
1001 dc.DrawBitmap(self._BackBuffer,0,0)
1002 #Draw the OnTop stuff
1003 i = 0
1004 for Object in self._TopDrawList:
1005 i+=1
1006 Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
1007 if i % self.NumBetweenBlits == 0:
1008 ScreenDC.Blit(0, 0, self.PanelSize[0],self.PanelSize[1], dc, 0, 0)
1009 dc.EndDrawing()
1010 else: # not using a Background DC
1011 dc = wxMemoryDC()
1012 dc.SelectObject(self._Buffer)
1013 dc.SetBackground(self.DrawPanel.BackgroundBrush)
1014 if self._DrawList:
1015 dc.BeginDrawing()
1016 dc.Clear()
1017 i = 0
1018 for Object in self._DrawList:
1019 if self.BBCheck(Object.BoundingBox,ViewPortBB):
1020 #print "object is in Bounding Box"
1021 i+=1
1022 Object._Draw(dc,self.WorldToPixel,self.ScaleFunction)
1023 if i % self.NumBetweenBlits == 0:
1024 ScreenDC.Blit(0, 0, self.PanelSize[0],self.PanelSize[1], dc, 0, 0)
1025 dc.EndDrawing()
1026 else:
1027 dc.Clear()
1028 # now refresh the screen
1029 #ScreenDC.DrawBitmap(self._Buffer,0,0) #NOTE: uisng DrawBitmap didn't work right on MSW
1030 ScreenDC.Blit(0, 0, self.PanelSize[0],self.PanelSize[1], dc, 0, 0)
1031
1032 # If the canvas is in the middle of a zoom or move, the Rubber Band box needs to be re-drawn
1033 if self.PrevRBBox:
1034 ScreenDC.SetPen(wxPen('WHITE', 2,wxSHORT_DASH))
1035 ScreenDC.SetBrush(wxTRANSPARENT_BRUSH)
1036 ScreenDC.SetLogicalFunction(wxXOR)
1037 ScreenDC.DrawRectangle(*self.PrevRBBox)
1038 elif self.PrevMoveBox:
1039 ScreenDC.SetPen(wxPen('WHITE', 1,))
1040 ScreenDC.SetBrush(wxTRANSPARENT_BRUSH)
1041 ScreenDC.SetLogicalFunction(wxXOR)
1042 ScreenDC.DrawRectangle(*self.PrevMoveBox)
1043 if self.Debug: print "Drawing took %f seconds of CPU time"%(clock()-start)
1044
1045 def BBCheck(self, BB1, BB2):
1046 """
1047
1048 BBCheck(BB1, BB2) returns True is the Bounding boxes intesect, False otherwise
1049
1050 """
1051 if ( (BB1[1,0] > BB2[0,0]) and (BB1[0,0] < BB2[1,0]) and
1052 (BB1[1,1] > BB2[0,1]) and (BB1[0,1] < BB2[1,1]) ):
1053 return True
1054 else:
1055 return False
1056
1057 def Move(self,shift,CoordType):
1058 """
1059 move the image in the window.
1060
1061 shift is an (x,y) tuple, specifying the amount to shift in each direction
1062
1063 It can be in any of three coordinates: Panel, Pixel, World,
1064 specified by the CoordType parameter
1065
1066 Panel coordinates means you want to shift the image by some
1067 fraction of the size of the displaed image
1068
1069 Pixel coordinates means you want to shift the image by some number of pixels
1070
1071 World coordinates meand you want to shift the image by an amount
1072 in Floating point world coordinates
1073
1074 """
1075
1076 shift = array(shift,Float)
1077 if CoordType == 'Panel':# convert from panel coordinates
1078 shift = shift * array((-1,1),Float) *self.PanelSize/self.TransformVector
1079 elif CoordType == 'Pixel': # convert from pixel coordinates
1080 shift = shift/self.TransformVector
1081 elif CoordType == 'World': # No conversion
1082 pass
1083 else:
1084 raise 'CoordType must be either "Panel", "Pixel", or "World"'
1085
1086 self.ViewPortCenter = self.ViewPortCenter + shift
1087 self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
1088 self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
1089 self._BackgroundDirty = 1
1090 self.Draw()
1091
1092 def Zoom(self,factor,center = None):
1093
1094 """
1095 Zoom(factor, center) changes the amount of zoom of the image by factor.
1096 If factor is greater than one, the image gets larger.
1097 If factor is less than one, the image gets smaller.
1098
1099 Center is a tuple of (x,y) coordinates of the center of the viewport, after zooming.
1100 If center is not given, the center will stay the same.
1101
1102 """
1103 self.Scale = self.Scale*factor
1104 if center:
1105 self.ViewPortCenter = array(center,Float)
1106 self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
1107 self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
1108 self._BackgroundDirty = 1
1109 self.Draw()
1110
1111 def ZoomToFit(self,event):
1112 self.ZoomToBB()
1113
1114 def ZoomToBB(self,NewBB = None,DrawFlag = 1):
1115
1116 """
1117
1118 Zooms the image to the bounding box given, or to the bounding
1119 box of all the objects on the canvas, if none is given.
1120
1121 """
1122
1123 if NewBB:
1124 BoundingBox = NewBB
1125 else:
1126 if self.BoundingBoxDirty:
1127 self._ResetBoundingBox()
1128 BoundingBox = self.BoundingBox
1129 if BoundingBox:
1130 self.ViewPortCenter = array(((BoundingBox[0,0]+BoundingBox[1,0])/2,
1131 (BoundingBox[0,1]+BoundingBox[1,1])/2 ),Float)
1132 self.MapProjectionVector = self.ProjectionFun(self.ViewPortCenter)
1133 # Compute the new Scale
1134 BoundingBox = BoundingBox * self.MapProjectionVector
1135 try:
1136 self.Scale = min((self.PanelSize[0] / (BoundingBox[1,0]-BoundingBox[0,0])),
1137 (self.PanelSize[1] / (BoundingBox[1,1]-BoundingBox[0,1])))*0.95
1138 except ZeroDivisionError: # this will happen if the BB has zero width or height
1139 try: #width
1140 self.Scale = (self.PanelSize[0] / (BoundingBox[1,0]-BoundingBox[0,0]))*0.95
1141 except ZeroDivisionError:
1142 try: # height
1143 self.Scale = (self.PanelSize[1] / (BoundingBox[1,1]-BoundingBox[0,1]))*0.95
1144 except ZeroDivisionError: #zero size! (must be a single point)
1145 self.Scale = 1
1146
1147 self.TransformVector = array((self.Scale,-self.Scale),Float)* self.MapProjectionVector
1148 if DrawFlag:
1149 self._BackgroundDirty = 1
1150 self.Draw()
1151
1152 def RemoveObjects(self,Objects):
1153 for Object in Objects:
1154 self.RemoveObject(Object,ResetBB = 0)
1155 self.BoundingBoxDirty = 1
1156
1157 def RemoveObject(self,Object,ResetBB = 1):
1158 if Object.Foreground:
1159 self._TopDrawList.remove(Object)
1160 else:
1161 self._DrawList.remove(Object)
1162 self._BackgroundDirty = 1
1163
1164 if ResetBB:
1165 self.BoundingBoxDirty = 1
1166
1167 def Clear(self, ResetBB = True):
1168 self._DrawList = []
1169 if self.UseBackground:
1170 self._TopDrawList = []
1171 self._BackgroundDirty = 1
1172 if ResetBB:
1173 self._ResetBoundingBox()
1174
1175 def _AddBoundingBox(self,NewBB):
1176 if self.BoundingBox is None:
1177 self.BoundingBox = NewBB
1178 self.ZoomToBB(NewBB,DrawFlag = 0)
1179 else:
1180 self.BoundingBox = array(((min(self.BoundingBox[0,0],NewBB[0,0]),
1181 min(self.BoundingBox[0,1],NewBB[0,1])),
1182 (max(self.BoundingBox[1,0],NewBB[1,0]),
1183 max(self.BoundingBox[1,1],NewBB[1,1]))),Float)
1184 def _ResetBoundingBox(self):
1185 # NOTE: could you remove an item without recomputing the entire bounding box?
1186 self.BoundingBox = None
1187 if self._DrawList:
1188 self.BoundingBox = self._DrawList[0].BoundingBox
1189 for Object in self._DrawList[1:]:
1190 self._AddBoundingBox(Object.BoundingBox)
1191 if self.UseBackground:
1192 for Object in self._TopDrawList:
1193 self._AddBoundingBox(Object.BoundingBox)
1194 if self.BoundingBox is None:
1195 self.ViewPortCenter= array( (0,0), Float)
1196 self.TransformVector = array( (1,-1), Float)
1197 self.MapProjectionVector = array( (1,1), Float)
1198 self.Scale = 1
1199 self.BoundingBoxDirty = 0
1200
1201 def PixelToWorld(self,Points):
1202 """
1203 Converts coordinates from Pixel coordinates to world coordinates.
1204
1205 Points is a tuple of (x,y) coordinates, or a list of such tuples, or a NX2 Numpy array of x,y coordinates.
1206
1207 """
1208 return (((array(Points,Float) - (self.PanelSize/2))/self.TransformVector) + self.ViewPortCenter)
1209
1210 def WorldToPixel(self,Coordinates):
1211 """
1212 This function will get passed to the drawing functions of the objects,
1213 to transform from world to pixel coordinates.
1214 Coordinates should be a NX2 array of (x,y) coordinates, or
1215 a 2-tuple, or sequence of 2-tuples.
1216 """
1217 return (((array(Coordinates,Float) - self.ViewPortCenter)*self.TransformVector)+(self.PanelSize/2)).astype('i')
1218
1219 def ScaleFunction(self,Lengths):
1220 """
1221 This function will get passed to the drawing functions of the objects,
1222 to Change a length from world to pixel coordinates.
1223
1224 Lengths should be a NX2 array of (x,y) coordinates, or
1225 a 2-tuple, or sequence of 2-tuples.
1226 """
1227 return (array(Lengths,Float)*self.TransformVector).astype('i')
1228
1229
1230 ## This is a set of methods that add objects to the Canvas. It kind
1231 ## of seems like a lot of duplication, but I wanted to be able to
1232 ## instantiate the draw objects separatley form adding them, but
1233 ## also to be able to do add one oin one step. I'm open to better
1234 ## ideas...
1235 def AddRectangle(self,x,y,width,height,
1236 LineColor = "Black",
1237 LineStyle = "Solid",
1238 LineWidth = 1,
1239 FillColor = None,
1240 FillStyle = "Solid",
1241 Foreground = 0):
1242 Object = Rectangle(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
1243 self.AddObject(Object)
1244 return Object
1245
1246 def AddEllipse(self,x,y,width,height,
1247 LineColor = "Black",
1248 LineStyle = "Solid",
1249 LineWidth = 1,
1250 FillColor = None,
1251 FillStyle = "Solid",
1252 Foreground = 0):
1253 Object = Ellipse(x,y,width,height,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
1254 self.AddObject(Object)
1255 return Object
1256
1257 def AddCircle(self,x,y,Diameter,
1258 LineColor = "Black",
1259 LineStyle = "Solid",
1260 LineWidth = 1,
1261 FillColor = None,
1262 FillStyle = "Solid",
1263 Foreground = 0):
1264 Object = Circle(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
1265 self.AddObject(Object)
1266 return Object
1267
1268 def AddDot(self,x,y,Diameter,
1269 LineColor = "Black",
1270 LineStyle = "Solid",
1271 LineWidth = 1,
1272 FillColor = None,
1273 FillStyle = "Solid",
1274 Foreground = 0):
1275 Object = Dot(x,y,Diameter,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
1276 self.AddObject(Object)
1277 return Object
1278
1279 def AddPolygon(self,Points,
1280 LineColor = "Black",
1281 LineStyle = "Solid",
1282 LineWidth = 1,
1283 FillColor = None,
1284 FillStyle = "Solid",
1285 Foreground = 0):
1286
1287 Object = Polygon(Points,LineColor,LineStyle,LineWidth,FillColor,FillStyle,Foreground)
1288 self.AddObject(Object)
1289 return Object
1290
1291 def AddLine(self,Points,
1292 LineColor = "Black",
1293 LineStyle = "Solid",
1294 LineWidth = 1,
1295 Foreground = 0):
1296
1297 Object = Line(Points,LineColor,LineStyle,LineWidth,Foreground)
1298 self.AddObject(Object)
1299 return Object
1300
1301 def AddLineSet(self,Points,
1302 LineColors = "Black",
1303 LineStyles = "Solid",
1304 LineWidths = 1,
1305 Foreground = 0):
1306
1307 Object = LineSet(Points,LineColors,LineStyles,LineWidths,Foreground)
1308 self.AddObject(Object)
1309 return Object
1310
1311 def AddPointSet(self,Points,
1312 Color = "Black",
1313 Diameter = 1,
1314 Foreground = 0):
1315
1316 Object = PointSet(Points,Color,Diameter,Foreground)
1317 self.AddObject(Object)
1318 return Object
1319
1320 def AddText(self,String,x,y,
1321 Size = 20,
1322 ForeGround = 'Black',
1323 BackGround = None,
1324 Family = 'Swiss',
1325 Style = 'Normal',
1326 Weight = 'Normal',
1327 Underline = 0,
1328 Position = 'tl',
1329 Foreground = 0):
1330 Object = Text(String,x,y,Size,ForeGround,BackGround,Family,Style,Weight,Underline,Position,Foreground)
1331 self.AddObject(Object)
1332 return Object
1333
1334 def AddObject(self,obj):
1335 # put in a reference to the Canvas, so remove and other stuff can work
1336 obj._Canvas = self
1337 if obj.Foreground and self.UseBackground:
1338 self._TopDrawList.append(obj)
1339 else:
1340 self._DrawList.append(obj)
1341 self._backgrounddirty = 1
1342 self._AddBoundingBox(obj.BoundingBox)
1343 return None
1344
1345
1346
1347
1348
8b9a4190 1349
8b9a4190 1350
wxWidgets (Impactor)