wxPython 4.3.2__cp315-cp315-win_arm64.whl

wx/lib/floatcanvas/Utilities/BBox.py

@@ -0,0 +1,313 @@
+#----------------------------------------------------------------------------
+# Name:         BBox.py
+# Purpose:
+#
+# Author:
+#
+# Created:
+# Version:
+# Date:
+# Licence:
+# Tags:         phoenix-port
+#----------------------------------------------------------------------------
+"""
+A Bounding Box object and assorted utilities , subclassed from a numpy array
+
+"""
+
+import numpy as np
+
+class BBox(np.ndarray):
+    """
+    A Bounding Box object:
+
+    Takes Data as an array. Data is any python sequence that can be turned into a
+    2x2 numpy array of floats::
+
+        [
+        [MinX, MinY ],
+        [MaxX, MaxY ]
+        ]
+
+    It is a subclass of numpy.ndarray, so for the most part it can be used as
+    an array, and arrays that fit the above description can be used in its place.
+
+    Usually created by the factory functions:
+
+        asBBox
+
+        and
+
+        fromPoints
+
+    """
+    def __new__(subtype, data):
+        """
+        Takes Data as an array. Data is any python sequence that can be turned
+        into a 2x2 numpy array of floats::
+
+            [
+            [MinX, MinY ],
+            [MaxX, MaxY ]
+            ]
+
+        You don't usually call this directly. BBox objects are created with
+        the factory functions:
+
+        asBBox
+
+        and
+
+        fromPoints
+
+        """
+        arr = np.array(data, float)
+        arr = arr.reshape(2, 2)
+        if arr[0,0] > arr[1,0] or arr[0,1] > arr[1,1]:
+            # note: zero sized BB OK.
+            raise ValueError("BBox values not aligned: \n minimum values must be less that maximum values")
+        return np.ndarray.__new__(subtype, shape=arr.shape, dtype=arr.dtype, buffer=arr)
+
+    def Overlaps(self, BB):
+        """
+        Overlap(BB):
+
+        Tests if the given Bounding Box overlaps with this one.
+        Returns True is the Bounding boxes overlap, False otherwise
+        If they are just touching, returns True
+        """
+
+        if np.isinf(self).all() or np.isinf(BB).all():
+            return True
+        if ( (self[1,0] >= BB[0,0]) and (self[0,0] <= BB[1,0]) and
+             (self[1,1] >= BB[0,1]) and (self[0,1] <= BB[1,1]) ):
+            return True
+        else:
+            return False
+
+    def Inside(self, BB):
+        """
+        Inside(BB):
+
+        Tests if the given Bounding Box is entirely inside this one.
+
+        Returns True if it is entirely inside, or touching the
+        border.
+
+        Returns False otherwise
+        """
+        if ( (BB[0,0] >= self[0,0]) and (BB[1,0] <= self[1,0]) and
+             (BB[0,1] >= self[0,1]) and (BB[1,1] <= self[1,1]) ):
+            return True
+        else:
+            return False
+
+    def PointInside(self, Point):
+        """
+        Inside(BB):
+
+        Tests if the given Point is entirely inside this one.
+
+        Returns True if it is entirely inside, or touching the
+        border.
+
+        Returns False otherwise
+
+        Point is any length-2 sequence (tuple, list, array) or two numbers
+        """
+        if Point[0] >= self[0,0] and \
+               Point[0] <= self[1,0] and \
+               Point[1] <= self[1,1] and \
+               Point[1] >= self[0,1]:
+            return True
+        else:
+            return False
+
+    def Merge(self, BB):
+        """
+        Joins this bounding box with the one passed in, maybe making this one bigger
+
+        """
+        if self.IsNull():
+            self[:] = BB
+        elif np.isnan(BB).all(): ## BB may be a regular array, so I can't use IsNull
+            pass
+        else:
+            if BB[0,0] < self[0,0]: self[0,0] = BB[0,0]
+            if BB[0,1] < self[0,1]: self[0,1] = BB[0,1]
+            if BB[1,0] > self[1,0]: self[1,0] = BB[1,0]
+            if BB[1,1] > self[1,1]: self[1,1] = BB[1,1]
+
+        return None
+
+    def IsNull(self):
+        return np.isnan(self).all()
+
+    ## fixme: it would be nice to add setter, too.
+    def _getLeft(self):
+        return self[0,0]
+    Left = property(_getLeft)
+    def _getRight(self):
+        return self[1,0]
+    Right = property(_getRight)
+    def _getBottom(self):
+        return self[0,1]
+    Bottom = property(_getBottom)
+    def _getTop(self):
+        return self[1,1]
+    Top = property(_getTop)
+
+    def _getWidth(self):
+        return self[1,0] - self[0,0]
+    Width = property(_getWidth)
+
+    def _getHeight(self):
+        return self[1,1] - self[0,1]
+    Height = property(_getHeight)
+
+    def _getCenter(self):
+        return self.sum(0) / 2.0
+    Center = property(_getCenter)
+    ### This could be used for a make BB from a bunch of BBs
+
+    #~ def _getboundingbox(bboxarray): # lrk: added this
+        #~ # returns the bounding box of a bunch of bounding boxes
+        #~ upperleft = N.minimum.reduce(bboxarray[:,0])
+        #~ lowerright = N.maximum.reduce(bboxarray[:,1])
+        #~ return N.array((upperleft, lowerright), float)
+    #~ _getboundingbox = staticmethod(_getboundingbox)
+
+
+    ## Save the ndarray __eq__ for internal use.
+    Array__eq__ = np.ndarray.__eq__
+    def __eq__(self, BB):
+        """
+        __eq__(BB) The equality operator
+
+        A == B if and only if all the entries are the same
+
+        """
+        if self.IsNull() and np.isnan(BB).all(): ## BB may be a regular array, so I can't use IsNull
+            return True
+        else:
+            return self.Array__eq__(BB).all()
+
+
+def asBBox(data):
+    """
+    returns a BBox object.
+
+    If object is a BBox, it is returned unaltered
+
+    If object is a numpy array, a BBox object is returned that shares a
+    view of the data with that array. The numpy array should be of the correct
+    format: a 2x2 numpy array of floats::
+
+        [
+        [MinX, MinY ],
+        [MaxX, MaxY ]
+        ]
+
+    """
+
+    if isinstance(data, BBox):
+        return data
+    arr = np.asarray(data, float)
+    return np.ndarray.__new__(BBox, shape=arr.shape, dtype=arr.dtype, buffer=arr)
+
+def fromPoints(Points):
+    """
+    fromPoints (Points).
+
+    reruns the bounding box of the set of points in Points. Points can
+    be any python object that can be turned into a numpy NX2 array of Floats.
+
+    If a single point is passed in, a zero-size Bounding Box is returned.
+
+    """
+    Points = np.asarray(Points, float).reshape(-1,2)
+
+    arr = np.vstack( (Points.min(0), Points.max(0)) )
+    return np.ndarray.__new__(BBox, shape=arr.shape, dtype=arr.dtype, buffer=arr)
+
+def fromBBArray(BBarray):
+    """
+    Builds a BBox object from an array of Bounding Boxes.
+    The resulting Bounding Box encompases all the included BBs.
+
+    The BBarray is in the shape: (Nx2x2) where BBarray[n] is a 2x2 array that represents a BBox
+    """
+
+    #upperleft = N.minimum.reduce(BBarray[:,0])
+    #lowerright = N.maximum.reduce(BBarray[:,1])
+
+ #   BBarray = N.asarray(BBarray, float).reshape(-1,2)
+ #   arr = N.vstack( (BBarray.min(0), BBarray.max(0)) )
+    BBarray = np.asarray(BBarray, float).reshape(-1,2,2)
+    arr = np.vstack( (BBarray[:,0,:].min(0), BBarray[:,1,:].max(0)) )
+    return asBBox(arr)
+    #return asBBox( (upperleft, lowerright) ) * 2
+
+def NullBBox():
+    """
+    Returns a BBox object with all NaN entries.
+
+    This represents a Null BB box;
+
+    BB merged with it will return BB.
+
+    Nothing is inside it.
+
+    """
+
+    arr = np.array(((np.nan, np.nan),(np.nan, np.nan)), float)
+    return np.ndarray.__new__(BBox, shape=arr.shape, dtype=arr.dtype, buffer=arr)
+
+def InfBBox():
+    """
+    Returns a BBox object with all -inf and inf entries
+
+    """
+
+    arr = np.array(((-np.inf, -np.inf),(np.inf, np.inf)), float)
+    return np.ndarray.__new__(BBox, shape=arr.shape, dtype=arr.dtype, buffer=arr)
+
+class RectBBox(BBox):
+    """
+    subclass of a BBox that can be used for a rotated Rectangle
+
+    contributed by MArco Oster (marco.oster@bioquant.uni-heidelberg.de)
+
+    """
+
+    def __new__(self, data, edges=None):
+        return BBox.__new__(self, data)
+
+    def __init__(self, data, edges=None):
+        """ assume edgepoints are ordered such you can walk along all edges with left rotation sense
+            This may be:
+            left-top
+            left-bottom
+            right-bottom
+            right-top
+
+            or any rotation.
+        """
+        BBox.BBox(data)
+        self.edges = np.asarray(edges)
+
+    def ac_leftOf_ab(self, a, b, c):
+        ab = np.array(b) - np.array(a)
+        ac = np.array(c) - np.array(a)
+
+        return (ac[0]*ab[1] - ac[1]*ab[0]) <= 0
+
+    def PointInside(self, point):
+        for edge in xrange(4):
+            if self.ac_leftOf_ab(self.edges[edge],
+                                 self.edges[(edge+1)%4],
+                                 point):
+                continue
+            else:
+                return False
+        return True

