def testSerialisationWithoutRepr( self ) : # Check that we can serialise plug values even when the # stored `IECore::Object` does not have a suitable # implementation of `repr()`. v1 = IECore.TransformationMatrixfData( IECore.TransformationMatrixf( imath.V3f( 1, 2, 3 ), imath.Eulerf(), imath.V3f( 1, 1, 1 ) ) ) v2 = IECore.TransformationMatrixfData( IECore.TransformationMatrixf( imath.V3f( 4, 5, 6 ), imath.Eulerf(), imath.V3f( 2, 2, 2 ) ) ) v3 = IECore.CompoundObject( { "a" : IECore.IntData( 10 ), "b" : v1, "c" : v2, "d" : IECore.StringData( "test" ), } ) with self.assertRaises( Exception ) : eval( repr( v1 ) ) s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["user"]["p1"] = Gaffer.ObjectPlug( defaultValue = v1, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["p2"] = Gaffer.ObjectPlug( defaultValue = v2, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s["n"]["user"]["p3"] = Gaffer.ObjectPlug( defaultValue = v3, flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["n"]["user"]["p1"].defaultValue(), v1 ) self.assertEqual( s2["n"]["user"]["p2"].defaultValue(), v2 ) self.assertEqual( s2["n"]["user"]["p3"].defaultValue(), v3 ) self.assertEqual( s2["n"]["user"]["p1"].getValue(), v1 ) self.assertEqual( s2["n"]["user"]["p2"].getValue(), v2 ) self.assertEqual( s2["n"]["user"]["p3"].getValue(), v3 ) s["n"]["user"]["p1"].setValue( v2 ) s["n"]["user"]["p2"].setValue( v3 ) s["n"]["user"]["p3"].setValue( v1 ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["n"]["user"]["p1"].defaultValue(), v1 ) self.assertEqual( s2["n"]["user"]["p2"].defaultValue(), v2 ) self.assertEqual( s2["n"]["user"]["p3"].defaultValue(), v3 ) self.assertEqual( s2["n"]["user"]["p1"].getValue(), v2 ) self.assertEqual( s2["n"]["user"]["p2"].getValue(), v3 ) self.assertEqual( s2["n"]["user"]["p3"].getValue(), v1 )
def testComparison(self): """Test TransformationMatrixfData comparison""" a = IECore.TransformationMatrixfData() b = IECore.TransformationMatrixfData() self.assertEqual( a, b ) b.value = IECore.TransformationMatrixf( imath.V3f( 0.00001, 0, 0 ), imath.Eulerf(), imath.V3f(0,0,0) ) self.assertNotEqual( a, b ) a.value = IECore.TransformationMatrixf( imath.V3f( 0.00001, 0, 0 ), imath.Eulerf(), imath.V3f(0,0,0) ) self.assertEqual( a, b )
def testOrientation(self): script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() script["cube"]["transform"]["rotate"]["y"].setValue(90) script["group"] = GafferScene.Group() script["group"]["in"][0].setInput(script["cube"]["out"]) script["group"]["transform"]["rotate"]["y"].setValue(90) view = GafferSceneUI.SceneView() view["in"].setInput(script["group"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/group/cube"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) # Local tool["orientation"].setValue(tool.Orientation.Local) with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 0, 90)) self.assertTrue( imath.V3f(0, 1, 0).equalWithAbsError( imath.V3f(1, 0, 0) * script["group"]["out"].fullTransform("/group/cube"), 0.000001)) script.undo() # Parent tool["orientation"].setValue(tool.Orientation.Parent) with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(90, 0, 0)) self.assertTrue( imath.V3f(0, 1, 0).equalWithAbsError( imath.V3f(1, 0, 0) * script["group"]["out"].fullTransform("/group/cube"), 0.000001)) script.undo() # World tool["orientation"].setValue(tool.Orientation.World) with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 0, 90)) self.assertTrue( imath.V3f(0, -1, 0).equalWithAbsError( imath.V3f(1, 0, 0) * script["group"]["out"].fullTransform("/group/cube"), 0.000001))
def testTransform(self): """Test TransformationMatrixf transform""" a = IECore.TransformationMatrixf() a.scale = imath.V3f(2, 2, 2) self.assertEqual(a.transform, imath.M44f().scale(imath.V3f(2, 2, 2))) a.rotate = imath.Eulerf(0.2, 0.2, 0.2) self.assertTrue( a.transform.equalWithAbsError( imath.M44f().scale(imath.V3f(2, 2, 2)) * imath.Eulerf(0.2, 0.2, 0.2).toMatrix44(), 0.01))
def testNegativeLocalScale(self): script = Gaffer.ScriptNode() script["plane"] = GafferScene.Plane() script["plane"]["transform"]["scale"]["z"].setValue(-10) view = GafferSceneUI.SceneView() view["in"].setInput(script["plane"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/plane"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) tool["orientation"].setValue(tool.Orientation.Local) # We want the direction of the handles to reflect the # flipped scale, but not its magnitude. self.assertTrue(tool.handlesTransform().equalWithAbsError( imath.M44f().scale(imath.V3f(1, 1, -1)), 0.000001)) # And the handles need to move the object in the right # direction still. with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 45, 0)) self.assertTrue(script["plane"]["transform"] ["rotate"].getValue().equalWithAbsError( imath.V3f(0, -45, 0), 0.0001)) script.undo() # When orientation is Parent or World, the scale should # not be reflected in the handles. for orientation in (tool.Orientation.World, tool.Orientation.Parent): tool["orientation"].setValue(orientation) self.assertEqual(tool.handlesTransform(), imath.M44f()) with Gaffer.UndoScope(script): tool.rotate(imath.Eulerf(0, 45, 0)) self.assertTrue(script["plane"]["transform"] ["rotate"].getValue().equalWithAbsError( imath.V3f(0, 45, 0), 0.0001)) script.undo()
def testConvertsToPointsPrimitive(self): self.makeScene() converter = IECoreMaya.FromMayaDagNodeConverter.create("instancer1") convertedPoints = converter.convert() self.assertTrue( convertedPoints.isInstanceOf(IECoreScene.TypeId.PointsPrimitive)) self.assertEqual(convertedPoints.numPoints, 4) self.assertUnorderedEqual( convertedPoints.keys(), ['P', 'age', 'id', 'instances', 'instanceType', 'orient']) self.assertEqual(convertedPoints["P"].data[0], imath.V3f(4, 0, 0)) self.assertEqual(convertedPoints["P"].data[1], imath.V3f(4, 4, 0)) self.assertEqual(convertedPoints["P"].data[2], imath.V3f(0, 4, 0)) self.assertEqual(convertedPoints["P"].data[3], imath.V3f(0, 0, 0)) self.assertEqual(convertedPoints["id"].data[0], 0) self.assertEqual(convertedPoints["id"].data[1], 1) self.assertEqual(convertedPoints["id"].data[2], 2) self.assertEqual(convertedPoints["id"].data[3], 3) self.assertEqual(convertedPoints["age"].data[0], 0.0) self.assertEqual(convertedPoints["age"].data[1], 0.0) self.assertEqual(convertedPoints["age"].data[2], 0.0) self.assertEqual(convertedPoints["age"].data[3], 0.0) # instance indices to ensure we can instance the correct object self.assertEqual(convertedPoints["instanceType"].data[0], 0) self.assertEqual(convertedPoints["instanceType"].data[1], 1) self.assertEqual(convertedPoints["instanceType"].data[2], 0) self.assertEqual(convertedPoints["instanceType"].data[3], 1) # rotation is converted to orient self.assertEqual(convertedPoints["orient"].data[0], imath.Eulerf(math.pi / 4.0, 0, 0).toQuat()) self.assertEqual(convertedPoints["orient"].data[1], imath.Eulerf(0, math.pi / 4.0, 0).toQuat()) self.assertEqual(convertedPoints["orient"].data[2], imath.Eulerf(0, 0, math.pi / 4.0).toQuat()) self.assertEqual( convertedPoints["orient"].data[3], imath.Eulerf(math.pi / 4.0, math.pi / 4.0, 0).toQuat()) # check we're capturing the locations in maya we're instancing self.assertEqual(convertedPoints["instances"].data, IECore.StringVectorData(['/pCube1', '/pSphere1']))
def testStaticPlugSerialisationWithoutRepr( self ) : # This exposed a bug not exposed by `testSerialisationWithoutRepr()`. In # this case the only part of the serialisation that requires `import # IECore` is the value itself, exposing a bug where the import was not # serialised. value = IECore.CompoundObject( { "a" : IECore.TransformationMatrixfData( IECore.TransformationMatrixf( imath.V3f( 1, 2, 3 ), imath.Eulerf(), imath.V3f( 1, 1, 1 ) ) ) } ) with self.assertRaises( Exception ) : eval( repr( v1 ) ) s = Gaffer.ScriptNode() s["n"] = self.TypedObjectPlugNode() s["n"]["p"].setValue( value ) s2 = Gaffer.ScriptNode() s2.execute( s.serialise() ) self.assertEqual( s2["n"]["p"].getValue(), s["n"]["p"].getValue() )
def testTransformationMatrixConverter(self): sphereTransform = maya.cmds.polySphere()[0] radToAng = 180. / 3.14159265 maya.cmds.setAttr(str(sphereTransform) + ".rotate", -1000 * radToAng, 30 * radToAng, 100 * radToAng, type="double3") ## \todo This section sometimes fails due to use of the unpredictable default conversion (see FromMayaObjectConverter.h # for a description). We probably need to remove the default conversion so that people aren't exposed to it, or fix it # so we can define which the default conversion is. converter = IECoreMaya.FromMayaConverter.create(str(sphereTransform)) res = converter.convert() self.assertTrue(not res.isInstanceOf( IECore.TransformationMatrixfData.staticTypeId())) self.assertTrue(not res.isInstanceOf( IECore.TransformationMatrixdData.staticTypeId())) # test TransformationMatrixData converter converter = IECoreMaya.FromMayaConverter.create( str(sphereTransform), IECore.TypeId.TransformationMatrixfData) self.assertTrue(converter) transform = converter.convert() self.assertTrue( transform.isInstanceOf( IECore.TransformationMatrixfData.staticTypeId())) self.assertAlmostEqual( (transform.value.rotate - imath.Eulerf(-1000, 30, 100)).length(), 0, 2)
def testMultiplication(self): vectorTypes = [ IECore.V3fVectorData( [imath.V3f(1), imath.V3f(2), imath.V3f(3)], IECore.GeometricData.Interpretation.Vector), IECore.V3dVectorData( [imath.V3d(1), imath.V3d(2), imath.V3d(3)], IECore.GeometricData.Interpretation.Vector), ] matrixTypes = [ IECore.M33fData(imath.M33f() * 3), IECore.M33dData(imath.M33d() * 3), IECore.M44fData(imath.M44f().scale(imath.V3f(3))), IECore.M44dData(imath.M44d().scale(imath.V3d(3))), IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(3), imath.Eulerf(), imath.V3f(0))), IECore.TransformationMatrixdData( IECore.TransformationMatrixd(imath.V3d(3), imath.Eulerd(), imath.V3d(0))), ] for vector in vectorTypes: targetVector = vector.copy() for i in range(len(targetVector)): targetVector[i] = targetVector[i] * 3 for matrix in matrixTypes: res = IECore.MatrixMultiplyOp()(object=vector.copy(), matrix=matrix) if res == targetVector: continue raise Exception("Error testing vector " + str(type(vector)) + " against matrix " + str(type(matrix)) + ". Resulted " + str(res))
def testTransformWithRotation(self): script = Gaffer.ScriptNode() script["plane"] = GafferScene.Plane() script["transformFilter"] = GafferScene.PathFilter() script["transformFilter"]["paths"].setValue( IECore.StringVectorData(["/plane"])) script["transform"] = GafferScene.Transform() script["transform"]["in"].setInput(script["plane"]["out"]) script["transform"]["filter"].setInput( script["transformFilter"]["out"]) script["transform"]["transform"]["rotate"]["y"].setValue(90) view = GafferSceneUI.SceneView() view["in"].setInput(script["transform"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/plane"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) tool.rotate(imath.Eulerf(90, 0, 0)) self.assertTrue( imath.V3f(0, 1, 0).equalWithAbsError( imath.V3f(1, 0, 0) * script["transform"]["out"].fullTransform("/plane"), 0.000001)) self.assertTrue( imath.V3f(0, 0, 1).equalWithAbsError( imath.V3f(0, 1, 0) * script["transform"]["out"].fullTransform("/plane"), 0.000001))
def testGlobalTransform(self): g = IECoreScene.Group() childGroup = IECoreScene.Group() g.addChild(childGroup) parentTransform = IECore.TransformationMatrixf() parentTransform.rotate = imath.Eulerf(0, 3.1415926 / 2, 0) childTransform = IECore.TransformationMatrixf() childTransform.translate = imath.V3f(1, 0, 2) childGroup.setTransform( IECoreScene.MatrixTransform(childTransform.transform)) g.setTransform(IECoreScene.MatrixTransform(parentTransform.transform)) # child group's translation should have been rotated 90 degrees about the y axis: s = imath.V3f() h = imath.V3f() r = imath.V3f() childGroupGlobalTranslation = imath.V3f() childGroup.globalTransformMatrix().extractSHRT( s, h, r, childGroupGlobalTranslation) self.assertAlmostEqual(childGroupGlobalTranslation.x, 2, 4) self.assertAlmostEqual(childGroupGlobalTranslation.y, 0, 4) self.assertAlmostEqual(childGroupGlobalTranslation.z, -1, 4)
def testConstructors(self): """Test TransformationMatrixfData constructors""" a = IECore.TransformationMatrixfData() self.assertEqual(a.value, IECore.TransformationMatrixf()) a = IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(2, 2, 2), imath.Eulerf(), imath.V3f(1, 0, 0))) self.assertEqual(a.value.scale, imath.V3f(2, 2, 2))
def testConstructors(self): """Test TransformationMatrixf constructors""" a = IECore.TransformationMatrixf() self.assertEqual( a.transform, imath.M44f() ) a = IECore.TransformationMatrixf( imath.V3f( 2, 2, 2 ), imath.Eulerf(), imath.V3f( 1, 0, 0 ) ) self.assertTrue( a.transform.equalWithAbsError( imath.M44f().scale( imath.V3f(2,2,2) ) * imath.M44f().translate( imath.V3f(1,0,0) ), 0.01) ) b = IECore.TransformationMatrixf( a ) self.assertEqual( a.transform, b.transform )
def testAngleOrder(self): """Test Eulerf angleOrder""" e = imath.Eulerf() o = e.angleOrder() self.assertIsInstance(o, imath.V3i) self.assertEqual(len(o), 3)
def testCopy(self): """Test TransformationMatrixfData copy""" a = IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(2, 2, 2), imath.Eulerf(), imath.V3f(1, 0, 0))) self.assertEqual(a.value.scale, imath.V3f(2, 2, 2)) b = a.copy() a.value = IECore.TransformationMatrixf() self.assertEqual(b.value.scale, imath.V3f(2, 2, 2)) self.assertEqual(a.value.scale, imath.V3f(1, 1, 1))
def testOrder(self): """Test Eulerf order""" self.assertEqual(len(imath.Eulerf.Order.values), 24) e = imath.Eulerf() for order in imath.Eulerf.Order.values.values(): e.setOrder(order) self.assertEqual(e.order(), order)
def testIO(self): """Test TransformationMatrixfData IO""" a = IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(2, 3, 4), imath.Eulerf(), imath.V3f(1, 2, 3))) w = IECore.ObjectWriter(a, self.testFile) w.write() r = IECore.ObjectReader(self.testFile) b = r.read() self.assertEqual(a, b)
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 testCanChangeInstancerRotationUnits( self ) : self.makeRotationOrderOrUnitScene( 0, True ) converter = IECoreMaya.FromMayaDagNodeConverter.create( "instancer1" ) convertedPoints = converter.convert() self.assertTrue( convertedPoints.isInstanceOf( IECoreScene.TypeId.PointsPrimitive ) ) self.assertEqual( convertedPoints.numPoints, 1 ) self.assertUnorderedEqual( convertedPoints.keys(), ['P', 'age', 'id', 'instances', 'instanceType', 'orient'] ) self.assertEqual( convertedPoints["orient"].data[0], imath.Eulerf( 90.0, 90.0, 0, imath.Eulerf.XYZ ).toQuat() )
def testInterpolation(self): """Test TranformationMatrixfData interpolation""" a = IECore.TransformationMatrixfData() b = IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(2, 3, 4), imath.Eulerf(), imath.V3f(1, 2, 3))) c = IECore.linearObjectInterpolation(a, b, 0.5) self.assertEqual(type(c), IECore.TransformationMatrixfData) self.assertTrue( c.value.scale.equalWithAbsError(imath.V3f(1.5, 2, 2.5), 0.01)) self.assertTrue( c.value.translate.equalWithAbsError(imath.V3f(0.5, 1, 1.5), 0.01))
def testGettingKnobValues(self): params = KnobConvertersTest.__parameters() knobHolder = KnobConvertersTest.KnobHolder() IECoreNuke.createKnobsFromParameter(knobHolder, params) knobs = knobHolder.knobs() IECoreNuke.setParameterFromKnobs(knobHolder, params) self.assertEqual(params["A"].getNumericValue(), 1) self.assertEqual(params["B"]["C"].getNumericValue(), 2.0) self.assertEqual(params["B"]["D"].getNumericValue(), 3.0) knobs["parm_A"].setValue(10) knobs["parm_B_C"].setValue(20.0) knobs["parm_B_D"].setValue(30.0) knobs["parm_E"].setValue("40") knobs["parm_F_G"].setValue("50 60 70") knobs["parm_F_H"].setValue("80") knobs["parm_F_I"].setValue("90") knobs["parm_J"].setValue("100\n110\n120") knobs["parm_K"].setValue("/tmp2/test.dpx") knobs["parm_L"].setValue("/tmp2") knobs["parm_M"].setValue("/tmp2/test.%02d.dpx") knobs["parm_N"].setValue(False) knobs["parm_O"].setValue("preset3") IECoreNuke.setParameterFromKnobs(knobHolder, params) self.assertEqual(params["A"].getNumericValue(), 10) self.assertEqual(params["B"]["C"].getNumericValue(), 20.0) self.assertEqual(params["B"]["D"].getNumericValue(), 30.0) self.assertEqual(params["E"].getTypedValue(), "40") self.assertEqual(params["F"]["G"].getValue(), IECore.FloatVectorData([50, 60, 70])) self.assertEqual(params["F"]["H"].getValue(), IECore.IntVectorData([80])) self.assertEqual(params["F"]["I"].getValue(), IECore.DoubleVectorData([90])) self.assertEqual(params["J"].getValue(), IECore.StringVectorData(["100", "110", "120"])) self.assertEqual(params["K"].getTypedValue(), "/tmp2/test.dpx") self.assertEqual(params["L"].getTypedValue(), "/tmp2") self.assertEqual(params["M"].getTypedValue(), "/tmp2/test.##.dpx") self.assertEqual(params["N"].getTypedValue(), False) self.assertEqual( params["O"].getValue(), IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(1), imath.Eulerf(), imath.V3f(4)))) # raises exception when trying to convert an invalid file sequence syntax knobs["parm_M"].setValue("/tmp2/test.%2d.dpx") self.assertRaises(RuntimeError, IECoreNuke.setParameterFromKnobs, knobHolder, params)
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 testInteractionWithParentConstraint(self): script = Gaffer.ScriptNode() script["sphere"] = GafferScene.Sphere() script["cube"] = GafferScene.Cube() script["cube"]["transform"]["translate"].setValue(imath.V3f(5, 5, 0)) script["cube"]["transform"]["rotate"]["x"].setValue(90) script["parent"] = GafferScene.Parent() script["parent"]["in"].setInput(script["sphere"]["out"]) script["parent"]["children"][0].setInput(script["cube"]["out"]) script["parent"]["parent"].setValue("/") script["sphereFilter"] = GafferScene.PathFilter() script["sphereFilter"]["paths"].setValue( IECore.StringVectorData(["/sphere"])) script["constraint"] = GafferScene.ParentConstraint() script["constraint"]["in"].setInput(script["parent"]["out"]) script["constraint"]["filter"].setInput(script["sphereFilter"]["out"]) script["constraint"]["target"].setValue("/cube") view = GafferSceneUI.SceneView() view["in"].setInput(script["constraint"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/sphere"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) tool["orientation"].setValue(tool.Orientation.Parent) self.assertEqual( tool.handlesTransform(), imath.M44f().translate( script["cube"]["transform"]["translate"].getValue())) tool["orientation"].setValue(tool.Orientation.Local) self.assertEqual(tool.handlesTransform(), script["constraint"]["out"].transform("/sphere")) tool.rotate(imath.Eulerf(0, 90, 0)) self.assertEqual(script["sphere"]["transform"]["rotate"].getValue(), imath.V3f(0, 90, 0))
def testEditScopes(self): script = Gaffer.ScriptNode() script["sphere"] = GafferScene.Sphere() script["sphere"]["transform"]["translate"].setValue(imath.V3f(1, 0, 0)) script["editScope"] = Gaffer.EditScope() script["editScope"].setup(script["sphere"]["out"]) script["editScope"]["in"].setInput(script["sphere"]["out"]) view = GafferSceneUI.SceneView() view["in"].setInput(script["editScope"]["out"]) view["editScope"].setInput(script["editScope"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/sphere"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) self.assertEqual(tool.handlesTransform(), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual(len(tool.selection()), 1) self.assertTrue(tool.selection()[0].editable()) self.assertFalse( GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"], "/sphere")) self.assertEqual(script["editScope"]["out"].transform("/sphere"), imath.M44f().translate(imath.V3f(1, 0, 0))) tool.rotate(imath.Eulerf(0, 90, 0)) self.assertEqual(tool.handlesTransform(), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual(len(tool.selection()), 1) self.assertTrue(tool.selection()[0].editable()) self.assertTrue( GafferScene.EditScopeAlgo.hasTransformEdit(script["editScope"], "/sphere")) self.assertEqual( script["editScope"]["out"].transform("/sphere"), imath.M44f().translate(imath.V3f(1, 0, 0)).rotate( imath.V3f(0, math.pi / 2, 0)), )
def testRotate(self): script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() view = GafferSceneUI.SceneView() view["in"].setInput(script["cube"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/cube"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) for i in range(0, 6): tool.rotate(imath.Eulerf(0, 90, 0)) self.assertEqual( script["cube"]["transform"]["rotate"]["y"].getValue(), (i + 1) * 90)
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 testSettingKnobValues(self): params = KnobConvertersTest.__parameters() knobHolder = KnobConvertersTest.KnobHolder() IECoreNuke.createKnobsFromParameter(knobHolder, params) # modify parameters params['A'] = 2 params['F']['G'] = IECore.FloatVectorData() params['F']['I'] = IECore.DoubleVectorData([9]) params['M'] = "/tmp/anotherTest.%d.dpx" params['N'] = False params['O'] = IECore.TransformationMatrixfData( IECore.TransformationMatrixf(imath.V3f(1), imath.Eulerf(), imath.V3f(3))) IECoreNuke.setKnobsFromParameter(knobHolder, params) knobs = knobHolder.knobs() self.assertEqual(knobs["parm_A"].getValue(), 2) self.assertEqual(knobs["parm_F_G"].getText(), "") self.assertEqual(knobs["parm_F_I"].getText(), "9.0") self.assertEqual(knobs["parm_M"].getText(), "/tmp/anotherTest.%d.dpx") self.assertEqual(knobs["parm_N"].getValue(), False) self.assertEqual(knobs["parm_O"].value(), "preset2")
def testMatrix(self): p = Gaffer.TransformPlug() p["translate"].setValue(imath.V3f(1, 2, 3)) p["rotate"].setValue(imath.V3f(90, 45, 0)) p["scale"].setValue(imath.V3f(1, 2, 4)) translate = imath.M44f().translate(p["translate"].getValue()) rotate = imath.Eulerf(IECore.degreesToRadians(p["rotate"].getValue()), imath.Eulerf.Order.XYZ) rotate = rotate.toMatrix44() scale = imath.M44f().scale(p["scale"].getValue()) transforms = { "t": translate, "r": rotate, "s": scale, } transform = imath.M44f() for m in ("s", "r", "t"): transform = transform * transforms[m] self.assertEqual(p.matrix(), transform)
def testInteractionWithGroupRotation(self): script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() script["group"] = GafferScene.Group() script["group"]["in"][0].setInput(script["cube"]["out"]) # Rotates the X axis onto the negative Z axis script["group"]["transform"]["rotate"]["y"].setValue(90) view = GafferSceneUI.SceneView() view["in"].setInput(script["group"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/group/cube"])) tool = GafferSceneUI.RotateTool(view) tool["active"].setValue(True) # Rotates 90 degrees using the Z handle. This will # rotate about the X axis in world space, because the # handle orientation has been affected by the group # transform (because default orientation is Parent). tool.rotate(imath.Eulerf(0, 0, 90)) # We expect this to have aligned the cube's local X axis onto # the Y axis in world space, and the local Y axis onto the world # Z axis. self.assertTrue( imath.V3f(0, 1, 0).equalWithAbsError( imath.V3f(1, 0, 0) * script["group"]["out"].fullTransform("/group/cube"), 0.000001)) self.assertTrue( imath.V3f(0, 0, 1).equalWithAbsError( imath.V3f(0, 1, 0) * script["group"]["out"].fullTransform("/group/cube"), 0.000001))
def test(self): # Prepare some points with a variety of primitive # variables specifying the same random orientations. points = IECoreScene.PointsPrimitive( IECore.V3fVectorData([imath.V3f(0)] * 100)) points["euler"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData()) points["quaternion"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.QuatfVectorData()) points["axis"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.V3fVectorData()) points["angle"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData()) random.seed(0) for i in range(0, points["P"].data.size()): radians = imath.Eulerf(random.uniform(0, math.pi / 2), random.uniform(0, math.pi / 2), random.uniform(0, math.pi / 2)) degrees = 180.0 * radians / math.pi q = radians.toQuat() points["euler"].data.append(degrees) points["quaternion"].data.append(q) points["axis"].data.append(q.axis()) points["angle"].data.append(q.angle()) pointsNode = GafferScene.ObjectToScene() pointsNode["object"].setValue(points) # No filter is applied, so should be a no-op orientation = GafferScene.Orientation() orientation["in"].setInput(pointsNode["out"]) self.assertScenesEqual(orientation["out"], orientation["in"]) self.assertSceneHashesEqual(orientation["out"], orientation["in"]) # Apply a filter filter = GafferScene.PathFilter() filter["paths"].setValue(IECore.StringVectorData(["/object"])) orientation["filter"].setInput(filter["out"]) # Test euler -> euler round tripping self.assertEqual(orientation["inMode"].getValue(), orientation.Mode.Euler) orientation["inEuler"].setValue("euler") orientation["outMode"].setValue(orientation.Mode.Euler) orientation["outEuler"].setValue("outEuler") for order in [ imath.Eulerf.XYZ, imath.Eulerf.XZY, imath.Eulerf.YZX, imath.Eulerf.YXZ, imath.Eulerf.ZXY, imath.Eulerf.ZYX, ]: orientation["inOrder"].setValue(order) orientation["outOrder"].setValue(order) self.__assertVectorDataAlmostEqual( orientation["in"].object("/object")["euler"].data, orientation["out"].object("/object")["outEuler"].data, delta=0.01) # Test euler -> quaternion orientation["inOrder"].setValue(imath.Eulerf.XYZ) orientation["outMode"].setValue(orientation.Mode.Quaternion) orientation["outQuaternion"].setValue("outQuaternion") self.__assertVectorDataAlmostEqual( orientation["in"].object("/object")["quaternion"].data, orientation["out"].object("/object")["outQuaternion"].data, ) # Test euler -> axis angle orientation["outMode"].setValue(orientation.Mode.AxisAngle) orientation["outAxis"].setValue("outAxis") orientation["outAngle"].setValue("outAngle") self.__assertVectorDataAlmostEqual( orientation["in"].object("/object")["axis"].data, orientation["out"].object("/object")["outAxis"].data, ) self.__assertVectorDataAlmostEqual( orientation["in"].object("/object")["angle"].data, orientation["out"].object("/object")["outAngle"].data, )