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)