Пример #1
0
	def testAppending( self ) :
		null = self.emptySop()
		scene = self.buildScene()
		self.failUnless( IECoreHoudini.ToHoudiniGroupConverter( scene ).convert( null ) )
		geo = null.geometry()
		nameAttr = geo.findPrimAttrib( "name" )
		self.assertEqual( sorted(nameAttr.strings()), [ "curveBoxGroup", "meshGroupA", "meshGroupB" ] )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupA" ]), 6 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupB" ]), 6 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup" ]), 12 )
		
		result = IECoreHoudini.FromHoudiniGroupConverter( null ).convert()
		children = result.children()
		for i in range ( 0, len(children) ) :
			name = children[i].blindData()['name'].value
			self.failUnless( name in nameAttr.strings() )
			self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), len([ x for x in geo.prims() if x.attribValue( "name" ) == name ] ) )
			
		self.failUnless( IECoreHoudini.ToHoudiniGroupConverter( scene ).convert( null, append=True ) )
		geo = null.geometry()
		nameAttr = geo.findPrimAttrib( "name" )
		self.assertEqual( sorted(nameAttr.strings()), [ "curveBoxGroup", "meshGroupA", "meshGroupB" ] )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupA" ]), 12 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupB" ]), 12 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup" ]), 24 )
		
		result = IECoreHoudini.FromHoudiniGroupConverter( null ).convert()
		children = result.children()
		for i in range ( 0, len(children) ) :
			name = children[i].blindData()['name'].value
			self.failUnless( name in nameAttr.strings() )
			self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), len([ x for x in geo.prims() if x.attribValue( "name" ) == name ] ) )
Пример #2
0
	def testAppending( self ) :
		null = self.emptySop()
		scene = self.buildScene()
		self.failUnless( IECoreHoudini.ToHoudiniGroupConverter( scene ).convert( null ) )
		geo = null.geometry()
		nameAttr = geo.findPrimAttrib( "name" )
		names = [ "curveBoxGroup", "curveBoxGroup/boxPoints", "meshGroupA", "meshGroupB", "pointsGroup" ]
		self.assertEqual( sorted(nameAttr.strings()), names )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupA" ]), 6 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupB" ]), 6 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup" ]), 12 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "pointsGroup" ]), 1 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup/boxPoints" ]), 1 )
		
		result = IECoreHoudini.FromHoudiniGroupConverter( null ).convert()
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		children = result.children()
		for i in range ( 0, len(children) ) :
			name = names[i]
			self.failUnless( name in nameAttr.strings() )
			if isinstance( children[i], IECore.PointsPrimitive ) :
				numPoints = sum( [ len(x.vertices()) for x in geo.prims() if x.attribValue( "name" ) == name ] )
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), 1 )
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ), numPoints )
			else :
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), len([ x for x in geo.prims() if x.attribValue( "name" ) == name ] ) )
			
		self.failUnless( IECoreHoudini.ToHoudiniGroupConverter( scene ).convert( null, append=True ) )
		geo = null.geometry()
		nameAttr = geo.findPrimAttrib( "name" )
		names = [ "curveBoxGroup", "curveBoxGroup/boxPoints", "meshGroupA", "meshGroupB", "pointsGroup" ] 
		self.assertEqual( sorted(nameAttr.strings()), names )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupA" ]), 12 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "meshGroupB" ]), 12 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup" ]), 24 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "pointsGroup" ]), 2 )
		self.assertEqual( len([ x for x in geo.prims() if x.attribValue( "name" ) == "curveBoxGroup/boxPoints" ]), 2 )
		
		result = IECoreHoudini.FromHoudiniGroupConverter( null ).convert()
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		children = result.children()
		for i in range ( 0, len(children) ) :
			name = names[i]
			self.failUnless( name in nameAttr.strings() )
			if isinstance( children[i], IECore.PointsPrimitive ) :
				numPoints = sum( [ len(x.vertices()) for x in geo.prims() if x.attribValue( "name" ) == name ] )
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), 1 )
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Vertex ), numPoints )
			else :
				self.assertEqual( children[i].variableSize( IECore.PrimitiveVariable.Interpolation.Uniform ), len([ x for x in geo.prims() if x.attribValue( "name" ) == name ] ) )
