root/trunk/RBRapier/RBRapier/Tools/RectangleBase.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 operator
import Numeric
from Transformations import TransformPrimitive3dh
from Transformations2d import TransformPrimitive2dh
from Vector import LinearMapping, LinearDimMapping

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

class RectangleBase(object):
    """
    >>> r = RectangleBase([2, 3, 5, 7])
    >>> r.Rectangle
    [2, 3, 5, 7]
    >>> r.X1, r.Y1, r.Width, r.Height
    (2, 3, 5, 7)
    >>> r.X1, r.Y1, r.X2, r.Y2 
    (2, 3, 7, 10)
    >>> r.Position, r.Dimension
    ([2, 3], [5, 7])
    >>> r.Position1, r.Position2
    ([2, 3], [7, 10])
    >>> r.AspectRatio
    1.3999999999999999
    >>> r.X, r.Y = 11, 13; r.Rectangle
    [11, 13, 5, 7]
    >>> r.X2, r.Y2 = 23, 29; r.Rectangle
    [18, 22, 5, 7]
    >>> r.Position1 = 1,2; r.Rectangle
    [1, 2, 5, 7]
    >>> r.Position2 = 31, 37; r.Rectangle
    [1, 2, 30, 35]
    """

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

    def __init__(self, Rectangle=None):
        self.Rectangle = Rectangle or [-1, -1, 2, 2]

    def __repr__(self):
        return "<x:%s y:%s w:%s h:%s>" % tuple(self.Rectangle)

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public properties
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def GetX1(self): return self.Rectangle[0]
    def SetX1(self, X): self.Rectangle[0] = X
    X = X1 = property(GetX1, SetX1)
    def GetX2(self): return self.Rectangle[0] + self.Rectangle[2]
    def SetX2(self, X): self.Rectangle[0] = X - self.Rectangle[2]
    X2 = property(GetX2, SetX2)
    def GetWidth(self): return self.Rectangle[2]
    def SetWidth(self, width):  self.Rectangle[2] = width
    Width = property(GetWidth, SetWidth)

    def GetY1(self): return self.Rectangle[1]
    def SetY1(self, Y): self.Rectangle[1] = Y
    Y = Y1 = property(GetY1, SetY1)
    def GetY2(self): return self.Rectangle[1] + self.Rectangle[3]
    def SetY2(self, Y): self.Rectangle[1] = Y - self.Rectangle[3]
    Y2 = property(GetY2, SetY2)
    def GetHeight(self): return self.Rectangle[3]
    def SetHeight(self, height):  self.Rectangle[3] = height
    Height = property(GetHeight, SetHeight)

    def GetPosition(self): return self.Rectangle[0:2]
    def SetPosition(self, position): self.Rectangle[0:2] = self.Rectangle.__class__(position)
    Position = Position1 = property(GetPosition, SetPosition)

    def GetPosition2(self): return map(operator.add, self.Rectangle[0:2], self.Rectangle[2:4])
    def SetPosition2(self, position): self.Rectangle[2:4] = map(operator.sub, self.Rectangle.__class__(position), self.Rectangle[0:2])
    Position2 = property(GetPosition2, SetPosition2)

    def GetDimension(self): return self.Rectangle[2:4]
    def SetDimension(self, dimension): self.Rectangle[2:4] = self.Rectangle.__class__(dimension)
    Dimension = property(GetDimension, SetDimension)

    def GetAspectRatio(self): return float(self.Rectangle[3]) / float(self.Rectangle[2])
    AspectRatio = property(GetAspectRatio)

    def GetBox(self):
        x, y, w, h = self.GetRectangle()
        return (x, y), (x+w, y+h)
    def SetBox(self, box):
        (x0, y0), (x1, y1) = box
        w, h = x1-x0, y1-y0
        return self.SetRectangle(x0,y0,w,h)

    def GetPts(self):
        return self.GetBox()
    def SetPts(self, pos0, pos1):
        return self.SetBox((pos0, pos1))

    def GetRectangle(self): 
        return map(float, self.Rectangle)
    def SetRectangle(self, *args): 
        if len(args) == 1: args = args[0]
        self.Rectangle[:] = self.Rectangle.__class__(args)

    def MapPointTo(self, point, *args, **kw):
        return self.MapPointsTo([point], *args, **kw)[0]

    def MapPointsTo(self, points, xspan=(-1., 1.), yspan=None, flipx=False, flipy=False):
        xspan, yspan = xspan or yspan, yspan or xspan
        if flipx: xspan = xspan[1], xspan[0]
        if flipy: yspan = yspan[1], yspan[0]
        x0, y0, w, h = self.Rectangle
        xfn = LinearMapping((x0, x0+w), xspan or yspan)
        yfn = LinearMapping((y0, y0+h), yspan or xspan)
        return [(xfn(x),yfn(y)) for x,y in points]

    def MapPointsFrom(self, point, *args, **kw):
        return self.MapPointsFrom([point], *args, **kw)[0]

    def MapPointsFrom(self, points, xspan=(-1., 1.), yspan=None, flipx=False, flipy=False):
        xspan, yspan = xspan or yspan, yspan or xspan
        if flipx: xspan = xspan[1], xspan[0]
        if flipy: yspan = yspan[1], yspan[0]
        x0, y0, w, h = self.Rectangle
        xfn = LinearMapping(xspan, (x0, x0+w))
        yfn = LinearMapping(yspan, (y0, y0+h))
        return [(xfn(x),yfn(y)) for x,y in points]

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

