def test_isometry3(self, T): Isometry3 = mut.Isometry3_[T] # - Default constructor transform = Isometry3() self.assertEqual(numpy_compare.resolve_type(transform.matrix()), T) X = np.eye(4, 4) numpy_compare.assert_float_equal(transform.matrix(), X) numpy_compare.assert_float_equal(copy.copy(transform).matrix(), X) if T == float: self.assertEqual(str(transform), str(X)) # - Constructor with (X) transform = Isometry3(matrix=X) numpy_compare.assert_float_equal(transform.matrix(), X) # - Copy constructor. cp = Isometry3(other=transform) numpy_compare.assert_equal(transform.matrix(), cp.matrix()) # - Identity transform = Isometry3.Identity() numpy_compare.assert_float_equal(transform.matrix(), X) # - Constructor with (R, p) R = np.array([[0., 1, 0], [-1, 0, 0], [0, 0, 1]]) p = np.array([1., 2, 3]) X = np.vstack((np.hstack((R, p.reshape((-1, 1)))), [0, 0, 0, 1])) transform = Isometry3(rotation=R, translation=p) numpy_compare.assert_float_equal(transform.matrix(), X) numpy_compare.assert_float_equal(transform.translation(), p) transform.set_translation(-p) numpy_compare.assert_float_equal(transform.translation(), -p) numpy_compare.assert_float_equal(transform.rotation(), R) transform.set_rotation(R.T) numpy_compare.assert_float_equal(transform.rotation(), R.T) # - Check transactions for bad values. if T != Expression: transform = Isometry3(rotation=R, translation=p) R_bad = np.copy(R) R_bad[0, 0] = 10. with self.assertRaises(RuntimeError): transform.set_rotation(R_bad) numpy_compare.assert_float_equal(transform.rotation(), R) X_bad = np.copy(X) X_bad[:3, :3] = R_bad with self.assertRaises(RuntimeError): transform.set_matrix(X_bad) numpy_compare.assert_float_equal(transform.matrix(), X) # Test `type_caster`s. if T == float: value = test_util.create_isometry() self.assertTrue(isinstance(value, mut.Isometry3)) test_util.check_isometry(value) # Operations. transform = Isometry3(rotation=R, translation=p) transform_I = transform.inverse().multiply(transform) numpy_compare.assert_float_equal(transform_I.matrix(), np.eye(4)) numpy_compare.assert_float_equal( transform.multiply(position=[10, 20, 30]), [21., -8, 33]) if six.PY3: numpy_compare.assert_float_equal( eval("transform.inverse() @ transform").matrix(), np.eye(4)) numpy_compare.assert_float_equal(eval("transform @ [10, 20, 30]"), [21., -8, 33])
def test_isometry3(self): # - Default constructor transform = mut.Isometry3() X = np.eye(4, 4) self.assertTrue(np.allclose(transform.matrix(), X)) self.assertTrue(np.allclose(copy.copy(transform).matrix(), X)) self.assertEqual(str(transform), str(X)) # - Constructor with (X) transform = mut.Isometry3(matrix=X) self.assertTrue(np.allclose(transform.matrix(), X)) # - Copy constructor. cp = mut.Isometry3(other=transform) self.assertTrue(np.allclose(transform.matrix(), cp.matrix())) # - Identity transform = mut.Isometry3.Identity() self.assertTrue(np.allclose(transform.matrix(), X)) # - Constructor with (R, p) R = np.array([ [0., 1, 0], [-1, 0, 0], [0, 0, 1]]) p = np.array([1., 2, 3]) X = np.vstack((np.hstack((R, p.reshape((-1, 1)))), [0, 0, 0, 1])) transform = mut.Isometry3(rotation=R, translation=p) self.assertTrue(np.allclose(transform.matrix(), X)) self.assertTrue(np.allclose(transform.translation(), p)) transform.set_translation(-p) self.assertTrue(np.allclose(transform.translation(), -p)) self.assertTrue(np.allclose(transform.rotation(), R)) transform.set_rotation(R.T) self.assertTrue(np.allclose(transform.rotation(), R.T)) # - Check transactions for bad values. transform = mut.Isometry3(rotation=R, translation=p) R_bad = np.copy(R) R_bad[0, 0] = 10. with self.assertRaises(RuntimeError): transform.set_rotation(R_bad) self.assertTrue(np.allclose(R, transform.rotation())) X_bad = np.copy(X) X_bad[:3, :3] = R_bad with self.assertRaises(RuntimeError): transform.set_matrix(X_bad) self.assertTrue(np.allclose(X, transform.matrix())) # Test `type_caster`s. value = test_util.create_isometry() self.assertTrue(isinstance(value, mut.Isometry3)) test_util.check_isometry(value) # Operations. transform = mut.Isometry3(rotation=R, translation=p) transform_I = transform.inverse().multiply(transform) self.assertTrue(np.allclose(transform_I.matrix(), np.eye(4))) self.assertTrue(( transform.multiply(position=[10, 20, 30]) == [21, -8, 33]).all()) if six.PY3: self.assertTrue(np.allclose( eval("transform.inverse() @ transform").matrix(), np.eye(4))) self.assertTrue(( eval("transform @ [10, 20, 30]") == [21, -8, 33]).all())
def test_isometry3(self): # - Default constructor transform = mut.Isometry3() X = np.eye(4, 4) self.assertTrue(np.allclose(transform.matrix(), X)) self.assertTrue(np.allclose(copy.copy(transform).matrix(), X)) self.assertEqual(str(transform), str(X)) # - Constructor with (X) transform = mut.Isometry3(matrix=X) self.assertTrue(np.allclose(transform.matrix(), X)) # - Copy constructor. cp = mut.Isometry3(other=transform) self.assertTrue(np.allclose(transform.matrix(), cp.matrix())) # - Identity transform = mut.Isometry3.Identity() self.assertTrue(np.allclose(transform.matrix(), X)) # - Constructor with (R, p) R = np.array([[0., 1, 0], [-1, 0, 0], [0, 0, 1]]) p = np.array([1., 2, 3]) X = np.vstack((np.hstack((R, p.reshape((-1, 1)))), [0, 0, 0, 1])) transform = mut.Isometry3(rotation=R, translation=p) self.assertTrue(np.allclose(transform.matrix(), X)) self.assertTrue(np.allclose(transform.translation(), p)) transform.set_translation(-p) self.assertTrue(np.allclose(transform.translation(), -p)) self.assertTrue(np.allclose(transform.rotation(), R)) transform.set_rotation(R.T) self.assertTrue(np.allclose(transform.rotation(), R.T)) # - Check transactions for bad values. transform = mut.Isometry3(rotation=R, translation=p) R_bad = np.copy(R) R_bad[0, 0] = 10. with self.assertRaises(RuntimeError): transform.set_rotation(R_bad) self.assertTrue(np.allclose(R, transform.rotation())) X_bad = np.copy(X) X_bad[:3, :3] = R_bad with self.assertRaises(RuntimeError): transform.set_matrix(X_bad) self.assertTrue(np.allclose(X, transform.matrix())) # Test `type_caster`s. value = test_util.create_isometry() self.assertTrue(isinstance(value, mut.Isometry3)) test_util.check_isometry(value) # Operations. transform = mut.Isometry3(rotation=R, translation=p) transform_I = transform.inverse().multiply(transform) self.assertTrue(np.allclose(transform_I.matrix(), np.eye(4))) self.assertTrue( (transform.multiply(position=[10, 20, 30]) == [21, -8, 33]).all()) if six.PY3: self.assertTrue( np.allclose( eval("transform.inverse() @ transform").matrix(), np.eye(4))) self.assertTrue((eval("transform @ [10, 20, 30]") == [21, -8, 33]).all())
def test_isometry3(self, T): Isometry3 = mut.Isometry3_[T] # - Default constructor transform = Isometry3() self.assertEqual(numpy_compare.resolve_type(transform.matrix()), T) X_I_np = np.eye(4, 4) numpy_compare.assert_float_equal(transform.matrix(), X_I_np) numpy_compare.assert_float_equal(copy.copy(transform).matrix(), X_I_np) if T == float: self.assertEqual(str(transform), str(X_I_np)) # - Constructor with (X_I_np) transform = Isometry3(matrix=X_I_np) numpy_compare.assert_float_equal(transform.matrix(), X_I_np) # - Copy constructor. cp = Isometry3(other=transform) numpy_compare.assert_equal(transform.matrix(), cp.matrix()) # - Identity transform = Isometry3.Identity() numpy_compare.assert_float_equal(transform.matrix(), X_I_np) # - Constructor with (R, p) R_AB = np.array([[0., 1, 0], [-1, 0, 0], [0, 0, 1]]) p_AB = np.array([1., 2, 3]) X_AB_np = np.eye(4) X_AB_np[:3, :3] = R_AB X_AB_np[:3, 3] = p_AB X_AB = Isometry3(rotation=R_AB, translation=p_AB) numpy_compare.assert_float_equal(X_AB.matrix(), X_AB_np) numpy_compare.assert_float_equal(X_AB.translation(), p_AB) numpy_compare.assert_float_equal(X_AB.rotation(), R_AB) # - Setters. X_AB = Isometry3() X_AB.set_translation(p_AB) numpy_compare.assert_float_equal(X_AB.translation(), p_AB) X_AB.set_rotation(R_AB) numpy_compare.assert_float_equal(X_AB.rotation(), R_AB) # - Cast self.check_cast(mut.Isometry3_, T) # - Check transactions for bad values. if T != Expression: X_temp = Isometry3(rotation=R_AB, translation=p_AB) R_bad = np.copy(R_AB) R_bad[0, 0] = 10. with self.assertRaises(RuntimeError): X_temp.set_rotation(R_bad) numpy_compare.assert_float_equal(X_temp.rotation(), R_AB) X_bad_np = np.copy(X_I_np) X_bad_np[:3, :3] = R_bad with self.assertRaises(RuntimeError): X_temp.set_matrix(X_bad_np) numpy_compare.assert_float_equal(X_temp.matrix(), X_AB_np) # Test `type_caster`s. if T == float: value = test_util.create_isometry() self.assertTrue(isinstance(value, mut.Isometry3)) test_util.check_isometry(value) # Operations. X_AB = Isometry3(rotation=R_AB, translation=p_AB) X_I = X_AB.inverse().multiply(X_AB) numpy_compare.assert_float_equal(X_I.matrix(), X_I_np) p_BQ = [10, 20, 30] p_AQ = [21., -8, 33] numpy_compare.assert_float_equal(X_AB.multiply(position=p_BQ), p_AQ) p_BQlist = np.array([p_BQ, p_BQ]).T p_AQlist = np.array([p_AQ, p_AQ]).T numpy_compare.assert_float_equal(X_AB.multiply(position=p_BQlist), p_AQlist) if six.PY3: numpy_compare.assert_float_equal( eval("X_AB.inverse() @ X_AB").matrix(), X_I_np) numpy_compare.assert_float_equal(eval("X_AB @ p_BQ"), p_AQ)
def check_isometry3(self, T): Isometry3 = mut.Isometry3_[T] # - Default constructor transform = Isometry3() self.assertEqual(npc.resolve_type(transform.matrix()), T) X = np.eye(4, 4) npc.assert_float_equal(transform.matrix(), X) npc.assert_float_equal(copy.copy(transform).matrix(), X) if T == float: self.assertEqual(str(transform), str(X)) # - Constructor with (X) transform = Isometry3(matrix=X) npc.assert_float_equal(transform.matrix(), X) # - Copy constructor. cp = Isometry3(other=transform) npc.assert_equal(transform.matrix(), cp.matrix()) # - Identity transform = Isometry3.Identity() npc.assert_float_equal(transform.matrix(), X) # - Constructor with (R, p) R = np.array([ [0., 1, 0], [-1, 0, 0], [0, 0, 1]]) p = np.array([1., 2, 3]) X = np.vstack((np.hstack((R, p.reshape((-1, 1)))), [0, 0, 0, 1])) transform = Isometry3(rotation=R, translation=p) npc.assert_float_equal(transform.matrix(), X) npc.assert_float_equal(transform.translation(), p) transform.set_translation(-p) npc.assert_float_equal(transform.translation(), -p) npc.assert_float_equal(transform.rotation(), R) transform.set_rotation(R.T) npc.assert_float_equal(transform.rotation(), R.T) # - Check transactions for bad values. if T != Expression: transform = Isometry3(rotation=R, translation=p) R_bad = np.copy(R) R_bad[0, 0] = 10. with self.assertRaises(RuntimeError): transform.set_rotation(R_bad) npc.assert_float_equal(transform.rotation(), R) X_bad = np.copy(X) X_bad[:3, :3] = R_bad with self.assertRaises(RuntimeError): transform.set_matrix(X_bad) npc.assert_float_equal(transform.matrix(), X) # Test `type_caster`s. if T == float: value = test_util.create_isometry() self.assertTrue(isinstance(value, mut.Isometry3)) test_util.check_isometry(value) # Operations. transform = Isometry3(rotation=R, translation=p) transform_I = transform.inverse().multiply(transform) npc.assert_float_equal(transform_I.matrix(), np.eye(4)) npc.assert_float_equal( transform.multiply(position=[10, 20, 30]), [21., -8, 33]) if six.PY3: npc.assert_float_equal( eval("transform.inverse() @ transform").matrix(), np.eye(4)) npc.assert_float_equal( eval("transform @ [10, 20, 30]"), [21., -8, 33])