예제 #1
0
    def test__mat_invert_(self):
        foo1 = Transform.create_translate(10.0,2.0,3.0)
        foo2 = Transform.create_rot_x(math.radians(37))
        foo3 = Transform.create_translate(1.0,-2.0,-6.0)
        foo4 = Transform.create_rot_y(math.radians(7))
        foo5 = Transform.create_translate(1.0,7.0,2.0)
        foo6 = Transform.create_rot_z(math.radians(137))

        foo7 = foo1 * foo2 * foo3 * foo4 * foo5 * foo6

        self.assertEqual(foo7.mat.get_invert(), foo7.mat_inv)
        self.assertEqual(foo7.mat_inv, foo7.mat_inv)
예제 #2
0
    def test___mul__(self):
        # ///////////////////////////////////////////__mul__ float
        foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
        foo2 = foo1 * 2.0

        self.assertEqual(foo2, Vector4d(2.0, 4.0, 6.0, 8.0))

        #///////////////////////////////////////////__imul__ float
        foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
        foo1 *= 2.0
        self.assertEqual(foo1, Vector4d(2.0, 4.0, 6.0, 8.0))

        #///////////////////////////////////////////__mul__ vector4d
        foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
        foo2 = Vector4d(2.0, 3.0, 4.0, 5.0)
        foo3 = foo1 * foo2
        self.assertEqual(foo3, Vector4d(2.0, 6.0, 12.0, 20.0))

        #///////////////////////////////////////////__imul__ vector4d
        foo1 = Vector4d(1.0, 2.0, 3.0, 4.0)
        foo1 *= Vector4d(2.0, 3.0, 4.0, 5.0)
        self.assertEqual(foo1, Vector4d(2.0, 6.0, 12.0, 20.0))

        #///////////////////////////////////////////__mul__ matrix44 Rotz
        foo1 = Vector4d(0.0, 2.0, 0.0, 1.0)
        foo2 = Transform.create_rot_z(math.radians(90))

        foo3 = foo1 * foo2.mat
        self.assertEqual(foo3, Vector4d(-2.0, 0.0, 0.0, 1.0))

        foo3 = foo3 * foo2.mat
        self.assertEqual(foo3, Vector4d(0.0, -2.0, 0.0, 1.0))

        #///////////////////////////////////////////__mul__ matrix44 Roty
        foo1 = Vector4d(2.0, 0.0, 0.0, 1.0)
        foo2 = Transform.create_rot_y(math.radians(90))

        foo3 = foo1 * foo2.mat
        self.assertEqual(foo3, Vector4d(0.0, 0.0, -2.0, 1.0))

        foo3 = foo3 * foo2.mat
        self.assertEqual(foo3, Vector4d(-2.0, 0.0, 0.0, 1.0))

        #///////////////////////////////////////////__mul__ matrix44 Rotx
        foo1 = Vector4d(0.0, 2.0, 0.0, 1.0)
        foo2 = Transform.create_rot_x(math.radians(90))

        foo3 =  foo1 * foo2.mat
        self.assertEqual(foo3, Vector4d(0.0, 0.0, 2.0, 1.0))

        foo3 = foo3 * foo2.mat
        self.assertEqual(foo3, Vector4d(0.0, -2.0, 0.0, 1.0))

        #///////////////////////////////////////////__mul__ matrix44 Rotx * Roty * Rotz
        foo1 = Vector4d(2.0, 0.0, 0.0, 1.0)
        foo2 = Transform.create_rot_x(math.radians(90))
        foo3 = Transform.create_rot_y(math.radians(90))
        foo4 = Transform.create_rot_z(math.radians(90))

        foo5 = foo2 * foo3 * foo4
        foo6 = foo1 * foo5.mat
        foo7 = Vector4d(0.0, 0.0, -2.0, 1.0)
        self.assertEqual(foo6, foo7)

        #///////////////////////////////////////////__mul__ matrix44 Tr * Rotz
        foo1 = Vector4d(0.0, 0.0, 0.0, 1.0)
        foo2 = Transform.create_translate(1.0, 0.0, 0.0)
        foo4 = Transform.create_rot_z(math.radians(90))

        foo5 = foo1 * foo2 * foo4

        foo7 = Vector4d(0.0, 1.0, 0.0, 1.0)

        self.assertEqual(foo5, foo7)
예제 #3
0
    def test___mul__(self):
        from core.transform import Transform
        from maths.matrix44 import Matrix44
        from maths.vector4d import Vector4d

        # //////////////////////////////////////////////////////I *I = I
        foo1 = Transform.create_identity()
        foo2 = Transform.create_identity()

        foo3 = foo1 * foo2

        for i in range(0, 4):
            for j in range(0, 4):
                if i == j:
                    self.assertEqual(foo3.mat[i][j], 1.0)
                    self.assertEqual(foo3.mat_inv[i][j], 1.0)
                else:
                    self.assertEqual(foo3.mat[i][j], 0.0)
                    self.assertEqual(foo3.mat_inv[i][j], 0.0)
        #//////////////////////////////////////////////////////Ta * Tb = Tab
        foo1 = Transform.create_translate(1.0, 0.0, 0.0)
        foo2 = Transform.create_translate(0.0, 2.0, 0.0)

        foo0 = foo1 * foo2

        for i in range(0, 3):
            for j in range(0, 4):
                if i == j:
                    self.assertEqual(foo3.mat[i][j], 1.0)
                else:
                    self.assertEqual(foo3.mat[i][j], 0.0)

        self.assertEqual(foo0.mat[3][0], 1.0)
        self.assertEqual(foo0.mat[3][1], 2.0)
        self.assertEqual(foo0.mat[3][2], 0.0)
        self.assertEqual(foo0.mat[3][3], 1.0)

        self.assertEqual(foo0.mat[3], Vector4d(1.0, 2.0, 0.0, 1.0))

        #//////////////////////////////////////////////////////RotXa * RotXb = RotXab
        foo0 = Transform.create_rot_x(math.radians(90))
        foo1 = Transform.create_rot_x(math.radians(45))
        foo2 = Transform.create_rot_x(math.radians(45))

        foo3 = foo1 * foo2

        self.assertEqual(foo0, foo3)

        #//////////////////////////////////////////////////////RotZ(a) * RotZ(-a) = I
        foo0 = Transform.create_rot_z(math.radians(90))
        foo1 = Transform.create_rot_z(math.radians(-90))

        foo2 = foo0 * foo1
        foo3 = Transform.create_identity()

        self.assertEqual(foo2, foo3)

        #//////////////////////////////////////////////////////Tr(a) * Tr(-a) = I
        foo0 = Transform.create_translate(1.0, 0.0, 0.0)
        foo1 = Transform.create_translate(-1.0, 0.0, 0.0)

        foo2 = foo0 * foo1
        foo3 = Transform.create_identity()

        self.assertEqual(foo2, foo3)

        #//////////////////////////////////////////////////////RotXa * T = RotXab
        foo0 = Transform.create_translate(1.0, 2.0, 3.0)
        foo1 = Transform.create_rot_x(math.radians(90))
        foo2 = Transform.create_rot_z(math.radians(22))
        foo3 = Transform.create_translate(1.0, 2.0, 3.0)

        foo4 = foo0 * foo1 * foo2 * foo3

        self.assertEqual(foo4.mat_inv, foo4.mat.get_invert())