def __plugPresetValues(nodeEntry, paramName, paramType): # options STRING "name:value|..." options = __aiMetadataGetStr(nodeEntry, paramName, "options") if not options: return None values = [o.rpartition(":")[2] for o in options.split("|") if o] if paramType == arnold.AI_TYPE_STRING: return IECore.StringVectorData(values) elif paramType in (arnold.AI_TYPE_INT, arnold.AI_TYPE_BYTE): return IECore.IntVectorData([int(v) for v in values]) elif paramType == arnold.AI_TYPE_UINT: return IECore.UIntVectorData([int(v) for v in values]) elif paramType == arnold.AI_TYPE_FLOAT: return IECore.FloatVectorData([float(v) for v in values]) elif paramType == arnold.AI_TYPE_BOOLEAN: falseVals = ("false", "no", "0") return IECore.BoolVectorData( [False if v.lower() in falseVals else True for v in values]) elif paramType == arnold.AI_TYPE_RGB: return IECore.Color3fVectorData( [imath.Color3f(*[float(x) for x in v.split(",")]) for v in values]) elif paramType == arnold.AI_TYPE_RGBA: return IECore.Color4fVectorData( [imath.Color4f(*[float(x) for x in v.split(",")]) for v in values]) elif paramType in (arnold.AI_TYPE_VECTOR, arnold.AI_TYPE_POINT): return IECore.V3fVectorData( [imath.V3f(*[float(x) for x in v.split(",")]) for v in values]) elif paramType == arnold.AI_TYPE_POINT2: return IECore.V2fVectorData( [imath.V2f(*[float(x) for x in v.split(",")]) for v in values]) return None
def testNestedTransform(self): script = Gaffer.ScriptNode() script["camera"] = GafferScene.Camera() script["group"] = GafferScene.Group() script["group"]["in"][0].setInput(script["camera"]["out"]) script["group"]["transform"]["rotate"]["y"].setValue(90) view = GafferSceneUI.SceneView() view["in"].setInput(script["group"]["out"]) view["camera"]["lookThroughEnabled"].setValue(True) view["camera"]["lookThroughCamera"].setValue("/group/camera") tool = GafferSceneUI.CameraTool(view) tool["active"].setValue(True) cameraTransform = imath.M44f().translate(imath.V3f(1, 2, 3)) view.viewportGadget().setCameraTransform(cameraTransform) self.assertTrue( cameraTransform.equalWithAbsError( script["group"]["out"].fullTransform("/group/camera"), 0.00001))
def testHandlesTransform(self): script = Gaffer.ScriptNode() script["plane"] = GafferScene.Plane() script["plane"]["transform"]["rotate"]["y"].setValue(90) view = GafferSceneUI.SceneView() view["in"].setInput(script["plane"]["out"]) GafferSceneUI.ContextAlgo.setSelectedPaths( view.getContext(), IECore.PathMatcher(["/plane"])) tool = GafferSceneUI.TranslateTool(view) tool["active"].setValue(True) tool["orientation"].setValue(tool.Orientation.Local) self.assertTrue(tool.handlesTransform().equalWithAbsError( imath.M44f().rotate(imath.V3f(0, math.pi / 2, 0)), 0.000001)) tool["orientation"].setValue(tool.Orientation.Parent) self.assertEqual(tool.handlesTransform(), imath.M44f()) tool["orientation"].setValue(tool.Orientation.World) self.assertEqual(tool.handlesTransform(), imath.M44f())
def testRead( self ) : sc = IECoreScene.SceneCache( self.__testFile, IECore.IndexedIO.OpenMode.Write ) t = sc.createChild( "transform" ) t.writeTransform( IECore.M44dData( imath.M44d().translate( imath.V3d( 1, 0, 0 ) ) ), 0.0 ) s = t.createChild( "shape" ) s.writeObject( IECoreScene.SpherePrimitive( 10 ), 0.0 ) del sc, t, s reader = GafferScene.SceneReader() reader["fileName"].setValue( self.__testFile ) # we have to remember to set the refresh counts to different values in different tests, otherwise # it thinks it's reading an old file... reader["refreshCount"].setValue( self.uniqueInt( self.__testFile ) ) scene = reader["out"] self.assertSceneValid( scene ) self.assertEqual( scene.transform( "transform" ), imath.M44f().translate( imath.V3f( 1, 0, 0 ) ) ) self.assertEqual( scene.object( "transform/shape" ), IECoreScene.SpherePrimitive( 10 ) )
def renderImage(self, group): r = IECoreGL.Renderer() r.setOption("gl:mode", IECore.StringData("immediate")) r.camera( "main", { "projection": "orthographic", "resolution": imath.V2i(256), "clippingPlanes": imath.V2f(1, 1000), "screenWindow": imath.Box2f(imath.V2f(-0.5), imath.V2f(0.5)) }) r.display(self.__imageFileName, "tif", "rgba", {}) r.setOption("gl:searchPath:texture", IECore.StringData("./")) r.setOption("gl:searchPath:shader", IECore.StringData("./test/IECoreGL/shaders")) with IECoreScene.WorldBlock(r): r.concatTransform(imath.M44f().translate(imath.V3f(0, 0, -5))) group.render(r) return IECore.Reader.create(self.__imageFileName).read()
def testSelectionMask(self): plane = GafferScene.Plane() plane["dimensions"].setValue(imath.V2f(10)) plane["transform"]["translate"]["z"].setValue(4) camera = GafferScene.Camera() group = GafferScene.Group() group["in"][0].setInput(plane["out"]) group["in"][1].setInput(camera["out"]) sg = GafferSceneUI.SceneGadget() sg.setScene(group["out"]) sg.setMinimumExpansionDepth(100) with GafferUI.Window() as w: gw = GafferUI.GadgetWidget(sg) w.setVisible(True) self.waitForIdle(10000) sg.waitForCompletion() gw.getViewportGadget().frame(sg.bound(), imath.V3f(0, 0, -1)) self.waitForIdle(10000) self.assertObjectsAt(sg, imath.Box2f(imath.V2f(0), imath.V2f(1)), ["/group/plane", "/group/camera"]) sg.setSelectionMask(IECore.StringVectorData(["MeshPrimitive"])) self.assertObjectsAt(sg, imath.Box2f(imath.V2f(0), imath.V2f(1)), ["/group/plane"]) sg.setSelectionMask(IECore.StringVectorData(["Camera"])) self.assertObjectsAt(sg, imath.Box2f(imath.V2f(0), imath.V2f(1)), ["/group/camera"])
def points(self): testObject = IECoreScene.PointsPrimitive( IECore.V3fVectorData([imath.V3f(x) for x in range(0, 10)])) testObject["a"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, IECore.FloatData(0.5)) testObject["b"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.FloatVectorData(range(0, 10))) testObject["c"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.FloatVectorData([0])) testObject["d"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Varying, IECore.FloatVectorData(range(0, 10))) testObject["e"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, IECore.FloatVectorData(range(0, 10))) self.assertTrue(testObject.arePrimitiveVariablesValid()) return testObject
def testNoVisualisation( self ) : r = IECoreGL.Renderer() r.setOption( "gl:mode", IECore.StringData( "immediate" ) ) r.camera( "main", { "projection" : IECore.StringData( "orthographic" ), "resolution" : IECore.V2iData( imath.V2i( 256 ) ), "clippingPlanes" : IECore.V2fData( imath.V2f( 1, 1000 ) ), "screenWindow" : IECore.Box2fData( imath.Box2f( imath.V2f( -1 ), imath.V2f( 1 ) ) ) } ) r.display( self.__outputFileName, "tif", "rgba", {} ) with IECoreScene.WorldBlock( r ) : r.concatTransform( imath.M44f().translate( imath.V3f( 0, 0, -5 ) ) ) r.coordinateSystem( "myCoordSys" ) i = IECore.Reader.create( self.__outputFileName ).read() a = i["A"] for i in range( a.size() ) : self.assertEqual( a[i], 0 )
def testMode( self ) : with IECoreArnold.UniverseBlock( writable = True ) : p = IECoreScene.PointsPrimitive( IECore.V3fVectorData( [ imath.V3f( i ) for i in range( 0, 10 ) ] ) ) n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "disk" ) p["type"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, "particle" ) n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "disk" ) p["type"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, "disk" ) n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "disk" ) p["type"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, "sphere" ) n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "sphere" ) p["type"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, "patch" ) n = IECoreArnold.NodeAlgo.convert( p, "testPoints" ) self.assertEqual( arnold.AiNodeGetStr( n, "mode" ), "quad" )
def testCanWriteAnimatedPrimitiveVariable ( self ): fileName = self.getOutputPath("usd_animated_primvar.usda") sceneWrite = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Write ) root = sceneWrite.createChild( "root" ) for t in range(32): positionData = [] primvarData = [] for i in range( 16 ) : for j in range( 16 ) : positionData.append( imath.V3f( [i, j, 0] ) ) primvarData.append ( i * 16 + j + t ) positions = IECore.V3fVectorData( positionData ) primvar = IECore.IntVectorData( primvarData) pointsPrimitive = IECoreScene.PointsPrimitive( positions ) pointsPrimitive["index"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, primvar ) root.writeObject( pointsPrimitive, t ) del root del sceneWrite sceneRead = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.OpenMode.Read ) self.assertEqual( sceneRead.childNames(), ["root"] ) readRoot = sceneRead.child( "root" ) self.assertTrue( readRoot.hasObject() ) readPoints = readRoot.readObject( 0.0 ) self.assertIsInstance( readPoints, IECoreScene.PointsPrimitive ) roundTripPositions = readPoints["P"].data self.assertEqual( roundTripPositions, positions )
def testMinMax( self ) : b = Gaffer.Box3fPlug( "p", Gaffer.Plug.Direction.In, imath.Box3f( imath.V3f( -0.5 ), imath.V3f( 0.5 ) ) ) v = Gaffer.V3fPlug() self.assertEqual( b.minValue(), v.minValue() ) self.assertEqual( b.maxValue(), v.maxValue() ) self.assertFalse( b.hasMinValue() ) self.assertFalse( b.hasMaxValue() ) self.assertEqual( b.minValue(), v.minValue() ) self.assertEqual( b.maxValue(), v.maxValue() ) b = Gaffer.Box3fPlug( "p", minValue = imath.V3f( -1, -2, -3 ), maxValue = imath.V3f( 1, 2, 3 ) ) self.assertTrue( b.hasMinValue() ) self.assertTrue( b.hasMaxValue() ) self.assertEqual( b.minValue(), imath.V3f( -1, -2, -3 ) ) self.assertEqual( b.maxValue(), imath.V3f( 1, 2, 3 ) ) c = b.createCounterpart( "c", Gaffer.Plug.Direction.In ) self.assertTrue( c.hasMinValue() ) self.assertTrue( c.hasMaxValue() ) self.assertEqual( c.minValue(), imath.V3f( -1, -2, -3 ) ) self.assertEqual( c.maxValue(), imath.V3f( 1, 2, 3 ) )
def testDuplicateDeserialise(self): s = Gaffer.ScriptNode() s["source"] = Gaffer.Node() s["source"]["p"] = Gaffer.V3fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["source"]["p"].setValue(imath.V3f(0.1, 0.2, 0.3)) s["dest"] = Gaffer.Node() s["dest"]["p"] = Gaffer.V3fPlug(flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic) s["e"] = Gaffer.Expression() s["e"].setExpression( "parent.dest.p.x = parent.source.p.x + 1;\n" + "parent.dest.p.y = parent.source.p.y + 2;\n" + "parent.dest.p.z = parent.source.p.z + 3;\n", "OSL", ) ss = s.serialise() s.execute(ss) s.execute(ss) self.assertEqual(s["dest"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3)) self.assertEqual(s["dest1"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3)) self.assertEqual(s["dest2"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3)) # Working well so far, but we've had a bug that could be hidden by the caching. Lets # try evaluating the plugs again, but flushing the cache each time Gaffer.ValuePlug.clearCache() self.assertEqual(s["dest"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3)) self.assertEqual(s["dest1"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3)) self.assertEqual(s["dest2"]["p"].getValue(), imath.V3f(1.1, 2.2, 3.3))
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.TranslateTool(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.translate(imath.V3f(0, 1, 0)) self.assertEqual(tool.handlesTransform(), imath.M44f().translate(imath.V3f(1, 1, 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, 1, 0)))
def testTypedValueFns(self): p = IECore.StringParameter(name="n", description="d", defaultValue="10") self.assertEqual(p.getTypedValue(), "10") p.setTypedValue("20") self.assertEqual(p.getTypedValue(), "20") self.assertEqual(p.typedDefaultValue, "10") self.assertRaises(AttributeError, setattr, p, "typedDefaultValue", "20") p = IECore.V3fParameter(name="n", description="d", defaultValue=imath.V3f(1, 2, 3)) self.assertEqual(p.getTypedValue(), imath.V3f(1, 2, 3)) p.setTypedValue(imath.V3f(12, 13, 14)) self.assertEqual(p.getTypedValue(), imath.V3f(12, 13, 14)) self.assertEqual(p.getValue(), IECore.V3fData(imath.V3f(12, 13, 14))) self.assertEqual(p.typedDefaultValue, imath.V3f(1, 2, 3)) self.assertRaises(AttributeError, setattr, p, "typedDefaultValue", imath.V3f(4, 5, 6))
def testParameterMinMaxMetadata( self ) : s = self.compileShader( os.path.dirname( __file__ ) + "/shaders/metadataMinMax.osl" ) n = GafferOSL.OSLShader() n.loadShader( s ) self.assertAlmostEqual( n["parameters"]["b"].minValue(), 2.3, delta = 0.00001 ) self.assertAlmostEqual( n["parameters"]["b"].maxValue(), 4.7, delta = 0.00001 ) self.assertEqual( n["parameters"]["c"].minValue(), 23 ) self.assertEqual( n["parameters"]["c"].maxValue(), 47 ) self.assertEqual( n["parameters"]["d"].minValue(), imath.Color3f( 1, 2, 3 ) ) self.assertEqual( n["parameters"]["d"].maxValue(), imath.Color3f( 4, 5, 6 ) ) self.assertEqual( n["parameters"]["e"].minValue(), imath.V3f( 1, 2, 3 ) ) self.assertEqual( n["parameters"]["e"].maxValue(), imath.V3f( 4, 5, 6 ) ) self.assertEqual( n["parameters"]["f"].minValue(), imath.V3f( 1, 2, 3 ) ) self.assertEqual( n["parameters"]["f"].maxValue(), imath.V3f( 4, 5, 6 ) ) self.assertEqual( n["parameters"]["g"].minValue(), imath.V3f( 1, 2, 3 ) ) self.assertEqual( n["parameters"]["g"].maxValue(), imath.V3f( 4, 5, 6 ) ) # Check default min/max if not specified self.assertFalse( n["parameters"]["h"].hasMinValue() ) self.assertFalse( n["parameters"]["h"].hasMaxValue() )
def testCompute(self): c = GafferScene.Cube() self.assertEqual(c["out"].object("/"), IECore.NullObject()) self.assertEqual(c["out"].transform("/"), imath.M44f()) self.assertEqual( c["out"].bound("/"), imath.Box3f(imath.V3f(-0.5, -0.5, -0.5), imath.V3f(0.5, 0.5, 0.5))) self.assertEqual(c["out"].childNames("/"), IECore.InternedStringVectorData(["cube"])) self.assertEqual( c["out"].object("/cube"), IECoreScene.MeshPrimitive.createBox( imath.Box3f(imath.V3f(-0.5), imath.V3f(0.5)))) self.assertEqual(c["out"].transform("/cube"), imath.M44f()) self.assertEqual( c["out"].bound("/cube"), imath.Box3f(imath.V3f(-0.5, -0.5, -0.5), imath.V3f(0.5, 0.5, 0.5))) self.assertEqual(c["out"].childNames("/cube"), IECore.InternedStringVectorData())
def testMotion(self): m1 = IECoreScene.MeshPrimitive.createPlane( imath.Box2f(imath.V2f(-1), imath.V2f(1))) IECoreScene.MeshNormalsOp()(input=m1, copyInput=False) m2 = m1.copy() m2["P"].data[0] -= imath.V3f(0, 0, 1) m2["P"].data[1] -= imath.V3f(0, 0, 1) IECoreScene.MeshNormalsOp()(input=m2, copyInput=False) with IECoreArnold.UniverseBlock(writable=True) as universe: node = IECoreArnold.NodeAlgo.convert([m1, m2], -0.25, 0.25, universe, "testMesh") vList = arnold.AiNodeGetArray(node, "vlist") self.assertEqual(arnold.AiArrayGetNumElements(vList.contents), 4) self.assertEqual(arnold.AiArrayGetNumKeys(vList.contents), 2) nList = arnold.AiNodeGetArray(node, "nlist") self.assertEqual(arnold.AiArrayGetNumElements(nList.contents), 4) self.assertEqual(arnold.AiArrayGetNumKeys(nList.contents), 2) for i in range(0, 4): p = arnold.AiArrayGetVec(vList, i) self.assertEqual(imath.V3f(p.x, p.y, p.z), m1["P"].data[i]) n = arnold.AiArrayGetVec(nList, i) self.assertEqual(imath.V3f(n.x, n.y, n.z), m1["N"].data[i]) for i in range(4, 8): p = arnold.AiArrayGetVec(vList, i) self.assertEqual(imath.V3f(p.x, p.y, p.z), m2["P"].data[i - 4]) n = arnold.AiArrayGetVec(nList, i) self.assertEqual(imath.V3f(n.x, n.y, n.z), m2["N"].data[i - 4]) self.assertEqual(arnold.AiNodeGetFlt(node, "motion_start"), -0.25) self.assertEqual(arnold.AiNodeGetFlt(node, "motion_end"), 0.25)
def makeTriangleScene(self): verticesPerFace = IECore.IntVectorData([3]) vertexIds = IECore.IntVectorData([0, 1, 2]) p = IECore.V3fVectorData( [imath.V3f(0, 0, 0), imath.V3f(1, 0, 0), imath.V3f(0, 1, 0)]) prefData = IECore.V3fVectorData( [imath.V3f(0, 0, 0), imath.V3f(0, -1, 0), imath.V3f(1, 0, 0)]) mesh = IECoreScene.MeshPrimitive(verticesPerFace, vertexIds, "linear", p) mesh["uv"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, IECore.V2fVectorData( [imath.V2f(0, 0), imath.V2f(1, 0), imath.V2f(0, 1)], IECore.GeometricData.Interpretation.UV)) mesh["foo"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, IECore.V2fVectorData( [imath.V2f(0, 0), imath.V2f(0, 1), imath.V2f(1, 0)], IECore.GeometricData.Interpretation.UV)) mesh["Pref"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, prefData) objectToScene = GafferScene.ObjectToScene() objectToScene["object"].setValue(mesh) return objectToScene
def testGeometricInterpretation( self ) : s = GafferScene.Sphere() p = GafferScene.PrimitiveVariables() p["in"].setInput( s["out"] ) p["primitiveVariables"].addMember( "myFirstData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Vector ) ) p["primitiveVariables"].addMember( "mySecondData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Normal ) ) p["primitiveVariables"].addMember( "myThirdData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Point ) ) o = p["out"].object( "/sphere" ) # test if the geometric interpretation makes it into the primitive variable self.assertEqual( o["myFirstData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector ) self.assertEqual( o["mySecondData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Normal ) self.assertEqual( o["myThirdData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point ) del o["myFirstData"] del o["mySecondData"] del o["myThirdData"] self.assertFalse( 'myFirstData' in o ) self.assertFalse( 'mySecondData' in o ) self.assertFalse( 'myThirdData' in o ) p["primitiveVariables"].addMember( "myFirstData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Point ) ) p["primitiveVariables"].addMember( "mySecondData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Vector ) ) p["primitiveVariables"].addMember( "myThirdData", IECore.V3fData( imath.V3f( 0 ), IECore.GeometricData.Interpretation.Normal ) ) o = p["out"].object( "/sphere" ) # test if the new geometric interpretation makes it into the primitive variable # this tests the hashing on the respective plugs self.assertEqual( o["myFirstData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point ) self.assertEqual( o["mySecondData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector ) self.assertEqual( o["myThirdData"].data.getInterpretation(), IECore.GeometricData.Interpretation.Normal )
def testSpaces(self): sphere = maya.cmds.polySphere(subdivisionsX=10, subdivisionsY=5, constructionHistory=False) maya.cmds.move(1, 2, 3, sphere) sphere = maya.cmds.listRelatives(sphere, shapes=True)[0] converter = IECoreMaya.FromMayaShapeConverter.create(sphere) self.assertEqual(converter["space"].getNumericValue(), IECoreMaya.FromMayaCurveConverter.Space.Object) m = converter.convert() self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f(imath.V3f(-1.0001), imath.V3f(1.0001)), m.bound())) converter["space"].setNumericValue( IECoreMaya.FromMayaShapeConverter.Space.World) m = converter.convert() self.assertTrue( imath.Box3f( imath.V3f(-1.0001) + imath.V3f(1, 2, 3), imath.V3f(1.0001) + imath.V3f(1, 2, 3)), m.bound())
def testSphere( self ) : m = IECoreScene.MeshPrimitive.createSphere( radius = 1, divisions = imath.V2i( 30, 40 ) ) self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ), m.bound() ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) me = IECoreScene.PrimitiveEvaluator.create( IECoreScene.MeshAlgo.triangulate( m ) ) mer = me.createResult() s = IECoreScene.SpherePrimitive( 1 ) se = IECoreScene.PrimitiveEvaluator.create( s ) ser = se.createResult() for s in range( 0, 100 ) : for t in range( 0, 100 ) : uv = imath.V2f( s / 100.0, t / 100.0 ) if not me.pointAtUV( uv, mer ) : # Not all UV coordinates are covered, # due to the row of triangles at the # poles. continue self.assertTrue( se.pointAtUV( uv, ser ) ) self.assertTrue( mer.point().equalWithAbsError( ser.point(), 1e-2 ) ) # test divisions m = IECoreScene.MeshPrimitive.createSphere( radius = 1, divisions = imath.V2i( 300, 300 ) ) self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ), m.bound() ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) me = IECoreScene.PrimitiveEvaluator.create( IECoreScene.MeshAlgo.triangulate( m ) ) mer = me.createResult() for s in range( 0, 100 ) : for t in range( 0, 100 ) : uv = imath.V2f( s / 100.0, t / 100.0 ) if not me.pointAtUV( uv, mer ) : # Not all UV coordinates are covered, # due to the row of triangles at the # poles. continue self.assertTrue( se.pointAtUV( uv, ser ) ) # more divisions means points are closer to ground truth self.assertTrue( mer.point().equalWithAbsError( ser.point(), 1e-4 ) ) # test radius m = IECoreScene.MeshPrimitive.createSphere( radius = 2, divisions = imath.V2i( 30, 40 ) ) self.assertFalse( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ), m.bound() ) ) self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -2 ), imath.V3f( 2 ) ), m.bound() ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) me = IECoreScene.PrimitiveEvaluator.create( IECoreScene.MeshAlgo.triangulate( m ) ) mer = me.createResult() s = IECoreScene.SpherePrimitive( 2 ) se = IECoreScene.PrimitiveEvaluator.create( s ) ser = se.createResult() for s in range( 0, 100 ) : for t in range( 0, 100 ) : uv = imath.V2f( s / 100.0, t / 100.0 ) if not me.pointAtUV( uv, mer ) : # Not all UV coordinates are covered, # due to the row of triangles at the # poles. continue self.assertTrue( se.pointAtUV( uv, ser ) ) self.assertTrue( mer.point().equalWithAbsError( ser.point(), 1e-2 ) ) # test zMin/zMax m = IECoreScene.MeshPrimitive.createSphere( radius = 1, zMin = -0.75, zMax = 0.75 ) self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -1, -1, -0.75 ), imath.V3f( 1, 1, 0.75 ) ), m.bound() ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) # test thetaMax m = IECoreScene.MeshPrimitive.createSphere( radius = 1, thetaMax = 300 ) self.assertTrue( IECore.BoxAlgo.contains( imath.Box3f( imath.V3f( -1 ), imath.V3f( 1 ) ), m.bound() ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) m2 = IECoreScene.MeshPrimitive.createSphere( radius = 1 ) self.assertTrue( m.numFaces() < m2.numFaces() )
def testPlane( self ) : m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 1 ) ) ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Constant ), 1 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Uniform ), 1 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ), 4 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Varying ), 4 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ), 4 ) self.assertEqual( m.numFaces(), 1 ) self.assertEqual( m.verticesPerFace, IECore.IntVectorData( [ 4 ] ) ) self.assertEqual( m.vertexIds, IECore.IntVectorData( [ 0, 1, 3, 2 ] ) ) self.assertEqual( m.bound(), imath.Box3f( imath.V3f( 0 ), imath.V3f( 1, 1, 0 ) ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) # verify uvs self.assertEqual( m["uv"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ) self.assertEqual( len( m["uv"].data ), len( m["P"].data ) ) self.assertEqual( m["uv"].indices, m.vertexIds ) # verify uvs self.assertEqual( m["N"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( len( m["N"].data ), len( m["P"].data ) ) self.assertEqual( m["N"].data, IECore.V3fVectorData( [ imath.V3f( 0, 0, 1 ) ] * len( m["P"].data ), IECore.GeometricData.Interpretation.Normal ) ) e = IECoreScene.MeshPrimitiveEvaluator( IECoreScene.MeshAlgo.triangulate( m ) ) r = e.createResult() self.assertTrue( e.pointAtUV( imath.V2f( 0, 0 ), r ) ) self.assertEqual( r.point(), m["P"].data[0] ) self.assertEqual( r.point(), imath.V3f( 0, 0, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 1, 0 ), r ) ) self.assertEqual( r.point(), m["P"].data[1] ) self.assertEqual( r.point(), imath.V3f( 1, 0, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 1, 1 ), r ) ) self.assertEqual( r.point(), m["P"].data[3] ) self.assertEqual( r.point(), imath.V3f( 1, 1, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 0, 1 ), r ) ) self.assertEqual( r.point(), m["P"].data[2] ) self.assertEqual( r.point(), imath.V3f( 0, 1, 0 ) ) # test divisions m = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 1 ) ), divisions = imath.V2i( 2, 3 ) ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Constant ), 1 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Uniform ), 6 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ), 12 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Varying ), 12 ) self.assertEqual( m.variableSize( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ), 24 ) self.assertEqual( m.numFaces(), 6 ) self.assertEqual( m.verticesPerFace, IECore.IntVectorData( [ 4 ] * 6 ) ) self.assertEqual( m.vertexIds, IECore.IntVectorData( [ 0, 1, 4, 3, 1, 2, 5, 4, 3, 4, 7, 6, 4, 5, 8, 7, 6, 7, 10, 9, 7, 8, 11, 10 ] ) ) self.assertEqual( m.bound(), imath.Box3f( imath.V3f( 0 ), imath.V3f( 1, 1, 0 ) ) ) self.assertTrue( m.arePrimitiveVariablesValid() ) # corners still have correct uvs e = IECoreScene.MeshPrimitiveEvaluator( IECoreScene.MeshAlgo.triangulate( m ) ) r = e.createResult() self.assertTrue( e.pointAtUV( imath.V2f( 0, 0 ), r ) ) self.assertEqual( r.point(), m["P"].data[0] ) self.assertEqual( r.point(), imath.V3f( 0, 0, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 1, 0 ), r ) ) self.assertEqual( r.point(), m["P"].data[2] ) self.assertEqual( r.point(), imath.V3f( 1, 0, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 1, 1 ), r ) ) self.assertEqual( r.point(), m["P"].data[11] ) self.assertEqual( r.point(), imath.V3f( 1, 1, 0 ) ) self.assertTrue( e.pointAtUV( imath.V2f( 0, 1 ), r ) ) self.assertEqual( r.point(), m["P"].data[9] ) self.assertEqual( r.point(), imath.V3f( 0, 1, 0 ) )
def testDetailAttributes(self): attr = self.testSetupAttributes() attr.parm("class").set(0) # detail attribute result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() attr.parm("value1").set(123.456) self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.FloatData) self.assert_(result["test_attribute"].data > IECore.FloatData(123.0)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # integer result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.IntData) self.assertEqual(result["test_attribute"].data, IECore.IntData(123)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(0) # float attr.parm("size").set(2) # 2 elementS attr.parm("value2").set(456.789) result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V2fData) self.assertEqual(result["test_attribute"].data.value, imath.V2f(123.456, 456.789)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # int result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V2iData) self.assertEqual(result["test_attribute"].data.value, imath.V2i(123, 456)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(0) # float attr.parm("size").set(3) # 3 elements attr.parm("value3").set(999.999) result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V3fData) self.assertEqual(result["test_attribute"].data.value, imath.V3f(123.456, 456.789, 999.999)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # int result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V3iData) self.assertEqual(result["test_attribute"].data.value, imath.V3i(123, 456, 999)) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(3) # string attr.parm("string").set("string!") result = IECoreHoudini.FromHoudiniPointsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.StringData) self.assertEqual(result["test_attribute"].data.value, "string!") self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant) self.assert_(result.arePrimitiveVariablesValid())
def testPointAttributes(self): attr = self.testSetupAttributes() result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() attr.parm("value1").set(123.456) self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.FloatVectorData) self.assert_(result["test_attribute"].data[0] > 123.0) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # integer result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.IntVectorData) self.assertEqual(result["test_attribute"].data[0], 123) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(0) # float attr.parm("size").set(2) # 2 elementS attr.parm("value2").set(456.789) result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V2fVectorData) self.assertEqual(result["test_attribute"].data[0], imath.V2f(123.456, 456.789)) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # int result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V2iVectorData) self.assertEqual(result["test_attribute"].data[0], imath.V2i(123, 456)) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(0) # float attr.parm("size").set(3) # 3 elements attr.parm("value3").set(999.999) result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V3fVectorData) self.assertEqual(result["test_attribute"].data[0], imath.V3f(123.456, 456.789, 999.999)) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(1) # int result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.V3iVectorData) self.assertEqual(result["test_attribute"].data[0], imath.V3i(123, 456, 999)) self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assert_(result.arePrimitiveVariablesValid()) attr.parm("type").set(3) # string attr.parm("string").setExpression( "'string %06d!' % pwd().curPoint().number()", hou.exprLanguage.Python) result = IECoreHoudini.FromHoudiniPointsConverter(attr).convert() self.assertEqual(result["test_attribute"].data.typeId(), IECore.TypeId.StringVectorData) self.assertEqual(result["test_attribute"].data[10], "string 000010!") self.assertEqual(result["test_attribute"].data.size(), 100) self.assertEqual(result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Vertex) self.assertEqual(result["test_attribute"].indices[10], 10) self.assertEqual(result["test_attribute"].indices.size(), 100) self.assert_(result.arePrimitiveVariablesValid())
def testFilter(self): p1 = GafferScene.Plane() p1["transform"]["translate"].setValue(imath.V3f(1, 2, 3)) p2 = GafferScene.Plane() p2["transform"]["translate"].setValue(imath.V3f(1, 2, 3)) g = GafferScene.Group() g["transform"]["translate"].setValue(imath.V3f(1, 0, 0)) g["in"][0].setInput(p1["out"]) g["in"][1].setInput(p2["out"]) f = GafferScene.PathFilter() f["paths"].setValue(IECore.StringVectorData(["/group/plane"])) t = GafferScene.FreezeTransform() t["in"].setInput(g["out"]) t["filter"].setInput(f["out"]) self.assertSceneValid(t["out"]) self.assertEqual(t["out"].transform("/group"), imath.M44f().translate(imath.V3f(1, 0, 0))) self.assertEqual(t["out"].transform("/group/plane"), imath.M44f()) self.assertEqual(t["out"].transform("/group/plane1"), imath.M44f().translate(imath.V3f(1, 2, 3))) self.assertEqual( t["out"].bound("/group/plane"), imath.Box3f(imath.V3f(0.5, 1.5, 3), imath.V3f(1.5, 2.5, 3))) self.assertEqual( t["out"].bound("/group/plane1"), imath.Box3f(imath.V3f(-0.5, -0.5, 0), imath.V3f(0.5, 0.5, 0))) self.assertEqual( t["out"].object("/group/plane").bound(), imath.Box3f(imath.V3f(0.5, 1.5, 3), imath.V3f(1.5, 2.5, 3))) self.assertEqual( t["out"].object("/group/plane1").bound(), imath.Box3f(imath.V3f(-0.5, -0.5, 0), imath.V3f(0.5, 0.5, 0))) f["paths"].setValue(IECore.StringVectorData(["/group", "/group/plane"])) self.assertSceneValid(t["out"]) self.assertEqual(t["out"].transform("/group"), imath.M44f()) self.assertEqual(t["out"].transform("/group/plane"), imath.M44f()) self.assertEqual(t["out"].transform("/group/plane1"), imath.M44f().translate(imath.V3f(1, 2, 3))) self.assertEqual( t["out"].bound("/group/plane"), imath.Box3f(imath.V3f(1.5, 1.5, 3), imath.V3f(2.5, 2.5, 3))) self.assertEqual( t["out"].bound("/group/plane1"), imath.Box3f(imath.V3f(0.5, -0.5, 0), imath.V3f(1.5, 0.5, 0)))
def __frame(self, nodes, extend=False, at=None): graphGadget = self.graphGadget() # get the bounds of the nodes bound = imath.Box3f() for node in nodes: nodeGadget = graphGadget.nodeGadget(node) if nodeGadget: bound.extendBy(nodeGadget.transformedBound(graphGadget)) # if there were no nodes then use the bound of the whole # graph. if bound.isEmpty(): bound = graphGadget.bound() # if there's still nothing then an arbitrary area in the centre of the world if bound.isEmpty(): bound = imath.Box3f(imath.V3f(-10, -10, 0), imath.V3f(10, 10, 0)) # pad it a little bit so # it sits nicer in the frame bound.setMin(bound.min() - imath.V3f(1, 1, 0)) bound.setMax(bound.max() + imath.V3f(1, 1, 0)) if extend: # we're extending the existing framing, which we assume the # user was happy with other than it not showing the nodes in question. # so we just take the union of the existing frame and the one for the nodes. cb = self.__currentFrame() bound.extendBy( imath.Box3f(imath.V3f(cb.min().x, cb.min().y, 0), imath.V3f(cb.max().x, cb.max().y, 0))) else: # we're reframing from scratch, so the frame for the nodes is all we need. # we do however want to make sure that we don't zoom in too far if the node # bounds are small, as having a single node filling the screen is of little use - # it's better to see some context around it. boundSize = bound.size() widgetSize = imath.V3f(self._qtWidget().width(), self._qtWidget().height(), 0) pixelsPerUnit = min(widgetSize.x / boundSize.x, widgetSize.y / boundSize.y) adjustedPixelsPerUnit = min(pixelsPerUnit, 10) newBoundSize = widgetSize / adjustedPixelsPerUnit boundCenter = bound.center() bound.setMin(boundCenter - newBoundSize / 2.0) bound.setMax(boundCenter + newBoundSize / 2.0) if at is not None: viewport = self.graphGadgetWidget().getViewportGadget() offset = viewport.rasterToGadgetSpace( imath.V2f(self.bound().size() / 2), graphGadget).p0 - viewport.rasterToGadgetSpace( at, graphGadget).p0 bound.setMin(bound.min() + offset) bound.setMax(bound.max() + offset) self.__gadgetWidget.getViewportGadget().frame(bound)
def test(self): targetTranslate = imath.V3f(1, 2, 3) constrainedTranslate = imath.V3f(10, 11, 12) constrainedScale = imath.V3f(1, 2, 3) constrainedRotate = imath.V3f(15, 45, 19) plane1 = GafferScene.Plane() plane1["transform"]["translate"].setValue(targetTranslate) plane1["transform"]["scale"].setValue(imath.V3f(1, 2, 3)) plane1["transform"]["rotate"].setValue(imath.V3f( 1000, 20, 39)) # shouldn't affect the result plane1["name"].setValue("target") plane2 = GafferScene.Plane() plane2["transform"]["translate"].setValue(constrainedTranslate) plane2["transform"]["scale"].setValue(constrainedScale) plane2["transform"]["rotate"].setValue(constrainedRotate) plane2["name"].setValue("constrained") group = GafferScene.Group() group["in"][0].setInput(plane1["out"]) group["in"][1].setInput(plane2["out"]) self.assertSceneValid(group["out"]) constraint = GafferScene.PointConstraint() constraint["target"].setValue("/group/target") constraint["in"].setInput(group["out"]) filter = GafferScene.PathFilter() filter["paths"].setValue( IECore.StringVectorData(["/group/constrained"])) constraint["filter"].setInput(filter["out"]) self.assertSceneValid(constraint["out"]) self.assertEqual( group["out"].fullTransform("/group/target").translation(), targetTranslate) self.assertEqual( group["out"].fullTransform("/group/constrained").translation(), constrainedTranslate) self.assertEqual( constraint["out"].fullTransform("/group/target").translation(), targetTranslate) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation(), targetTranslate) beforeS, beforeH, beforeR, beforeT = imath.V3f(), imath.V3f( ), imath.V3f(), imath.V3f() group["out"].fullTransform("/group/constrained").extractSHRT( beforeS, beforeH, beforeR, beforeT) afterS, afterH, afterR, afterT = imath.V3f(), imath.V3f(), imath.V3f( ), imath.V3f() constraint["out"].fullTransform("/group/constrained").extractSHRT( afterS, afterH, afterR, afterT) self.assertEqual(beforeS, afterS) self.assertEqual(beforeH, afterH) self.assertEqual(beforeR, afterR) constraint["xEnabled"].setValue(False) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().x, constrainedTranslate.x) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().y, targetTranslate.y) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().z, targetTranslate.z) constraint["yEnabled"].setValue(False) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().x, constrainedTranslate.x) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().y, constrainedTranslate.y) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().z, targetTranslate.z) constraint["zEnabled"].setValue(False) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().x, constrainedTranslate.x) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().y, constrainedTranslate.y) self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation().z, constrainedTranslate.z) # Test behaviour for missing target plane1["name"].setValue("targetX") constraint["xEnabled"].setValue(True) constraint["yEnabled"].setValue(True) constraint["zEnabled"].setValue(True) with six.assertRaisesRegex( self, RuntimeError, 'PointConstraint.out.transform : Constraint target does not exist: "/group/target"' ): constraint["out"].fullTransform("/group/constrained") constraint["ignoreMissingTarget"].setValue(True) self.assertEqual(constraint["out"].fullTransform("/group/constrained"), constraint["in"].fullTransform("/group/constrained")) # Constrain to root constraint["target"].setValue("/") self.assertEqual( constraint["out"].fullTransform( "/group/constrained").translation(), imath.V3f(0)) # No op constraint["target"].setValue("") self.assertEqual(constraint["out"].fullTransform("/group/constrained"), constraint["in"].fullTransform("/group/constrained"))
def testLength( self ) : l = IECore.LineSegment3f( imath.V3f( 1 ), imath.V3f( 2 ) ) self.assertEqual( l.length(), imath.V3f( 1 ).length() ) self.assertEqual( l.length2(), imath.V3f( 1 ).length2() )
def testClosestPoints( self ) : r = imath.Rand32( 100 ) for i in range( 0, 1000 ) : x = r.nextf( -10, 10 ) y = r.nextf( -10, 10 ) z1 = r.nextf( -10, 10 ) z2 = r.nextf( -10, 10 ) l1 = IECore.LineSegment3f( imath.V3f( -10, y, z1 ), imath.V3f( 10, y, z1 ) ) l2 = IECore.LineSegment3f( imath.V3f( x, -10, z2 ), imath.V3f( x, 10, z2 ) ) p1, p2 = l1.closestPoints( l2 ) p3, p4 = l2.closestPoints( l1 ) self.assert_( p1.equalWithAbsError( p4, 0.00001 ) ) self.assert_( p2.equalWithAbsError( p3, 0.00001 ) ) # | # | # | ------ # | # | l1 = IECore.LineSegment3f( imath.V3f( 0, 0, 0 ), imath.V3f( 0, 2, 0 ) ) l2 = IECore.LineSegment3f( imath.V3f( 1, 1, 0 ), imath.V3f( 3, 1, 0 ) ) p1, p2 = l1.closestPoints( l2 ) p3, p4 = l2.closestPoints( l1 ) self.assertEqual( p1, p4 ) self.assertEqual( p2, p3 ) self.assertEqual( p1, imath.V3f( 0, 1, 0 ) ) self.assertEqual( p2, imath.V3f( 1, 1, 0 ) ) # \ # \ # # / # / l1 = IECore.LineSegment3f( imath.V3f( 0, 0, 0 ), imath.V3f( 2, 2, 0 ) ) l2 = IECore.LineSegment3f( imath.V3f( 0, 5, 0 ), imath.V3f( 2, 3, 0 ) ) p1, p2 = l1.closestPoints( l2 ) p3, p4 = l2.closestPoints( l1 ) self.assertEqual( p1, p4 ) self.assertEqual( p2, p3 ) self.assertEqual( p1, imath.V3f( 2, 2, 0 ) ) self.assertEqual( p2, imath.V3f( 2, 3, 0 ) )
def testEditSubdivisionAttributes(self): script = Gaffer.ScriptNode() script["cube"] = GafferScene.Cube() script["cube"]["dimensions"].setValue(imath.V3f(2)) script["meshType"] = GafferScene.MeshType() script["meshType"]["in"].setInput(script["cube"]["out"]) script["meshType"]["meshType"].setValue("catmullClark") script["attributes"] = GafferArnold.ArnoldAttributes() script["attributes"]["in"].setInput(script["meshType"]["out"]) script["attributes"]["attributes"]["subdivIterations"][ "enabled"].setValue(True) script["catalogue"] = GafferImage.Catalogue() script["outputs"] = GafferScene.Outputs() script["outputs"].addOutput( "beauty", IECoreScene.Output( "test", "ieDisplay", "rgba", { "driverType": "ClientDisplayDriver", "displayHost": "localhost", "displayPort": str(script['catalogue'].displayDriverServer().portNumber() ), "remoteDisplayType": "GafferImage::GafferDisplayDriver", })) script["outputs"]["in"].setInput(script["attributes"]["out"]) script["imageStats"] = GafferImage.ImageStats() script["imageStats"]["in"].setInput(script["catalogue"]["out"]) script["imageStats"]["channels"].setValue( IECore.StringVectorData(["R", "G", "B", "A"])) script["imageStats"]["area"].setValue( imath.Box2i(imath.V2i(0), imath.V2i(640, 480))) script["options"] = GafferScene.StandardOptions() script["options"]["in"].setInput(script["outputs"]["out"]) script["options"]["options"]["filmFit"]["enabled"].setValue(True) script["options"]["options"]["filmFit"]["value"].setValue( IECoreScene.Camera.FilmFit.Fit) script["render"] = self._createInteractiveRender() script["render"]["in"].setInput(script["options"]["out"]) # Render the cube with one level of subdivision. Check we get roughly the # alpha coverage we expect. script["render"]["state"].setValue(script["render"].State.Running) self.uiThreadCallHandler.waitFor(1) self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(), 0.381, delta=0.001) # Now up the number of subdivision levels. The alpha coverage should # increase as the shape tends towards the limit surface. script["attributes"]["attributes"]["subdivIterations"][ "value"].setValue(4) self.uiThreadCallHandler.waitFor(1) self.assertAlmostEqual(script["imageStats"]["average"][3].getValue(), 0.424, delta=0.001) script["render"]["state"].setValue(script["render"].State.Stopped)