wx/lib/floatcanvas/Utilities/Colors.py

@@ -0,0 +1,137 @@
+#----------------------------------------------------------------------------
+# Name:         Colors.py
+# Purpose:      Contains color lists used in FloatCanvas
+#
+# Author:
+#
+# Created:
+# Version:
+# Date:
+# Licence:
+# Tags:         phoenix-port, unittest, documented, py3-port
+#----------------------------------------------------------------------------
+
+"""
+Colors.py
+
+Assorted stuff for Colors support. At the moment, only a few color sets.
+
+Many of these are from:
+http://geography.uoregon.edu/datagraphics/color_scales.htm
+
+They may have been modified some
+
+CategoricalColor1: A list of colors that are distict.
+BlueToRed11: 11 colors from blue to red
+
+
+"""
+
+## Categorical 12-step scheme, after ColorBrewer 11-step Paired Scheme
+## From: http://geography.uoregon.edu/datagraphics/color_scales.htm
+# CategoricalColor1 = [ (255, 191, 127),
+#                       (255, 127,   0),
+#                       (255, 255, 153),
+#                       (255, 255,  50),
+#                       (178, 255, 140),
+#                       ( 50, 255,   0),
+#                       (165, 237, 255),
+#                       (25, 178, 255),
+#                       (204, 191, 255),
+#                       (101,  76, 255),
+#                       (255, 153, 191),
+#                       (229,  25,  50),
+#                       ]
+
+CategoricalColor1 = [ (229,  25,  50),
+                      (101,  76, 255),
+                      ( 50, 255,   0),
+                      (255, 127,   0),
+                      (255, 255,  50),
+                      (255, 153, 191),
+                      (25, 178, 255),
+                      (178, 255, 140),
+                      (255, 191, 127),
+                      (204, 191, 255),
+                      (165, 237, 255),
+                      (255, 255, 153),
+                      ]
+
+RedToBlue11 = [ (165,  0,   33),
+                (216,  38,  50),
+                (247, 109,  94),
+                (255, 173, 114),
+                (255, 224, 153),
+                (255, 255, 191),
+                (224, 255, 255),
+                (170, 247, 255),
+                (114, 216, 255),
+                ( 63, 160, 255),
+                ( 38, 76,  255),
+                ]
+
+BlueToDarkRed12 = [( 41,  10, 216),
+                   ( 38,  77, 255),
+                   ( 63, 160, 255),
+                   (114, 217, 255),
+                   (170, 247, 255),
+                   (224, 255, 255),
+                   (255, 255, 191),
+                   (255, 224, 153),
+                   (255, 173, 114),
+                   (247, 109,  94),
+                   (216,  38,  50),
+                   (165,   0,  33),
+                   ]
+
+BlueToDarkRed10 = [( 41,  10, 216),
+                   ( 38,  77, 255),
+                   ( 63, 160, 255),
+                   (114, 217, 255),
+                   (170, 247, 255),
+                   (255, 224, 153),
+                   (255, 173, 114),
+                   (247, 109,  94),
+                   (216,  38,  50),
+                   (165,   0,  33),
+                   ]
+
+BlueToDarkRed8 = [( 41,  10, 216),
+                   ( 38,  77, 255),
+                   ( 63, 160, 255),
+                   (114, 217, 255),
+                   (255, 173, 114),
+                   (247, 109,  94),
+                   (216,  38,  50),
+                   (165,   0,  33),
+                   ]
+
+
+
+if __name__ == "__main__":
+    import wx
+    # tiny test app
+    AllSchemes = [("CategoricalColor1", CategoricalColor1),
+                  ("RedToBlue11", RedToBlue11),
+                  ("BlueToDarkRed12", BlueToDarkRed12),
+                  ("BlueToDarkRed10", BlueToDarkRed10),
+                  ("BlueToDarkRed8", BlueToDarkRed8)
+                  ]
+    class TestFrame(wx.Frame):
+        def __init__(self, *args, **kwargs):
+            wx.Frame.__init__(self, *args, **kwargs)
+            Hsizer = wx.BoxSizer(wx.HORIZONTAL)
+            for scheme in AllSchemes:
+                Sizer = wx.BoxSizer(wx.VERTICAL)
+                Sizer.Add(wx.StaticText(self, label=scheme[0]), 0, wx.ALL, 5)
+                for c in scheme[1]:
+                    w = wx.Window(self, size=(100, 20))
+                    w.SetBackgroundColour(wx.Colour(*c))
+                    Sizer.Add(w, 0, wx.ALL, 5)
+                Hsizer.Add(Sizer, 0, wx.ALL, 5)
+            self.SetSizerAndFit(Hsizer)
+            self.Show()
+
+    A = wx.App(False)
+    F = TestFrame(None)
+    A.MainLoop()