class RectangleMappingBase(object):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    _fromrect = RectangleBase()
    _torect = RectangleBase()

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

    def __init__(self, fromrect=None, torect=None):
        if isinstance(fromrect, (list, tuple)):
            self._fromrect = RectangleBase(fromrect)
        elif fromrect is not None:
            self._fromrect = fromrect
        if isinstance(torect, (list, tuple)):
            self._torect = RectangleBase(torect)
        elif torect is not None:
            self._torect = torect

    def __repr__(self):
        return "<%s from:%r to:%r>" % (self.__class__.__name__, self.MapFrom, self.MapTo)

    def GetMapTo(self):
        return self._torect
    def SetMapTo(self, torect):
        self._torect = torect
    def DelMapTo(self):
        del self._torect
    MapTo = property(GetMapTo, SetMapTo, DelMapTo)

    def GetMapFrom(self):
        return self._fromrect
    def SetMapFrom(self, fromrect):
        self._fromrect = fromrect
    def DelMapFrom(self):
        del self._fromrect
    MapFrom = property(GetMapFrom, SetMapFrom, DelMapFrom)

    def _GetMapping(self, frombox, tobox):
        (x0f, y0f), (x1f, y1f) = frombox
        (x0t, y0t), (x1t, y1t) = tobox
        sx, tx = LinearMapping((x0f, x1f), (x0t, x1t), False)
        sy, ty = LinearMapping((y0f, y1f), (y0t, y1t), False)
        return (sx, tx), (sy,ty)

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

class RectangleMappingMatrix3dh(RectangleMappingBase, TransformPrimitive3dh):
    def asArray4x4(self):
        (sx, tx), (sy, ty) = self._GetMapping(self.GetMapFrom().GetBox(), self.GetMapTo().GetBox())
        result = Numeric.asarray([
            [sx,  0,  0, tx],
            [ 0, sy,  0, ty],
            [ 0,  0,  1,  0],
            [ 0,  0,  0,  1]], self.NumericType)
        return result

    def asInverse4x4_(self):
        (sx, tx), (sy, ty) = self._GetMapping(self.GetMapTo().GetBox(), self.GetMapFrom().GetBox())
        result = Numeric.asarray([
            [sx,  0,  0, tx],
            [ 0, sy,  0, ty],
            [ 0,  0,  1,  0],
            [ 0,  0,  0,  1]], self.NumericType)
        return result

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

class RectangleMappingMatrix2dh(RectangleMappingBase, TransformPrimitive2dh):
    def asArray4x4(self):
        (sx, tx), (sy, ty) = self._GetMapping(self.GetMapFrom().GetBox(), self.GetMapTo().GetBox())
        result = Numeric.asarray([
            [sx,  0, tx],
            [ 0, sy, ty],
            [ 0,  0,  1]], self.NumericType)
        return result

    def asInverse4x4_(self):
        (sx, tx), (sy, ty) = self._GetMapping(self.GetMapTo().GetBox(), self.GetMapFrom().GetBox())
        result = Numeric.asarray([
            [sx,  0, tx],
            [ 0, sy, ty],
            [ 0,  0,  1]], self.NumericType)
        return result

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

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