def testAugmentedDivide(self):
x = Vector(2.0, 2.0, 2.0)
y = 0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.a), str(y)) )
self.a /= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == x, 'Incorrect vector value: %s' % (str(self.a))
self.a = Vector(1.0, 1.0, 1.0)
w = Vector(-2.0, -2.0, -2.0)
y = -0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.a), str(y)) )
self.a /= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == w, 'Incorrect vector value: %s' % (str(self.a))
y = 0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.c), str(y)) )
self.c /= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == w, 'Incorrect vector value: %s' % (str(self.c))
self.c = Vector(-1.0, -1.0, -1.0)
y = -0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.c), str(y)) )
self.c /= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == x, 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(TypeError, Vector.__idiv__, self.a, self.b)
def setUp(self):
self.a = Vector(1.0, 1.0, 1.0)
self.b = Vector(2.0, 2.0, 2.0)
self.c = Vector(-1.0, -1.0, -1.0)
self.d = Vector(-2.0, -2.0, -2.0)
self.e = Vector(3.0, 3.0, 3.0)
self.f = Vector(-3.0, -3.0, -3.0)
def testAugmentedMultiply(self):
y = 3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.a), str(y)) )
self.a *= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == self.e, 'Incorrect vector value: %s' % (str(self.a))
self.a = Vector(1.0, 1.0, 1.0)
y = -3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.a), str(y)) )
self.a *= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == self.f, 'Incorrect vector value: %s' % (str(self.a))
y = 3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.c), str(y)) )
self.c *= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == self.f, 'Incorrect vector value: %s' % (str(self.c))
self.c = Vector(-1.0, -1.0, -1.0)
y = -3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.c), str(y)) )
self.c *= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == self.e, 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(TypeError, Vector.__imul__, self.a, self.b)
def __init__(self):
self.id = 0
self.name = ''
self.direction = Vector()
self.length = 0
self.orientation = Vector()
self.orientation_order = []
self.dof = []
self.limits = []
class AcclaimRoot(object):
"""This is a class that contains data in the Acclaim root Mocap data format."""
# Setup logging
logger = logging.getLogger('AcclaimRoot')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s %(asctime)s %(name)s Line: %(lineno)d | %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
# Class constants
# -----------------------------------------------------------------------
# Class Functions
# -----------------------------------------------------------------------
# None
# -----------------------------------------------------------------------
# Instance Functions
# -----------------------------------------------------------------------
def __init__(self):
self.amc_data_order = []
self.orientation_order = []
self.position = Vector()
self.orientation = Vector()
def __str__(self):
output = ''
token_str = ''
for i, order in enumerate(self.amc_data_order):
token_str += str(order)
if i < len(self.amc_data_order) - 1:
token_str += ' '
output += 'Data Order: %s ' %( token_str )
token_str = ''
for i, order in enumerate(self.orientation_order):
token_str += str(order)
if i < len(self.orientation_order) - 1:
token_str += ' '
output += 'Orientation Order: %s ' %( token_str )
output += 'Position: %s ' %( self.position.toString('(', ', ', ')') )
output += 'Orientation: %s' %( self.orientation.toString('(', ', ', ')') )
return output
def __init__(self):
self.amc_data_order = []
self.orientation_order = []
self.position = Vector()
self.orientation = Vector()
class VectorTest(unittest.TestCase):
# Setup logging
logger = logging.getLogger('VectorTest')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s %(asctime)s %(name)s Line: %(lineno)d | %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
def setUp(self):
self.a = Vector(1.0, 1.0, 1.0)
self.b = Vector(2.0, 2.0, 2.0)
self.c = Vector(-1.0, -1.0, -1.0)
self.d = Vector(-2.0, -2.0, -2.0)
self.e = Vector(3.0, 3.0, 3.0)
self.f = Vector(-3.0, -3.0, -3.0)
def tearDown(self):
pass
@log_test(logger, globals.log_seperator)
def testNegative(self):
VectorTest.logger.info( 'Operation: -%s' % (str(self.a)) )
VectorTest.logger.info( 'Result: %s' % (str(-Vector(self.a))) )
assert -self.a == self.c, 'Incorrect vector value: %s' % (str(-self.a))
VectorTest.logger.info( 'Operation: -%s' % (str(self.a)) )
VectorTest.logger.info( 'Result: %s' % (str(-Vector(self.d))) )
assert -self.d == self.b, 'Incorrect vector value: %s' % (str(-self.d))
@log_test(logger, globals.log_seperator)
def testAdd(self):
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.a), str(self.b)) )
z = self.a + self.b
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.b), str(self.c)) )
z = self.b + self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.c), str(self.d)) )
z = self.c + self.d
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(AttributeError, Vector.__add__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testReflectiveAdd(self):
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.a), str(self.b)) )
z = self.a + self.b
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.b), str(self.c)) )
z = self.b + self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s + %s' % (str(self.c), str(self.d)) )
z = self.c + self.d
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(AttributeError, Vector.__radd__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testAugmentedAdd(self):
VectorTest.logger.info( 'Operation: %s += %s' % (str(self.a), str(self.b)) )
self.a += self.b
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == self.e, 'Incorrect vector value: %s' % (str(self.a))
VectorTest.logger.info( 'Operation: %s += %s' % (str(self.b), str(self.c)) )
self.b += self.c
VectorTest.logger.info( 'Result: %s' % (str(self.b)) )
assert self.b == Vector(1.0, 1.0, 1.0), 'Incorrect vector value: %s' % (str(self.b))
VectorTest.logger.info( 'Operation: %s += %s' % (str(self.c), str(self.d)) )
self.c += self.d
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == self.f, 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(AttributeError, Vector.__iadd__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testSubtract(self):
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.b), str(self.a)) )
z = self.b - self.a
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.c), str(self.b)) )
z = self.c - self.b
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.d), str(self.c)) )
z = self.d - self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.c, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(AttributeError, Vector.__sub__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testReflectiveSubtract(self):
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.b), str(self.a)) )
z = self.b - self.a
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.c), str(self.b)) )
z = self.c - self.b
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: %s - %s' % (str(self.d), str(self.c)) )
z = self.d - self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.c, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(AttributeError, Vector.__rsub__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testAugmentedSubtract(self):
VectorTest.logger.info( 'Operation: %s -= %s' % (str(self.b), str(self.a)) )
self.b -= self.a
VectorTest.logger.info( 'Result: %s' % (str(self.b)) )
assert self.b == self.a, 'Incorrect vector value: %s' % (str(self.b))
VectorTest.logger.info( 'Operation: %s -= %s' % (str(self.d), str(self.a)) )
self.d -= self.a
VectorTest.logger.info( 'Result: %s' % (str(self.d)) )
assert self.d == self.f, 'Incorrect vector value: %s' % (str(self.d))
VectorTest.logger.info( 'Operation: %s -= %s' % (str(self.c), str(self.f)) )
self.c -= self.f
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == Vector(2.0, 2.0, 2.0), 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(AttributeError, Vector.__isub__, self.a, 1)
@log_test(logger, globals.log_seperator)
def testMultiply(self):
y = 3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(self.a), str(y)) )
z = self.a * y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
y = -3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(self.a), str(y)) )
z = self.a * y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
y = 3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(self.c), str(y)) )
z = self.c * y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
y = -3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(self.c), str(y)) )
z = self.c * y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(TypeError, Vector.__mul__, self.a, self.b)
@log_test(logger, globals.log_seperator)
def testReflectiveMultiply(self):
y = 3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(y), str(self.a)) )
z = y * self.a
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
y = -3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(y), str(self.a)) )
z = y * self.a
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
y = 3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(y), str(self.c)) )
z = y * self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.f, 'Incorrect vector value: %s' % (str(z))
y = -3.0
VectorTest.logger.info( 'Operation: %s * %s' % (str(y), str(self.c)) )
z = y * self.c
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.e, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(TypeError, Vector.__rmul__, self.a, self.b)
@log_test(logger, globals.log_seperator)
def testAugmentedMultiply(self):
y = 3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.a), str(y)) )
self.a *= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == self.e, 'Incorrect vector value: %s' % (str(self.a))
self.a = Vector(1.0, 1.0, 1.0)
y = -3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.a), str(y)) )
self.a *= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == self.f, 'Incorrect vector value: %s' % (str(self.a))
y = 3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.c), str(y)) )
self.c *= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == self.f, 'Incorrect vector value: %s' % (str(self.c))
self.c = Vector(-1.0, -1.0, -1.0)
y = -3.0
VectorTest.logger.info( 'Operation: %s *= %s' % (str(self.c), str(y)) )
self.c *= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == self.e, 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(TypeError, Vector.__imul__, self.a, self.b)
@log_test(logger, globals.log_seperator)
def testDivide(self):
x = Vector(2.0, 2.0, 2.0)
y = 0.5
VectorTest.logger.info( 'Operation: %s / %s' % (str(self.a), str(y)) )
z = self.a / y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == x, 'Incorrect vector value: %s' % (str(z))
w = Vector(-2.0, -2.0, -2.0)
y = -0.5
VectorTest.logger.info( 'Operation: %s / %s' % (str(self.a), str(y)) )
z = self.a / y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == w, 'Incorrect vector value: %s' % (str(z))
y = 0.5
VectorTest.logger.info( 'Operation: %s / %s' % (str(self.c), str(y)) )
z = self.c / y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == w, 'Incorrect vector value: %s' % (str(z))
y = -0.5
VectorTest.logger.info( 'Operation: %s / %s' % (str(self.c), str(y)) )
z = self.c / y
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == x, 'Incorrect vector value: %s' % (str(z))
self.assertRaises(TypeError, Vector.__div__, self.a, self.b)
@log_test(logger, globals.log_seperator)
def testAugmentedDivide(self):
x = Vector(2.0, 2.0, 2.0)
y = 0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.a), str(y)) )
self.a /= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == x, 'Incorrect vector value: %s' % (str(self.a))
self.a = Vector(1.0, 1.0, 1.0)
w = Vector(-2.0, -2.0, -2.0)
y = -0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.a), str(y)) )
self.a /= y
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
assert self.a == w, 'Incorrect vector value: %s' % (str(self.a))
y = 0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.c), str(y)) )
self.c /= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == w, 'Incorrect vector value: %s' % (str(self.c))
self.c = Vector(-1.0, -1.0, -1.0)
y = -0.5
VectorTest.logger.info( 'Operation: %s /= %s' % (str(self.c), str(y)) )
self.c /= y
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
assert self.c == x, 'Incorrect vector value: %s' % (str(self.c))
self.assertRaises(TypeError, Vector.__idiv__, self.a, self.b)
@log_test(logger, globals.log_seperator)
def testEqual(self):
z = Vector(1.0, 1.0, 1.0)
VectorTest.logger.info( 'Operation: %s = %s' % (str(self.a), str(z)) )
assert self.a == z, 'Vector equality error.'
z = Vector(-1.0, -1.0, -1.0)
VectorTest.logger.info( 'Operation: %s = %s' % (str(self.c), str(z)) )
assert self.c == z, 'Vector equality error.'
@log_test(logger, globals.log_seperator)
def testNotEqual(self):
z = Vector(-1.0, -1.0, -1.0)
VectorTest.logger.info( 'Operation: %s = %s' % (str(self.a), str(z)) )
assert self.a != z, 'Vector inequality error.'
z = Vector(1.0, 1.0, 1.0)
VectorTest.logger.info( 'Operation: %s = %s' % (str(self.c), str(z)) )
assert self.c != z, 'Vector inequality error.'
@log_test(logger, globals.log_seperator)
def testAbsoluteValue(self):
VectorTest.logger.info( 'Operation: abs( %s )' % (str(self.a)) )
z = abs(self.a)
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
VectorTest.logger.info( 'Operation: abs( %s )' % (str(self.c)) )
z = abs(self.c)
VectorTest.logger.info( 'Result: %s' % (str(z)) )
assert z == self.a, 'Incorrect vector value: %s' % (str(z))
@log_test(logger, globals.log_seperator)
def testGetItem(self):
VectorTest.logger.info( 'Operation: v[0] on %s' % (str(self.a)) )
assert self.a[0] == self.a.x, 'Incorrect vector value: %s' % (str(self.a[0]))
VectorTest.logger.info( 'Operation: v[1] on %s' % (str(self.a)) )
assert self.a[1] == self.a.y, 'Incorrect vector value: %s' % (str(self.a[1]))
VectorTest.logger.info( 'Operation: v[2] on %s' % (str(self.a)) )
assert self.a[2] == self.a.z, 'Incorrect vector value: %s' % (str(self.a[2]))
self.assertRaises(IndexError, Vector.__getitem__, self.a, 4)
@log_test(logger, globals.log_seperator)
def testSetItem(self):
z = Vector()
VectorTest.logger.info( 'Operation: v[0] = %s' % (str(self.a.x)) )
z[0] = self.a.x
assert z[0] == self.a.x, 'Incorrect vector value: %s' % (str(z[0]))
VectorTest.logger.info( 'Operation: v[1] = %s' % (str(self.a.y)) )
z[1] = self.a.y
assert z[1] == self.a.y, 'Incorrect vector value: %s' % (str(z[1]))
VectorTest.logger.info( 'Operation: v[2] = %s' % (str(self.a.z)) )
z[2] = self.a.z
assert z[2] == self.a.z, 'Incorrect vector value: %s' % (str(z[2]))
self.assertRaises(IndexError, Vector.__setitem__, z, 4, 1.0)
@log_test(logger, globals.log_seperator)
def testCall(self):
z = 2.5
VectorTest.logger.info( 'Operation: v(%s, %s, %s)' % (str(z), str(z), str(z)) )
self.a(z, z, z)
assert self.a == Vector(z, z, z), 'Incorrect vector value: %s' % (str(self.a))
y = (z, z, z)
VectorTest.logger.info( 'Operation: v( (%s, %s, %s) )' % (str(z), str(z), str(z)) )
self.a(y)
assert self.a == Vector(y), 'Incorrect vector value: %s' % (str(self.a))
VectorTest.logger.info( 'Operation: v( %s )' % (str(self.c)) )
self.a(self.c)
assert self.a == self.c, 'Incorrect vector value: %s' % (str(self.a))
self.assertRaises(ValueError, Vector.__call__, self.a, 1.0, 1.0, 1.0, 1.0)
@log_test(logger, globals.log_seperator)
def testString(self):
VectorTest.logger.info( 'Operation: str(%s)' % (str(self.a)) )
vec_str = '(' + str( self.a.x ) + ", " + str( self.a.y ) + ", " + str( self.a.z ) + ')'
assert str(self.a) == vec_str, 'Incorrect vector value: %s' % (str(self.a))
@log_test(logger, globals.log_seperator)
def testToString(self):
start_token = '('
separator = ';'
end_token = ')'
VectorTest.logger.info( 'Operation: v.ToString("%s", "%s", "%s")' % (start_token, separator, end_token) )
vec_str = start_token + str( self.a.x ) + separator + str( self.a.y ) + separator + str( self.a.z ) + end_token
a_str = self.a.toString(start_token, separator, end_token)
assert a_str == vec_str, 'Incorrect vector value: %s' % (a_str)
@log_test(logger, globals.log_seperator)
def testDistance(self):
threshold = 0.001
z = 1.73205080757
VectorTest.logger.info( 'Operation: Vector( %s ).distance( Vector(%s) )' % (str(self.a), str(self.b)) )
y = self.a.distance(self.b)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
z = 3.46410161514
VectorTest.logger.info( 'Operation: Vector( %s ).distance( Vector(%s) )' % (str(self.a), str(self.c)) )
y = self.a.distance(self.c)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
z = 1.73205080757
VectorTest.logger.info( 'Operation: Vector( %s ).distance( Vector(%s) )' % (str(self.c), str(self.d)) )
y = self.c.distance(self.d)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
@log_test(logger, globals.log_seperator)
def testMagnitude(self):
threshold = 0.001
z = 1.73205080757
VectorTest.logger.info( 'Operation: Vector( %s ).magnitude()' % (str(self.a)) )
y = self.a.magnitude()
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
VectorTest.logger.info( 'Operation: Vector( %s ).magnitude()' % (str(self.c)) )
y = self.c.magnitude()
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
@log_test(logger, globals.log_seperator)
def testDot(self):
threshold = 0.001
z = 6.0
VectorTest.logger.info( 'Operation: Vector( %s ).dot(Vector( %s ))' % (str(self.a), str(self.b)) )
y = self.a.dot(self.b)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
z = -3.0
VectorTest.logger.info( 'Operation: Vector( %s ).dot(Vector( %s ))' % (str(self.a), str(self.c)) )
y = self.a.dot(self.c)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
z = 6.0
VectorTest.logger.info( 'Operation: Vector( %s ).dot(Vector( %s ))' % (str(self.c), str(self.d)) )
y = self.c.dot(self.d)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert lambda y, z, threshold: abs(y - z) < threshold, 'Incorrect vector value: %s' % (y)
@log_test(logger, globals.log_seperator)
def testCross(self):
z = Vector(1.0, 0.0, 0.0)
VectorTest.logger.info( 'Operation: Vector( %s ).cross(Vector( %s ))' % (str(self.a), str(z)) )
y = self.a.cross(z)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert y == Vector(0.0, 1.0, -1.0), 'Incorrect vector value: %s' % (y)
VectorTest.logger.info( 'Operation: Vector( %s ).cross(Vector( %s ))' % (str(self.c), str(z)) )
y = self.c.cross(z)
VectorTest.logger.info( 'Result: %s' % (str(y)) )
assert y == Vector(0.0, -1.0, 1.0), 'Incorrect vector value: %s' % (y)
@log_test(logger, globals.log_seperator)
def testNormalize(self):
threshold = 0.1
x = 1.0
VectorTest.logger.info( 'Operation: Vector( %s ).normalize()' % (str(self.a)))
self.a.normalize()
VectorTest.logger.info( 'Result: %s' % (str(self.a)) )
y = self.a.magnitude()
assert lambda y, x, threshold: abs(y - x) < threshold, 'Incorrect vector value: %s' % (y)
VectorTest.logger.info( 'Operation: Vector( %s ).normalize()' % (str(self.c)))
self.c.normalize()
VectorTest.logger.info( 'Result: %s' % (str(self.c)) )
y = self.c.magnitude()
assert lambda y, x, threshold: abs(y - x) < threshold, 'Incorrect vector value: %s' % (y)
class AcclaimBone(object):
"""This is a class that contains data in the Acclaim bone Mocap data format."""
# Setup logging
logger = logging.getLogger('AcclaimBone')
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(levelname)s %(asctime)s %(name)s Line: %(lineno)d | %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger.addHandler(handler)
# Class constants
# -----------------------------------------------------------------------
# Class Functions
# -----------------------------------------------------------------------
# None
# -----------------------------------------------------------------------
# Instance Functions
# -----------------------------------------------------------------------
def __init__(self):
self.id = 0
self.name = ''
self.direction = Vector()
self.length = 0
self.orientation = Vector()
self.orientation_order = []
self.dof = []
self.limits = []
def __str__(self):
output = '%s (%d) ' % (self.name, self.id)
output += 'Direction: %s Length: %d ' % (self.direction.toString('(', ', ', ')'), self.length)
token_str = ''
for i, order in enumerate(self.orientation_order):
token_str += str(order)
if i < len(self.orientation_order) - 1:
token_str += ' '
output += 'Orientation: %s Orientation Order: %s ' % (self.orientation.toString('(', ', ', ')'), token_str)
token_str = ''
for i, order in enumerate(self.dof):
token_str += str(order)
if i < len(self.dof) - 1:
token_str += ' '
output += 'Dof: %s ' % (token_str)
output += 'Limits: '
for i, limit in enumerate(self.limits):
limit_str = ''.join( str(limit)[1:-1].split(',') )
output += '%s' % (limit_str)
if i < len(self.limits) -1:
output += ' :: '
return output
