Mercurial > parpg-core

comparison src/parpg/grease/geometry.py @ 27:09b581087d68

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added base files for grease
author KarstenBock@gmx.net
date Tue, 12 Jul 2011 10:16:48 +0200
parents
children
comparison
equal deleted inserted replaced
26:5529dd5644b8 27:09b581087d68
1 __version__ = "$Id$"
2 __docformat__ = "reStructuredText"
3
4 import operator
5 import math
6 import ctypes
7
8 class Vec2d(ctypes.Structure):
9 """2d vector class, supports vector and scalar operators,
10 and also provides a bunch of high level functions
11 """
12 __slots__ = ['x', 'y']
13
14 @classmethod
15 def from_param(cls, arg):
16 return cls(arg)
17
18 def __init__(self, x_or_pair, y = None):
19
20 if y == None:
21 self.x = x_or_pair[0]
22 self.y = x_or_pair[1]
23 else:
24 self.x = x_or_pair
25 self.y = y
26
27 def __len__(self):
28 return 2
29
30 def __getitem__(self, key):
31 if key == 0:
32 return self.x
33 elif key == 1:
34 return self.y
35 else:
36 raise IndexError("Invalid subscript "+str(key)+" to Vec2d")
37
38 def __setitem__(self, key, value):
39 if key == 0:
40 self.x = value
41 elif key == 1:
42 self.y = value
43 else:
44 raise IndexError("Invalid subscript "+str(key)+" to Vec2d")
45
46 # String representaion (for debugging)
47 def __repr__(self):
48 return 'Vec2d(%s, %s)' % (self.x, self.y)
49
50 # Comparison
51 def __eq__(self, other):
52 if hasattr(other, "__getitem__") and len(other) == 2:
53 return self.x == other[0] and self.y == other[1]
54 else:
55 return False
56
57 def __ne__(self, other):
58 if hasattr(other, "__getitem__") and len(other) == 2:
59 return self.x != other[0] or self.y != other[1]
60 else:
61 return True
62
63 def __nonzero__(self):
64 return self.x or self.y
65
66 # Generic operator handlers
67 def _o2(self, other, f):
68 "Any two-operator operation where the left operand is a Vec2d"
69 if isinstance(other, Vec2d):
70 return Vec2d(f(self.x, other.x),
71 f(self.y, other.y))
72 elif (hasattr(other, "__getitem__")):
73 return Vec2d(f(self.x, other[0]),
74 f(self.y, other[1]))
75 else:
76 return Vec2d(f(self.x, other),
77 f(self.y, other))
78
79 def _r_o2(self, other, f):
80 "Any two-operator operation where the right operand is a Vec2d"
81 if (hasattr(other, "__getitem__")):
82 return Vec2d(f(other[0], self.x),
83 f(other[1], self.y))
84 else:
85 return Vec2d(f(other, self.x),
86 f(other, self.y))
87
88 def _io(self, other, f):
89 "inplace operator"
90 if (hasattr(other, "__getitem__")):
91 self.x = f(self.x, other[0])
92 self.y = f(self.y, other[1])
93 else:
94 self.x = f(self.x, other)
95 self.y = f(self.y, other)
96 return self
97
98 # Addition
99 def __add__(self, other):
100 if isinstance(other, Vec2d):
101 return Vec2d(self.x + other.x, self.y + other.y)
102 elif hasattr(other, "__getitem__"):
103 return Vec2d(self.x + other[0], self.y + other[1])
104 else:
105 return Vec2d(self.x + other, self.y + other)
106 __radd__ = __add__
107
108 def __iadd__(self, other):
109 if isinstance(other, Vec2d):
110 self.x += other.x
111 self.y += other.y
112 elif hasattr(other, "__getitem__"):
113 self.x += other[0]
114 self.y += other[1]
115 else:
116 self.x += other
117 self.y += other
118 return self
119
120 # Subtraction
121 def __sub__(self, other):
122 if isinstance(other, Vec2d):
123 return Vec2d(self.x - other.x, self.y - other.y)
124 elif (hasattr(other, "__getitem__")):
125 return Vec2d(self.x - other[0], self.y - other[1])
126 else:
127 return Vec2d(self.x - other, self.y - other)
128 def __rsub__(self, other):
129 if isinstance(other, Vec2d):
130 return Vec2d(other.x - self.x, other.y - self.y)
131 if (hasattr(other, "__getitem__")):
132 return Vec2d(other[0] - self.x, other[1] - self.y)
133 else:
134 return Vec2d(other - self.x, other - self.y)
135 def __isub__(self, other):
136 if isinstance(other, Vec2d):
137 self.x -= other.x
138 self.y -= other.y
139 elif (hasattr(other, "__getitem__")):
140 self.x -= other[0]
141 self.y -= other[1]
142 else:
143 self.x -= other
144 self.y -= other
145 return self
146
147 # Multiplication
148 def __mul__(self, other):
149 if isinstance(other, Vec2d):
150 return Vec2d(self.x*other.y, self.y*other.y)
151 if (hasattr(other, "__getitem__")):
152 return Vec2d(self.x*other[0], self.y*other[1])
153 else:
154 return Vec2d(self.x*other, self.y*other)
155 __rmul__ = __mul__
156
157 def __imul__(self, other):
158 if isinstance(other, Vec2d):
159 self.x *= other.x
160 self.y *= other.y
161 elif (hasattr(other, "__getitem__")):
162 self.x *= other[0]
163 self.y *= other[1]
164 else:
165 self.x *= other
166 self.y *= other
167 return self
168
169 # Division
170 def __div__(self, other):
171 return self._o2(other, operator.div)
172 def __rdiv__(self, other):
173 return self._r_o2(other, operator.div)
174 def __idiv__(self, other):
175 return self._io(other, operator.div)
176
177 def __floordiv__(self, other):
178 return self._o2(other, operator.floordiv)
179 def __rfloordiv__(self, other):
180 return self._r_o2(other, operator.floordiv)
181 def __ifloordiv__(self, other):
182 return self._io(other, operator.floordiv)
183
184 def __truediv__(self, other):
185 return self._o2(other, operator.truediv)
186 def __rtruediv__(self, other):
187 return self._r_o2(other, operator.truediv)
188 def __itruediv__(self, other):
189 return self._io(other, operator.floordiv)
190
191 # Modulo
192 def __mod__(self, other):
193 return self._o2(other, operator.mod)
194 def __rmod__(self, other):
195 return self._r_o2(other, operator.mod)
196
197 def __divmod__(self, other):
198 return self._o2(other, divmod)
199 def __rdivmod__(self, other):
200 return self._r_o2(other, divmod)
201
202 # Exponentation
203 def __pow__(self, other):
204 return self._o2(other, operator.pow)
205 def __rpow__(self, other):
206 return self._r_o2(other, operator.pow)
207
208 # Bitwise operators
209 def __lshift__(self, other):
210 return self._o2(other, operator.lshift)
211 def __rlshift__(self, other):
212 return self._r_o2(other, operator.lshift)
213
214 def __rshift__(self, other):
215 return self._o2(other, operator.rshift)
216 def __rrshift__(self, other):
217 return self._r_o2(other, operator.rshift)
218
219 def __and__(self, other):
220 return self._o2(other, operator.and_)
221 __rand__ = __and__
222
223 def __or__(self, other):
224 return self._o2(other, operator.or_)
225 __ror__ = __or__
226
227 def __xor__(self, other):
228 return self._o2(other, operator.xor)
229 __rxor__ = __xor__
230
231 # Unary operations
232 def __neg__(self):
233 return Vec2d(operator.neg(self.x), operator.neg(self.y))
234
235 def __pos__(self):
236 return Vec2d(operator.pos(self.x), operator.pos(self.y))
237
238 def __abs__(self):
239 return Vec2d(abs(self.x), abs(self.y))
240
241 def __invert__(self):
242 return Vec2d(-self.x, -self.y)
243
244 # vectory functions
245 def get_length_sqrd(self):
246 """Get the squared length of the vector.
247 It is more efficent to use this method instead of first call
248 get_length() or access .length and then do a sqrt().
249
250 :return: The squared length
251 """
252 return self.x**2 + self.y**2
253
254 def get_length(self):
255 """Get the length of the vector.
256
257 :return: The length
258 """
259 return math.sqrt(self.x**2 + self.y**2)
260 def __setlength(self, value):
261 length = self.get_length()
262 self.x *= value/length
263 self.y *= value/length
264 length = property(get_length, __setlength, doc = """Gets or sets the magnitude of the vector""")
265
266 def rotate(self, angle_degrees):
267 """Rotate the vector by angle_degrees degrees clockwise."""
268 radians = -math.radians(angle_degrees)
269 cos = math.cos(radians)
270 sin = math.sin(radians)
271 x = self.x*cos - self.y*sin
272 y = self.x*sin + self.y*cos
273 self.x = x
274 self.y = y
275
276 def rotated(self, angle_degrees):
277 """Create and return a new vector by rotating this vector by
278 angle_degrees degrees clockwise.
279
280 :return: Rotated vector
281 """
282 radians = -math.radians(angle_degrees)
283 cos = math.cos(radians)
284 sin = math.sin(radians)
285 x = self.x*cos - self.y*sin
286 y = self.x*sin + self.y*cos
287 return Vec2d(x, y)
288
289 def get_angle(self):
290 if (self.get_length_sqrd() == 0):
291 return 0
292 return math.degrees(math.atan2(self.y, self.x))
293 def __setangle(self, angle_degrees):
294 self.x = self.length
295 self.y = 0
296 self.rotate(angle_degrees)
297 angle = property(get_angle, __setangle, doc="""Gets or sets the angle of a vector""")
298
299 def get_angle_between(self, other):
300 """Get the angle between the vector and the other in degrees
301
302 :return: The angle
303 """
304 cross = self.x*other[1] - self.y*other[0]
305 dot = self.x*other[0] + self.y*other[1]
306 return math.degrees(math.atan2(cross, dot))
307
308 def normalized(self):
309 """Get a normalized copy of the vector
310
311 :return: A normalized vector
312 """
313 length = self.length
314 if length != 0:
315 return self/length
316 return Vec2d(self)
317
318 def normalize_return_length(self):
319 """Normalize the vector and return its length before the normalization
320
321 :return: The length before the normalization
322 """
323 length = self.length
324 if length != 0:
325 self.x /= length
326 self.y /= length
327 return length
328
329 def perpendicular(self):
330 return Vec2d(-self.y, self.x)
331
332 def perpendicular_normal(self):
333 length = self.length
334 if length != 0:
335 return Vec2d(-self.y/length, self.x/length)
336 return Vec2d(self)
337
338 def dot(self, other):
339 """The dot product between the vector and other vector
340 v1.dot(v2) -> v1.x*v2.x + v1.y*v2.y
341
342 :return: The dot product
343 """
344 return float(self.x*other[0] + self.y*other[1])
345
346 def get_distance(self, other):
347 """The distance between the vector and other vector
348
349 :return: The distance
350 """
351 return math.sqrt((self.x - other[0])**2 + (self.y - other[1])**2)
352
353 def get_dist_sqrd(self, other):
354 """The squared distance between the vector and other vector
355 It is more efficent to use this method than to call get_distance()
356 first and then do a sqrt() on the result.
357
358 :return: The squared distance
359 """
360 return (self.x - other[0])**2 + (self.y - other[1])**2
361
362 def projection(self, other):
363 other_length_sqrd = other[0]*other[0] + other[1]*other[1]
364 projected_length_times_other_length = self.dot(other)
365 return other*(projected_length_times_other_length/other_length_sqrd)
366
367 def cross(self, other):
368 """The cross product between the vector and other vector
369 v1.cross(v2) -> v1.x*v2.y - v2.y-v1.x
370
371 :return: The cross product
372 """
373 return self.x*other[1] - self.y*other[0]
374
375 def interpolate_to(self, other, range):
376 return Vec2d(self.x + (other[0] - self.x)*range, self.y + (other[1] - self.y)*range)
377
378 def convert_to_basis(self, x_vector, y_vector):
379 return Vec2d(self.dot(x_vector)/x_vector.get_length_sqrd(), self.dot(y_vector)/y_vector.get_length_sqrd())
380
381 # Extra functions, mainly for chipmunk
382 def cpvrotate(self, other):
383 return Vec2d(self.x*other.x - self.y*other.y, self.x*other.y + self.y*other.x)
384 def cpvunrotate(self, other):
385 return Vec2d(self.x*other.x + self.y*other.y, self.y*other.x - self.x*other.y)
386
387 # Pickle, does not work atm.
388 def __getstate__(self):
389 return [self.x, self.y]
390
391 def __setstate__(self, dict):
392 self.x, self.y = dict
393 def __newobj__(cls, *args):
394 return cls.__new__(cls, *args)
395 Vec2d._fields_ = [
396 ('x', ctypes.c_double),
397 ('y', ctypes.c_double),
398 ]
399
400
401 class Vec2dArray(list):
402
403 def __init__(self, iterable=()):
404 list.__init__(self, (Vec2d(i) for i in iterable))
405
406 def __setitem__(self, index, value):
407 list.__setitem__(self, index, Vec2d(value))
408
409 def append(self, value):
410 """Append a vector to the array"""
411 list.append(self, Vec2d(value))
412
413 def insert(self, index, value):
414 """Insert a vector into the array"""
415 list.insert(self, index, Vec2d(value))
416
417 def transform(self, offset=Vec2d(0,0), angle=0, scale=1.0):
418 """Return a new transformed Vec2dArray"""
419 offset = Vec2d(offset)
420 angle = math.radians(-angle)
421 rot_vec = Vec2d(math.cos(angle), math.sin(angle))
422 xformed = Vec2dArray()
423 for vec in self:
424 xformed.append(vec.cpvrotate(rot_vec) * scale + offset)
425 return xformed
426
427 def segments(self, closed=True):
428 """Generate arrays of line segments connecting adjacent vetices
429 in this array, exploding the shape into it's constituent segments
430 """
431 if len(self) >= 2:
432 last = self[0]
433 for vert in self[1:]:
434 yield Vec2dArray((last, vert))
435 last = vert
436 if closed:
437 yield Vec2dArray((last, self[0]))
438 elif self and closed:
439 yield Vec2dArray((self[0], self[0]))
440
441
442
443 class Rect(ctypes.Structure):
444 """Simple rectangle. Will gain more functionality as needed"""
445 _fields_ = [
446 ('left', ctypes.c_double),
447 ('top', ctypes.c_double),
448 ('right', ctypes.c_double),
449 ('bottom', ctypes.c_double),
450 ]
451
452 def __init__(self, rect_or_left, bottom=None, right=None, top=None):
453 if bottom is not None:
454 assert right is not None and top is not None, "No enough arguments to Rect"
455 self.left = rect_or_left
456 self.bottom = bottom
457 self.right = right
458 self.top = top
459 else:
460 self.left = rect_or_left.left
461 self.bottom = rect_or_left.bottom
462 self.right = rect_or_left.right
463 self.top = rect_or_left.top
464
465 @property
466 def width(self):
467 """Rectangle width"""
468 return self.right - self.left
469
470 @property
471 def height(self):
472 """Rectangle height"""
473 return self.top - self.bottom
474
475
476 ########################################################################
477 ## Unit Testing ##
478 ########################################################################
479 if __name__ == "__main__":
480
481 import unittest
482 import pickle
483
484 ####################################################################
485 class UnitTestVec2d(unittest.TestCase):
486
487 def setUp(self):
488 pass
489
490 def testCreationAndAccess(self):
491 v = Vec2d(111, 222)
492 self.assert_(v.x == 111 and v.y == 222)
493 v.x = 333
494 v[1] = 444
495 self.assert_(v[0] == 333 and v[1] == 444)
496
497 def testMath(self):
498 v = Vec2d(111,222)
499 self.assertEqual(v + 1, Vec2d(112, 223))
500 self.assert_(v - 2 == [109, 220])
501 self.assert_(v * 3 == (333, 666))
502 self.assert_(v / 2.0 == Vec2d(55.5, 111))
503 #self.assert_(v / 2 == (55, 111)) # Not supported since this is a c_float structure in the bottom
504 self.assert_(v ** Vec2d(2, 3) == [12321, 10941048])
505 self.assert_(v + [-11, 78] == Vec2d(100, 300))
506 #self.assert_(v / [11,2] == [10,111]) # Not supported since this is a c_float structure in the bottom
507
508 def testReverseMath(self):
509 v = Vec2d(111, 222)
510 self.assert_(1 + v == Vec2d(112, 223))
511 self.assert_(2 - v == [-109, -220])
512 self.assert_(3 * v == (333, 666))
513 #self.assert_([222,999] / v == [2,4]) # Not supported since this is a c_float structure in the bottom
514 self.assert_([111, 222] ** Vec2d(2, 3) == [12321, 10941048])
515 self.assert_([-11, 78] + v == Vec2d(100, 300))
516
517 def testUnary(self):
518 v = Vec2d(111, 222)
519 v = -v
520 self.assert_(v == [-111, -222])
521 v = abs(v)
522 self.assert_(v == [111, 222])
523
524 def testLength(self):
525 v = Vec2d(3,4)
526 self.assert_(v.length == 5)
527 self.assert_(v.get_length_sqrd() == 25)
528 self.assert_(v.normalize_return_length() == 5)
529 self.assertAlmostEquals(v.length, 1)
530 v.length = 5
531 self.assert_(v == Vec2d(3, 4))
532 v2 = Vec2d(10, -2)
533 self.assert_(v.get_distance(v2) == (v - v2).get_length())
534
535 def testAngles(self):
536 v = Vec2d(0, 3)
537 self.assertEquals(v.angle, 90)
538 v2 = Vec2d(v)
539 v.rotate(-90)
540 self.assertEqual(v.get_angle_between(v2), 90)
541 v2.angle -= 90
542 self.assertEqual(v.length, v2.length)
543 self.assertEquals(v2.angle, 0)
544 self.assertEqual(v2, [3, 0])
545 self.assert_((v - v2).length < .00001)
546 self.assertEqual(v.length, v2.length)
547 v2.rotate(300)
548 self.assertAlmostEquals(v.get_angle_between(v2), -60, 5) # Allow a little more error than usual (floats..)
549 v2.rotate(v2.get_angle_between(v))
550 angle = v.get_angle_between(v2)
551 self.assertAlmostEquals(v.get_angle_between(v2), 0)
552
553 def testHighLevel(self):
554 basis0 = Vec2d(5.0, 0)
555 basis1 = Vec2d(0, .5)
556 v = Vec2d(10, 1)
557 self.assert_(v.convert_to_basis(basis0, basis1) == [2, 2])
558 self.assert_(v.projection(basis0) == (10, 0))
559 self.assert_(basis0.dot(basis1) == 0)
560
561 def testCross(self):
562 lhs = Vec2d(1, .5)
563 rhs = Vec2d(4, 6)
564 self.assert_(lhs.cross(rhs) == 4)
565
566 def testComparison(self):
567 int_vec = Vec2d(3, -2)
568 flt_vec = Vec2d(3.0, -2.0)
569 zero_vec = Vec2d(0, 0)
570 self.assert_(int_vec == flt_vec)
571 self.assert_(int_vec != zero_vec)
572 self.assert_((flt_vec == zero_vec) == False)
573 self.assert_((flt_vec != int_vec) == False)
574 self.assert_(int_vec == (3, -2))
575 self.assert_(int_vec != [0, 0])
576 self.assert_(int_vec != 5)
577 self.assert_(int_vec != [3, -2, -5])
578
579 def testInplace(self):
580 inplace_vec = Vec2d(5, 13)
581 inplace_ref = inplace_vec
582 inplace_src = Vec2d(inplace_vec)
583 inplace_vec *= .5
584 inplace_vec += .5
585 inplace_vec /= (3, 6)
586 inplace_vec += Vec2d(-1, -1)
587 alternate = (inplace_src*.5 + .5)/Vec2d(3, 6) + [-1, -1]
588 self.assertEquals(inplace_vec, inplace_ref)
589 self.assertEquals(inplace_vec, alternate)
590
591 def testPickle(self):
592 return # pickling does not work atm
593 testvec = Vec2d(5, .3)
594 testvec_str = pickle.dumps(testvec)
595 loaded_vec = pickle.loads(testvec_str)
596 self.assertEquals(testvec, loaded_vec)
597
598 ####################################################################
599 unittest.main()
600