def testConstructors(self): """Test Quatf constructors""" q = imath.Quatf() q = imath.Quatf(q) q = imath.Quatf(0.1, 0.2, 0.3, 0.4) q = imath.Quatf(0.1, imath.V3f(0.2, 0.3, 0.4))
def testEquality(self): """Test Quatf comparison for equality""" q1 = imath.Quatf(1, 2, 3, 4) q2 = imath.Quatf(1, 2, 3, 4) self.assertEqual(q1, q1) self.assertEqual(q1, q2) q2 = imath.Quatf(5, 2, 3, 4) self.assert_(q1 != q2)
def testTransformationMatrixParsing(self): p = IECore.CompoundParameter(members=[ IECore.TransformationMatrixfParameter( name="t", description="d", defaultValue=IECore.TransformationMatrixf(), ), ]) args = [ "-t", '1', '2', '3', '10', '11', '12', '4', '5', '6', '7', '8', '9', 'ZYX', '1', '21', '22', '23', '26', '27', '28', '36', '37', '38', '46', '47', '48', '56', '57', '58' ] IECore.ParameterParser().parse(args, p) t = p["t"].getTypedValue() self.assertEqual(t.translate, imath.V3f(1, 2, 3)) self.assertEqual(t.scale, imath.V3f(10, 11, 12)) self.assertEqual(t.shear, imath.V3f(4, 5, 6)) self.assertEqual(t.rotate, imath.V3f(7, 8, 9)) self.assertEqual(t.rotate.order(), imath.Eulerf.Order.ZYX) self.assertEqual(t.rotationOrientation, imath.Quatf(1, 21, 22, 23)) self.assertEqual(t.rotatePivot, imath.V3f(26, 27, 28)) self.assertEqual(t.rotatePivotTranslation, imath.V3f(36, 37, 38)) self.assertEqual(t.scalePivot, imath.V3f(46, 47, 48)) self.assertEqual(t.scalePivotTranslation, imath.V3f(56, 57, 58))
def testTypeConvertion( self ) : self.assertEqual( IECore.DataCastOp()( object = IECore.FloatData( 2 ), targetType = int(IECore.TypeId.DoubleData) ), IECore.DoubleData( 2 ) ) self.assertEqual( IECore.DataCastOp()( object = IECore.DoubleData( 2 ), targetType = int(IECore.TypeId.FloatData) ), IECore.FloatData( 2 ) ) self.assertEqual( IECore.DataCastOp()( object = IECore.IntData( 2 ), targetType = int(IECore.TypeId.UIntData) ), IECore.UIntData( 2 ) ) self.assertEqual( IECore.DataCastOp()( object = IECore.V3fData( imath.V3f( 2 ) ), targetType = int(IECore.TypeId.V3dData) ), IECore.V3dData( imath.V3d( 2 ) ) ) self.assertEqual( IECore.DataCastOp()( object = IECore.QuatfData( imath.Quatf( 1,2,3,4 ) ), targetType = int(IECore.TypeId.QuatdData) ), IECore.QuatdData( imath.Quatd( 1,2,3,4 ) ) )
def test(self): tm = IECore.TransformationMatrixfData() p = IECore.TransformationMatrixfParameter( name="f", description="d", defaultValue=tm, ) p.validate() self.assertEqual(p.name, "f") self.assertEqual(p.description, "d") self.assertEqual(p.valueValid()[0], True) self.assertTrue(isinstance(p.getTypedValue().translate, imath.V3f)) self.assertEqual(p.getTypedValue().translate, imath.V3f(0, 0, 0)) self.assertEqual(p.getTypedValue().rotate, imath.Eulerf(0, 0, 0)) self.assertEqual(p.getTypedValue().rotationOrientation, imath.Quatf(1, 0, 0, 0)) self.assertEqual(p.getTypedValue().scale, imath.V3f(1, 1, 1)) self.assertEqual(p.getTypedValue().shear, imath.V3f(0, 0, 0)) self.assertEqual(p.getTypedValue().rotatePivot, imath.V3f(0, 0, 0)) self.assertEqual(p.getTypedValue().rotatePivotTranslation, imath.V3f(0, 0, 0)) self.assertEqual(p.getTypedValue().scalePivot, imath.V3f(0, 0, 0)) self.assertEqual(p.getTypedValue().scalePivotTranslation, imath.V3f(0, 0, 0)) tm = IECore.TransformationMatrixdData() p = IECore.TransformationMatrixdParameter( name="f", description="d", defaultValue=tm, ) p.validate() self.assertEqual(p.name, "f") self.assertEqual(p.description, "d") self.assertEqual(p.valueValid()[0], True) self.assertTrue(isinstance(p.getTypedValue().translate, imath.V3d)) self.assertEqual(p.getTypedValue().translate, imath.V3d(0, 0, 0)) self.assertEqual(p.getTypedValue().rotate, imath.Eulerd(0, 0, 0)) self.assertEqual(p.getTypedValue().rotationOrientation, imath.Quatd(1, 0, 0, 0)) self.assertEqual(p.getTypedValue().scale, imath.V3d(1, 1, 1)) self.assertEqual(p.getTypedValue().shear, imath.V3d(0, 0, 0)) self.assertEqual(p.getTypedValue().rotatePivot, imath.V3d(0, 0, 0)) self.assertEqual(p.getTypedValue().rotatePivotTranslation, imath.V3d(0, 0, 0)) self.assertEqual(p.getTypedValue().scalePivot, imath.V3d(0, 0, 0)) self.assertEqual(p.getTypedValue().scalePivotTranslation, imath.V3d(0, 0, 0))
def testTransform( self ) : point = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( 4, 0, 0 ) ] ) ) point["orientation"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.QuatfVectorData( [ imath.Quatf().setAxisAngle( imath.V3f( 0, 1, 0 ), math.pi / 2.0 ) ] ) ) point["scale"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData( [ imath.V3f( 2, 3, 4 ) ] ) ) point["uniformScale"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData( [ 10 ] ) ) objectToScene = GafferScene.ObjectToScene() objectToScene["object"].setValue( point ) sphere = GafferScene.Sphere() instancer = GafferScene.Instancer() instancer["in"].setInput( objectToScene["out"] ) instancer["instances"].setInput( sphere["out"] ) instancer["parent"].setValue( "/object" ) self.assertEqual( instancer["out"].transform( "/object/instances/sphere/0" ), imath.M44f().translate( imath.V3f( 4, 0, 0 ) ) ) instancer["orientation"].setValue( "orientation" ) self.assertTrue( imath.V3f( 4, 0, -1 ).equalWithAbsError( imath.V3f( 1, 0, 0 ) * instancer["out"].transform( "/object/instances/sphere/0" ), 0.00001 ) ) instancer["scale"].setValue( "scale" ) self.assertTrue( imath.V3f( 4, 0, -2 ).equalWithAbsError( imath.V3f( 1, 0, 0 ) * instancer["out"].transform( "/object/instances/sphere/0" ), 0.00001 ) ) instancer["scale"].setValue( "uniformScale" ) self.assertTrue( imath.V3f( 4, 0, -10 ).equalWithAbsError( imath.V3f( 1, 0, 0 ) * instancer["out"].transform( "/object/instances/sphere/0" ), 0.00001 ) )
def testExtract(self): """Test Eulerf extract""" e = imath.Eulerf() e.extract(imath.M33f()) e.extract(imath.M44f()) e.extract(imath.Quatf()) m = e.toMatrix33() m = e.toMatrix44() q = e.toQuat() v = e.toXYZVector()
def testAttributes(self): """Test TransformationMatrixf attributes""" a = IECore.TransformationMatrixf() self.assertEqual(a.scalePivot, imath.V3f(0, 0, 0)) self.assertEqual(a.scale, imath.V3f(1, 1, 1)) self.assertEqual(a.shear, imath.V3f(0, 0, 0)) self.assertEqual(a.scalePivotTranslation, imath.V3f(0, 0, 0)) self.assertEqual(a.rotatePivot, imath.V3f(0, 0, 0)) self.assertEqual(a.rotationOrientation, imath.Quatf()) self.assertEqual(a.rotate, imath.Eulerf()) self.assertEqual(a.rotatePivotTranslation, imath.V3f(0, 0, 0)) self.assertEqual(a.translate, imath.V3f(0, 0, 0)) try: a.transform = 1 except: pass else: raise Exception("Should not be able to set transform.")
def testCanWriteVariousPrimVarTypes(self): fileName = self.getOutputPath("usd_various_primvars.usdc") sceneWrite = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write) root = sceneWrite.createChild("root") child = root.createChild("child") positions = IECore.V3fVectorData([imath.V3f(0, 0, 0)]) c3f = IECore.Color3fVectorData([imath.Color3f(0, 0, 0)]) intStr = IECore.InternedStringVectorData([IECore.InternedString("a")]) quat = IECore.QuatfVectorData([imath.Quatf(0, 1, 2, 3)]) pointsPrimitive = IECoreScene.PointsPrimitive(positions) pointsPrimitive["c3f"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, c3f) pointsPrimitive["token"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, intStr) pointsPrimitive["quat"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, quat) child.writeObject(pointsPrimitive, 0.0) del root del sceneWrite sceneRead = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read) self.assertEqual(sceneRead.childNames(), ["root"]) readRoot = sceneRead.child("root") readChild = readRoot.child("child") readObject = readChild.readObject(0.0) self.assertTrue("c3f" in readObject) self.assertIsInstance(readObject["c3f"].data, IECore.Color3fVectorData) self.assertTrue("token" in readObject) self.assertIsInstance(readObject["token"].data, IECore.InternedStringVectorData) self.assertTrue("quat" in readObject) self.assertIsInstance(readObject["quat"].data, IECore.QuatfVectorData)
def buildTestPoints(): positions = [ imath.V3f(1, 0, 0), imath.V3f(1, 0, 1), imath.V3f(0, 0, 1), imath.V3f(0, 0, 0) ] agent_id = [0, 1, 2, 3] agent_type = ["atomsRobot", "atomsRobot", "atoms2Robot", "atoms2Robot"] agent_variation = ["Robot1", "Robot2", "RedRobot", "PurpleRobot"] agent_lod = ["", "B", "A", ""] agent_velocity = [ imath.V3f(1, 0, 0), imath.V3f(1, 0, 0), imath.V3f(0, 0, 0), imath.V3f(1, 0, 0) ] agent_direction = [ imath.V3f(1, 0, 0), imath.V3f(1, 0, 0), imath.V3f(1, 0, 0), imath.V3f(1, 0, 0) ] agent_scale = [ imath.V3f(1, 1, 1), imath.V3f(1, 1, 1), imath.V3f(1, 1, 1), imath.V3f(1, 1, 1) ] agent_orientation = [ imath.Quatf(), imath.Quatf(), imath.Quatf(), imath.Quatf() ] points = IECoreScene.PointsPrimitive(IECore.V3fVectorData(positions)) points["atoms:agentId"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.IntVectorData(agent_id)) points["atoms:agentType"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.StringVectorData(agent_type)) points["atoms:variation"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.StringVectorData(agent_variation)) points["atoms:lod"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.StringVectorData(agent_lod)) points["atoms:velocity"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData(agent_velocity)) points["atoms:direction"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData(agent_direction)) points["atoms:scale"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData(agent_scale)) points["atoms:orientation"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.QuatfVectorData(agent_orientation)) return points
def testPrimVarTypes(self): root = IECoreScene.SceneInterface.create( os.path.dirname(__file__) + "/data/primVars.usda", IECore.IndexedIO.OpenMode.Read) object = root.child("root").child("sphere").readObject(0.0) expected = { 'test_Bool_Scalar_constant': IECore.BoolData(0), 'test_Double2_Array_constant': IECore.V2dVectorData([ imath.V2d(1.1, 1.2), imath.V2d(2.1, 2.2), imath.V2d(3.1, 3.2) ]), 'test_Double2_Scalar_constant': IECore.V2dData(imath.V2d(0.1, 0.2)), 'test_Double3_Array_constant': IECore.V3dVectorData([ imath.V3d(1.1, 1.2, 1.3), imath.V3d(2.1, 2.2, 2.3), imath.V3d(3.1, 3.2, 3.3) ]), 'test_Double3_Scalar_constant': IECore.V3dData(imath.V3d(0.1, 0.2, 0.3)), 'test_Double_Array_constant': IECore.DoubleVectorData([1.2, 1.3, 1.4]), 'test_Double_Scalar_constant': IECore.DoubleData(1.1), 'test_Float2_Array_constant': IECore.V2fVectorData([ imath.V2f(1.1, 1.2), imath.V2f(2.1, 2.2), imath.V2f(3.1, 3.2) ]), 'test_Float2_Scalar_constant': IECore.V2fData(imath.V2f(0.1, 0.2)), 'test_Float3_Array_constant': IECore.V3fVectorData([ imath.V3f(1.1, 1.2, 1.3), imath.V3f(2.1, 2.2, 2.3), imath.V3f(3.1, 3.2, 3.3) ]), 'test_Float3_Scalar_constant': IECore.V3fData(imath.V3f(0.1, 0.2, 0.3)), 'test_Float_Array_constant': IECore.FloatVectorData([0.7, 0.8, 0.9]), 'test_Float_Scalar_constant': IECore.FloatData(0.6), 'test_Half_Array_constant': IECore.HalfVectorData([0.0999756, 0.199951, 0.300049]), 'test_Half_Scalar_constant': IECore.HalfData(0.5), 'test_Int2_Array_constant': IECore.V2iVectorData( [imath.V2i(3, 4), imath.V2i(5, 6), imath.V2i(7, 8)]), 'test_Int2_Scalar_constant': IECore.V2iData(imath.V2i(1, 2)), 'test_Int3_Array_constant': IECore.V3iVectorData( [imath.V3i(3, 4, 5), imath.V3i(5, 6, 7), imath.V3i(7, 8, 9)]), 'test_Int3_Scalar_constant': IECore.V3iData(imath.V3i(1, 2, 3)), 'test_Int64_Array_constant': IECore.Int64VectorData([ 9223372036854775805, 9223372036854775806, 9223372036854775807 ]), 'test_Int64_Scalar_constant': IECore.Int64Data(-9223372036854775808), 'test_Int_Array_constant': IECore.IntVectorData([0, -1, -2]), 'test_Int_Scalar_constant': IECore.IntData(-1), 'test_String_Array_constant': IECore.StringVectorData(["is", "a", "test"]), 'test_String_Scalar_constant': IECore.StringData('this'), 'test_Token_Array_constant': IECore.InternedStringVectorData([ IECore.InternedString("t-is"), IECore.InternedString("t-a"), IECore.InternedString("t-test") ]), 'test_Token_Scalar_constant': IECore.InternedStringData(IECore.InternedString("t-this")), 'test_UChar_Array_constant': IECore.UCharVectorData([0, 1, 2]), 'test_UChar_Scalar_constant': IECore.UCharData(0), 'test_UInt64_Array_constant': IECore.UInt64VectorData([ 18446744073709551613, 18446744073709551614, 18446744073709551615 ]), 'test_UInt64_Scalar_constant': IECore.UInt64Data(18446744073709551615), 'test_UInt_Array_constant': IECore.UIntVectorData([4294967293, 4294967294, 4294967295]), 'test_UInt_Scalar_constant': IECore.UIntData(4294967295), #'test_color3d_Array_constant' : IECore.Color3dVectorData([IECore.Color3d(1.1, 1.2, 1.3), IECore.Color3d(2.1, 2.2, 2.3), IECore.Color3d(3.1, 3.2, 3.3)]), #'test_color3d_Scalar_constant' : IECore.Color3dData(IECore.Color3d(0.1, 0.2, 0.3)), 'test_color3f_Array_constant': IECore.Color3fVectorData([ imath.Color3f(1.1, 1.2, 1.3), imath.Color3f(2.1, 2.2, 2.3), imath.Color3f(3.1, 3.2, 3.3) ]), 'test_color3f_Scalar_constant': IECore.Color3fData(imath.Color3f(0.1, 0.2, 0.3)), #'test_color4d_Array_constant' : IECore.Color4dVectorData([IECore.Color4d(1.1, 1.2, 1.3, 1.4), IECore.Color4d(2.1, 2.2, 2.3, 2.4), IECore.Color4d(3.1, 3.2, 3.3, 3.4)]), #'test_color4d_Scalar_constant' : IECore.Color4dData(IECore.Color4d(0.1, 0.2, 0.3, 0.4)), 'test_color4f_Array_constant': IECore.Color4fVectorData([ imath.Color4f(1.1, 1.2, 1.3, 1.4), imath.Color4f(2.1, 2.2, 2.3, 2.4), imath.Color4f(3.1, 3.2, 3.3, 3.4) ]), 'test_color4f_Scalar_constant': IECore.Color4fData(imath.Color4f(0.1, 0.2, 0.3, 0.4)), 'test_matrix3d_Array_constant': IECore.M33dVectorData([ imath.M33d(0, 0, 0, 0, 1, 0, 0, 0, 0), imath.M33d(0, 0, 0, 0, 0, 0, 0, 0, 2), imath.M33d(0, 0, 4, 0, 0, 0, 0, 0, 0) ]), 'test_matrix3d_Scalar_constant': IECore.M33dData(imath.M33d(0, 0, 0, 0, 0, 0, 0, 0, 0)), 'test_matrix4d_Array_constant': IECore.M44dVectorData([ imath.M44d(1, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0), imath.M44d(1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), imath.M44d(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0) ]), 'test_matrix4d_Scalar_constant': IECore.M44dData( imath.M44d(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)), 'test_normal3d_Array_constant': IECore.V3dVectorData([ imath.V3d(1.1, 1.2, 1.3), imath.V3d(2.1, 2.2, 2.3), imath.V3d(3.1, 3.2, 3.3) ]), 'test_normal3d_Scalar_constant': IECore.V3dData(imath.V3d(0.1, 0.2, 0.3)), 'test_normal3f_Array_constant': IECore.V3fVectorData([ imath.V3f(1.1, 1.2, 1.3), imath.V3f(2.1, 2.2, 2.3), imath.V3f(3.1, 3.2, 3.3) ]), 'test_normal3f_Scalar_constant': IECore.V3fData(imath.V3f(0.1, 0.2, 0.3)), 'test_point3d_Array_constant': IECore.V3dVectorData([ imath.V3d(1.1, 1.2, 1.3), imath.V3d(2.1, 2.2, 2.3), imath.V3d(3.1, 3.2, 3.3) ]), 'test_point3d_Scalar_constant': IECore.V3dData(imath.V3d(0.1, 0.2, 0.3)), 'test_point3f_Array_constant': IECore.V3fVectorData([ imath.V3f(1.1, 1.2, 1.3), imath.V3f(2.1, 2.2, 2.3), imath.V3f(3.1, 3.2, 3.3) ]), 'test_point3f_Scalar_constant': IECore.V3fData(imath.V3f(0.1, 0.2, 0.3)), 'test_quatd_Array_constant': IECore.QuatdVectorData([ imath.Quatd(1, 0, 0, 0), imath.Quatd(0, 1, 0, 0), imath.Quatd(0, 0, 1, 0) ]), 'test_quatd_Scalar_constant': IECore.QuatdData(imath.Quatd(0, 0, 0, 1)), 'test_quatf_Array_constant': IECore.QuatfVectorData([ imath.Quatf(1, 0, 0, 0), imath.Quatf(0, 1, 0, 0), imath.Quatf(0, 0, 1, 0) ]), 'test_quatf_Scalar_constant': IECore.QuatfData(imath.Quatf(0, 0, 0, 1)), 'test_vector3d_Array_constant': IECore.V3dVectorData([ imath.V3d(1.1, 1.2, 1.3), imath.V3d(2.1, 2.2, 2.3), imath.V3d(3.1, 3.2, 3.3) ]), 'test_vector3d_Scalar_constant': IECore.V3dData(imath.V3d(0.1, 0.2, 0.3)), 'test_vector3f_Array_constant': IECore.V3fVectorData([ imath.V3f(1.1, 1.2, 1.3), imath.V3f(2.1, 2.2, 2.3), imath.V3f(3.1, 3.2, 3.3) ]), 'test_vector3f_Scalar_constant': IECore.V3fData(imath.V3f(0.1, 0.2, 0.3)), } for primVarName, primVarExpectedValue in expected.items(): self.assertTrue(primVarName in object.keys()) p = object[primVarName] self.assertEqual(p.data, primVarExpectedValue)
def testMiscMethods(self): """Test Quatf miscellaneous methods""" q1 = imath.Quatf(1, 2, 3, 4) self.assertAlmostEqual(q1.length(), math.sqrt(q1.r() * q1.r() + (q1.v() ^ q1.v())), 3) # axis/angle axis = imath.V3f(1, 2, 3) axis.normalize() q1.setAxisAngle(axis, 0.5) self.assertAlmostEqual(q1.axis().x, axis.x, 3) self.assertAlmostEqual(q1.axis().y, axis.y, 3) self.assertAlmostEqual(q1.axis().z, axis.z, 3) self.assertAlmostEqual(q1.angle(), 0.5, 3) # Rotate x axis onto y axis q1.setRotation(imath.V3f(1, 0, 0), imath.V3f(0, 1, 0)) #We should have gone 90 degrees about the +ve z-axis self.assertAlmostEqual(q1.angle(), 90.0 * math.pi / 180.0, 3) self.assertAlmostEqual(q1.axis().x, 0.0, 3) self.assertAlmostEqual(q1.axis().y, 0.0, 3) self.assertAlmostEqual(q1.axis().z, 1.0, 3) #inversion q1 = imath.Quatf(1, 2, 3, 4) qdot = q1 ^ q1 qi_test = imath.Quatf(q1.r() / qdot, -q1.v() / qdot) qi = q1.inverse() self.assertAlmostEqual(qi.r(), qi_test.r(), 3) self.assertAlmostEqual(qi.v()[0], qi_test.v()[0], 3) self.assertAlmostEqual(qi.v()[1], qi_test.v()[1], 3) self.assertAlmostEqual(qi.v()[2], qi_test.v()[2], 3) q1.invert() self.assertAlmostEqual(qi.r(), qi_test.r(), 3) self.assertAlmostEqual(qi.v()[0], qi_test.v()[0], 3) self.assertAlmostEqual(qi.v()[1], qi_test.v()[1], 3) self.assertAlmostEqual(qi.v()[2], qi_test.v()[2], 3) #slerp q2 = imath.Quatf(0.5, 0.6, 0.7, 0.8) qs = q1.slerp(q2, 0.5) # normalization qn = qi.normalized() qn_test = imath.Quatf(qi.r() / qi.length(), qi.v() / qi.length()) self.assertAlmostEqual(qn.r(), qn_test.r(), 3) self.assertAlmostEqual(qn.v()[0], qn_test.v()[0], 3) self.assertAlmostEqual(qn.v()[1], qn_test.v()[1], 3) self.assertAlmostEqual(qn.v()[2], qn_test.v()[2], 3) qn = qi.normalize() self.assertAlmostEqual(qn.r(), qn_test.r(), 3) self.assertAlmostEqual(qn.v()[0], qn_test.v()[0], 3) self.assertAlmostEqual(qn.v()[1], qn_test.v()[1], 3) self.assertAlmostEqual(qn.v()[2], qn_test.v()[2], 3) #matrix conversion fromDir = imath.V3f(1, 0, 0) toDir = imath.V3f(0, 1, 0) q1.setRotation(fromDir, toDir) m = q1.toMatrix33() m = q1.toMatrix44()
def createQuatf(value): return imath.Quatf(value, 0, 0, 0)
def testOperators(self): """Test Quatf operators""" q1 = imath.Quatf(1, 2, 3, 4) q2 = imath.Quatf(5, 6, 7, 8) self.assertAlmostEqual(q1 ^ q2, q1.r() * q2.r() + (q1.v() ^ q2.v()), 3)
def points(self): pData = IECore.V3fVectorData([ imath.V3f(0, 1, 2), imath.V3f(1), imath.V3f(2), imath.V3f(3), imath.V3f(4), imath.V3f(5), imath.V3f(6), imath.V3f(7), imath.V3f(8), imath.V3f(9), imath.V3f(10), imath.V3f(11), ]) points = IECoreScene.PointsPrimitive(pData) floatData = IECore.FloatData(1.5) v2fData = IECore.V2fData(imath.V2f(1.5, 2.5)) v3fData = IECore.V3fData(imath.V3f(1.5, 2.5, 3.5)) v3fData = IECore.V3fData(imath.V3f(1.5, 2.5, 3.5)) color3fData = IECore.Color3fData(imath.Color3f(1.5, 2.5, 3.5)) intData = IECore.IntData(1) v2iData = IECore.V2iData(imath.V2i(1, 2)) v3iData = IECore.V3iData(imath.V3i(1, 2, 3)) stringData = IECore.StringData("this is a string") m33fData = IECore.M33fData( imath.M33f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)) m44fData = IECore.M44fData( imath.M44f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0)) intRange = range(1, 13) floatVectorData = IECore.FloatVectorData([x + 0.5 for x in intRange]) v2fVectorData = IECore.V2fVectorData( [imath.V2f(x, x + 0.5) for x in intRange]) v3fVectorData = IECore.V3fVectorData( [imath.V3f(x, x + 0.5, x + 0.75) for x in intRange]) color3fVectorData = IECore.Color3fVectorData( [imath.Color3f(x, x + 0.5, x + 0.75) for x in intRange]) quatVectorData = IECore.QuatfVectorData( [imath.Quatf(x, x + 0.25, x + 0.5, x + 0.75) for x in intRange]) intVectorData = IECore.IntVectorData(intRange) v2iVectorData = IECore.V2iVectorData( [imath.V2i(x, -x) for x in intRange]) v3iVectorData = IECore.V3iVectorData( [imath.V3i(x, -x, x * 2) for x in intRange]) stringVectorData = IECore.StringVectorData( ["string number %06d!" % x for x in intRange]) m33fVectorData = IECore.M33fVectorData([ imath.M33f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0) for x in intRange ]) m44fVectorData = IECore.M44fVectorData([ imath.M44f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0) for x in intRange ]) detailInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Constant uniformInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Uniform pointInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Vertex # add all valid detail attrib types points["floatDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, floatData) points["v2fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2fData) points["v3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3fData) points["color3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, color3fData) points["intDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, intData) points["v2iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2iData) points["v3iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3iData) points["stringDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, stringData) points["m33fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, m33fData) points["m44fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, m44fData) # add all valid prim attrib types points["floatPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, floatVectorData[:1]) points["v2fPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, v2fVectorData[:1]) points["v3fPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, v3fVectorData[:1]) points["color3fPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, color3fVectorData[:1]) points["quatPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, quatVectorData[:1]) points["intPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, intVectorData[:1]) points["v2iPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, v2iVectorData[:1]) points["v3iPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, v3iVectorData[:1]) points["stringPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, stringVectorData[:1], IECore.IntVectorData([0])) points["m33fPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, m33fVectorData[:1]) points["m44fPrim"] = IECoreScene.PrimitiveVariable( uniformInterpolation, m44fVectorData[:1]) # add all valid point attrib types points["floatPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, floatVectorData) points["v2fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2fVectorData) points["v3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3fVectorData) points["color3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, color3fVectorData) points["quatPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, quatVectorData) points["intPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, intVectorData) points["v2iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2iVectorData) points["v3iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3iVectorData) points["stringPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, stringVectorData, IECore.IntVectorData(range(0, 12))) points["m33fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, m33fVectorData) points["m44fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, m44fVectorData) return points
def testBlindDataToHeader(self): displayWindow = imath.Box2i(imath.V2i(0, 0), imath.V2i(9, 9)) dataWindow = displayWindow headerValues = { "one": IECore.IntData(1), "two": IECore.FloatData(2), "three": IECore.DoubleData(3), "four": { "five": IECore.V2fData(imath.V2f(5)), "six": IECore.V2iData(imath.V2i(6)), "seven": IECore.V3fData(imath.V3f(7)), "eight": IECore.V3iData(imath.V3i(8)), "nine": { "ten": IECore.Box2iData(imath.Box2i(imath.V2i(0), imath.V2i(10))), "eleven": IECore.Box2fData(imath.Box2f(imath.V2f(0), imath.V2f(11))), "twelve": IECore.M33fData(imath.M33f(12)), "thirteen": IECore.M44fData(imath.M44f(13)), }, "fourteen": IECore.StringData("fourteen"), "fifteen": IECore.TimeCodeData( IECore.TimeCode(1, 2, 3, 4, dropFrame=True, bgf2=True, binaryGroup4=4)), } } if IECoreImage.OpenImageIOAlgo.version() >= 20206: headerValues["sixteen"] = IECore.FloatVectorData([0, 1, 2, 3, 4]) imgOrig = self.__makeFloatImage(dataWindow, dataWindow) imgOrig.blindData().update(headerValues.copy()) # now add some unsupported types imgOrig.blindData()['notSupported1'] = IECore.QuatfVectorData( [imath.Quatf(x, imath.V3f(x)) for x in [0, 1, 2, 3, 4]]) imgOrig.blindData()['four']['notSupported2'] = IECore.DoubleVectorData( [0, 1, 2, 3, 4]) w = IECore.Writer.create(imgOrig, "test/IECoreImage/data/exr/output.exr") self.assertIsInstance(w, IECoreImage.ImageWriter) w.write() self.assertTrue(os.path.exists("test/IECoreImage/data/exr/output.exr")) r = IECore.Reader.create("test/IECoreImage/data/exr/output.exr") imgNew = r.read() imgBlindData = imgNew.blindData() # eliminate default header info that comes from OIIO del imgBlindData['oiio:ColorSpace'] if IECoreImage.OpenImageIOAlgo.version() >= 20206: del imgBlindData['oiio:subimages'] del imgBlindData['compression'] del imgBlindData['PixelAspectRatio'] del imgBlindData['displayWindow'] del imgBlindData['dataWindow'] del imgBlindData['screenWindowCenter'] del imgBlindData['screenWindowWidth'] del imgBlindData["Software"] del imgBlindData["HostComputer"] del imgBlindData["DateTime"] self.assertEqual(imgBlindData, IECore.CompoundData(headerValues))
def save_pos_cache(path=None, start_frame=0, end_frame=1, fps=24.0, objA=[]): """ :param path: :param objA: :return: """ if not objA: return idA = get_idA(objA=objA) # print idA if not idA: return if len(objA) != len(idA): return cmds.currentTime(start_frame, update=True) arch = alembic.Abc.OArchive(path) root = arch.getTop() timesamp = alembic.AbcCoreAbstract.TimeSampling(1.0 / fps, start_frame / fps) # print timesamp index = arch.addTimeSampling(timesamp) opoints = alembic.AbcGeom.OPoints(root, "position_cache", index) # Export Extra myCrazyDataContainer = opoints.getSchema().getArbGeomParams() # Export Shotgun IDs prop_sg_id = alembic.Abc.OUInt64ArrayProperty(myCrazyDataContainer, "sg_id") # Export Rotation prop_rot = alembic.Abc.OQuatfArrayProperty(myCrazyDataContainer, "rotation") # Export Scale prop_scale = alembic.Abc.OV3fArrayProperty(myCrazyDataContainer, "scale") prop_rot.setTimeSampling(timesamp) prop_scale.setTimeSampling(timesamp) for i in range(start_frame, end_frame + 1): sg_idA = imath.IntArray(len(objA)) posA = imath.V3fArray(len(objA)) rotA = imath.QuatfArray(len(objA)) sclA = imath.V3fArray(len(objA)) cmds.currentTime(i, update=True) opoints_sample = alembic.AbcGeom.OPointsSchemaSample() ids = imath.IntArray(len(objA)) for y in range(0, len(objA)): ids[y] = y tr = cmds.xform(objA[y], query=True, translation=True) rt = cmds.xform(objA[y], query=True, rotation=True) scl = cmds.xform(objA[y], query=True, r=True, scale=True) quat = euler_to_quat(rt) sg_idA[y] = idA[y] posA[y] = imath.V3f(tr[0], tr[1], tr[2]) rotA[y] = imath.Quatf(quat[0], quat[1], quat[2], quat[3]) sclA[y] = imath.V3f(scl[0], scl[1], scl[2]) # print sclA[y] opoints_sample.setPositions(posA) opoints_sample.setIds(ids) opoints.getSchema().set(opoints_sample) prop_sg_id.setValue(sg_idA) prop_rot.setValue(rotA) prop_scale.setValue(sclA) arch = None del arch print 'Done...'