root/trunk/RBRapier/RBRapier/Tools/Vector.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation library is intended to ease some 
##- aspects of writing intricate Jabber, XML, and User Interface (wxPython, etc.) 
##- applications, while providing the flexibility to modularly change the 
##- architecture. Enjoy.
##~ 
##~ Copyright (C) 2002  TechGame Networks, LLC.
##~ 
##~ This library is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~ 
##~ TechGame Networks, LLC can be reached at:
##~ 3578 E. Hartsel Drive #211
##~ Colorado Springs, Colorado, USA, 80920
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import math
import Numeric
from RBFoundation.IndexedProperty import IndexedProperty 

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Constants / Variables / Etc. 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

_NumericType = Numeric.Float32

def DotH(v1, v2):
    return Numeric.dot(v1[:3], v2[:3]) * v1[-1] * v2[-1]

def Cross3(v1, v2):
    a1, b1, c1 = v1
    a2, b2, c2 = v2
    return (b1*c2-c1*b2, c1*a2-a1*c2, a1*b2-b1*a2)

def CrossMag3(v1, v2):
    a1, b1, c1 = v1
    a2, b2, c2 = v2
    return Numeric.sqrt((b1*c2-c1*b2)**2 + (c1*a2-a1*c2)**2 + (a1*b2-b1*a2)**2)

def DotCross3(v1, v2):
    a1, b1, c1 = v1
    a2, b2, c2 = v2
    return (a1*a2 + b1*b2 + c1*c2), (b1*c2-c1*b2, c1*a2-a1*c2, a1*b2-b1*a2)

def DotCross3H(v1, v2):
    a1, b1, c1, h1 = v1
    a2, b2, c2, h2 = v2
    return (a1*a2 + b1*b2 + c1*c2)*h1*h2, (b1*c2-c1*b2, c1*a2-a1*c2, a1*b2-b1*a2, h1*h2)

def Cross3H(v1, v2):
    a1, b1, c1, h1 = v1
    a2, b2, c2, h2 = v2
    return (b1*c2-c1*b2, c1*a2-a1*c2, a1*b2-b1*a2, h1*h2)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def LinearMapping((low_from, hi_from), (low_to, hi_to), aslambda=True):
    """
    >>> LinearMapping((10.,20.), (-1.,1.))
    (0.20000000000000001, -3.0)
    >>> LinearMapping((-1.,1.), (10.,20.))
    (5.0, 15.0)
    """
    wr = (hi_to - low_to)/(hi_from - low_from)
    tr = low_to - low_from*wr
    if aslambda:
        return lambda r: wr*(r-low_from)+low_to
    else: 
        return (wr, low_to - low_from*wr)

def LinearDimMapping((low_from, dim_from), (low_to, dim_to), aslambda=True):
    """
    >>> LinearDimMapping((10.,10.), (-1.,2.))
    (0.20000000000000001, -3.0)
    >>> LinearDimMapping((-1.,2.), (10.,10.))
    (5.0, 15.0)
    """
    wr = dim_to/dim_from
    if aslambda:
        return lambda r: wr*(r-low_from)+low_to
    else: 
        return (wr, low_to - low_from*wr)