wx/lib/floatcanvas/Utilities/GUI.py

@@ -0,0 +1,91 @@
+#----------------------------------------------------------------------------
+# Name:         GUI.py
+# Purpose:      Contains GUI related utilities for FloatCanvas
+#
+# Author:
+#
+# Created:
+# Version:
+# Date:
+# Licence:
+# Tags:         phoenix-port, unittest, documented, py3-port
+#----------------------------------------------------------------------------
+"""
+
+Part of the floatcanvas.Utilities package.
+
+This module contains assorted GUI-related utilities that can be used
+with FloatCanvas
+
+So far, they are:
+
+RubberBandBox: used to draw a RubberBand Box on the screen
+
+"""
+
+import numpy as np
+
+import wx
+from wx.lib.floatcanvas import FloatCanvas, GUIMode
+
+class RubberBandBox(GUIMode.GUIBase):
+    """
+    Class to provide a GUI Mode that makes a rubber band box that can be drawn on a Window
+
+    """
+
+    def __init__(self, CallBack, Tol=5):
+
+        """
+        Default class constructor.
+
+        :param `CallBack`: is the method you want called when the mouse is
+                  released. That method will be called, passing in a rect
+                  parameter, where rect is: (Point, WH) of the rect in
+                  world coords.
+        :param `Tol`: The tolerance for the smallest rectangle allowed. defaults
+                  to 5. In pixels
+        """
+
+        self.Canvas = None # this will be set when the mode is set on a Canvas
+        self.CallBack = CallBack
+        self.Tol = Tol
+
+        self.Drawing = False
+        self.RBRect = None
+        self.StartPointWorld = None
+
+        return None
+
+    def OnMove(self, event):
+        if self.Drawing:
+            x, y = self.StartPoint
+            Cornerx, Cornery = event.GetPosition()
+            w, h = ( Cornerx - x, Cornery - y)
+            if abs(w) > self.Tol and abs(h) > self.Tol:
+                # draw the RB box
+                dc = wx.ClientDC(self.Canvas)
+                dc.SetPen(wx.Pen('WHITE', 2, wx.SHORT_DASH))
+                dc.SetBrush(wx.TRANSPARENT_BRUSH)
+                dc.SetLogicalFunction(wx.XOR)
+                if self.RBRect:
+                    dc.DrawRectangle(*self.RBRect)
+                self.RBRect = ((x, y), (w, h) )
+                dc.DrawRectangle(*self.RBRect)
+        self.Canvas._RaiseMouseEvent(event,FloatCanvas.EVT_FC_MOTION)
+
+    def OnLeftDown(self, event):
+        # Start drawing
+        self.Drawing = True
+        self.StartPoint = event.GetPosition()
+
+    def OnLeftUp(self, event):
+        # Stop Drawing
+        if self.Drawing:
+            self.Drawing = False
+            if self.RBRect:
+                world_rect = (self.Canvas.PixelToWorld(self.RBRect[0]),
+                              self.Canvas.ScalePixelToWorld(self.RBRect[1])
+                              )
+                wx.CallAfter(self.CallBack, world_rect)
+        self.RBRect = None

