def testGeometryTransformaton__repr__(self):
"""repr(Transformation)"""
t = Transformation()
self.assert_((eval(repr(t)) == t).all())
self.assert_(repr(Transformation(((1, 2), ))) == 'matrix([[1, 2]])')
def testGeometryTransformation_applyremove_context(self):
"""Transformation._(apply|remove)_context"""
def T(t, context, expected):
elem = Element()
elem.transform = context
got = t._apply_context(context)
self.assert_(
repr(expected) == repr(got),
'apply_context - got: %s expected: %s' % (got, expected))
got = got._remove_context(context)
expected = t
self.assert_(
repr(expected) == repr(got),
'apply_context - got: %s expected: %s' % (got, expected))
class e(object):
def __init__(self, transform):
self.transform = transform
self._transform_real = transform
T(Transformation(), e(Transformation()), Transformation())
T(Transformation(), e(Translation(V(1, 1))), Translation(V(1, 1)))
T(Translation(V(-1, -1)), e(Translation(V(1, 1))), Transformation())
def testGeometryTransformationCallable(self):
return
"""Transformation class objects are callable"""
def T(x):
self.assert_(x)
T(Transformation(v=(1, 0))((0, 0)) == (1, 0))
T(Transformation(v=(1, 0))((0, 1)) == (1, 1))
T(Transformation(v=(1, 0))(((0, 1), (3, 4))) == ((1, 1), (4, 4)))
T(Transformation(v = (10,10)) \
(((0,1),((3,4),(5,6)))) == (((10,11),((13,14),(15,16)))))
T(Transformation(v = (10,10)) \
(((0,1),[],[(3,4),(5,6)])) == (((10,11),[],[(13,14),(15,16)])))
T(Transformation(v=(1, 0))(()) == ())
T(Transformation(v=(1, 0))([]) == [])
T(Transformation(v=(1, 0))([(), ()]) == [(), ()])
def T(i):
self.assertRaises(TypeError, lambda x: Transformation()(x), i)
T('asdf')
T(None)
T((None, ))
T((1, 2, 3))
T(((1, 1), ((3, 4), (), (lambda x: x, 1))))
def testGeometryTransformation(self):
"""Transformation class"""
def T(x):
self.assert_(x)
a = Transformation()
T((a(V(5, 6.6)) == V(5, 6.6)).all())
def testGeometryTransformation_build_context(self):
"""Transformation._build_context()"""
def T(got, expected=True):
self.assert_(
repr(expected) == repr(got),
'got: %s expected: %s' % (got, expected))
T(Transformation()._build_context(Transformation(), False),
Transformation())
T(Transformation()._build_context(Transformation(), True),
Transformation())
T(Transformation()._build_context(Translation(V(1, 1)), False),
Translation(V(1, 1)))
T(
Translation(V(1, 1))._build_context(Transformation(), True),
Translation(V(-1, -1)))
T(
Translation(V(1, 1))._build_context(Translation(V(1, 1)), True),
Transformation())
def test_centerof(self):
"""centerof()"""
def T(a,b):
self.assert_((a == b).all())
e = Element()
T(centerof(e),V(0,0))
translate(e,V(1,2))
T(centerof(e),V(1,2))
self.assertRaises(TypeError,lambda: centerof(V(0,0)))
self.assertRaises(TypeError,lambda: centerof(Transformation()))
self.assertRaises(TypeError,lambda: centerof('asdf'))
def __new__(cls, **kwargs):
from Tuke.geometry import Transformation
self = context.source.Source.__new__(cls)
self.__dict_shadow__['id'] = Tuke.Id('.')
self.__dict_shadow__['transform'] = Transformation()
self.parent = None
# Initialize from kwargs
#
# All key/value pairs in kwargs will be added to self, self.key = value
# Default arguments can be provided in defaults
#
# If a key is present in required, but not in kwargs, a TypeError will
# be raised. If a key is present in kwargs, but not in required or
# defaults, a TypeError will be raised.
# Check that all versions are compatible.
cls_version_required = self.__class__.__dict__.get(
'__version__', (0, 0))
cls_version_given = kwargs.get('__version__', cls_version_required)
if not versions_compatible(cls_version_required, cls_version_given):
raise TypeError, \
"Incompatible versions: got %s but need %s to create a %s" % \
(cls_version_given,cls_version_required,self.__class__)
# Setup the dict with args from kwargs
req, df = self._required_and_default_kwargs()
valid = req | set(df.keys())
extra = set(kwargs.keys()).difference(valid)
if extra:
raise TypeError, 'Extra arguments %s' % str(extra)
for k in req:
try:
setattr(self, k, kwargs[k])
except KeyError:
raise TypeError, 'Missing required argument %s' % k
for k, d in df.items():
setattr(self, k, kwargs.get(k, d))
# Call all the _init methods for all the classes.
for cls in reversed(self.__class__.__mro__):
if issubclass(cls, Element):
cls._init(self)
return context.wrapper.wrap(self, self)
def T(i):
self.assertRaises(TypeError, lambda x: Transformation()(x), i)