class Vector(object):
    """
    >>> x = Vector(1., 0., 0.); x
    <[1.0, 0.0, 0.0]>
    >>> y = Vector(0., 1., 0.); y
    <[0.0, 1.0, 0.0]>
    >>> z = Vector(0., 0., 1.); z
    <[0.0, 0.0, 1.0]>
    >>> xyz = Vector(x + y + z); xyz
    <[1.0, 1.0, 1.0]>
    >>> Vector.Cross3(x,y)
    <[0.0, 0.0, 1.0]>
    >>> Vector.Cross3(x,z)
    <[0.0, -1.0, 0.0]>
    >>> Vector.Cross3(y,z)
    <[1.0, 0.0, 0.0]>
    >>> Vector.Cross3(y,x)
    <[0.0, 0.0, -1.0]>
    >>> Vector.Cross3(z,y)
    <[-1.0, 0.0, 0.0]>
    >>> Vector.Cross3(z,z)
    <[0.0, 0.0, 0.0]>
    >>> Vector.Cross3(z,x)
    <[0.0, 1.0, 0.0]>
    >>> Vector.Cross3(x,x)
    <[0.0, 0.0, 0.0]>
    >>> Vector.Cross3(y,y)
    <[0.0, 0.0, 0.0]>
    >>> Vector.DeltaAngle(x,y)
    90.000002504478161
    >>> Vector.DeltaAngle(x,z)
    90.000002504478161
    >>> Vector.DeltaAngle(y,z)
    90.000002504478161
    >>> Vector.DeltaRadians(x,z)
    1.57079637051
    >>> Vector.DeltaRadians(x,y)
    1.57079637051
    >>> Vector.DeltaRadians(z,y)
    1.57079637051
    >>> x * 4
    <[4.0, 0.0, 0.0]>
    >>> x / 4.
    <[0.25, 0.0, 0.0]>
    >>> x + 1.
    <[2.0, 1.0, 1.0]>
    >>> x - 1.
    <[0.0, -1.0, -1.0]>
    >>> x + y
    <[1.0, 1.0, 0.0]>
    >>> x - y
    <[1.0, -1.0, 0.0]>
    >>> x * y
    0.0
    >>> x * y.Cross3(z)
    1.0
    >>> x * z.Cross3(y)
    -1.0
    >>> abs(4*x), abs(3*y), abs(2*z)
    (4.0, 3.0, 2.0)
    >>> -x
    <[-1.0, 0.0, 0.0]>
    >>> x = Vector(1.,1.,1.); x
    <[1.0, 1.0, 1.0]>
    >>> x.iNormalize(); x
    <[0.57735025882720947, 0.57735025882720947, 0.57735025882720947]>
    """
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    NumericType = _NumericType
    Default = Numeric.asarray((0.,0.,0.), NumericType)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Special 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, *args, **kw):
        NumericType = kw.get('NumericType', None)
        if NumericType is not None: self.NumericType = NumericType
        if not args:
            self.Set(self.Default)
        elif isinstance(args[0], (Vector, self.__class__)):
            self.Set(args[0])
        elif isinstance(args[0], (tuple, list, Numeric.ArrayType)):
            self.Set(args[0])
        else:
            self.Set(args[:len(self)])

    def __repr__(self):
        return "<%r>" % self.tolist()

    def __len__(self): 
        return len(self.Default)
    def __getitem__(self, key): 
        return self._array[key]
    def __setitem__(self, key, value): 
        self._array[key] = value
    def _self(self):
        return self

    def __pos__(self): 
        return self
    def __neg__(self): 
        return self.__class__(-1 * self._array)
    def __abs__(self):
        return self.Magnitude()

    def __iadd__(self, other): 
        if isinstance(other, Vector): other = other._array
        self.Set(self._array + other)
        return self
    def __add__(self, other): 
        if isinstance(other, Vector): other = other._array
        return self.__class__(self._array + other)
    def __radd__(self, other): 
        if isinstance(other, Vector): other = other._array
        return self.__class__(other + self._array)
    def __isub__(self, other): 
        if isinstance(other, Vector): other = other._array
        self.Set(self._array - other)
        return self
    def __sub__(self, other): 
        if isinstance(other, Vector): other = other._array
        return self.__class__(self._array - other)
    def __rsub__(self, other): 
        if isinstance(other, Vector): other = other._array
        return self.__class__(other - self._array)
        
    def __idiv__(self, other):
        if isinstance(other, Vector):
            raise TypeError, "can't divide a Vector by a Vector"
        else:
            self.Set(self._array / other)
        return self
    def __div__(self, other):
        if isinstance(other, Vector):
            raise TypeError, "can't divide a Vector by a Vector"
        else: return self.__class__(self._array / other)

    def __imul__(self, other):
        if isinstance(other, Vector):
            raise TypeError, "can't multiply by a Vector in-place"
        else:
            self.Set(self._array * other)
        return self

    def __mul__(self, other):
        if isinstance(other, Vector):
            return self.Dot(other)
        else: return self.__class__(self._array * other)

    def __rmul__(self, other):
        if isinstance(other, Vector):
            return other.Dot(self)
        else: return self.__class__(other * self._array)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def asarray(self, *args):
        if args: return Numeric.asarray(self._array, *args)
        else: return self._array

    def tolist(self):
        return self._array.tolist()

    def Set(self, other):
        self._array = self._simplify(other)

    def Dot(self, other):
        return Numeric.dot(self._array, other._array)

    def iCross3(self, other):
        self[:] = Cross3(self._arrayh, other._array)

    def Cross3(self, other):
        return self.__class__(Cross3(self._array, other._array))

    def Magnitude(self, squared=0):
        value = self.Dot(self)
        if squared: return value
        else: return Numeric.sqrt(value)

    def iNormalize(self):
        self /= self.Magnitude()

    def Normalize(self):
        mag = self.Magnitude()
        return self / mag

    def DeltaAngle(self, other):
        return math.degrees(self.DeltaRadians(other))

    def DeltaRadians(self, other):
        return Numeric.arccos(self.Dot(other))

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Protected Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _simplify(self, value):
        try: value = list(value[:len(self.Default)]) + list(self.Default[len(value):])
        except TypeError: raise TypeError, 'New vector value must be iterable.  (value=%r)' % value
        return Numeric.asarray(value, self.NumericType)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Vector3(Vector):
    """
    >>> a = Vector3(1,2,3); a
    <[1.0, 2.0, 3.0]>
    >>> a.X
    1.0
    >>> a.Y
    2.0
    >>> a.Z
    3.0
    """
    X = IndexedProperty(Vector._self, 0)
    Y = IndexedProperty(Vector._self, 1)
    Z = IndexedProperty(Vector._self, 2)