Пример #3
0
	def testConvertSceneFromNameAttribute( self ) :
		merge = self.buildScene()
		converter = IECoreHoudini.FromHoudiniGroupConverter( merge )
		converter["groupingMode"].setTypedValue( IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.NameAttribute )
		result = converter.convert()
		
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 5 )
		self.assertEqual( set([ x.typeId() for x in result.children() ]), set([IECore._IECore.TypeId.CurvesPrimitive, IECore._IECore.TypeId.MeshPrimitive, IECore._IECore.TypeId.PointsPrimitive]) )
		names = [ "curveBoxGroup", "curveBoxGroup", "pointsGroup", "torusAGroup", "torusBGroup" ]
		expectedTypes = [ IECore.TypeId.MeshPrimitive, IECore.TypeId.CurvesPrimitive, IECore.TypeId.PointsPrimitive, IECore.TypeId.MeshPrimitive, IECore.TypeId.MeshPrimitive ]
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		
		for i in range( 0, len(result.children()) ) :
		
			child = result.children()[i]
			self.failUnless( child.arePrimitiveVariablesValid() )
			self.failUnless( "name" not in child )
			self.failUnless( "nameIndices" not in child )
			self.assertTrue( child.isInstanceOf( expectedTypes[i] ) )
			blindData = IECore.CompoundData() if names[i] == "" else IECore.CompoundData( { "name" : names[i] } )
			self.assertEqual( child.blindData(), blindData )
		
		null = merge.parent().createNode( "null" )
		self.failUnless( IECoreHoudini.ToHoudiniGeometryConverter.create( result ).convert( null ) )
		for prim in null.geometry().prims() :
			self.failUnless( prim.stringAttribValue( "name" ) in names )
    def testInterpolation(self):

        torusA = self.torusA()
        attrA = torusA.createOutputNode("attribcreate",
                                        node_name="interpolation",
                                        exact_type_name=True)
        attrA.parm("name").set("ieMeshInterpolation")
        attrA.parm("class").set(1)  # prim
        attrA.parm("type").set(3)  # string
        attrA.parm("string").set("subdiv")
        torusB = self.torusB()
        attrB = torusB.createOutputNode("attribcreate",
                                        node_name="interpolation",
                                        exact_type_name=True)
        attrB.parm("name").set("ieMeshInterpolation")
        attrB.parm("class").set(1)  # prim
        attrB.parm("type").set(3)  # string
        attrB.parm("string").set("poly")
        merge = self.geo().createNode("merge")
        merge.setInput(0, attrA)
        merge.setInput(1, attrB)

        result = IECoreHoudini.FromHoudiniGroupConverter(merge).convert()
        self.assertTrue(
            "ieMeshInterpolation" not in result.children()[0].keys())
        self.assertEqual(result.children()[0].interpolation, "catmullClark")
        self.assertTrue(
            "ieMeshInterpolation" not in result.children()[1].keys())
        self.assertEqual(result.children()[1].interpolation, "linear")