wx/lib/floatcanvas/Utilities/__init__.py

@@ -0,0 +1,7 @@
+"""
+__init__ for the floatcanvas Utilities package
+
+"""
+pass
+
+

wx/lib/floatcanvas/__init__.py

@@ -0,0 +1,124 @@
+#----------------------------------------------------------------------------
+# Name:         __init__.py
+# Purpose:      The FloatCanvas package
+#
+# Author:
+#
+# Created:
+# Version:
+# Date:
+# Licence:
+# Tags:         phoenix-port, unittest, documented, py3-port
+#----------------------------------------------------------------------------
+"""
+This is the floatcanvas package, the main classes are
+:class:`~lib.floatcanvas.FloatCanvas` and
+:class:`~lib.floatcanvas.NavCanvas`, in each class documentation there
+is at least one sample on how to use them and many more samples are provided
+in `wxPhoenix/samples` folder.
+
+FloatCanvas.py contains the main :class:`~lib.floatcanvas.FloatCanvas`
+class, and its supporting classes.  NavCanvas.py contains the
+:class:`~lib.floatcanvas.NavCanvas` wrapper for the FloatCanvas that
+provides the canvas and a toolbar with tools that allow you to navigate
+the canvas (zooming, panning, etc.)  Resources.py is a module that
+contains a few resources required by the FloatCanvas (icons, etc)
+
+The FloatCanvas 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 <http://www.numpy.org/>`_, which is needed for speed
+(maybe, I haven't profiled properly) and convenience.
+
+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
+haven'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 weird results. It
+doesn't seem to actually cause any problems other than weird 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 <http://www.numpy.org/>`_ 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.
+
+If you are zoomed in, it checks the Bounding box of an object before
+drawing it. This makes it a great deal faster when there are a lot of
+objects and you are zoomed in so that only a few are shown.
+
+Mouse Events:
+
+There are a full set of custom mouse events. They are just like the
+regular mouse events, but include an extra attribute: Event.GetCoords(),
+that returns the (x,y) position in world coordinates, as a length-2
+`NumPy <http://www.numpy.org/>`_ vector of Floats.
+
+There are also a full set of bindings to mouse events on objects, so
+that you can specify a given function be called when an object is
+clicked, mouse-over'd, etc.
+
+See the Demo for what it can do, and how to use it.
+
+Copyright: Christopher Barker
+License: Same as the version of wxPython you are using it with.
+
+TRAC site for some docs and updates:
+
+http://trac.paulmcnett.com/floatcanvas
+
+Mailing List:
+
+http://mail.paulmcnett.com/cgi-bin/mailman/listinfo/floatcanvas
+
+The latest code is in the main wx SVN:
+
+For classic:
+
+http://svn.wxwidgets.org/viewvc/wx/wxPython/3rdParty/FloatCanvas/
+
+For Phoenix:
+
+http://svn.wxwidgets.org/svn/wx/wxPython/Phoenix/trunk/wx/lib/floatcanvas
+
+Check for updates or answers to questions, send me an email.
+Please let me know if you're using this!!!
+
+Contact me at:
+
+Chris.Barker@noaa.gov
+
+"""
+
+__version__ = "0.9.18"
+
+