1 """Point and Rectangle classes.
   2 
   3 This code is in the public domain.
   4 
   5 Point  -- point with (x,y) coordinates
   6 Rect  -- two points, forming a rectangle
   7 """
   8 
   9 import math
  10 
  11 
  12 class Point:
  13     
  14     """A point identified by (x,y) coordinates.
  15     
  16     supports: +, -, *, /, str, repr
  17     
  18     length  -- calculate length of vector to point from origin
  19     distance_to  -- calculate distance between two points
  20     as_tuple  -- construct tuple (x,y)
  21     clone  -- construct a duplicate
  22     integerize  -- convert x & y to integers
  23     floatize  -- convert x & y to floats
  24     move_to  -- reset x & y
  25     slide  -- move (in place) +dx, +dy, as spec'd by point
  26     slide_xy  -- move (in place) +dx, +dy
  27     rotate  -- rotate around the origin
  28     rotate_about  -- rotate around another point
  29     """
  30     
  31     def __init__(self, x=0.0, y=0.0):
  32         self.x = x
  33         self.y = y
  34     
  35     def __add__(self, p):
  36         """Point(x1+x2, y1+y2)"""
  37         return Point(self.x+p.x, self.y+p.y)
  38     
  39     def __sub__(self, p):
  40         """Point(x1-x2, y1-y2)"""
  41         return Point(self.x-p.x, self.y-p.y)
  42     
  43     def __mul__( self, scalar ):
  44         """Point(x1*x2, y1*y2)"""
  45         return Point(self.x*scalar, self.y*scalar)
  46     
  47     def __div__(self, scalar):
  48         """Point(x1/x2, y1/y2)"""
  49         return Point(self.x/scalar, self.y/scalar)
  50     
  51     def __str__(self):
  52         return "(%s, %s)" % (self.x, self.y)
  53     
  54     def __repr__(self):
  55         return "%s(%r, %r)" % (self.__class__.__name__, self.x, self.y)
  56     
  57     def length(self):
  58         return math.sqrt(self.x**2 + self.y**2)
  59     
  60     def distance_to(self, p):
  61         """Calculate the distance between two points."""
  62         return (self - p).length()
  63     
  64     def as_tuple(self):
  65         """(x, y)"""
  66         return (self.x, self.y)
  67     
  68     def clone(self):
  69         """Return a full copy of this point."""
  70         return Point(self.x, self.y)
  71     
  72     def integerize(self):
  73         """Convert co-ordinate values to integers."""
  74         self.x = int(self.x)
  75         self.y = int(self.y)
  76     
  77     def floatize(self):
  78         """Convert co-ordinate values to floats."""
  79         self.x = float(self.x)
  80         self.y = float(self.y)
  81     
  82     def move_to(self, x, y):
  83         """Reset x & y coordinates."""
  84         self.x = x
  85         self.y = y
  86     
  87     def slide(self, p):
  88         '''Move to new (x+dx,y+dy).
  89         
  90         Can anyone think up a better name for this function?
  91         slide? shift? delta? move_by?
  92         '''
  93         self.x = self.x + p.x
  94         self.y = self.y + p.y
  95     
  96     def slide_xy(self, dx, dy):
  97         '''Move to new (x+dx,y+dy).
  98         
  99         Can anyone think up a better name for this function?
 100         slide? shift? delta? move_by?
 101         '''
 102         self.x = self.x + dx
 103         self.y = self.y + dy
 104     
 105     def rotate(self, rad):
 106         """Rotate counter-clockwise by rad radians.
 107         
 108         Positive y goes *up,* as in traditional mathematics.
 109         
 110         Interestingly, you can use this in y-down computer graphics, if
 111         you just remember that it turns clockwise, rather than
 112         counter-clockwise.
 113         
 114         The new position is returned as a new Point.
 115         """
 116         s, c = [f(rad) for f in (math.sin, math.cos)]
 117         x, y = (c*self.x - s*self.y, s*self.x + c*self.y)
 118         return Point(x,y)
 119     
 120     def rotate_about(self, p, theta):
 121         """Rotate counter-clockwise around a point, by theta degrees.
 122         
 123         Positive y goes *up,* as in traditional mathematics.
 124         
 125         The new position is returned as a new Point.
 126         """
 127         result = self.clone()
 128         result.slide(-p.x, -p.y)
 129         result.rotate(theta)
 130         result.slide(p.x, p.y)
 131         return result
 132 
 133 
 134 class Rect:
 135 
 136     """A rectangle identified by two points.
 137 
 138     The rectangle stores left, top, right, and bottom values.
 139 
 140     Coordinates are based on screen coordinates.
 141 
 142     origin                               top
 143        +-----> x increases                |
 144        |                           left  -+-  right
 145        v                                  |
 146     y increases                         bottom
 147 
 148     set_points  -- reset rectangle coordinates
 149     contains  -- is a point inside?
 150     overlaps  -- does a rectangle overlap?
 151     top_left  -- get top-left corner
 152     bottom_right  -- get bottom-right corner
 153     expanded_by  -- grow (or shrink)
 154     """
 155 
 156     def __init__(self, pt1, pt2):
 157         """Initialize a rectangle from two points."""
 158         self.set_points(pt1, pt2)
 159 
 160     def set_points(self, pt1, pt2):
 161         """Reset the rectangle coordinates."""
 162         (x1, y1) = pt1.as_tuple()
 163         (x2, y2) = pt2.as_tuple()
 164         self.left = min(x1, x2)
 165         self.top = min(y1, y2)
 166         self.right = max(x1, x2)
 167         self.bottom = max(y1, y2)
 168 
 169     def contains(self, pt):
 170         """Return true if a point is inside the rectangle."""
 171         x,y = pt.as_tuple()
 172         return (self.left <= x <= self.right and
 173                 self.top <= y <= self.bottom)
 174 
 175     def overlaps(self, other):
 176         """Return true if a rectangle overlaps this rectangle."""
 177         return (self.right > other.left and self.left < other.right and
 178                 self.top < other.bottom and self.bottom > other.top)
 179     
 180     def top_left(self):
 181         """Return the top-left corner as a Point."""
 182         return Point(self.left, self.top)
 183     
 184     def bottom_right(self):
 185         """Return the bottom-right corner as a Point."""
 186         return Point(self.right, self.bottom)
 187     
 188     def expanded_by(self, n):
 189         """Return a rectangle with extended borders.
 190 
 191         Create a new rectangle that is wider and taller than the
 192         immediate one. All sides are extended by "n" points.
 193         """
 194         p1 = Point(self.left-n, self.top-n)
 195         p2 = Point(self.right+n, self.bottom+n)
 196         return Rect(p1, p2)
 197     
 198     def __str__( self ):
 199         return "<Rect (%s,%s)-(%s,%s)>" % (self.left,self.top,
 200                                            self.right,self.bottom)
 201     
 202     def __repr__(self):
 203         return "%s(%r, %r)" % (self.__class__.__name__,
 204                                Point(self.left, self.top),
 205                                Point(self.right, self.bottom))