class Vector4(Vector):
    Default = Numeric.asarray((0.,0.,0.,0.), Vector.NumericType)

class ColorVector(Vector):
    """
    >>> a = ColorVector(1,2,3,4); a
    <[1.0, 2.0, 3.0, 4.0]>
    >>> a.R
    1.0
    >>> a.G
    2.0
    >>> a.B
    3.0
    >>> a.A
    4.0
    """

    Default = Numeric.asarray((0.,0.,0.,1.), Vector.NumericType)
    R = IndexedProperty(Vector._self, 0)
    G = IndexedProperty(Vector._self, 1)
    B = IndexedProperty(Vector._self, 2)
    A = IndexedProperty(Vector._self, 3)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class VectorH(Vector):
    """
    >>> x = VectorH(1., 0., 0.); x
    <[1.0, 0.0, 0.0, 1.0]>
    >>> y = VectorH(0., 1., 0.); y
    <[0.0, 1.0, 0.0, 1.0]>
    >>> z = VectorH(0., 0., 1.); z
    <[0.0, 0.0, 1.0, 1.0]>
    >>> xyz = VectorH(x + y + z); xyz
    <[1.0, 1.0, 1.0, 1.0]>
    >>> VectorH.Cross3H(x,y)
    <[0.0, 0.0, 1.0, 1.0]>
    >>> VectorH.Cross3H(x,z)
    <[0.0, -1.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(y,z)
    <[1.0, 0.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(y,x)
    <[0.0, 0.0, -1.0, 1.0]>
    >>> VectorH.Cross3H(z,y)
    <[-1.0, 0.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(z,z)
    <[0.0, 0.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(z,x)
    <[0.0, 1.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(x,x)
    <[0.0, 0.0, 0.0, 1.0]>
    >>> VectorH.Cross3H(y,y)
    <[0.0, 0.0, 0.0, 1.0]>
    >>> VectorH.DeltaAngle(x,y)
    90.000002504478161
    >>> VectorH.DeltaAngle(x,z)
    90.000002504478161
    >>> VectorH.DeltaAngle(y,z)
    90.000002504478161
    >>> VectorH.DeltaRadians(x,z)
    1.57079637051
    >>> VectorH.DeltaRadians(x,y)
    1.57079637051
    >>> VectorH.DeltaRadians(z,y)
    1.57079637051
    >>> x * 4
    <[4.0, 0.0, 0.0, 1.0]>
    >>> x / 4.
    <[0.25, 0.0, 0.0, 1.0]>
    >>> x + 1.
    <[2.0, 1.0, 1.0, 1.0]>
    >>> x - 1.
    <[0.0, -1.0, -1.0, 1.0]>
    >>> x + y
    <[1.0, 1.0, 0.0, 1.0]>
    >>> x - y
    <[1.0, -1.0, 0.0, 1.0]>
    >>> x * y
    0.0
    >>> x * y.Cross3H(z)
    1.0
    >>> x * z.Cross3H(y)
    -1.0
    >>> abs(4*x), abs(3*y), abs(2*z)
    (4.0, 3.0, 2.0)
    >>> -x
    <[-1.0, 0.0, 0.0, 1.0]>
    """

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    NumericType = _NumericType
    Default = Numeric.asarray((0.,0.,0.,1.), NumericType)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Special 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, *args):
        if not args:
            Vector.__init__(self, *args)
        elif isinstance(args[0], VectorH):
            self.Set(args[0])
        elif isinstance(args[0], Vector):
            self.Set(args[0][0:len(self)-1])
        else:
            Vector.__init__(self, *args)

    def __getitem__(self, key): 
        return self._arrayh[key]
    def __setitem__(self, key, value): 
        self._arrayh[key] = value
        try: self._arrayh /= self._arrayh[-1:]
        except ZeroDivisionError: pass

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def asarray(self, *args):
        if args: return Numeric.asarray(self._arrayh, *args)
        else: return self._arrayh

    def tolist(self):
        return self._arrayh.tolist()

    def Set(self, other):
        self._arrayh = self._simplify(other)

    def iCross3H(self, other):
        self[:] = Cross3H(self._arrayh, other._arrayh)

    def Cross3H(self, other):
        return self.__class__(Cross3H(self._arrayh, other._arrayh))

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Protected Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def _GetArray(self):
        return self._arrayh[:-1]
    def _SetArray(self, value):
        self._arrayh[:-1] = value
    _array = property(_GetArray, _SetArray)

    def _simplify(self, value):
        try: value = list(value[:len(self.Default)]) + list(self.Default[len(value):])
        except TypeError: raise TypeError, 'New vector value must be iterable.  (value=%r)' % value
        result = Numeric.asarray(value, self.NumericType)
        # Homogonize
        try: result /= result[-1:]
        except ZeroDivisionError: pass
        return result 

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Vector3H(VectorH):
    """
    >>> a = Vector3H(2,4,6,2); a
    <[1.0, 2.0, 3.0, 1.0]>
    >>> a.X
    1.0
    >>> a.Y
    2.0
    >>> a.Z
    3.0
    >>> a.W
    1.0
    >>> a.W = 0.25; a.W
    1.0
    >>> a
    <[4.0, 8.0, 12.0, 1.0]>
    """
    X = IndexedProperty(Vector._self, 0)
    Y = IndexedProperty(Vector._self, 1)
    Z = IndexedProperty(Vector._self, 2)
    W = IndexedProperty(Vector._self, 3)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class UnitVector(Vector):
    Default = Numeric.asarray((0.,0.,1.), Vector.NumericType)

    def __setitem__(self, key, value): 
        A = self._array
        A[key] = value
        try: A /= A[-1:]
        except ZeroDivisionError: pass
        A /= Numeric.sqrt(Numeric.dot(A, A))

    def _simplify(self, value):
        try: value = list(value[:len(self.Default)]) + list(self.Default[len(value):])
        except TypeError: raise TypeError, 'New vector value must be iterable.  (value=%r)' % value
        result = Numeric.asarray(value, self.NumericType)
        # Normalize
        result /= Numeric.sqrt(Numeric.dot(result, result))
        return result

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

