vector2d.py

'''2D Vector with related methods

Created for HIT3046 AI for Games by Clinton Woodward cwoodward@swin.edu.au
Updated by Steve Dower
'''

from math import sqrt, cos, sin, acos, asin, tan, atan
from random import uniform

MIN_FLOAT = 1e-300

def is_equal(a, b):
    return abs(a-b) < 1e-12

# Not needed, but fyi ...
#def PointToVector2D(pt):
#    return Vector2D(pt.x, pt.y)
#
#def Vector2DToPoint(v):
#    return Point2D(v.x, v.y)

class Rect(object):
    def __init__(self, rect={'left': 0, 'bottom': 0, 'top': 10, 'right': 10}):
        self.left = rect['left']
        self.top = rect['top']
        self.right = rect['right']
        self.bottom = rect['bottom']

    def getBox(self):
        return (self.left, self.top, self.right, self.bottom)

    def getPoints(self):
        return [
            Vector2D(self.left, self.top),
            Vector2D(self.right, self.top),
            Vector2D(self.right, self.bottom),
            Vector2D(self.left, self.bottom)
        ]




class Points(object):
    def __init__(self, pts = []):
        self.pts = pts


    def append(self, pt):
        self.pts.append(pt)

    def transform(self, matrix):
        matrix.transform_vector2d_list(self.pts)
        return self

    def copy(self):
        return Points([p.copy() for p in self.pts])

    def reverse(self):
        self.pts.reverse()
        return self

    def __str__(self):
        return str([str(p) for p in self.pts])



class Vector2D(object):
    __slots__ = ('x', 'y')

    def __init__(self,x=0.,y=0.):
        self.x = x
        self.y = y

    def zero(self):
        ''' set x and y to zero '''
        self.x = 0.
        self.y = 0.

    def is_zero(self):
        ''' return true if both x and y are zero '''
        return (self.x**2 + self.y**2) < MIN_FLOAT

    def length(self):
        ''' return the length of the vector '''
        x = self.x
        y = self.y
        return sqrt(x*x + y*y)

    def lengthSq(self):
        ''' return the squared length (avoid sqrt()) '''
        x = self.x
        y = self.y
        return x*x + y*y

    def normalise(self):
        ''' normalise self to a unit vector of length = 1.0 '''
        x = self.x
        y = self.y
        l = sqrt(x*x + y*y)
        try:
            self.x = x/l
            self.y = y/l
        except ZeroDivisionError:
            self.x = 0.
            self.y = 0.
        return self

    def get_normalised(self):
        ''' return a normalised copy of self '''
        result = self.copy()
        return result.normalise()

    def dot(self, v2):
        ''' The dot (inner) product of self and v2 vector '''
        return self.x*v2.x + self.y*v2.y

    def sign(self, v2):
        ''' return +1 if v2 is clockwise of self.
            return -1 if v2 is anti-clockwise of self
            Assumes Y axis points down and X points right '''
        if self.y*v2.x > self.x*v2.y:
            return -1
        else:
            return 1

    def perp(self):
        ''' return a vector perpendicular to self. '''
        return Vector2D(-self.y, self.x)

    def truncate(self, maxlength):
        ''' limit the length (scale x and y) to maxlength '''
        if self.length() > maxlength:
            self.normalise() # unit vector length = 1.0
            self *= maxlength # so length is 1.0 * maxlength

        return self

    def distance(self, v2):
        ''' the distance between self and v2 vector '''
        dx = v2.x - self.x
        dy = v2.y - self.y
        return sqrt(dx*dx + dy*dy)

    def distanceSq(self, v2):
        ''' the squared distance between self and v2 vector '''
        dx = v2.x - self.x
        dy = v2.y - self.y
        return dx*dx + dy*dy

    def distanceTo(self, v2):
        ''' the distance between self and v2 vector '''
        dx = v2.x - self.x
        dy = v2.y - self.y
        return Vector2D(dx, dy)

    def reflect(self, norm):
        ''' Reflect self around the norm vector provided. '''
        # eg the path of a ball reflected off a wall
        self += 2.0 * self.dot(norm) * norm.get_reverse()

        return self

    def get_reflected(self, norm):
        ''' Reflect self around the norm vector provided. '''
        # eg the path of a ball reflected off a wall
        temp = self.copy()
        temp += 2.0 * temp.dot(norm) * norm.get_reverse()

        return temp


    def reverse(self):
        ''' reverse of ourself, return self for chaining. '''
        self.x *= -1
        self.y *= -1

        return self


    def get_reversed(self):
        ''' return a new vector that is the reverse of self. '''
        return Vector2D(-self.x, -self.y)


    def rotate(self, angle):

        cs = cos(angle)
        sn = sin(angle)

        px = self.x * cs - self.y * sn;
        py = self.x * sn + self.y * cs;

        self.x = px
        self.y = py

        return self



    def get_rotated(self, angle):
        ''' return a new gector that is the '''
        return self.copy().rotate(angle)


    def tuple(self):
        return (self.x, self.y)



    def __neg__(self): #
        ''' get_reverse(), but using - operator based instead. '''
        return Vector2D(-self.x, -self.y)

    def copy(self):
        ''' Simple copy Vector2D with self values '''
        return Vector2D(self.x, self.y)

    def __iadd__(self, rhs): # +=
        self.x += rhs.x
        self.y += rhs.y
        return self

    def __isub__(self, rhs): # -=
        self.x -= rhs.x
        self.y -= rhs.y
        return self

    def __imul__(self, rhs): # *=
        self.x *= rhs
        self.y *= rhs
        return self

    def __idiv__(self, rhs): # /=
        self.x /= rhs
        self.y /= rhs
        return self

    def __eq__(self, rhs): # ==
        return is_equal(self.x, rhs.x) and is_equal(self.y, rhs.y)

    def __ne__(self, rhs): # !=
        return (self.x != rhs.x) or (self.y != rhs.y)

    def __add__(self, rhs): # self + rhs
        return Vector2D(self.x+rhs.x, self.y+rhs.y)

    def __sub__(self, rhs): # self - rhs
        return Vector2D(self.x-rhs.x, self.y-rhs.y)

    def __mul__(self, rhs): # self * rhs (scalar)
        return Vector2D(self.x*rhs, self.y*rhs)
    def __rmul__(self, lhs): # lhs * self
        return Vector2D(self.x*lhs, self.y*lhs)

    def __div__(self, rhs): # self / rhs (scalar)
        return Vector2D(self.x/rhs, self.y/rhs)
    def __rdiv__(self, lhs): # lhs (scalar) / self
        return Vector2D(lhs/self.x, lhs/self.y)

    def __str__(self):
        return '(%7.2f, %7.2f)' % (self.x, self.y)

    @staticmethod
    def random(magnitude=1):
        return Vector2D(uniform(0, 1), uniform(0, 1)).normalise() * magnitude