def testPrimitiveGroupModeWithTransformAttribute(self):
cache = self.cacheSop(
file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
cache.parm("groupingMode").set(0)
hou.parm("/obj/geo1/group1/entity").set(0)
hou.setFrame(2)
orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
cache.parm("transformAttribute").set("transform")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assertNotEqual(orig, result)
self.assertNotEqual(orig['P'], result['P'])
self.assertNotEqual(orig['N'], result['N'])
self.assertEqual(orig['P'].data.size(), result['P'].data.size())
self.assertEqual(orig['N'].data.size(), result['N'].data.size())
self.assertEqual(orig['Cs'], result['Cs'])
self.assertEqual(orig['pointId'], result['pointId'])
i = IECore.InterpolatedCache(
cache.parm("cacheSequence").eval(),
IECore.InterpolatedCache.Interpolation.Linear,
IECore.OversamplesCalculator(24, 1))
matrix = i.read(2, "torus", "transform").value.transform
origP = orig["P"].data
origN = orig["N"].data
resultP = result["P"].data
resultN = result["N"].data
for i in range(0, origP.size()):
self.assertNotEqual(resultP[i], origP[i])
self.assertNotEqual(resultN[i], origN[i])
self.assertEqual(resultP[i], matrix.multVecMatrix(origP[i]))
self.failUnless(resultN[i].equalWithAbsError(
matrix.multDirMatrix(origN[i]), 1e-6))
def testParticlePrimitive(self):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
popnet = geo.createNode("popnet")
location = popnet.createNode("location")
detailAttr = popnet.createOutputNode("attribcreate",
exact_type_name=True)
detailAttr.parm("name").set("float3detail")
detailAttr.parm("class").set(0) # detail
detailAttr.parm("type").set(0) # float
detailAttr.parm("size").set(3) # 3 elements
detailAttr.parm("value1").set(1)
detailAttr.parm("value2").set(2)
detailAttr.parm("value3").set(3)
pointAttr = detailAttr.createOutputNode("attribcreate",
exact_type_name=True)
pointAttr.parm("name").set("float3point")
pointAttr.parm("class").set(2) # point
pointAttr.parm("type").set(0) # float
pointAttr.parm("size").set(3) # 3 elements
pointAttr.parm("value1").set(1)
pointAttr.parm("value2").set(2)
pointAttr.parm("value3").set(3)
hou.setFrame(5)
converter = IECoreHoudini.FromHoudiniPolygonsConverter(pointAttr)
self.assertRaises(RuntimeError, converter.convert)
add = pointAttr.createOutputNode("add")
add.parm("keep").set(1) # deletes primitive and leaves points
m = IECoreHoudini.FromHoudiniPolygonsConverter(add).convert()
self.failUnless(isinstance(m, IECoreScene.MeshPrimitive))
self.assertEqual(m, IECoreScene.MeshPrimitive())
def testAttrPrefixAndSuffix(self):
cache = self.cacheSop()
cache.parm("attributeFixes1").set("C")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" not in result)
self.assert_("pointId" in result)
self.assert_("d" in result)
cache.parm("attributeFixes1").set("")
cache.parm("attributeFixes2").set("tId")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" in result)
self.assert_("pointId" not in result)
self.assert_("poin" in result)
cache.parm("attributeFixes1").set("po")
cache.parm("attributeFixes2").set("tId")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" in result)
self.assert_("pointId" not in result)
self.assert_("in" in result)
cache.parm("attributeFixes1").set("C")
cache.parm("attributeFixes2").set("tId")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" not in result)
self.assert_("pointId" not in result)
self.assert_("poin" in result)
self.assert_("d" in result)
cache.parm("attributeFixes1").set("oin")
cache.parm("attributeFixes2").set("tI")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" in result)
self.assert_("pointId" in result)
def testBadObjectHandle(self):
cache = self.cacheSop()
orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" in orig)
cache.parm("objectFixes1").set("nope")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("Cs" not in result)
def testAppendingIntoLockedSop( self ) : mesh = self.mesh() meshNumPoints = mesh.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) sop = self.meshSop() orig = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() origNumPoints = orig.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertNotEqual( orig, mesh ) sop.setHardLocked( True ) self.assert_( sop.isHardLocked() ) self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop, True ) ) self.assert_( sop.isHardLocked() ) self.comparePrimAndAppendedSop( mesh, sop, orig ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() resultNumPoints = result.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( resultNumPoints, origNumPoints + meshNumPoints ) for i in range( 0, mesh["P"].data.size() ) : self.assertEqual( result["P"].data[ origNumPoints + i ], mesh["P"].data[i] ) sop.setHardLocked( False ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() resultNumPoints = result.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( resultNumPoints, origNumPoints ) self.assert_( "floatDetail" not in result.keys() ) self.assert_( "floatPoint" not in result.keys() )
def testInterpolation(self):
torus = self.createTorus()
normals = torus.createOutputNode("facet")
normals.parm("postnml").set(True)
result = IECoreHoudini.FromHoudiniPolygonsConverter(normals).convert()
self.assertTrue("ieMeshInterpolation" not in result.keys())
self.assertEqual(result.interpolation, "linear")
self.assertTrue("N" in result.keys())
attr = normals.createOutputNode("attribcreate",
node_name="interpolation",
exact_type_name=True)
attr.parm("name").set("ieMeshInterpolation")
attr.parm("class").set(1) # prim
attr.parm("type").set(3) # string
attr.parm("string").set("subdiv")
result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert()
self.assertTrue("ieMeshInterpolation" not in result.keys())
self.assertEqual(result.interpolation, "catmullClark")
self.assertTrue("N" not in result.keys())
attr.parm("string").set("poly")
result = IECoreHoudini.FromHoudiniPolygonsConverter(attr).convert()
self.assertTrue("ieMeshInterpolation" not in result.keys())
self.assertEqual(result.interpolation, "linear")
self.assertTrue("N" in result.keys())
def testTimeDependency(self):
cache = self.cacheSop()
orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
hou.setFrame(1.5)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assertNotEqual(orig, result)
self.assertNotEqual(orig['P'], result['P'])
self.assertNotEqual(orig['Cs'], result['Cs'])
self.assertEqual(orig['pointId'], result['pointId'])
def testAttributeMismatchBetweenFrames(self):
cache = self.cacheSop()
hou.setFrame(1.5)
self.failUnless(isinstance(cache.geometry(), hou.Geometry))
orig = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
hou.setFrame(2.5)
self.assertEqual(cache.geometry(), None)
self.failUnless("Entry not found" in cache.errors())
hou.setFrame(3)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless(isinstance(cache.geometry(), hou.Geometry))
self.assertNotEqual(orig, result)
def testName( self ) : torus = self.createTorus() name = torus.createOutputNode( "name" ) name.parm( "name1" ).set( "testName" ) result = IECoreHoudini.FromHoudiniPolygonsConverter( name ).convert() self.assertEqual( result.blindData()['name'].value, "testName" ) self.assertFalse( "name" in result ) self.assertFalse( "nameIndices" in result ) group = torus.createOutputNode( "group" ) group.parm( "crname" ).set( "testGroup" ) result = IECoreHoudini.FromHoudiniPolygonsConverter( group ).convert() self.assertEqual( result.blindData()['name'].value, "testGroup" )
def testPrimitiveGroupModeWithVertexAttribs(self):
# N defaults to a Point attrib
hou.setFrame(4)
cache = self.cacheSop()
self.failUnless(
isinstance(cache.geometry().findPointAttrib("N"), hou.Attrib))
self.failUnless(cache.geometry().findVertexAttrib("N") is None)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("N" in result.keys())
self.assertEqual(result["N"].interpolation,
IECore.PrimitiveVariable.Interpolation.Vertex)
self.assertEqual(
len(result["N"].data),
result.variableSize(IECore.PrimitiveVariable.Interpolation.Vertex))
# Since N actually has more values than points should, N becomes a Vertex attrib if we use PrimitiveGroup mode
group = hou.node("/obj/geo1/group1")
group.parm("entity").set(0)
cache.parm("groupingMode").set(0)
self.failUnless(cache.geometry().findPointAttrib("N") is None)
self.failUnless(
isinstance(cache.geometry().findVertexAttrib("N"), hou.Attrib))
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("N" in result.keys())
self.assertEqual(result["N"].interpolation,
IECore.PrimitiveVariable.Interpolation.FaceVarying)
self.assertEqual(
len(result["N"].data),
result.variableSize(
IECore.PrimitiveVariable.Interpolation.FaceVarying))
# Even if we create N as a Point attrib before the cache, it remains a Vertex attrib since the sizes do not match
facet = group.createOutputNode("facet")
facet.parm("postnml").set(True)
cache.setInput(0, facet)
self.failUnless(
isinstance(facet.geometry().findPointAttrib("N"), hou.Attrib))
self.failUnless(facet.geometry().findVertexAttrib("N") is None)
self.failUnless(cache.geometry().findPointAttrib("N") is None)
self.failUnless(
isinstance(cache.geometry().findVertexAttrib("N"), hou.Attrib))
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("N" in result.keys())
self.assertEqual(result["N"].interpolation,
IECore.PrimitiveVariable.Interpolation.FaceVarying)
self.assertEqual(
len(result["N"].data),
result.variableSize(
IECore.PrimitiveVariable.Interpolation.FaceVarying))
def testMultipleConversions( self ) : mesh = self.mesh() meshNumPoints = mesh.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) sop = self.meshSop() orig = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() origNumPoints = orig.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertNotEqual( orig, mesh ) self.assert_( not sop.isHardLocked() ) self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop, True ) ) self.assert_( sop.isHardLocked() ) self.comparePrimAndAppendedSop( mesh, sop, orig ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() resultNumPoints = result.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( resultNumPoints, origNumPoints + meshNumPoints ) for i in range( 0, mesh["P"].data.size() ) : self.assertEqual( result["P"].data[ origNumPoints + i ], mesh["P"].data[i] ) self.assert_( sop.isHardLocked() ) self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop, True ) ) self.assert_( sop.isHardLocked() ) self.comparePrimAndAppendedSop( mesh, sop, result, multipleConversions=True ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() resultNumPoints = result.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( resultNumPoints, origNumPoints + 2*meshNumPoints ) for i in range( 0, mesh["P"].data.size() ) : self.assertEqual( result["P"].data[ origNumPoints + i ], mesh["P"].data[i] ) self.assertEqual( result["P"].data[ origNumPoints + meshNumPoints + i ], mesh["P"].data[i] ) self.assert_( sop.isHardLocked() ) self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop, True ) ) self.assert_( sop.isHardLocked() ) self.comparePrimAndAppendedSop( mesh, sop, result, multipleConversions=True ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() resultNumPoints = result.variableSize( IECoreScene.PrimitiveVariable.Interpolation.Vertex ) self.assertEqual( resultNumPoints, origNumPoints + 3*meshNumPoints ) for i in range( 0, mesh["P"].data.size() ) : self.assertEqual( result["P"].data[ origNumPoints + i ], mesh["P"].data[i] ) self.assertEqual( result["P"].data[ origNumPoints + meshNumPoints + i ], mesh["P"].data[i] ) self.assertEqual( result["P"].data[ origNumPoints + 2*meshNumPoints + i ], mesh["P"].data[i] )
def testAdjustedStringVectorIndices(self):
box = self.box()
geo = box.parent()
group = box.createOutputNode("group")
attr = group.createOutputNode("attribcreate", exact_type_name=True)
attr.parm("class").set(1) # prim
attr.parm("type").set(3) # string
attr.parm("string").set("box1")
box2 = geo.createNode("box")
group2 = box2.createOutputNode("group")
attr2 = group2.createOutputNode("attribcreate", exact_type_name=True)
attr2.parm("class").set(1) # prim
attr2.parm("type").set(3) # string
attr2.parm("string").set("box2")
merge = attr.createOutputNode("merge")
merge.setInput(1, attr2)
g = IECoreHoudini.FromHoudiniGroupConverter(merge).convert()
for c in g.children():
null = geo.createNode("null")
IECoreHoudini.ToHoudiniPolygonsConverter(c).convert(null)
m = IECoreHoudini.FromHoudiniPolygonsConverter(null).convert()
self.assertEqual(m.vertexIds, c.vertexIds)
self.assertEqual(m.verticesPerFace, c.verticesPerFace)
self.assertEqual(m.keys(), c.keys())
for key in m.keys():
self.assertEqual(m[key].interpolation, c[key].interpolation)
self.assertEqual(m[key].data, c[key].data)
self.assertEqual(m[key], c[key])
def testCornersAndCreases( self ):
box = self.createBox() # create cube geometry
crease = box.createOutputNode("crease", exact_type_name=True)
crease.parm("group").set("p5-6 p4-5-1")
crease.parm("crease").set(1.29)
dodgyCorner = crease.createOutputNode("crease", exact_type_name=True)
dodgyCorner.parm("group").set("p7")
dodgyCorner.parm("crease").set(10.0)
dodgyCorner.parm("creaseattrib").set("cornerweight")
corner = dodgyCorner.createOutputNode("attribpromote", exact_type_name=True)
corner.parm("inname").set("cornerweight")
corner.parm("inclass").set(3) # vertex
corner.parm("method").set(1) # minimum (to avoid interpolation)
result = IECoreHoudini.FromHoudiniPolygonsConverter( corner ).convert()
self.assertTrue( result.arePrimitiveVariablesValid() )
self.assertEqual( result.keys(), [ "P" ] )
self.assertEqual( result.cornerIds(), IECore.IntVectorData( [ 7 ] ) )
self.assertEqual( result.cornerSharpnesses(), IECore.FloatVectorData( [ 10.0 ] ) )
self.assertEqual( result.creaseLengths(), IECore.IntVectorData( [ 2, 2, 2 ] ) )
self.assertEqual( result.creaseIds(), IECore.IntVectorData( [ 1, 5, 4, 5, 5, 6 ] ) )
self.assertEqual( result.creaseSharpnesses(), IECore.FloatVectorData( [ 1.29, 1.29, 1.29 ] ) )
def testWithUnacceptablePrimVars( self ) : mesh = self.mesh() mesh["badDetail"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Constant, IECore.TransformationMatrixfData() ) mesh["badPoint"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Vertex, IECore.DoubleVectorData( [ 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5 ] ) ) mesh["badPrim"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.DoubleVectorData( [ 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5 ] ) ) mesh["badVert"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, IECore.DoubleVectorData( [ 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5 ] ) ) sop = self.emptySop() self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop ) ) self.assert_( "badDetail" not in [ x.name() for x in sop.geometry().globalAttribs() ] ) self.assert_( "badPoint" not in [ x.name() for x in sop.geometry().pointAttribs() ] ) self.assert_( "badPrim" not in [ x.name() for x in sop.geometry().primAttribs() ] ) self.assert_( "badVert" not in [ x.name() for x in sop.geometry().vertexAttribs() ] ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() self.assertNotEqual( result, mesh ) self.assert_( "badDetail" not in result ) self.assert_( "badPoint" not in result ) self.assert_( "badPrim" not in result ) self.assert_( "badVert" not in result ) del mesh["badDetail"] del mesh["badPoint"] del mesh["badPrim"] del mesh["badVert"] self.comparePrimAndSop( mesh, sop )
def testExpandedUVRoundTrip( self ) : mesh = IECore.Reader.create( "test/IECore/data/cobFiles/twoTrianglesWithSharedUVs.cob" ).read() mesh["uv"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.FaceVarying, mesh["uv"].expandedData(), None ) mesh["uv"].indices = None uvData = mesh["uv"].data sop = self.emptySop() self.assertTrue( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop ) ) geo = sop.geometry() self.assertTrue( "uv" in [ x.name() for x in geo.vertexAttribs() ] ) uvs = geo.findVertexAttrib( "uv" ) i = 0 for prim in geo.prims() : verts = list(prim.vertices()) verts.reverse() for vert in verts : uvValues = vert.attribValue( uvs ) self.assertAlmostEqual( uvValues[0], uvData[i][0] ) self.assertAlmostEqual( uvValues[1], uvData[i][1] ) i += 1 converter = IECoreHoudini.FromHoudiniPolygonsConverter( sop ) result = converter.convert() self.assertEqual( result["uv"].data.getInterpretation(), IECore.GeometricData.Interpretation.UV ) # we cannot guarantee to generate the same data when extracting from Houdini # because we always generate indices, but we can generate correctly indexed data self.assertEqual( result["uv"].data.size(), 4 ) self.assertEqual( result["uv"].indices.size(), 6 ) for i in range( 0, mesh.variableSize( mesh["uv"].interpolation ) ) : self.assertEqual( mesh["uv"].data[i], result["uv"].data[ result["uv"].indices[i] ] )
def testMultipleConversions(self):
mesh = self.mesh()
points = self.points()
ints = self.ints()
sop = self.meshSop()
orig = IECoreHoudini.FromHoudiniPolygonsConverter(sop).convert()
self.assertNotEqual(orig, mesh)
converter = IECoreHoudini.ToHoudiniCortexObjectConverter(mesh)
converter["name"].setTypedValue("myMesh")
self.assertTrue(converter.convert(sop, True))
self.assertTrue(sop.isHardLocked())
self.verifyAppendedSop(sop, mesh, orig, "myMesh")
self.assertTrue(sop.isHardLocked())
converter["src"].setValue(points)
converter["name"].setTypedValue("myPoints")
self.assertTrue(converter.convert(sop, True))
self.assertTrue(sop.isHardLocked())
self.verifyAppendedSop(sop, points, orig, "myPoints", numAppends=2)
self.assertTrue(sop.isHardLocked())
converter["src"].setValue(ints)
converter["name"].setTypedValue("myInts")
self.assertTrue(converter.convert(sop, True))
self.assertTrue(sop.isHardLocked())
self.verifyAppendedSop(sop, ints, orig, "myInts", numAppends=3)
def testConvertMesh(self):
torus = self.createTorus()
converter = IECoreHoudini.FromHoudiniPolygonsConverter(torus)
result = converter.convert()
self.assertEqual(result.typeId(),
IECoreScene.MeshPrimitive.staticTypeId())
bbox = result.bound()
self.assertEqual(bbox.min().x, -1.5)
self.assertEqual(bbox.max().x, 1.5)
self.assertEqual(
result.variableSize(
IECoreScene.PrimitiveVariable.Interpolation.Vertex), 100)
self.assertEqual(result.numFaces(), 100)
self.assertEqual(len(result.verticesPerFace), 100)
for i in range(len(result.verticesPerFace)):
self.assertEqual(result.verticesPerFace[i], 4)
self.assertEqual(len(result.vertexIds), 400)
for i in range(len(result.vertexIds)):
self.assert_(result.vertexIds[i] >= 0)
self.assert_(result.vertexIds[i] < 100)
def testPrimitiveGroupModeWithMultipleObjects(self):
hou.setFrame(3)
cache = self.cacheSop(
file="test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
cache.parm("groupingMode").set(0)
hou.parm("/obj/geo1/group1/entity").set(0)
torus = cache.parent().createNode("file")
torus.parm("file").set(
"test/IECoreHoudini/data/torusWithVertexNormals.bgeo")
group = torus.createOutputNode("group")
group.parm("crname").set("torus2")
merge = cache.inputs()[0].createOutputNode("merge")
merge.setInput(1, group)
cache.setInput(0, merge)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
numTorusPoints = len(torus.geometry().points())
for key in ["P", "Cs"]:
self.assert_(key in result)
self.assertEqual(result[key].data.size(), 2 * numTorusPoints)
for i in range(0, numTorusPoints):
self.assertNotEqual(result['P'].data[i],
result['P'].data[numTorusPoints + i])
self.assertEqual(result['Cs'].data[i],
result['Cs'].data[numTorusPoints + i])
numTorusVerts = sum(
[len(x.vertices()) for x in torus.geometry().prims()])
self.assert_("N" in result)
self.assertEqual(result["N"].data.size(), 2 * numTorusVerts)
for i in range(0, numTorusVerts):
self.assertNotEqual(result['N'].data[i],
result['N'].data[numTorusPoints + i])
def testConvertNull(self):
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
null = geo.createNode("null")
m = IECoreHoudini.FromHoudiniPolygonsConverter(null).convert()
self.failUnless(isinstance(m, IECoreScene.MeshPrimitive))
self.assertEqual(m, IECoreScene.MeshPrimitive())
def testStandardAttributeConversion(self):
torus = self.createTorus()
color = torus.createOutputNode("color")
color.parm("colortype").set(2)
rest = color.createOutputNode("rest")
scale = rest.createOutputNode("attribcreate")
scale.parm("name1").set("pscale")
scale.parm("value1v1").setExpression("$PT")
uvunwrap = scale.createOutputNode("uvunwrap")
converter = IECoreHoudini.FromHoudiniPolygonsConverter(uvunwrap)
result = converter.convert()
self.assertEqual(result.keys(),
["Cs", "P", "Pref", "s", "t", "varmap", "width"])
self.assertTrue(result.arePrimitiveVariablesValid())
self.assertEqual(result["P"].data.getInterpretation(),
IECore.GeometricData.Interpretation.Point)
self.assertEqual(result["Pref"].data.getInterpretation(),
IECore.GeometricData.Interpretation.Point)
sData = result["s"].data
tData = result["t"].data
geo = uvunwrap.geometry()
uvs = geo.findVertexAttrib("uv")
i = 0
for prim in geo.prims():
verts = list(prim.vertices())
verts.reverse()
for vert in verts:
uvValues = vert.attribValue(uvs)
self.assertAlmostEqual(sData[i], uvValues[0])
self.assertAlmostEqual(tData[i], 1 - uvValues[1])
i += 1
converter["convertStandardAttributes"].setTypedValue(False)
result = converter.convert()
self.assertEqual(result.keys(),
["Cd", "P", "pscale", "rest", "uv", "varmap"])
self.assertTrue(result.arePrimitiveVariablesValid())
self.assertEqual(result["P"].data.getInterpretation(),
IECore.GeometricData.Interpretation.Point)
self.assertEqual(result["rest"].data.getInterpretation(),
IECore.GeometricData.Interpretation.Point)
uvData = result["uv"].data
geo = uvunwrap.geometry()
uvs = geo.findVertexAttrib("uv")
i = 0
for prim in geo.prims():
verts = list(prim.vertices())
verts.reverse()
for vert in verts:
uvValues = vert.attribValue(uvs)
self.assertAlmostEqual(uvData[i][0], uvValues[0])
self.assertAlmostEqual(uvData[i][1], uvValues[1])
i += 1
def testWrongP(self):
hou.setFrame(3)
cache = self.cacheSop()
group = cache.inputs()[0]
group.parm("crname").set("badObject")
cache.parm("attributeFixes1").set("wrong")
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.assert_("P" in result)
def testFloat4attr( self ) : # we can't deal with float 4's right now
attr = self.testSetupAttributes()
attr.parm("name").set( "test_attribute" )
attr.parm("size").set(4) # 4 elements per point-attribute
converter = IECoreHoudini.FromHoudiniPolygonsConverter( attr )
result = converter.convert()
self.assertTrue( "test_attribute" not in result.keys() ) # invalid due to being float[4]
self.assertTrue( result.arePrimitiveVariablesValid() )
def testCreateConverter(self):
box = self.createBox()
converter = IECoreHoudini.FromHoudiniPolygonsConverter(box)
self.assert_(
converter.isInstanceOf(
IECore.TypeId(
IECoreHoudini.TypeId.FromHoudiniPolygonsConverter)))
return converter
def testAnimatingGeometry( self ) :
obj = hou.node( "/obj" )
geo = obj.createNode( "geo", run_init_scripts=False )
torus = geo.createNode( "torus" )
facet = geo.createNode( "facet" )
facet.parm("postnml").set(True)
mountain = geo.createNode( "mountain" )
mountain.parm("offset1").setExpression( "$FF" )
facet.setInput( 0, torus )
mountain.setInput( 0, facet )
converter = IECoreHoudini.FromHoudiniPolygonsConverter( mountain )
hou.setFrame( 1 )
mesh1 = converter.convert()
hou.setFrame( 2 )
converter = IECoreHoudini.FromHoudiniPolygonsConverter( mountain )
mesh2 = converter.convert()
self.assertNotEqual( mesh1["P"].data, mesh2["P"].data )
self.assertNotEqual( mesh1, mesh2 )
def testObjectWasDeleted( self ) : mesh = self.mesh() sop = self.meshSop() converter = IECoreHoudini.ToHoudiniPolygonsConverter( mesh ) self.assert_( converter.convert( sop, False ) ) self.comparePrimAndSop( mesh, sop ) result = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() del mesh sop.setHardLocked( False ) self.assertNotEqual( IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert(), result ) self.assert_( converter.convert( sop, False ) ) self.assertEqual( IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert(), result )
def testPrimitiveGroupModeWithPrimAttribs(self):
# Cd defaults to a Point attrib
cache = self.cacheSop()
self.failUnless(
isinstance(cache.geometry().findPointAttrib("Cd"), hou.Attrib))
self.failUnless(cache.geometry().findPrimAttrib("Cd") is None)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("Cs" in result.keys())
self.assertEqual(result["Cs"].interpolation,
IECore.PrimitiveVariable.Interpolation.Vertex)
self.assertEqual(
len(result["Cs"].data),
result.variableSize(IECore.PrimitiveVariable.Interpolation.Vertex))
# Since the point and prim count match, Cd becomes a Primitive attrib if we use PrimitiveGroup mode
group = hou.node("/obj/geo1/group1")
group.parm("entity").set(0)
cache.parm("groupingMode").set(0)
self.failUnless(cache.geometry().findPointAttrib("Cd") is None)
self.failUnless(
isinstance(cache.geometry().findPrimAttrib("Cd"), hou.Attrib))
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("Cs" in result.keys())
self.assertEqual(result["Cs"].interpolation,
IECore.PrimitiveVariable.Interpolation.Uniform)
self.assertEqual(
len(result["Cs"].data),
result.variableSize(
IECore.PrimitiveVariable.Interpolation.Uniform))
# By creating Cd as a Point attrib before the cache, we can force it's type
color = group.createOutputNode("color")
cache.setInput(0, color)
self.failUnless(
isinstance(cache.geometry().findPointAttrib("Cd"), hou.Attrib))
self.failUnless(cache.geometry().findPrimAttrib("Cd") is None)
result = IECoreHoudini.FromHoudiniPolygonsConverter(cache).convert()
self.failUnless("Cs" in result.keys())
self.assertEqual(result["Cs"].interpolation,
IECore.PrimitiveVariable.Interpolation.Vertex)
self.assertEqual(
len(result["Cs"].data),
result.variableSize(IECore.PrimitiveVariable.Interpolation.Vertex))
def testWeldUVs( self ) : torus = self.createTorus() uvunwrap = torus.createOutputNode( "uvunwrap" ) converter = IECoreHoudini.FromHoudiniPolygonsConverter( uvunwrap ) result = converter.convert() if hou.applicationVersion()[0] >= 15 : self.assertEqual( result.keys(), [ "P", "uv" ] ) else : self.assertEqual( result.keys(), [ "P", "uv", "varmap" ] ) self.assertTrue( result.arePrimitiveVariablesValid() ) self.assertEqual( result["uv"].data.getInterpretation(), IECore.GeometricData.Interpretation.UV ) self.assertEqual( result["uv"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ) uvData = result["uv"].data uvIndices = result["uv"].indices geo = uvunwrap.geometry() uvs = geo.findVertexAttrib( "uv" ) i = 0 for prim in geo.prims() : verts = list(prim.vertices()) verts.reverse() for vert in verts : uvValues = vert.attribValue( uvs ) self.assertAlmostEqual( uvData[ uvIndices[i] ][0], uvValues[0] ) self.assertAlmostEqual( uvData[ uvIndices[i] ][1], uvValues[1] ) i += 1 converter["weldUVs"].setTypedValue( False ) result = converter.convert() if hou.applicationVersion()[0] >= 15 : self.assertEqual( result.keys(), [ "P", "uv" ] ) else : self.assertEqual( result.keys(), [ "P", "uv", "varmap" ] ) self.assertTrue( result.arePrimitiveVariablesValid() ) self.assertEqual( result["uv"].data.getInterpretation(), IECore.GeometricData.Interpretation.UV ) self.assertEqual( result["uv"].interpolation, IECoreScene.PrimitiveVariable.Interpolation.FaceVarying ) uvData = result["uv"].data self.assertEqual( result["uv"].indices, None ) geo = uvunwrap.geometry() uvs = geo.findVertexAttrib( "uv" ) i = 0 for prim in geo.prims() : verts = list(prim.vertices()) verts.reverse() for vert in verts : uvValues = vert.attribValue( uvs ) self.assertAlmostEqual( uvData[i][0], uvValues[0] ) self.assertAlmostEqual( uvData[i][1], uvValues[1] ) i += 1
def testObjectWasDeleted( self ) :
obj = hou.node("/obj")
geo = obj.createNode("geo", run_init_scripts=False)
torus = geo.createNode( "torus" )
converter = IECoreHoudini.FromHoudiniPolygonsConverter( torus )
g1 = converter.convert()
torus.destroy()
g2 = converter.convert()
self.assertEqual( g2, g1 )
self.assertRaises( RuntimeError, IECore.curry( IECoreHoudini.FromHoudiniPolygonsConverter, torus ) )
def testConversionIntoExistingSop( self ) : mesh = self.mesh() sop = self.meshSop() orig = IECoreHoudini.FromHoudiniPolygonsConverter( sop ).convert() self.assertNotEqual( orig, mesh ) self.assert_( IECoreHoudini.ToHoudiniPolygonsConverter( mesh ).convert( sop, False ) ) self.comparePrimAndSop( mesh, sop )
def testNewScene(self):
box = self.createBox()
w = weakref.ref(box)
converter = IECoreHoudini.FromHoudiniPolygonsConverter(box)
result = converter.convert()
hou.hipFile.clear(False)
self.assertRaises(Exception, w())
self.assertEqual(converter.convert(), result)