UnitVector3 = UnitVector

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class UnitVectorH(VectorH):
    Default = Numeric.asarray((0.,0.,1.,1.), VectorH.NumericType)

    def __setitem__(self, key, value): 
        A = self._arrayh
        A[key] = value
        try: A /= A[-1:]
        except ZeroDivisionError: pass
        A[:-1] /= Numeric.sqrt(Numeric.dot(A[:-1], A[:-1]))

    def _simplify(self, value):
        try: value = list(value[:len(self.Default)]) + list(self.Default[len(value):])
        except TypeError: raise TypeError, 'New vector value must be iterable.  (value=%r)' % value
        result = Numeric.asarray(value, self.NumericType)
        # Homogonize
        try: result /= result[-1:]
        except ZeroDivisionError: pass
        # Normalize
        result[:-1] /= Numeric.sqrt(Numeric.dot(result[:-1], result[:-1]))
        return result

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

UnitVector3H = UnitVectorH

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Vector Property Definitions
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class VectorPropertyMixin(object):
    def __init__(self, name, default=None, lazy=1, doc='', **kw):
        self.__name__ = name
        self.__doc__ = doc
        self._hidden_name = '__' + name + 'Vector'
        self._lazy = lazy
        self._createkw = kw
        if default is not None: 
            self.VectorClass = type(self.VectorClass.__name__+'%', (self.VectorClass,), 
                {'Default': Numeric.asarray(default, self.VectorClass.NumericType)})

    def __get__(self, obj, klass):
        if obj: 
            result = getattr(obj, self._hidden_name, None)
            if result is None and self._lazy:
                result = self.VectorClass(**self._createkw)
                setattr(obj, self._hidden_name, result)
            return result
        else: return self

    def __set__(self, obj, value):
        vector = getattr(obj, self._hidden_name, None)
        if vector is None: 
            setattr(obj, self._hidden_name, self.VectorClass(value))
        else: vector.Set(value)

    def __delete__(self, obj):
        delattr(obj, self._hidden_name)

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Vector3Property(VectorPropertyMixin): 
    """
    >>> class Test(object):
    ...     vp = Vector3Property('vp')
    ...
    >>> t = Test()
    >>> t.vp
    <[0.0, 0.0, 0.0]>
    >>> t.vp = 1.,
    >>> t.vp
    <[1.0, 0.0, 0.0]>
    >>> t.vp = 1.,2.,3.,4.,5.,6.,
    >>> t.vp
    <[1.0, 2.0, 3.0]>
    >>> t.vp = 1.,2.,3.
    >>> t.vp
    <[1.0, 2.0, 3.0]>
    >>> t.vp[1]
    2.0
    >>> t.vp[1] = 13.
    >>> t.vp
    <[1.0, 13.0, 3.0]>
    >>>
    """
    VectorClass = Vector3