Пример #5
0
 def testConvertScene(self):
     result = IECoreHoudini.FromHoudiniGroupConverter(
         self.buildScene()).convert()
     self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
     self.assertEqual(len(result.children()), 5)
     self.assertEqual(result.children()[0].blindData()["name"].value,
                      "curveBoxGroup")
     self.failUnless(result.children()[0].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
     self.assertEqual(result.children()[1].blindData()["name"].value,
                      "curveBoxGroup")
     self.failUnless(result.children()[1].isInstanceOf(
         IECore.TypeId.CurvesPrimitive))
     self.assertEqual(result.children()[2].blindData()["name"].value,
                      "pointsGroup")
     self.failUnless(result.children()[2].isInstanceOf(
         IECore.TypeId.PointsPrimitive))
     self.assertEqual(result.children()[3].blindData()["name"].value,
                      "torusAGroup")
     self.failUnless(result.children()[3].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
     self.assertEqual(result.children()[4].blindData()["name"].value,
                      "torusBGroup")
     self.failUnless(result.children()[4].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
Пример #6
0
	def testStandardAttributeConversion( self ) :
		
		merge = self.buildScene()
		color = merge.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.FromHoudiniGroupConverter( uvunwrap )
		result = converter.convert()
		for child in result.children() :
			self.assertEqual( child.keys(), ['Cs', 'P', 'Pref', 'accel', 'born', 'event', 'generator', 'generatorIndices', 'id', 'life', 'nextid', 'parent', 'pstate', 's', 'source', 't', 'v', 'varmap', 'width'] )
			self.assertTrue( child.arePrimitiveVariablesValid() )
			self.assertEqual( child["P"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point )
			self.assertEqual( child["Pref"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point )
			self.assertEqual( child["accel"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
			self.assertEqual( child["v"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
		
		converter["convertStandardAttributes"].setTypedValue( False )
		result = converter.convert()
		for child in result.children() :
			self.assertEqual( child.keys(), ['Cd', 'P', 'accel', 'born', 'event', 'generator', 'generatorIndices', 'id', 'life', 'nextid', 'parent', 'pscale', 'pstate', 'rest', 'source', 'uv', 'v', 'varmap'] )
			self.assertTrue( child.arePrimitiveVariablesValid() )
			self.assertEqual( child["P"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point )
			self.assertEqual( child["rest"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point )
			self.assertEqual( child["accel"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
			self.assertEqual( child["v"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
Пример #7
0
	def testConvertGroupedPolygons( self ) :
		result = IECoreHoudini.FromHoudiniGroupConverter( self.torusA() ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 1 )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.failUnless( result.children()[0].isInstanceOf( IECore.TypeId.MeshPrimitive ) )
		self.assertEqual( result.children()[0].blindData(), IECore.CompoundData( { "name" : "torusAGroup" } ) )
Пример #8
0
	def testConvertUngroupedCurves( self ) :
		result = IECoreHoudini.FromHoudiniGroupConverter( self.curve() ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 1 )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.failUnless( result.children()[0].isInstanceOf( IECore.TypeId.CurvesPrimitive ) )
		self.assertEqual( result.children()[0].blindData(), IECore.CompoundData() )
Пример #9
0
    def testNonPrimitiveNameAttribute(self):
        merge = self.buildScene()
        for node in merge.parent().children():
            if node.type().name() == "name":
                node.bypass(True)

        attrib = merge.createOutputNode("attribcreate")
        attrib.parm("name1").set("name")
        attrib.parm("class1").set(2)  # Point
        attrib.parm("type1").set(3)  # String
        converter = IECoreHoudini.FromHoudiniGroupConverter(attrib)
        converter["groupingMode"].setTypedValue(
            IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.NameAttribute)
        result = converter.convert()
        self.assertTrue(result.isInstanceOf(IECore.TypeId.Group))
        self.assertEqual(result.blindData(), IECore.CompoundData())
        self.assertEqual(len(result.children()), 3)
        for i in range(0, 3):
            self.assertEqual(result.children()[i].blindData(),
                             IECore.CompoundData())
        self.assertTrue(result.children()[0].isInstanceOf(
            IECore.TypeId.MeshPrimitive))
        self.assertTrue(result.children()[1].isInstanceOf(
            IECore.TypeId.CurvesPrimitive))
        self.assertTrue(result.children()[2].isInstanceOf(
            IECore.TypeId.PointsPrimitive))
Пример #10
0
 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])
Пример #11
0
	def testObjectWasDeleted( self ) :
		torii = self.twoTorii()
		converter = IECoreHoudini.FromHoudiniGroupConverter( torii )
		g1 = converter.convert()
		torii.destroy()
		g2 = converter.convert()
		self.assertEqual( g2, g1 )
		self.assertRaises( RuntimeError, IECore.curry( IECoreHoudini.FromHoudiniGroupConverter, torii ) )
Пример #12
0
 def testConvertGroupedPoints(self):
     result = IECoreHoudini.FromHoudiniGroupConverter(
         self.points()).convert()
     self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
     self.assertEqual(len(result.children()), 1)
     self.failUnless(result.children()[0].isInstanceOf(
         IECore.TypeId.PointsPrimitive))
     self.assertEqual(result.children()[0].blindData()["name"].value,
                      "pointsGroup")
Пример #13
0
	def testConvertUngroupedPolygons( self ) :
		group = self.torusA()
		group.bypass( True )
		result = IECoreHoudini.FromHoudiniGroupConverter( group ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 1 )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.failUnless( result.children()[0].isInstanceOf( IECore.TypeId.MeshPrimitive ) )
		self.assertEqual( result.children()[0].blindData(), IECore.CompoundData() )
Пример #14
0
	def testConvertGroupedCurves( self ) :
		curve = self.curve()
		name = curve.createOutputNode( "name" )
		name.parm( "name1" ).set( "curvesGroup" )
		result = IECoreHoudini.FromHoudiniGroupConverter( name ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 1 )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.failUnless( result.children()[0].isInstanceOf( IECore.TypeId.CurvesPrimitive ) )
		self.assertEqual( result.children()[0].blindData(), IECore.CompoundData( { "name" : "curvesGroup" } ) )
Пример #15
0
	def testConvertUngroupedMultiPolygons( self ) :
		merge = self.twoTorii()
		merge.inputs()[0].bypass( True )
		merge.inputs()[1].bypass( True )
		result = IECoreHoudini.FromHoudiniGroupConverter( merge ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 1 )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.failUnless( result.children()[0].isInstanceOf( IECore.TypeId.MeshPrimitive ) )
		self.assertEqual( result.children()[0].blindData(), IECore.CompoundData() )
		self.assertEqual( result.children()[0]["P"].data.size(), 200 )
Пример #16
0
	def testConvertScene( self ) :
		result = IECoreHoudini.FromHoudiniGroupConverter( self.buildScene() ).convert()
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 5 )
		names = [ "curveBoxGroup", "curveBoxGroup", "pointsGroup", "torusAGroup", "torusBGroup" ]
		expectedTypes = [ IECore.TypeId.MeshPrimitive, IECore.TypeId.CurvesPrimitive, IECore.TypeId.PointsPrimitive, IECore.TypeId.MeshPrimitive, IECore.TypeId.MeshPrimitive ]
		for i in range( 0, len(result.children()) ) :
		
			child = result.children()[i]
			self.assertTrue( child.isInstanceOf( expectedTypes[i] ) )
			self.assertEqual( child.blindData(), IECore.CompoundData( { "name" : names[i] } ) )
Пример #17
0
 def testConvertGroupedCurves(self):
     curve = self.curve()
     group = curve.createOutputNode("group")
     group.parm("crname").set("curvesGroup")
     result = IECoreHoudini.FromHoudiniGroupConverter(group).convert()
     self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
     self.assertEqual(len(result.children()), 1)
     self.failUnless(result.children()[0].isInstanceOf(
         IECore.TypeId.CurvesPrimitive))
     self.assertEqual(result.children()[0].blindData()["name"].value,
                      "curvesGroup")
Пример #18
0
	def testInterpretation( self ) :
		
		merge = self.buildScene()
		converter = IECoreHoudini.FromHoudiniGroupConverter( merge )
		result = converter.convert()
		for child in result.children() :
			self.assertTrue( child.isInstanceOf( IECore.TypeId.Primitive ) )
			self.assertEqual( sorted(child.keys()), ['Cs', 'P', 'accel', 'born', 'event', 'generator', 'generatorIndices', 'id', 'life', 'nextid', 'parent', 'pstate', 'source', 'v', 'varmap'] )
			self.assertEqual( child["P"].data.getInterpretation(), IECore.GeometricData.Interpretation.Point )
			self.assertEqual( child["accel"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
			self.assertEqual( child["life"].data.getInterpretation(), IECore.GeometricData.Interpretation.Numeric )
			self.assertEqual( child["v"].data.getInterpretation(), IECore.GeometricData.Interpretation.Vector )
Пример #19
0
    def testNameAttributeExistsButSomeValuesAreEmpty(self):

        merge = self.buildScene()
        values = []
        namers = [
            x for x in merge.parent().children() if x.type().name() == "name"
        ]
        for namer in namers:
            values.append(namer.parm("name1").eval())
            if namer.parm("name1").eval() == "torusBGroup":
                namer.bypass(True)
                values[-1] = ""

        converter = IECoreHoudini.FromHoudiniGroupConverter(merge)
        converter["groupingMode"].setTypedValue(
            IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.NameAttribute)
        result = converter.convert()

        self.failUnless(result.isInstanceOf(IECoreScene.TypeId.Group))
        self.assertEqual(len(result.children()), 5)
        self.assertEqual({x.typeId()
                          for x in result.children()}, {
                              IECoreScene.TypeId.CurvesPrimitive,
                              IECoreScene.TypeId.MeshPrimitive,
                              IECoreScene.TypeId.PointsPrimitive
                          })
        names = [
            "", "curveBoxGroup", "curveBoxGroup", "pointsGroup", "torusAGroup"
        ]
        expectedTypes = [
            IECoreScene.TypeId.MeshPrimitive, IECoreScene.TypeId.MeshPrimitive,
            IECoreScene.TypeId.CurvesPrimitive,
            IECoreScene.TypeId.PointsPrimitive,
            IECoreScene.TypeId.MeshPrimitive
        ]
        self.assertEqual(result.blindData(), IECore.CompoundData())

        for i in range(0, len(result.children())):

            child = result.children()[i]
            self.failUnless(child.arePrimitiveVariablesValid())
            self.failUnless("name" not in child)
            self.assertTrue(child.isInstanceOf(expectedTypes[i]))
            blindData = IECore.CompoundData(
            ) if names[i] == "" else IECore.CompoundData({"name": names[i]})
            self.assertEqual(child.blindData(), blindData)

        null = merge.parent().createNode("null")
        self.failUnless(
            IECoreHoudini.ToHoudiniGeometryConverter.create(result).convert(
                null))
        for prim in null.geometry().prims():
            self.failUnless(prim.stringAttribValue("name") in values)
Пример #20
0
 def testConvertGroupedCurvesAndPolygons(self):
     result = IECoreHoudini.FromHoudiniGroupConverter(
         self.curveBox()).convert()
     self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
     self.assertEqual(len(result.children()), 2)
     self.assertEqual(result.children()[0].blindData()["name"].value,
                      "curveBoxGroup")
     self.failUnless(result.children()[0].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
     self.assertEqual(result.children()[1].blindData()["name"].value,
                      "curveBoxGroup")
     self.failUnless(result.children()[1].isInstanceOf(
         IECore.TypeId.CurvesPrimitive))
Пример #21
0
    def testConvertSceneFromNameAttribute(self):
        merge = self.buildScene()
        converter = IECoreHoudini.FromHoudiniGroupConverter(merge)
        converter["groupingMode"].setTypedValue(
            IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.NameAttribute)
        result = converter.convert()

        self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
        self.assertEqual(len(result.children()), 5)
        self.assertEqual(
            set([x.typeId() for x in result.children()]),
            set([
                IECore._IECore.TypeId.CurvesPrimitive,
                IECore._IECore.TypeId.MeshPrimitive,
                IECore._IECore.TypeId.PointsPrimitive
            ]))
        names = [
            "curveBoxGroup", "curveBoxGroup", "pointsGroup", "torusAGroup",
            "torusBGroup"
        ]
        self.assertEqual(
            sorted([x.blindData()["name"].value for x in result.children()]),
            names)

        for child in result.children():

            self.failUnless(child.arePrimitiveVariablesValid())
            self.failUnless("name" not in child)
            self.failUnless("nameIndices" not in child)
            if child.blindData()["name"].value == "pointsGroup":
                self.failUnless(
                    child.isInstanceOf(IECore.TypeId.PointsPrimitive))
            elif child.blindData()["name"].value == "torusAGroup":
                self.failUnless(child.isInstanceOf(
                    IECore.TypeId.MeshPrimitive))
            elif child.blindData()["name"].value == "torusBGroup":
                self.failUnless(child.isInstanceOf(
                    IECore.TypeId.MeshPrimitive))
            elif child.blindData()["name"].value == "curveBoxGroup":
                self.failUnless(
                    child.isInstanceOf(IECore.TypeId.CurvesPrimitive)
                    or child.isInstanceOf(IECore.TypeId.MeshPrimitive))
            else:
                raise RuntimeError, "An unexpected shape name exists"

        null = merge.parent().createNode("null")
        self.failUnless(
            IECoreHoudini.ToHoudiniGeometryConverter.create(result).convert(
                null))
        for prim in null.geometry().prims():
            self.failUnless(prim.stringAttribValue("name") in names)
Пример #22
0
 def testConvertGroupedMultiPolygons(self):
     result = IECoreHoudini.FromHoudiniGroupConverter(
         self.twoTorii()).convert()
     self.failUnless(result.isInstanceOf(IECore.TypeId.Group))
     self.assertEqual(len(result.children()), 2)
     childNames = [x.blindData()["name"].value for x in result.children()]
     self.failUnless(result.children()[0].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
     self.failUnless("torusAGroup" in childNames)
     self.assertEqual(result.children()[0]["P"].data.size(), 100)
     self.failUnless(result.children()[1].isInstanceOf(
         IECore.TypeId.MeshPrimitive))
     self.failUnless("torusBGroup" in childNames)
     self.assertEqual(result.children()[1]["P"].data.size(), 100)
Пример #23
0
    def testAttributeFilter(self):

        merge = self.buildScene()
        uvunwrap = merge.createOutputNode("uvunwrap")
        converter = IECoreHoudini.FromHoudiniGroupConverter(uvunwrap)
        result = converter.convert()
        expectedKeys = [
            'Cs', 'P', 'accel', 'born', 'event', 'generator',
            'generatorIndices', 'id', 'life', 'nextid', 'parent', 'pstate',
            's', 'source', 't', 'v', 'varmap'
        ]
        if hou.applicationVersion()[0] == 13:
            expectedKeys.remove("varmap")

        for child in result.children():
            self.assertTrue(child.isInstanceOf(IECore.TypeId.Primitive))
            self.assertEqual(sorted(child.keys()), expectedKeys)

        converter.parameters()["attributeFilter"].setTypedValue("P")
        result = converter.convert()
        for child in result.children():
            self.assertEqual(sorted(child.keys()), ["P"])

        converter.parameters()["attributeFilter"].setTypedValue(
            "* ^generator* ^varmap ^born ^event")
        result = converter.convert()
        for child in result.children():
            self.assertEqual(sorted(child.keys()), [
                'Cs', 'P', 'accel', 'id', 'life', 'nextid', 'parent', 'pstate',
                's', 'source', 't', 'v'
            ])

        converter.parameters()["attributeFilter"].setTypedValue("* ^P")
        result = converter.convert()
        for child in result.children():
            # P must be converted
            self.assertTrue("P" in child.keys())

        # have to filter the source attr uv and not s, t
        converter.parameters()["attributeFilter"].setTypedValue("s t Cs")
        result = converter.convert()
        for child in result.children():
            self.assertEqual(sorted(child.keys()), ['P'])

        converter.parameters()["attributeFilter"].setTypedValue("uv Cd")
        result = converter.convert()
        for child in result.children():
            self.assertEqual(sorted(child.keys()), ['Cs', 'P', 's', 't'])
Пример #24
0
 def testConvertGroupedMultiPolygons(self):
     result = IECoreHoudini.FromHoudiniGroupConverter(
         self.twoTorii()).convert()
     self.failUnless(result.isInstanceOf(IECoreScene.TypeId.Group))
     self.assertEqual(len(result.children()), 2)
     self.assertEqual(result.blindData(), IECore.CompoundData())
     self.failUnless(result.children()[0].isInstanceOf(
         IECoreScene.TypeId.MeshPrimitive))
     self.assertEqual(result.children()[0]["P"].data.size(), 100)
     self.assertEqual(result.children()[0].blindData(),
                      IECore.CompoundData({"name": "torusAGroup"}))
     self.failUnless(result.children()[1].isInstanceOf(
         IECoreScene.TypeId.MeshPrimitive))
     self.assertEqual(result.children()[1]["P"].data.size(), 100)
     self.assertEqual(result.children()[1].blindData(),
                      IECore.CompoundData({"name": "torusBGroup"}))
Пример #25
0
	def testFakeNameAttribute( self ) :
		merge = self.buildScene()
		noName = merge.createOutputNode( "attribute" )
		noName.parm( "primdel" ).set( "name" )
		
		converter = IECoreHoudini.FromHoudiniGroupConverter( noName )
		converter["groupingMode"].setTypedValue( IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.NameAttribute )
		result = converter.convert()
		self.assertTrue( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		self.assertEqual( len(result.children()), 3 )
		for i in range( 0, 3 ) :
			self.assertEqual( result.children()[i].blindData(), IECore.CompoundData() )
		self.assertTrue( result.children()[0].isInstanceOf( IECore.TypeId.MeshPrimitive ) )
		self.assertTrue( result.children()[1].isInstanceOf( IECore.TypeId.CurvesPrimitive ) )
		self.assertTrue( result.children()[2].isInstanceOf( IECore.TypeId.PointsPrimitive ) )
Пример #26
0
	def testConvertSceneFromGroups( self ) :
		
		merge = self.buildScene()
		for node in merge.parent().children() :
			if node.type().name() == "name" :
				node.bypass( True )
				group = node.createOutputNode( "group" )
				group.parm( "crname" ).set( node.parm( "name1" ).eval() )
				connection = node.outputConnections()[0]
				connection.outputNode().setInput( connection.inputIndex(), group )
		
		converter = IECoreHoudini.FromHoudiniGroupConverter( merge )
		converter["groupingMode"].setTypedValue( IECoreHoudini.FromHoudiniGroupConverter.GroupingMode.PrimitiveGroup )
		result = converter.convert()
		
		self.failUnless( result.isInstanceOf( IECore.TypeId.Group ) )
		self.assertEqual( len(result.children()), 4 )
		self.assertEqual( set([ x.typeId() for x in result.children() ]), set([IECore._IECore.TypeId.Group, IECore._IECore.TypeId.MeshPrimitive, IECore._IECore.TypeId.PointsPrimitive]) )
		names = [ "pointsGroup", "torusAGroup", "torusBGroup", "curveBoxGroup" ]
		expectedTypes = [ IECore.TypeId.PointsPrimitive, IECore.TypeId.MeshPrimitive, IECore.TypeId.MeshPrimitive, IECore.TypeId.Group ]
		self.assertEqual( result.blindData(), IECore.CompoundData() )
		
		for i in range( 0, len(result.children()) ) :
			
			child = result.children()[i]
			self.assertTrue( child.isInstanceOf( expectedTypes[i] ) )
			self.assertEqual( child.blindData(), IECore.CompoundData( { "name" : names[i] } ) )
			
			if child.isInstanceOf( IECore.TypeId.Primitive ) :
				self.failUnless( child.arePrimitiveVariablesValid() )
				self.failUnless( "name" not in child )
				self.failUnless( "nameIndices" not in child )
			
			elif child.isInstanceOf( IECore.TypeId.Group ) :
				self.assertEqual( child.blindData(), IECore.CompoundData( { "name" : "curveBoxGroup" } ) )
				self.failUnless( child.children()[0].isInstanceOf( IECore.TypeId.MeshPrimitive ) )
				self.assertEqual( child.children()[0].blindData(), IECore.CompoundData() )
				self.failUnless( child.children()[1].isInstanceOf( IECore.TypeId.CurvesPrimitive ) )
				self.assertEqual( child.children()[1].blindData(), IECore.CompoundData() )
		
		null = merge.parent().createNode( "null" )
		self.failUnless( IECoreHoudini.ToHoudiniGeometryConverter.create( result ).convert( null ) )
		for prim in null.geometry().prims() :
			self.failUnless( prim.stringAttribValue( "name" ) in names )
Пример #27
0
    def testInterpretation(self):

        merge = self.buildScene()
        converter = IECoreHoudini.FromHoudiniGroupConverter(merge)
        result = converter.convert()
        expectedKeys = [
            'Cs', 'P', 'accel', 'born', 'event', 'generator', 'id', 'life',
            'nextid', 'parent', 'pstate', 'source', 'v', 'varmap'
        ]
        if hou.applicationVersion()[0] >= 13:
            expectedKeys.remove("varmap")

        for child in result.children():
            self.assertTrue(child.isInstanceOf(IECoreScene.TypeId.Primitive))
            self.assertEqual(sorted(child.keys()), expectedKeys)
            self.assertEqual(child["P"].data.getInterpretation(),
                             IECore.GeometricData.Interpretation.Point)
            self.assertEqual(child["accel"].data.getInterpretation(),
                             IECore.GeometricData.Interpretation.Vector)
            self.assertEqual(child["life"].data.getInterpretation(),
                             IECore.GeometricData.Interpretation.None)
            self.assertEqual(child["v"].data.getInterpretation(),
                             IECore.GeometricData.Interpretation.Vector)
Пример #28
0
 def testCreateConverter(self):
     converter = IECoreHoudini.FromHoudiniGroupConverter(self.box())
     self.failUnless(
         converter.isInstanceOf(
             IECore.TypeId(IECoreHoudini.TypeId.FromHoudiniGroupConverter)))