def doOperation(self, args):
assert args["a"].value == 10
assert abs(args["b"].value - 20.2) < 0.0001
assert args["c"].value == 40.5
assert args["d"].value == "hello"
assert args["e"] == IECore.IntVectorData([2, 4, 5])
assert args["f"] == IECore.StringVectorData([
"one", "two", "three", "-1", "-dash", "\\-slashDash",
"\\\\-slashSlashDash", "inline-dash"
])
assert args["g"] == IECore.V2fData(imath.V2f(2, 4))
assert args["h"] == IECore.V3fData(imath.V3f(1, 4, 8))
assert args["i"] == IECore.V2dData(imath.V2d(2, 4))
assert args["compound"]["j"] == IECore.V3dData(imath.V3d(1, 4, 8))
assert args["compound"]["k"] == IECore.M44fData(
imath.M44f(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
assert args["l"] == IECore.Color3fData(imath.Color3f(1, 0, 0))
assert args["m"] == IECore.Color4fData(imath.Color4f(1, 1, 0, 1))
assert args["o"] == IECore.StringData("myFile.tif")
assert args["p"] == IECore.StringData("test")
assert args["q"] == IECore.BoolData(True)
assert args["r"] == IECore.StringData("mySequence.####.tif")
assert args["s"] == IECore.Box2dData(
imath.Box2d(imath.V2d(-1, -2), imath.V2d(10, 20)))
assert args["t"] == IECore.Box3fData(
imath.Box3f(imath.V3f(-1, -2, -3), imath.V3f(10, 20, 30)))
assert args["u"] == IECore.V2iData(imath.V2i(64, 128))
assert args["v"] == IECore.V3iData(imath.V3i(25, 26, 27))
assert self["w"].getFrameListValue().asList() == IECore.FrameRange(
0, 500, 250).asList()
assert args["x"] == IECore.TransformationMatrixfData()
assert args["y"] == IECore.TransformationMatrixdData()
return IECore.IntData(1)
def testSerialisationOnlyUsesDataWhenNecessary( self ) : s = Gaffer.ScriptNode() s["n"] = Gaffer.Node() s["n"]["p"] = Gaffer.Plug( flags = Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic ) for value in [ "s", 1, 2.0, True, imath.Color3f( 0 ), imath.V2f( 0 ), imath.V2i( 0 ), imath.V3i( 0 ), IECore.StringVectorData( [ "one", "two" ] ), IECore.IntVectorData( [ 1, 2, 3 ] ), ] : Gaffer.Metadata.registerValue( s["n"], "test", value ) Gaffer.Metadata.registerValue( s["n"]["p"], "test", value ) self.assertEqual( Gaffer.Metadata.value( s["n"], "test" ), value ) self.assertEqual( Gaffer.Metadata.value( s["n"]["p"], "test" ), value ) ss = s.serialise() if not isinstance( value, IECore.Data ) : self.assertTrue( "Data" not in ss ) s2 = Gaffer.ScriptNode() s2.execute( ss ) self.assertEqual( Gaffer.Metadata.value( s2["n"], "test" ), value ) self.assertEqual( Gaffer.Metadata.value( s2["n"]["p"], "test" ), value )
def testConstantPrimVarTemporarilyOverridesShaderParameter(self):
c1 = IECoreScene.Group()
c1.addChild(self.mesh())
c1.addState(self.colorShader())
c2 = c1.copy()
c1.state()[0].parameters["rgbF"] = IECore.V3iData(imath.V3i(0, 1, 1))
c1.children()[0]["rgbF"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Constant,
IECore.V3fData(imath.V3f(1, 1, 0)))
c1.setTransform(
IECoreScene.MatrixTransform(imath.M44f().translate(
imath.V3f(0.2, 0, 0))))
c2.setTransform(
IECoreScene.MatrixTransform(imath.M44f().translate(
imath.V3f(-0.2, 0, 0))))
g = IECoreScene.Group()
g.addChild(c1)
g.addChild(c2)
image = self.renderImage(g)
self.assertImageValues(image, [
(imath.V2f(0.7, 0.5), imath.Color4f(1, 1, 0, 1)),
(imath.V2f(0.3, 0.5), imath.Color4f(0, 0, 0, 1)),
])
def testCanReadV3iArrayUserData(self):
s = self.compileShader(
os.path.dirname(__file__) + "/shaders/V3iArrayAttributeRead.osl")
e = GafferOSL.ShadingEngine(
IECore.ObjectVector([IECoreScene.Shader(s, "osl:surface")]))
p = self.rectanglePoints()
numPoints = len(p["P"])
p["v3i"] = IECore.V3iVectorData(numPoints)
for i in range(numPoints):
p["v3i"][i] = imath.V3i([i, i + 1, i + 2])
r = e.shade(p)
for i, c in enumerate(r["Ci"]):
if i < 50:
expected = imath.Color3f(0.0, i / 100.0, i / 200.0)
else:
expected = imath.Color3f(1.0, 0.0, 0.0)
self.assertEqual(c, expected)
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.assertTrue( result["test_attribute"].data > IECore.FloatData( 123.0 ) )
self.assertEqual( result["test_attribute"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.Constant )
self.assertTrue( 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.assertTrue( 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.assertTrue( 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.assertTrue( 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.assertTrue( 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.assertTrue( 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.assertTrue( result.arePrimitiveVariablesValid() )
def testCube(self):
m = IECore.Reader.create(
"test/IECore/data/cobFiles/pCubeShape1.cob").read()
op = IECoreScene.MeshVertexReorderOp()
result = op(input=m, startingVertices=imath.V3i(0, 1, 3))
self.assert_(result.arePrimitiveVariablesValid())
def testBoxTypes(self):
p = Gaffer.CompoundDataPlug()
for name, value in [
("b2f",
IECore.Box2fData(imath.Box2f(imath.V2f(0, 1), imath.V2f(1, 2)))),
("b2i",
IECore.Box2iData(imath.Box2i(imath.V2i(-1, 10), imath.V2i(11,
20)))),
("b3f",
IECore.Box3fData(
imath.Box3f(imath.V3f(0, 1, 2), imath.V3f(3, 4, 5)))),
("b3i",
IECore.Box3iData(
imath.Box3i(imath.V3i(0, 1, 2), imath.V3i(3, 4, 5)))),
]:
p.addChild(Gaffer.NameValuePlug(name, value))
self.assertEqual(p.memberDataAndName(p[-1]), (value, name))
def testInterleaveIntoV3( self ) : i = IECore.ObjectVector( [ IECore.IntVectorData( [ 1, 2 ] ), IECore.IntVectorData( [ 11, 12 ] ), IECore.IntVectorData( [ 21, 22 ] ), ] ) o = IECore.DataInterleaveOp()( data=i, targetType = IECore.V3iVectorData.staticTypeId() ) self.assertEqual( o, IECore.V3iVectorData( [ imath.V3i( 1, 11, 21 ), imath.V3i( 2, 12, 22 ), ] ) )
def testVectorIntData( self ) : with IECoreArnold.UniverseBlock( writable = True ) as universe : n = arnold.AiNode( universe, "standard_surface" ) IECoreArnold.ParameterAlgo.setParameter( n, "customV2i", IECore.V2iData( imath.V2i( 3, 4 ) ) ) self.assertEqual( arnold.AiNodeGetVec2( n, "customV2i" ), arnold.AtVector2( 3, 4 ) ) IECoreArnold.ParameterAlgo.setParameter( n, "customV3i", IECore.V3iData( imath.V3i( 3, 4, 5 ) ) ) self.assertEqual( arnold.AiNodeGetVec( n, "customV3i" ), arnold.AtVector( 3, 4, 5 ) )
def testDefaultValueSerialisation(self):
s = Gaffer.ScriptNode()
s["s"] = Gaffer.Spreadsheet()
s["s"]["rows"].addColumn(
Gaffer.V3iPlug("c1", defaultValue=imath.V3i(1, 2, 3)))
s["s"]["rows"].addColumn(
Gaffer.Box2iPlug("c2",
defaultValue=imath.Box2i(imath.V2i(0),
imath.V2i(1))))
s["s"]["rows"].addRows(3)
# Change defaults for some plugs
s["s"]["rows"][1]["name"].setValue("testName")
s["s"]["rows"][1]["cells"]["c1"]["value"].setValue(imath.V3i(4, 5, 6))
s["s"]["rows"][2]["enabled"].setValue(False)
s["s"]["rows"][2]["cells"]["c1"]["value"]["x"].setValue(10)
s["s"]["rows"][3]["cells"]["c1"]["enabled"].setValue(False)
s["s"]["rows"][3]["cells"]["c2"]["value"].setValue(
imath.Box2i(imath.V2i(10), imath.V2i(11)))
s["s"]["rows"][1]["name"].resetDefault()
# Change values for some plugs, some of which also had their
# defaults changed.
s["s"]["rows"][1]["name"].setValue("testName2")
s["s"]["rows"][1]["cells"]["c1"]["value"]["x"].setValue(7)
s["s"]["rows"][3]["enabled"].setValue(False)
# Check that everything round-trips correctly through a serialisation and load.
s2 = Gaffer.ScriptNode()
s2.execute(s.serialise())
self.assertEqual(s["s"]["rows"].defaultHash(),
s2["s"]["rows"].defaultHash())
self.assertEqual(s["s"]["rows"].hash(), s2["s"]["rows"].hash())
def testCanReadDoubleMetadata(self):
sourcePath = os.path.join(self.dataDir, "sphere.vdb")
vdb = IECoreVDB.VDBObject(sourcePath)
grid = vdb.findGrid("ls_sphere")
grid.updateMetadata({"test": 0.0})
vdb.insertGrid(grid)
metadata = vdb.metadata("ls_sphere")
# skip the file size
del metadata['file_mem_bytes']
expected = IECore.CompoundObject({
'name':
IECore.StringData('ls_sphere'),
'file_voxel_count':
IECore.Int64Data(270638),
'file_bbox_min':
IECore.V3iData(imath.V3i(-62, -62, -62)),
'file_bbox_max':
IECore.V3iData(imath.V3i(62, 62, 62)),
'is_local_space':
IECore.BoolData(0),
'is_saved_as_half_float':
IECore.BoolData(1),
'value_type':
IECore.StringData('float'),
'class':
IECore.StringData('level set'),
#'file_mem_bytes': IECore.Int64Data( 2643448 ),
'vector_type':
IECore.StringData('invariant'),
'test':
IECore.DoubleData(0.0)
})
self.assertEqual(metadata, expected)
def testValueTypes( self ) : for v in [ IECore.FloatVectorData( [ 1, 2, 3 ] ), IECore.IntVectorData( [ 1, 2, 3 ] ), IECore.StringVectorData( [ "1", "2", "3" ] ), IECore.V3fVectorData( [ imath.V3f( x ) for x in range( 1, 5 ) ] ), IECore.Color3fVectorData( [ imath.Color3f( x ) for x in range( 1, 5 ) ] ), IECore.M44fVectorData( [ imath.M44f() * x for x in range( 1, 5 ) ] ), IECore.V2iVectorData( [ imath.V2i( x ) for x in range( 1, 5 ) ] ), IECore.V3fData( imath.V3f( 1, 2, 3 ) ), IECore.V2fData( imath.V2f( 1, 2 ) ), IECore.M44fData( imath.M44f( *range(16) ) ), IECore.Box2fData( imath.Box2f( imath.V2f( 0, 1 ), imath.V2f( 1, 2 ) ) ), IECore.Box2iData( imath.Box2i( imath.V2i( -1, 10 ), imath.V2i( 11, 20 ) ) ), IECore.Box3fData( imath.Box3f( imath.V3f( 0, 1, 2 ), imath.V3f( 3, 4, 5 ) ) ), IECore.Box3iData( imath.Box3i( imath.V3i( 0, 1, 2 ), imath.V3i( 3, 4, 5 ) ) ), IECore.InternedStringVectorData( [ "a", "b" ] ) ]: if 'value' in dir( v ): expected = v.value else: expected = v self.assertEqual( expected, Gaffer.NameValuePlug( "test", v )["value"].getValue() )
def testSphere(self):
m = IECore.Reader.create(
"test/IECore/data/cobFiles/pSphereShape1.cob").read()
op = IECoreScene.MeshVertexReorderOp()
result = op(input=m, startingVertices=imath.V3i(20, 1, 21))
self.assert_(result.arePrimitiveVariablesValid())
expected = IECore.Reader.create(
"test/IECore/data/expectedResults/meshVertexReorderSphere.cob"
).read()
self.assertEqual(result, expected)
def testConstructors(self):
"""Test V2f constructors"""
v = imath.V2f()
v = imath.V2f(1)
self.assertEqual(v.x, 1)
self.assertEqual(v.y, 1)
v = imath.V2f(2, 3)
self.assertEqual(v.x, 2)
self.assertEqual(v.y, 3)
self.assertEqual(imath.V2f(imath.V2i(1, 2)), imath.V2f(1, 2))
self.assertEqual(imath.V2f(imath.V2f(1, 2)), imath.V2f(1, 2))
self.assertEqual(imath.V2f(imath.V2d(1, 2)), imath.V2f(1, 2))
self.assertEqual(imath.V2d(imath.V2i(1, 2)), imath.V2d(1, 2))
self.assertEqual(imath.V2d(imath.V2f(1, 2)), imath.V2d(1, 2))
self.assertEqual(imath.V2d(imath.V2d(1, 2)), imath.V2d(1, 2))
self.assertEqual(imath.V2i(imath.V2i(1, 2)), imath.V2i(1, 2))
self.assertEqual(imath.V2i(imath.V2f(1, 2)), imath.V2i(1, 2))
self.assertEqual(imath.V2i(imath.V2d(1, 2)), imath.V2i(1, 2))
self.assertEqual(imath.V3f(imath.V3i(1, 2, 3)), imath.V3f(1, 2, 3))
self.assertEqual(imath.V3f(imath.V3f(1, 2, 3)), imath.V3f(1, 2, 3))
self.assertEqual(imath.V3f(imath.V3d(1, 2, 3)), imath.V3f(1, 2, 3))
self.assertEqual(imath.V3d(imath.V3i(1, 2, 3)), imath.V3d(1, 2, 3))
self.assertEqual(imath.V3d(imath.V3f(1, 2, 3)), imath.V3d(1, 2, 3))
self.assertEqual(imath.V3d(imath.V3d(1, 2, 3)), imath.V3d(1, 2, 3))
self.assertEqual(imath.V3i(imath.V3i(1, 2, 3)), imath.V3i(1, 2, 3))
self.assertEqual(imath.V3i(imath.V3f(1, 2, 3)), imath.V3i(1, 2, 3))
self.assertEqual(imath.V3i(imath.V3d(1, 2, 3)), imath.V3i(1, 2, 3))
v = imath.V2f([1, 1])
self.assertEqual(v.x, 1)
self.assertEqual(v.y, 1)
self.assertRaises(RuntimeError, imath.V2f, [1])
self.assertRaises(RuntimeError, imath.V2f, [1, 2, 3])
def test(self):
for v in [
imath.V2i(1),
imath.V2f(1),
imath.V2d(1.5),
imath.V3i(1),
imath.V3f(1),
imath.V3d(1.5),
imath.Box2i(),
imath.Box2i(imath.V2i(1), imath.V2i(1)),
imath.Box2f(imath.V2f(-1), imath.V2f(1)),
imath.Box2f(),
imath.Box3f(imath.V3f(-1), imath.V3f(1)),
imath.Box3f(), "test", 10, 10.5
]:
self.assertTrue(type(v) is type(eval(IECore.repr(v))))
self.assertEqual(v, eval(IECore.repr(v)))
def testVectors( self ) : fileName = os.path.join( self.temporaryDirectory(), "attributes.scc" ) scene = IECoreScene.SceneInterface.create( fileName, IECore.IndexedIO.Write ) child = scene.createChild( "child" ) for name, value in [ ( "v2f", IECore.V2fData( imath.V2f( 1, 2 ) ) ), ( "v3f", IECore.V3fData( imath.V3f( 3, 4, 5 ) ) ), ( "v2i", IECore.V2iData( imath.V2i( 6, 7 ) ) ), ( "v3i", IECore.V3iData( imath.V3i( 8, 9, 10 ) ) ), ( "v2d", IECore.V2dData( imath.V2d( 11, 12 ) ) ), ( "v3d", IECore.V3dData( imath.V3d( 13, 14, 15 ) ) ), ] : child.writeAttribute( name, value, 1 ) del scene, child sceneReader = GafferScene.SceneReader() sceneReader["fileName"].setValue( fileName ) childFilter = GafferScene.PathFilter() childFilter["paths"].setValue( IECore.StringVectorData( [ "/child" ] ) ) visualiser = GafferScene.AttributeVisualiser() visualiser["in"].setInput( sceneReader["out"] ) visualiser["filter"].setInput( childFilter["out"] ) for name, value in [ ( "v2f", imath.Color3f( 1, 2, 0 ) ), ( "v3f", imath.Color3f( 3, 4, 5 ) ), ( "v2i", imath.Color3f( 6, 7, 0 ) ), ( "v3i", imath.Color3f( 8, 9, 10 ) ), ( "v2d", imath.Color3f( 11, 12, 0 ) ), ( "v3d", imath.Color3f( 13, 14, 15 ) ), ] : visualiser["attributeName"].setValue( name ) self.assertEqual( visualiser["out"].attributes( "/child" )["gl:surface"].outputShader().parameters["Cs"].value, value, )
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 mesh( self ) : vertsPerFace = IECore.IntVectorData( [ 4, 4, 4, 4, 4, 4 ] ) vertexIds = IECore.IntVectorData( [ 1, 5, 4, 0, 2, 6, 5, 1, 3, 7, 6, 2, 0, 4, 7, 3, 2, 1, 0, 3, 5, 6, 7, 4 ] ) mesh = IECoreScene.MeshPrimitive( vertsPerFace, vertexIds ) floatData = IECore.FloatData( 1.5 ) v2fData = IECore.V2fData( imath.V2f( 1.5, 2.5 ), IECore.GeometricData.Interpretation.Vector ) 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" ) intRange = range( 1, 25 ) 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 ], IECore.GeometricData.Interpretation.Normal ) color3fVectorData = IECore.Color3fVectorData( [ imath.Color3f( x, 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 ] ) detailInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Constant pointInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Vertex primitiveInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Uniform vertexInterpolation = IECoreScene.PrimitiveVariable.Interpolation.FaceVarying # add all valid detail attrib types mesh["floatDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, floatData ) mesh["v2fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2fData ) mesh["v3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3fData ) mesh["color3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, color3fData ) mesh["intDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, intData ) mesh["v2iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2iData ) mesh["v3iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3iData ) mesh["stringDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, stringData ) # add all valid point attrib types 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 ), ], IECore.GeometricData.Interpretation.Point ) mesh["P"] = IECoreScene.PrimitiveVariable( pointInterpolation, pData ) mesh["floatPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, floatVectorData[:8] ) mesh["v2fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2fVectorData[:8] ) mesh["v3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3fVectorData[:8] ) mesh["color3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, color3fVectorData[:8] ) mesh["intPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, intVectorData[:8] ) mesh["v2iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2iVectorData[:8] ) mesh["v3iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3iVectorData[:8] ) mesh["stringPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, stringVectorData[:8], IECore.IntVectorData( range( 0, 8 ) ) ) # add all valid primitive attrib types mesh["floatPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, floatVectorData[:6] ) mesh["v2fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v2fVectorData[:6] ) mesh["v3fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v3fVectorData[:6] ) mesh["color3fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, color3fVectorData[:6] ) mesh["intPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, intVectorData[:6] ) mesh["v2iPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v2iVectorData[:6] ) mesh["v3iPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v3iVectorData[:6] ) mesh["stringPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, stringVectorData[:6], IECore.IntVectorData( range( 0, 6 ) ) ) # add all valid vertex attrib types mesh["floatVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, floatVectorData ) mesh["v2fVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, v2fVectorData ) mesh["v3fVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, v3fVectorData ) mesh["color3fVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, color3fVectorData ) mesh["intVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, intVectorData ) mesh["v2iVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, v2iVectorData ) mesh["v3iVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, v3iVectorData ) mesh["stringVert"] = IECoreScene.PrimitiveVariable( vertexInterpolation, stringVectorData, IECore.IntVectorData( range( 0, 24 ) ) ) return mesh
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))
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")
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])
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 %d!" % x for x in intRange])
detailInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Constant
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)
# 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["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.blindData()['name'] = "pointsGroup"
return points
def testContextChangedAndGIL(self):
script = Gaffer.ScriptNode()
script["plane"] = GafferScene.Plane()
script["plane"]["divisions"].setValue(imath.V2i(20))
script["sphere"] = GafferScene.Sphere()
script["expression"] = Gaffer.Expression()
script["expression"].setExpression(
"parent['sphere']['radius'] = context.get( 'minRadius', 0.1 ) + context.getFrame()"
)
script["instancer"] = GafferScene.Instancer()
script["instancer"]["in"].setInput(script["plane"]["out"])
script["instancer"]["instances"].setInput(script["sphere"]["out"])
script["instancer"]["parent"].setValue("/plane")
context = Gaffer.Context()
traverseConnection = Gaffer.ScopedConnection(
GafferSceneTest.connectTraverseSceneToContextChangedSignal(
script["instancer"]["out"], context))
with context:
context.setFrame(10)
context.setFramesPerSecond(50)
context.setTime(1)
context.set("a", 1)
context.set("a", 2.0)
context.set("a", "a")
context.set("a", imath.V2i())
context.set("a", imath.V3i())
context.set("a", imath.V2f())
context.set("a", imath.V3f())
context.set("a", imath.Color3f())
context.set("a", IECore.BoolData(True))
context["b"] = 1
context["b"] = 2.0
context["b"] = "b"
context["b"] = imath.V2i()
context["b"] = imath.V3i()
context["b"] = imath.V2f()
context["b"] = imath.V3f()
context["b"] = imath.Color3f()
context["b"] = IECore.BoolData(True)
with Gaffer.BlockedConnection(traverseConnection):
# Must add it with the connection disabled, otherwise
# the addition causes a traversal, and then remove() gets
# all its results from the cache.
context["minRadius"] = 0.2
context.remove("minRadius")
with Gaffer.BlockedConnection(traverseConnection):
context["minRadius"] = 0.3
del context["minRadius"]
def testPlane(self):
verticesPerFace = IECore.IntVectorData()
vertexIds = IECore.IntVectorData()
verticesPerFace.append(3)
vertexIds.append(0)
vertexIds.append(1)
vertexIds.append(2)
verticesPerFace.append(3)
vertexIds.append(1)
vertexIds.append(3)
vertexIds.append(2)
m = IECoreScene.MeshPrimitive(verticesPerFace, vertexIds)
p = IECore.V3fVectorData()
p.append(imath.V3f(-1, -1, 0))
p.append(imath.V3f(1, -1, 0))
p.append(imath.V3f(-1, 1, 0))
p.append(imath.V3f(1, 1, 0))
s = IECore.FloatVectorData()
s.append(0)
s.append(1)
s.append(0)
s.append(1)
s.append(1)
s.append(0)
t = IECore.FloatVectorData()
t.append(0)
t.append(0)
t.append(1)
t.append(0)
t.append(1)
t.append(1)
uni = IECore.IntVectorData()
uni.append(0)
uni.append(1)
m["P"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Vertex, p)
m["s"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, s)
m["t"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, t)
m["uni"] = IECoreScene.PrimitiveVariable(
IECoreScene.PrimitiveVariable.Interpolation.Uniform, uni)
self.assert_(m.arePrimitiveVariablesValid())
op = IECoreScene.MeshVertexReorderOp()
result = op(input=m, startingVertices=imath.V3i(2, 3, 1))
expectedVerticesPerFace = IECore.IntVectorData()
expectedVerticesPerFace.append(3)
expectedVerticesPerFace.append(3)
self.assertEqual(result.verticesPerFace, expectedVerticesPerFace)
expectedVertexIds = IECore.IntVectorData()
expectedVertexIds.append(0)
expectedVertexIds.append(1)
expectedVertexIds.append(2)
expectedVertexIds.append(0)
expectedVertexIds.append(2)
expectedVertexIds.append(3)
self.assertEqual(result.vertexIds, expectedVertexIds)
expectedP = IECore.V3fVectorData()
expectedP.append(imath.V3f(-1, 1, 0))
expectedP.append(imath.V3f(1, 1, 0))
expectedP.append(imath.V3f(1, -1, 0))
expectedP.append(imath.V3f(-1, -1, 0))
self.assertEqual(result["P"].data, expectedP)
expectedS = IECore.FloatVectorData()
expectedS.append(0)
expectedS.append(1)
expectedS.append(1)
expectedS.append(0)
expectedS.append(1)
expectedS.append(0)
self.assertEqual(result["s"].data, expectedS)
expectedT = IECore.FloatVectorData()
expectedT.append(1)
expectedT.append(1)
expectedT.append(0)
expectedT.append(1)
expectedT.append(0)
expectedT.append(0)
self.assertEqual(result["t"].data, expectedT)
expectedUni = IECore.IntVectorData()
expectedUni.append(1)
expectedUni.append(0)
self.assertEqual(result["uni"].data, expectedUni)
self.assert_(result.arePrimitiveVariablesValid())
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 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)),
}
}
imgOrig = self.__makeFloatImage(dataWindow, dataWindow)
imgOrig.blindData().update(headerValues.copy())
# now add some unsupported types
imgOrig.blindData()['notSupported1'] = IECore.FloatVectorData(
[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.assertEqual(type(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']
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 testBoxTypes(self):
p = IECore.Parameterised("")
p.parameters().addParameters([
IECore.Box3iParameter(
"b",
"",
imath.Box3i(
imath.V3i(-1, -2, -3),
imath.V3i(2, 1, 3),
),
)
])
ph = GafferCortex.ParameterisedHolderNode()
ph.setParameterised(p)
self.assertIsInstance(ph["parameters"]["b"], Gaffer.Box3iPlug)
self.assertIsInstance(ph["parameters"]["b"]["min"], Gaffer.V3iPlug)
self.assertIsInstance(ph["parameters"]["b"]["max"], Gaffer.V3iPlug)
self.assertEqual(ph["parameters"]["b"]["min"].getValue(),
imath.V3i(-1, -2, -3))
self.assertEqual(ph["parameters"]["b"]["max"].getValue(),
imath.V3i(2, 1, 3))
ph["parameters"]["b"]["min"].setValue(imath.V3i(-10, -20, -30))
ph["parameters"]["b"]["max"].setValue(imath.V3i(10, 20, 30))
ph.parameterHandler().setParameterValue()
self.assertEqual(
p["b"].getTypedValue(),
imath.Box3i(imath.V3i(-10, -20, -30), imath.V3i(10, 20, 30)))
with ph.parameterModificationContext():
p["b"].setTypedValue(
imath.Box3i(imath.V3i(-2, -4, -6), imath.V3i(2, 4, 6)))
self.assertEqual(ph["parameters"]["b"]["min"].getValue(),
imath.V3i(-2, -4, -6))
self.assertEqual(ph["parameters"]["b"]["max"].getValue(),
imath.V3i(2, 4, 6))
def __addMenuDefinition(self):
result = IECore.MenuDefinition()
result.append(
"/Add/Bool", {
"command":
functools.partial(Gaffer.WeakMethod(self.__addItem), "",
IECore.BoolData(False))
})
result.append(
"/Add/Float", {
"command":
functools.partial(Gaffer.WeakMethod(self.__addItem), "",
IECore.FloatData(0))
})
result.append(
"/Add/Int", {
"command":
functools.partial(Gaffer.WeakMethod(self.__addItem), "",
IECore.IntData(0))
})
result.append("/Add/NumericDivider", {"divider": True})
result.append(
"/Add/String", {
"command":
functools.partial(Gaffer.WeakMethod(self.__addItem), "",
IECore.StringData(""))
})
result.append("/Add/StringDivider", {"divider": True})
result.append(
"/Add/V2i/Vector", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2iData(imath.V2i(0),
IECore.GeometricData.Interpretation.Vector))
})
result.append(
"/Add/V2i/Normal", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2iData(imath.V2i(0),
IECore.GeometricData.Interpretation.Normal))
})
result.append(
"/Add/V2i/Point", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2iData(imath.V2i(0),
IECore.GeometricData.Interpretation.Point))
})
result.append(
"/Add/V3i/Vector", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3iData(imath.V3i(0),
IECore.GeometricData.Interpretation.Vector))
})
result.append(
"/Add/V3i/Normal", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3iData(imath.V3i(0),
IECore.GeometricData.Interpretation.Normal))
})
result.append(
"/Add/V3i/Point", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3iData(imath.V3i(0),
IECore.GeometricData.Interpretation.Point))
})
result.append(
"/Add/V2f/Vector", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2fData(imath.V2f(0),
IECore.GeometricData.Interpretation.Vector))
})
result.append(
"/Add/V2f/Normal", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2fData(imath.V2f(0),
IECore.GeometricData.Interpretation.Normal))
})
result.append(
"/Add/V2f/Point", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V2fData(imath.V2f(0),
IECore.GeometricData.Interpretation.Point))
})
result.append(
"/Add/V3f/Vector", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3fData(imath.V3f(0),
IECore.GeometricData.Interpretation.Vector))
})
result.append(
"/Add/V3f/Normal", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3fData(imath.V3f(0),
IECore.GeometricData.Interpretation.Normal))
})
result.append(
"/Add/V3f/Point", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.V3fData(imath.V3f(0),
IECore.GeometricData.Interpretation.Point))
})
result.append("/Add/VectorDivider", {"divider": True})
result.append(
"/Add/Color3f", {
"command":
functools.partial(Gaffer.WeakMethod(self.__addItem), "",
IECore.Color3fData(imath.Color3f(0)))
})
result.append(
"/Add/Color4f", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.Color4fData(imath.Color4f(0, 0, 0, 1)))
})
result.append("/Add/BoxDivider", {"divider": True})
result.append(
"/Add/Box2i", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.Box2iData(imath.Box2i(imath.V2i(0), imath.V2i(1))))
})
result.append(
"/Add/Box2f", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.Box2fData(imath.Box2f(imath.V2f(0), imath.V2f(1))))
})
result.append(
"/Add/Box3i", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.Box3iData(imath.Box3i(imath.V3i(0), imath.V3i(1))))
})
result.append(
"/Add/Box3f", {
"command":
functools.partial(
Gaffer.WeakMethod(self.__addItem), "",
IECore.Box3fData(imath.Box3f(imath.V3f(0), imath.V3f(1))))
})
result.append("/Add/BoxDivider", {"divider": True})
for label, plugType in [
("Float", Gaffer.FloatVectorDataPlug),
("Int", Gaffer.IntVectorDataPlug),
("NumericDivider", None),
("String", Gaffer.StringVectorDataPlug),
]:
if plugType is not None:
result.append(
"/Add/Array/" + label, {
"command":
IECore.curry(Gaffer.WeakMethod(self.__addItem), "",
plugType.ValueType())
})
else:
result.append("/Add/Array/" + label, {"divider": True})
return result
def curves( self, basis=IECore.CubicBasisf.linear(), periodic=False, numCurves=4 ) : vertsPerCurve = IECore.IntVectorData() pData = IECore.V3fVectorData() pData.setInterpretation( IECore.GeometricData.Interpretation.Point ) for i in range( 0, numCurves ) : p = TestToHoudiniCurvesConverter.__curveCoordinates[i%4] if not periodic and basis == IECore.CubicBasisf.bSpline() : vertsPerCurve.append( len(p) + 4 ) else : vertsPerCurve.append( len(p) ) pData.extend( p ) curves = IECoreScene.CurvesPrimitive( vertsPerCurve, basis, periodic ) 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 ) ) 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" ) intRange = range( 1, pData.size()+1 ) 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 ] ) 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 ] ) detailInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Constant pointInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Vertex primitiveInterpolation = IECoreScene.PrimitiveVariable.Interpolation.Uniform # add all valid detail attrib types curves["floatDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, floatData ) curves["v2fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2fData ) curves["v3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3fData ) curves["color3fDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, color3fData ) curves["intDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, intData ) curves["v2iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v2iData ) curves["v3iDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, v3iData ) curves["stringDetail"] = IECoreScene.PrimitiveVariable( detailInterpolation, stringData ) # add all valid point attrib types if not periodic and basis == IECore.CubicBasisf.bSpline() : modPData = IECore.V3fVectorData() modPData.setInterpretation( IECore.GeometricData.Interpretation.Point ) floatPointData = IECore.FloatVectorData() v2fPointData = IECore.V2fVectorData() v3fPointData = IECore.V3fVectorData() color3fPointData = IECore.Color3fVectorData() intPointData = IECore.IntVectorData() v2iPointData = IECore.V2iVectorData() v3iPointData = IECore.V3iVectorData() stringPointData = IECore.StringVectorData() datas = [ modPData, floatPointData, v2fPointData, v3fPointData, color3fPointData, intPointData, v2iPointData, v3iPointData, stringPointData ] rawDatas = [ pData, floatVectorData, v2fVectorData, v3fVectorData, color3fVectorData, intVectorData, v2iVectorData, v3iVectorData, stringVectorData ] pIndex = 0 for i in range( 0, numCurves ) : for j in range( 0, len(datas) ) : index = 8*i datas[j].extend( [ rawDatas[j][index], rawDatas[j][index] ] ) datas[j].extend( rawDatas[j][index:index+8] ) datas[j].extend( [ rawDatas[j][index+7], rawDatas[j][index+7] ] ) curves["P"] = IECoreScene.PrimitiveVariable( pointInterpolation, modPData ) curves["floatPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, floatPointData ) curves["v2fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation,v2fPointData ) curves["v3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3fPointData ) curves["color3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, color3fPointData ) curves["intPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, intPointData ) curves["v2iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2iPointData ) curves["v3iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3iPointData ) else : curves["P"] = IECoreScene.PrimitiveVariable( pointInterpolation, pData ) curves["floatPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, floatVectorData[:8*numCurves] ) curves["v2fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2fVectorData[:8*numCurves] ) curves["v3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3fVectorData[:8*numCurves] ) curves["color3fPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, color3fVectorData[:8*numCurves] ) curves["intPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, intVectorData[:8*numCurves] ) curves["v2iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v2iVectorData[:8*numCurves] ) curves["v3iPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, v3iVectorData[:8*numCurves] ) curves["stringPoint"] = IECoreScene.PrimitiveVariable( pointInterpolation, stringVectorData[:8*numCurves], IECore.IntVectorData( range( 0, 8*numCurves ) ) ) # add all valid primitive attrib types curves["floatPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, floatVectorData[:numCurves] ) curves["v2fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v2fVectorData[:numCurves] ) curves["v3fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v3fVectorData[:numCurves] ) curves["color3fPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, color3fVectorData[:numCurves] ) curves["intPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, intVectorData[:numCurves] ) curves["v2iPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v2iVectorData[:numCurves] ) curves["v3iPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, v3iVectorData[:numCurves] ) curves["stringPrim"] = IECoreScene.PrimitiveVariable( primitiveInterpolation, stringVectorData[:numCurves], IECore.IntVectorData( range( 0, numCurves ) ) ) self.assertTrue( curves.arePrimitiveVariablesValid() ) return curves
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 testResetDefault(self):
script = Gaffer.ScriptNode()
script["node"] = Gaffer.Node()
script["node"]["user"]["i"] = Gaffer.IntPlug(
defaultValue=1,
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
script["node"]["user"]["v"] = Gaffer.V3iPlug(
defaultValue=imath.V3i(1, 2, 3),
flags=Gaffer.Plug.Flags.Default | Gaffer.Plug.Flags.Dynamic)
def assertPreconditions(script):
self.assertTrue(script["node"]["user"]["i"].isSetToDefault())
self.assertEqual(script["node"]["user"]["i"].defaultValue(), 1)
self.assertEqual(script["node"]["user"]["i"].getValue(), 1)
self.assertTrue(script["node"]["user"]["v"].isSetToDefault())
self.assertEqual(script["node"]["user"]["v"].defaultValue(),
imath.V3i(1, 2, 3))
self.assertEqual(script["node"]["user"]["v"].getValue(),
imath.V3i(1, 2, 3))
assertPreconditions(script)
with Gaffer.UndoScope(script):
script["node"]["user"]["i"].setValue(2)
script["node"]["user"]["i"].resetDefault()
script["node"]["user"]["v"].setValue(imath.V3i(10, 11, 12))
script["node"]["user"]["v"].resetDefault()
def assertPostconditions(script):
self.assertTrue(script["node"]["user"]["i"].isSetToDefault())
self.assertEqual(script["node"]["user"]["i"].defaultValue(), 2)
self.assertEqual(script["node"]["user"]["i"].getValue(), 2)
self.assertTrue(script["node"]["user"]["v"].isSetToDefault())
self.assertEqual(script["node"]["user"]["v"].defaultValue(),
imath.V3i(10, 11, 12))
self.assertEqual(script["node"]["user"]["v"].getValue(),
imath.V3i(10, 11, 12))
script.undo()
assertPreconditions(script)
script.redo()
assertPostconditions(script)
script.undo()
assertPreconditions(script)
script.redo()
assertPostconditions(script)
script2 = Gaffer.ScriptNode()
script2.execute(script.serialise())
assertPostconditions(script2)
def testTypes(self):
c = Gaffer.Context()
c["int"] = 1
self.assertEqual(c["int"], 1)
self.assertEqual(c.get("int"), 1)
compare = c.hash()
c.set("int", 2)
self.assertEqual(c["int"], 2)
self.assertIsInstance(c["int"], int)
self.assertNotEqual(compare, c.hash())
c["float"] = 1.0
self.assertEqual(c["float"], 1.0)
self.assertEqual(c.get("float"), 1.0)
compare = c.hash()
c.set("float", 2.0)
self.assertEqual(c["float"], 2.0)
self.assertIsInstance(c["float"], float)
self.assertNotEqual(compare, c.hash())
c["string"] = "hi"
self.assertEqual(c["string"], "hi")
self.assertEqual(c.get("string"), "hi")
compare = c.hash()
c.set("string", "bye")
self.assertEqual(c["string"], "bye")
self.assertIsInstance(c["string"], str)
self.assertNotEqual(compare, c.hash())
c["v2i"] = imath.V2i(1, 2)
self.assertEqual(c["v2i"], imath.V2i(1, 2))
self.assertEqual(c.get("v2i"), imath.V2i(1, 2))
compare = c.hash()
c.set("v2i", imath.V2i(3, 4))
self.assertEqual(c["v2i"], imath.V2i(3, 4))
self.assertIsInstance(c["v2i"], imath.V2i)
self.assertNotEqual(compare, c.hash())
c["v3i"] = imath.V3i(1, 2, 3)
self.assertEqual(c["v3i"], imath.V3i(1, 2, 3))
self.assertEqual(c.get("v3i"), imath.V3i(1, 2, 3))
compare = c.hash()
c.set("v3i", imath.V3i(4, 5, 6))
self.assertEqual(c["v3i"], imath.V3i(4, 5, 6))
self.assertIsInstance(c["v3i"], imath.V3i)
self.assertNotEqual(compare, c.hash())
c["v2f"] = imath.V2f(1, 2)
self.assertEqual(c["v2f"], imath.V2f(1, 2))
self.assertEqual(c.get("v2f"), imath.V2f(1, 2))
compare = c.hash()
c.set("v2f", imath.V2f(3, 4))
self.assertEqual(c["v2f"], imath.V2f(3, 4))
self.assertIsInstance(c["v2f"], imath.V2f)
self.assertNotEqual(compare, c.hash())
c["v3f"] = imath.V3f(1, 2, 3)
self.assertEqual(c["v3f"], imath.V3f(1, 2, 3))
self.assertEqual(c.get("v3f"), imath.V3f(1, 2, 3))
compare = c.hash()
c.set("v3f", imath.V3f(4, 5, 6))
self.assertEqual(c["v3f"], imath.V3f(4, 5, 6))
self.assertIsInstance(c["v3f"], imath.V3f)
self.assertNotEqual(compare, c.hash())
def __init__(self):
IECore.Op.__init__(
self, "test all parameter types.",
IECore.IntParameter(
name="result",
description="one if everything is ok",
defaultValue=0,
))
self.parameters().addParameters([
IECore.IntParameter(
name="a",
description=
"An int which has a very long description to help test the help formatting. i wonder if there's anything more interesting i could write here.",
defaultValue=1,
),
IECore.FloatParameter(
name="b",
description=
"A float which has a very long description to help test the help formatting. i wonder if there's anything more interesting i could write here.",
defaultValue=2,
),
IECore.DoubleParameter(
name="c",
description="A double",
defaultValue=3,
),
IECore.StringParameter(
name="d",
description="A string",
defaultValue="ssss",
),
IECore.IntVectorParameter(
name="e",
description="An array of ints",
defaultValue=IECore.IntVectorData([4, -1, 2]),
),
IECore.StringVectorParameter(
name="f",
description="An array of strings",
defaultValue=IECore.StringVectorData(["one", "two", "three"]),
),
IECore.V2fParameter(
name="g",
description="A v2f",
defaultValue=IECore.V2fData(imath.V2f(1, 2)),
),
IECore.V3fParameter(name="h",
description="a v3f",
defaultValue=IECore.V3fData(imath.V3f(1, 1,
1)),
presets=(("x", imath.V3f(1, 0, 0)),
("y", imath.V3f(0, 1, 0)),
("z", imath.V3f(0, 0, 1)))),
IECore.V2dParameter(
name="i",
description="a v2d",
defaultValue=IECore.V2dData(imath.V2d(1, 1)),
),
IECore.CompoundParameter(
name="compound",
description="a compound parameter",
members=[
IECore.V3dParameter(name="j",
description="a v3d",
defaultValue=IECore.V3dData(
imath.V3d(8, 16, 32)),
presets=(("one", imath.V3d(1)),
("two", imath.V3d(2)))),
IECore.M44fParameter(name="k",
description="an m44f",
defaultValue=IECore.M44fData(),
presets=(("one", imath.M44f(1)),
("two", imath.M44f(2)))),
]),
IECore.Color3fParameter(
name="l",
description="a color3f",
defaultValue=IECore.Color3fData(imath.Color3f(1, 0, 1)),
),
IECore.Color4fParameter(
name="m",
description="a color4f",
defaultValue=IECore.Color4fData(imath.Color4f(1, 0, 1, 0.5)),
),
IECore.FileNameParameter(
name="o",
description="tif file please!",
defaultValue="",
extensions="tif",
allowEmptyString=True,
),
IECore.DirNameParameter(
name="p",
description="directory please!",
defaultValue="",
check=IECore.DirNameParameter.CheckType.MustExist,
allowEmptyString=True,
),
IECore.BoolParameter(
name="q",
description="blah",
defaultValue=False,
),
IECore.FileSequenceParameter(name="r",
description="File sequence please!",
defaultValue=""),
IECore.Box2dParameter(name="s",
description="boxboxbox",
defaultValue=imath.Box2d(
imath.V2d(-1), imath.V2d(1))),
IECore.Box3fParameter(name="t",
description="boxboxbox",
defaultValue=imath.Box3f(
imath.V3f(-1), imath.V3f(1))),
IECore.V2iParameter(
name="u",
description="A v2i",
defaultValue=IECore.V2iData(imath.V2i(2, 2)),
),
IECore.V3iParameter(
name="v",
description="A v3i",
defaultValue=IECore.V3iData(imath.V3i(5, 5, 5)),
),
IECore.FrameListParameter(
name="w",
description="A FrameList",
defaultValue="",
),
IECore.TransformationMatrixfParameter(
name="x",
description="",
defaultValue=IECore.TransformationMatrixf(),
),
# We'd like to have one with a non-standard rotation order
# here, but they're not currently supported in Maya.
IECore.TransformationMatrixdParameter(
name="y",
description="",
defaultValue=IECore.TransformationMatrixd(),
),
IECore.ObjectParameter(name="p1",
description="",
defaultValue=IECore.CompoundObject(),
types=[IECore.TypeId.CompoundObject]),
IECore.LineSegment3fParameter(name="p2",
description="",
defaultValue=IECore.LineSegment3f(
imath.V3f(1), imath.V3f(2))),
IECore.LineSegment3dParameter(name="p3",
description="",
defaultValue=IECore.LineSegment3d(
imath.V3d(1), imath.V3d(2))),
IECore.DateTimeParameter(name="p4",
description="",
defaultValue=datetime.datetime.now()),
])