class Vector4Property(VectorPropertyMixin): 
    VectorClass = Vector4

class ColorVectorProperty(VectorPropertyMixin): 
    VectorClass = ColorVector

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Vector3HProperty(VectorPropertyMixin): 
    """
    >>> class Test(object):
    ...     vp = Vector3HProperty('vp')
    ...
    >>> t = Test()
    >>> t.vp
    <[0.0, 0.0, 0.0, 1.0]>
    >>> t.vp = 1.,
    >>> t.vp
    <[1.0, 0.0, 0.0, 1.0]>
    >>> t.vp = 1.,2.,3.,4.,5.,6.,
    >>> t.vp
    <[0.25, 0.5, 0.75, 1.0]>
    >>> t.vp = 1.,2.,3.
    >>> t.vp
    <[1.0, 2.0, 3.0, 1.0]>
    >>> t.vp[1]
    2.0
    >>> t.vp[1] = 13.
    >>> t.vp
    <[1.0, 13.0, 3.0, 1.0]>
    >>>
    """
    VectorClass = Vector3H

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class UnitVector3Property(VectorPropertyMixin):
    """
    >>> class Test(object):
    ...     vp = UnitVector3Property('vp')
    ...
    >>> t = Test(); t.vp
    <[0.0, 0.0, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,; t.vp
    <[0.70710676908493042, 0.0, 0.70710676908493042]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,2.,3.,4.,5.,6.,; t.vp
    <[0.26726123690605164, 0.53452247381210327, 0.80178368091583252]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,2.,3.; t.vp
    <[0.26726123690605164, 0.53452247381210327, 0.80178368091583252]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp[1]
    0.53452247381210327
    >>> t.vp[1] = 13.; t.vp
    <[0.02051524817943573, 0.99789345264434814, 0.06154574453830719]>
    >>> round(abs(t.vp), 4)
    1.0
    """
    VectorClass = UnitVector3

class UnitVector3HProperty(VectorPropertyMixin):
    """
    >>> class Test(object):
    ...     vp = UnitVector3HProperty('vp')
    ...
    >>> t = Test(); t.vp
    <[0.0, 0.0, 1.0, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,; t.vp
    <[0.70710676908493042, 0.0, 0.70710676908493042, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,2.,3.,4.,5.,6.,; t.vp
    <[0.26726123690605164, 0.53452247381210327, 0.80178368091583252, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp = 1.,2.,3.; t.vp
    <[0.26726123690605164, 0.53452247381210327, 0.80178368091583252, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    >>> t.vp[1]
    0.53452247381210327
    >>> t.vp[1] = 13.; t.vp
    <[0.02051524817943573, 0.99789345264434814, 0.06154574453830719, 1.0]>
    >>> round(abs(t.vp), 4)
    1.0
    """
    VectorClass = UnitVector3H

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Testing 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if __name__=='__main__':
    print "Testing..."
    import doctest, Vector
    doctest.testmod(Vector)
    print "Test complete."