def testAppendingIntoLockedSop( self ) :
		curves = self.curves()
		curvesNumPoints = curves.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		sop = self.curvesSop()
		
		orig = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		origNumPoints = orig.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertNotEqual( orig, curves )
		
		sop.setHardLocked( True )
		self.assert_( sop.isHardLocked() )
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, True ) )
		self.assert_( sop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, sop, orig )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )
		
		sop.setHardLocked( False )
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints )
		self.assert_( "floatDetail" not in result.keys() )
		self.assert_( "floatPoint" not in result.keys() )
示例#2
0
    def testErrorStates(self):

        # no prims
        merge = self.createCurves(4)
        add = merge.createOutputNode("add")
        add.parm("keep").set(True)  # deletes primitive and leaves points
        converter = IECoreHoudini.FromHoudiniCurvesConverter(add)
        self.assertRaises(RuntimeError, converter.convert)

        # non-curve prims
        merge = self.createCurves(4)
        merge.createInputNode(5, "box")
        converter = IECoreHoudini.FromHoudiniCurvesConverter(merge)
        self.assertRaises(RuntimeError, converter.convert)

        # many curves, different orders
        merge = self.createCurves(4)
        hou.parm("/obj/geo3/curve3/order").set(3)
        converter = IECoreHoudini.FromHoudiniCurvesConverter(merge)
        self.assertRaises(RuntimeError, converter.convert)

        # many curves, different periodicity
        merge = self.createCurves(4)
        hou.parm("/obj/geo4/curve3/close").set(True)
        converter = IECoreHoudini.FromHoudiniCurvesConverter(merge)
        self.assertRaises(RuntimeError, converter.convert)
示例#3
0
 def testAnimatingGeometry(self):
     curves = self.createCurves(4)
     mountain = curves.createOutputNode("mountain")
     mountain.parm("offset1").setExpression("$FF")
     converter = IECoreHoudini.FromHoudiniCurvesConverter(mountain)
     hou.setFrame(1)
     result1 = converter.convert()
     hou.setFrame(2)
     converter = IECoreHoudini.FromHoudiniCurvesConverter(mountain)
     result2 = converter.convert()
     self.assertNotEqual(result1["P"].data, result2["P"].data)
     self.assertNotEqual(result1, result2)
示例#4
0
    def testName(self):

        curves = self.createCurves(4)
        name = curves.createOutputNode("name")
        name.parm("name1").set("testName")
        result = IECoreHoudini.FromHoudiniCurvesConverter(name).convert()
        self.assertEqual(result.blindData()['name'].value, "testName")
        self.assertFalse("name" in result)
        self.assertFalse("nameIndices" in result)

        group = curves.createOutputNode("group")
        group.parm("crname").set("testGroup")
        result = IECoreHoudini.FromHoudiniCurvesConverter(group).convert()
        self.assertEqual(result.blindData()['name'].value, "testGroup")
	def testWithUnacceptablePrimVars( self ) :
		curves = self.curves()
		curves["badDetail"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Constant, IECore.TransformationMatrixfData() )
		curves["badPoint"] = IECore.PrimitiveVariable( IECore.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 ] ) )
		curves["badPrim"] = IECore.PrimitiveVariable( IECore.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 ] ) )
		curves["badVert"] = IECore.PrimitiveVariable( IECore.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.ToHoudiniCurvesConverter( curves ).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.FromHoudiniCurvesConverter( sop ).convert()
		self.assertNotEqual( result, curves )
		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 curves["badDetail"]
		del curves["badPoint"]
		del curves["badPrim"]
		del curves["badVert"]
		self.comparePrimAndSop( curves, sop )
示例#6
0
    def testAttributeFilter(self):

        curves = self.createCurves(4)
        uvunwrap = curves.createOutputNode("uvunwrap")
        converter = IECoreHoudini.FromHoudiniCurvesConverter(uvunwrap)
        self.assertEqual(sorted(converter.convert().keys()), [
            'P', 'detailAttribute', 'pointAttribute', 'primAttribute', 's',
            't', 'varmap', 'vertexAttribute'
        ])
        converter.parameters()["attributeFilter"].setTypedValue("P")
        self.assertEqual(sorted(converter.convert().keys()), ["P"])
        converter.parameters()["attributeFilter"].setTypedValue(
            "* ^primAttribute ^varmap")
        self.assertEqual(sorted(converter.convert().keys()), [
            'P', 'detailAttribute', 'pointAttribute', 's', 't',
            'vertexAttribute'
        ])
        # P must be converted
        converter.parameters()["attributeFilter"].setTypedValue("* ^P")
        self.assertTrue("P" in converter.convert().keys())
        # have to filter the source attr uv and not s, t
        converter.parameters()["attributeFilter"].setTypedValue("s t")
        self.assertEqual(sorted(converter.convert().keys()), ["P"])
        converter.parameters()["attributeFilter"].setTypedValue("s")
        self.assertEqual(sorted(converter.convert().keys()), ["P"])
        converter.parameters()["attributeFilter"].setTypedValue("uv")
        self.assertEqual(sorted(converter.convert().keys()), ["P", "s", "t"])
	def testMultipleConversions( self ) :
		curves = self.curves()
		curvesNumPoints = curves.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		sop = self.curvesSop()
		
		orig = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		origNumPoints = orig.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertNotEqual( orig, curves )
		
		self.assert_( not sop.isHardLocked() )
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, True ) )
		self.assert_( sop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, sop, orig )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )

		self.assert_( sop.isHardLocked() )
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, True ) )
		self.assert_( sop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, sop, result, multipleConversions=True )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + 2*curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )
			self.assertEqual( result["P"].data[ origNumPoints + curvesNumPoints + i ], curves["P"].data[i] )
		
		self.assert_( sop.isHardLocked() )
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, True ) )
		self.assert_( sop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, sop, result, multipleConversions=True )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + 3*curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )
			self.assertEqual( result["P"].data[ origNumPoints + curvesNumPoints + i ], curves["P"].data[i] )
			self.assertEqual( result["P"].data[ origNumPoints + 2*curvesNumPoints + i ], curves["P"].data[i] )
示例#8
0
    def testStandardAttributeConversion(self):

        curves = self.createCurves(4)
        color = curves.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.FromHoudiniCurvesConverter(uvunwrap)
        result = converter.convert()
        self.assertEqual(result.keys(), [
            "Cs", "P", "Pref", "detailAttribute", "pointAttribute",
            "primAttribute", "s", "t", "varmap", "vertexAttribute", "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():
            for vert in prim.vertices():
                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", "detailAttribute", "pointAttribute", "primAttribute",
            "pscale", "rest", "uv", "varmap", "vertexAttribute"
        ])
        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():
            for vert in prim.vertices():
                uvValues = vert.attribValue(uvs)
                self.assertAlmostEqual(uvData[i][0], uvValues[0])
                self.assertAlmostEqual(uvData[i][1], uvValues[1])
                i += 1
示例#9
0
    def testCreateConverter(self):
        curve = self.createCurve()
        converter = IECoreHoudini.FromHoudiniCurvesConverter(curve)
        self.assert_(
            converter.isInstanceOf(
                IECore.TypeId(
                    IECoreHoudini.TypeId.FromHoudiniCurvesConverter)))

        return converter
示例#10
0
	def comparePrimAndSop( self, prim, sop ) :
		geo = sop.geometry()
		for key in [ "floatDetail", "intDetail", "stringDetail" ] :
			self.assertEqual( prim[key].data.value, geo.attribValue( key ) )
		
		for key in [ "v2fDetail", "v3fDetail", "color3fDetail", "v2iDetail", "v3iDetail" ] :
			self.assertEqual( tuple(prim[key].data.value), geo.attribValue( key ) )
		
		sopPoints = geo.points()
		for key in [ "floatPoint", "intPoint" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( data[i], sopPoints[i].attribValue( key ) )
		
		for key in [ "P", "v2fPoint", "v3fPoint", "color3fPoint", "v2iPoint", "v3iPoint" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( tuple(data[i]), sopPoints[i].attribValue( key ) )
		
		data = prim["stringPoint"].data
		dataIndices = prim["stringPointIndices"].data
		for i in range( 0, data.size() ) :
			self.assertEqual( data[ dataIndices[i] ], sopPoints[i].attribValue( "stringPoint" ) )
		
		sopPrims = geo.prims()
		self.assertEqual( len(sopPrims), prim.numCurves() )
		
		for key in [ "floatPrim", "intPrim" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( data[i], sopPrims[i].attribValue( key ) )
		
		for key in [ "v2fPrim", "v3fPrim", "color3fPrim", "v2iPrim", "v3iPrim" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( tuple(data[i]), sopPrims[i].attribValue( key ) )
		
		data = prim["stringPrim"].data
		dataIndices = prim["stringPrimIndices"].data
		for i in range( 0, data.size() ) :
			self.assertEqual( data[ dataIndices[i] ], sopPrims[i].attribValue( "stringPrim" ) )
		
		sopVerts = []
		for i in range( 0, len(sopPrims) ) :
			verts = list(sopPrims[i].vertices())
			self.assertEqual( len(verts), prim.verticesPerCurve()[i] )
			verts.reverse()
			sopVerts.extend( verts )
		
		self.assertEqual( len(sopVerts), prim["P"].data.size() )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		self.assertEqual( result.verticesPerCurve(), prim.verticesPerCurve() )
		self.assertEqual( result.keys(), prim.keys() )
		for key in prim.keys() :
			self.assertEqual( result[key], prim[key] )
		self.assertEqual( result, prim )
示例#11
0
	def testObjectWasDeleted( self ) :
		curves = self.curves()
		sop = self.curvesSop()
		
		converter = IECoreHoudini.ToHoudiniCurvesConverter( curves )
		
		self.assert_( converter.convert( sop, False ) )
		
		self.comparePrimAndSop( curves, sop )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		
		del curves
		
		sop.setHardLocked( False )
		self.assertNotEqual( IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert(), result )
		self.assert_( converter.convert( sop, False ) )
		self.assertEqual( IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert(), result )
示例#12
0
    def testName(self):

        curves = self.createCurves(4)
        name = curves.createOutputNode("name")
        name.parm("name1").set("curvesA")
        curves2 = self.createCurve(parent=curves.parent())
        name2 = curves2.createOutputNode("name")
        name2.parm("name1").set("curvesB")
        merge = name.createOutputNode("merge")
        merge.setInput(1, name2)

        converter = IECoreHoudini.FromHoudiniCurvesConverter(merge)
        result = converter.convert()
        # names are not stored on the object at all
        self.assertEqual(result.blindData(), IECore.CompoundData())
        self.assertFalse("name" in result)
        self.assertFalse("nameIndices" in result)
        # all curves were converted as one CurvesPrimitive
        self.assertEqual(
            result.variableSize(
                IECore.PrimitiveVariable.Interpolation.Uniform), 5)
        self.assertTrue(result.arePrimitiveVariablesValid())

        converter = IECoreHoudini.FromHoudiniGeometryConverter.create(
            merge, "curvesA")
        self.assertTrue(
            converter.isInstanceOf(
                IECore.TypeId(
                    IECoreHoudini.TypeId.FromHoudiniCurvesConverter)))
        result = converter.convert()
        # names are not stored on the object at all
        self.assertEqual(result.blindData(), IECore.CompoundData())
        self.assertFalse("name" in result)
        self.assertFalse("nameIndices" in result)
        # only the named curves were converted
        self.assertEqual(
            result.variableSize(
                IECore.PrimitiveVariable.Interpolation.Uniform), 4)
        self.assertTrue(result.arePrimitiveVariablesValid())

        converter = IECoreHoudini.FromHoudiniGeometryConverter.create(
            merge, "curvesB")
        self.assertTrue(
            converter.isInstanceOf(
                IECore.TypeId(
                    IECoreHoudini.TypeId.FromHoudiniCurvesConverter)))
        result = converter.convert()
        # names are not stored on the object at all
        self.assertEqual(result.blindData(), IECore.CompoundData())
        self.assertFalse("name" in result)
        self.assertFalse("nameIndices" in result)
        # only the named curves were converted
        self.assertEqual(
            result.variableSize(
                IECore.PrimitiveVariable.Interpolation.Uniform), 1)
        self.assertTrue(result.arePrimitiveVariablesValid())
示例#13
0
	def testConversionIntoExistingSop( self ) :
		curves = self.curves()
		sop = self.curvesSop()
		
		orig = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		self.assertNotEqual( orig, curves )
		
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, False ) )
		
		self.comparePrimAndSop( curves, sop )
示例#14
0
	def testSaveLoadWithLockedSop( self ) :
		hou.hipFile.clear( suppress_save_prompt=True )
		
		curves = self.curves()
		curvesNumPoints = curves.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		sop = self.curvesSop()
		sopPath = sop.path()
		
		orig = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		origNumPoints = orig.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertNotEqual( orig, curves )
		
		sop.setHardLocked( True )
		self.assert_( sop.isHardLocked() )
		self.assert_( IECoreHoudini.ToHoudiniCurvesConverter( curves ).convert( sop, True ) )
		self.assert_( sop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, sop, orig )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )
		
		hou.hipFile.save( TestToHoudiniCurvesConverter.__testScene )
		hou.hipFile.clear( suppress_save_prompt=True )
		hou.hipFile.load( TestToHoudiniCurvesConverter.__testScene )
		
		newSop = hou.node( sopPath )
		
		self.assert_( newSop.isHardLocked() )
		
		self.comparePrimAndAppendedSop( curves, newSop, orig )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( newSop ).convert()
		resultNumPoints = result.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( resultNumPoints, origNumPoints + curvesNumPoints )
		for i in range( 0, curves["P"].data.size() ) :
			self.assertEqual( result["P"].data[ origNumPoints + i ], curves["P"].data[i] )
示例#15
0
    def verifyBSplineCurves(self, sop):
        result = IECoreHoudini.FromHoudiniCurvesConverter(sop).convert()
        self.assertEqual(result.typeId(), IECoreScene.TypeId.CurvesPrimitive)
        self.assert_(result.arePrimitiveVariablesValid())

        geo = sop.geometry()
        bBox = result.bound()
        hBBox = geo.boundingBox()
        for i in range(0, 3):
            self.assertAlmostEqual(bBox.min()[i], hBBox.minvec()[i])
            self.assertAlmostEqual(bBox.max()[i], hBBox.maxvec()[i])

        if result.periodic():
            extraPoints = 0
        else:
            extraPoints = 4

        self.assertEqual(
            result.variableSize(
                IECoreScene.PrimitiveVariable.Interpolation.Vertex),
            len(geo.points()) + extraPoints * len(geo.prims()))
        self.assertEqual(result.verticesPerCurve().size(), len(geo.prims()))
        self.assertEqual(result["P"].data.getInterpretation(),
                         IECore.GeometricData.Interpretation.Point)

        pIndex = 0
        for i in range(len(result.verticesPerCurve())):
            self.assertEqual(result.verticesPerCurve()[i],
                             geo.prims()[i].numVertices() + extraPoints)

            hVertices = geo.prims()[i].vertices()
            for j in range(len(hVertices)):

                if not result.periodic() and (j == 0
                                              or j == len(hVertices) - 1):
                    self.assertEqual(tuple(result["P"].data[pIndex]),
                                     tuple(hVertices[j].point().position()))
                    self.assertEqual(tuple(result["P"].data[pIndex + 1]),
                                     tuple(hVertices[j].point().position()))
                    pIndex += 2

                self.assertEqual(tuple(result["P"].data[pIndex]),
                                 tuple(hVertices[j].point().position()))
                pIndex += 1

        self.assertEqual(result.basis(), IECore.CubicBasisf.bSpline())

        for attr in geo.globalAttribs():
            if attr.name() == "varmap":
                continue

            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Constant)
            self.assertEqual(result[attr.name()].data.value,
                             geo.attribValue(attr.name()))

        sopPoints = geo.points()
        for attr in geo.pointAttribs():
            if attr.name() == "Pw":
                continue

            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Vertex)

        for attr in geo.vertexAttribs():
            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Vertex)

        sopPrims = geo.prims()
        self.assertEqual(len(sopPrims), len(result.verticesPerCurve()))

        for attr in geo.primAttribs():
            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Uniform)

            data = result[attr.name()].data
            for i in range(0, data.size()):
                self.assertEqual(tuple(data[i]),
                                 sopPrims[i].attribValue(attr.name()))

        pIndex = 0
        for i in range(len(result.verticesPerCurve())):
            hVertices = sopPrims[i].vertices()
            self.assertEqual(
                len(hVertices) + extraPoints,
                result.verticesPerCurve()[i])
            for j in range(len(hVertices)):

                for attr in geo.pointAttribs():
                    if attr.name() == "Pw":
                        continue

                    data = result[attr.name()].data
                    self.assertEqual(
                        tuple(data[pIndex]),
                        hVertices[j].point().attribValue(attr.name()))

                    if not result.periodic() and (j == 0
                                                  or j == len(hVertices) - 1):
                        self.assertEqual(
                            tuple(data[pIndex + 1]),
                            hVertices[j].point().attribValue(attr.name()))
                        self.assertEqual(
                            tuple(data[pIndex + 2]),
                            hVertices[j].point().attribValue(attr.name()))

                for attr in geo.vertexAttribs():
                    data = result[attr.name()].data
                    self.assertEqual(data[pIndex],
                                     hVertices[j].attribValue(attr.name()))

                    if not result.periodic() and (j == 0
                                                  or j == len(hVertices) - 1):
                        self.assertEqual(data[pIndex + 1],
                                         hVertices[j].attribValue(attr.name()))
                        self.assertEqual(data[pIndex + 2],
                                         hVertices[j].attribValue(attr.name()))

                if not result.periodic() and (j == 0
                                              or j == len(hVertices) - 1):
                    pIndex += 3
                else:
                    pIndex += 1
示例#16
0
    def verifyLinearCurves(self, sop):
        result = IECoreHoudini.FromHoudiniCurvesConverter(sop).convert()
        self.assertEqual(result.typeId(), IECoreScene.TypeId.CurvesPrimitive)
        self.assert_(result.arePrimitiveVariablesValid())

        geo = sop.geometry()
        bBox = result.bound()
        hBBox = geo.boundingBox()
        for i in range(0, 3):
            self.assertAlmostEqual(bBox.min()[i], hBBox.minvec()[i])
            self.assertAlmostEqual(bBox.max()[i], hBBox.maxvec()[i])

        self.assertEqual(
            result.variableSize(
                IECoreScene.PrimitiveVariable.Interpolation.Vertex),
            len(geo.points()))
        self.assertEqual(result.verticesPerCurve().size(), len(geo.prims()))
        index = 0
        for i in range(len(result.verticesPerCurve())):
            self.assertEqual(result.verticesPerCurve()[i],
                             geo.prims()[i].numVertices())

            hVertices = geo.prims()[i].vertices()
            for j in range(len(hVertices)):
                self.assertEqual(tuple(result["P"].data[index + j]),
                                 tuple(hVertices[j].point().position()))

            index += result.verticesPerCurve()[i]

        self.assertEqual(result.basis(), IECore.CubicBasisf.linear())

        for attr in geo.globalAttribs():
            if attr.name() == "varmap":
                continue

            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Constant)
            self.assertEqual(result[attr.name()].data.value,
                             geo.attribValue(attr.name()))

        sopPoints = geo.points()
        for attr in geo.pointAttribs():
            if attr.name() == "Pw":
                continue

            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Vertex)

            data = result[attr.name()].data
            for i in range(0, data.size()):
                self.assertEqual(tuple(data[i]),
                                 sopPoints[i].attribValue(attr.name()))

        sopPrims = geo.prims()
        self.assertEqual(len(sopPrims), len(result.verticesPerCurve()))

        for attr in geo.primAttribs():
            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Uniform)

            data = result[attr.name()].data
            for i in range(0, data.size()):
                self.assertEqual(tuple(data[i]),
                                 sopPrims[i].attribValue(attr.name()))

        sopVerts = []
        for i in range(0, len(sopPrims)):
            verts = list(sopPrims[i].vertices())
            self.assertEqual(len(verts), result.verticesPerCurve()[i])
            sopVerts.extend(verts)

        self.assertEqual(result["P"].data.getInterpretation(),
                         IECore.GeometricData.Interpretation.Point)
        self.assertEqual(len(sopVerts), result["P"].data.size())
        for attr in geo.vertexAttribs():
            self.assert_(attr.name() in result)
            self.assertEqual(
                result[attr.name()].interpolation,
                IECoreScene.PrimitiveVariable.Interpolation.Vertex)
            data = result[attr.name()].data
            for i in range(0, data.size()):
                self.assertEqual(data[i], sopVerts[i].attribValue(attr.name()))
示例#17
0
	def compareOpenSplinePrimAndSop( self, prim, sop ) :
		geo = sop.geometry()
		for key in [ "floatDetail", "intDetail", "stringDetail" ] :
			self.assertEqual( prim[key].data.value, geo.attribValue( key ) )
		
		for key in [ "v2fDetail", "v3fDetail", "color3fDetail", "v2iDetail", "v3iDetail" ] :
			self.assertEqual( tuple(prim[key].data.value), geo.attribValue( key ) )
		
		sopPrims = geo.prims()
		
		pIndex = 0
		for i in range( prim.numCurves() ) :
			hVertices = sopPrims[i].vertices()
			self.assertEqual( len(hVertices) + 4, prim.verticesPerCurve()[i] )
			for j in range( len(hVertices) ) :
				
				for attr in geo.pointAttribs() :
					if attr.name() == "Pw" :
						continue
					
					data = prim[attr.name()].data
					if attr.name() in [ "floatPoint", "intPoint" ] :
						self.assertEqual( data[pIndex], hVertices[j].point().attribValue( attr.name() ) )
					else :
						self.assertEqual( tuple(data[pIndex]), hVertices[j].point().attribValue( attr.name() ) )
					
					if ( j == 0 or j == len(hVertices)-1 ) :
						if attr.name() in [ "floatPoint", "intPoint" ] :
							self.assertEqual( data[pIndex+1], hVertices[j].point().attribValue( attr.name() ) )
							self.assertEqual( data[pIndex+2], hVertices[j].point().attribValue( attr.name() ) )
						else :
							self.assertEqual( tuple(data[pIndex+1]), hVertices[j].point().attribValue( attr.name() ) )
							self.assertEqual( tuple(data[pIndex+2]), hVertices[j].point().attribValue( attr.name() ) )
				
				if ( j == 0 or j == len(hVertices)-1 ) :
					pIndex += 3
				else :
					pIndex += 1
		
		self.assertEqual( len(sopPrims), prim.numCurves() )
		
		for key in [ "floatPrim", "intPrim" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( data[i], sopPrims[i].attribValue( key ) )
		
		for key in [ "v2fPrim", "v3fPrim", "color3fPrim", "v2iPrim", "v3iPrim" ] :
			data = prim[key].data
			for i in range( 0, data.size() ) :
				self.assertEqual( tuple(data[i]), sopPrims[i].attribValue( key ) )
		
		data = prim["stringPrim"].data
		dataIndices = prim["stringPrimIndices"].data
		for i in range( 0, data.size() ) :
			self.assertEqual( data[ dataIndices[i] ], sopPrims[i].attribValue( "stringPrim" ) )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		self.assertEqual( result.verticesPerCurve(), prim.verticesPerCurve() )
		self.assertEqual( result.keys(), prim.keys() )
		for key in prim.keys() :
			self.assertEqual( result[key], prim[key] )
		self.assertEqual( result, prim )
示例#18
0
	def comparePrimAndAppendedSop( self, prim, sop, origSopPrim, multipleConversions=False ) :
		geo = sop.geometry()
		for key in [ "floatDetail", "intDetail", "stringDetail" ] :
			self.assertEqual( prim[key].data.value, geo.attribValue( key ) )
		
		for key in [ "v2fDetail", "v3fDetail", "color3fDetail", "v2iDetail", "v3iDetail" ] :
			self.assertEqual( tuple(prim[key].data.value), geo.attribValue( key ) )
		
		sopPoints = geo.points()
		numPoints = prim.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		origNumPoints = origSopPrim.variableSize( IECore.PrimitiveVariable.Interpolation.Vertex )
		self.assertEqual( len(sopPoints), origNumPoints + numPoints )
		
		for key in [ "floatPoint", "intPoint" ] :
			data = prim[key].data
			
			if multipleConversions :
				defaultValue = origSopPrim[key].data
			else :
				defaultValue = [ 0 ] * origNumPoints
			
			for i in range( 0, origNumPoints ) :
				self.assertEqual( defaultValue[i], sopPoints[ i ].attribValue( key ) )
			
			for i in range( 0, data.size() ) :
				self.assertEqual( data[i], sopPoints[ origNumPoints + i ].attribValue( key ) )
		
		for key in [ "P", "v2fPoint", "v3fPoint", "color3fPoint", "v2iPoint", "v3iPoint" ] :
			data = prim[key].data
			
			if multipleConversions or key is "P" :
				defaultValue = origSopPrim[key].data
			else :
				defaultValue = [ [ 0 ] * data[0].dimensions() ] * origNumPoints
			
			for i in range( 0, origNumPoints ) :
				self.assertEqual( tuple(defaultValue[i]), sopPoints[ i ].attribValue( key ) )
			
			for i in range( 0, data.size() ) :
				self.assertEqual( tuple(data[i]), sopPoints[ origNumPoints + i ].attribValue( key ) )
		
		data = prim["stringPoint"].data
		dataIndices = prim["stringPointIndices"].data
		
		if multipleConversions :
			defaultData = origSopPrim["stringPoint"].data
			defaultIndices = origSopPrim["stringPointIndices"].data
			for i in range( 0, origNumPoints ) :
				val = "" if ( defaultIndices[i] >= defaultData.size() ) else defaultData[ defaultIndices[i] ]
				self.assertEqual( val, sopPoints[ i ].attribValue( "stringPoint" ) )
		else :
			defaultValues = [ "" ] * origNumPoints
			for i in range( 0, origNumPoints ) :
				self.assertEqual( defaultValues[i], sopPoints[ i ].attribValue( "stringPoint" ) )
		
		sopPrims = geo.prims()
		origNumPrims = origSopPrim.numCurves()
		self.assertEqual( len(sopPrims), origNumPrims + prim.numCurves() )
		
		for key in [ "floatPrim", "intPrim" ] :
			data = prim[key].data
			
			if multipleConversions :
				defaultValue = origSopPrim[key].data
			else :
				defaultValue = [ 0 ] * origNumPrims
			
			for i in range( 0, origNumPrims ) :
				self.assertEqual( defaultValue[i], sopPrims[ i ].attribValue( key ) )
			
			for i in range( 0, data.size() ) :
				self.assertEqual( data[i], sopPrims[ origNumPrims + i ].attribValue( key ) )
		
		for key in [ "v2fPrim", "v3fPrim", "color3fPrim", "v2iPrim", "v3iPrim" ] :
			data = prim[key].data
			
			if multipleConversions :
				defaultValue = origSopPrim[key].data
			else :
				defaultValue = [ [ 0 ] * data[0].dimensions() ] * origNumPrims
			
			for i in range( 0, origNumPrims ) :
				self.assertEqual( tuple(defaultValue[i]), sopPrims[ i ].attribValue( key ) )
			
			for i in range( 0, data.size() ) :
				self.assertEqual( tuple(data[i]), sopPrims[ origNumPrims + i ].attribValue( key ) )
		
		data = prim["stringPrim"].data
		dataIndices = prim["stringPrimIndices"].data
		
		if multipleConversions :
			defaultData = origSopPrim["stringPrim"].data
			defaultIndices = origSopPrim["stringPrimIndices"].data
			for i in range( 0, origNumPrims ) :
				val = "" if ( defaultIndices[i] >= defaultData.size() ) else defaultData[ defaultIndices[i] ]
				self.assertEqual( val, sopPrims[ i ].attribValue( "stringPrim" ) )
		else :
			defaultValues = [ "" ] * origNumPrims
			for i in range( 0, origNumPrims ) :
				self.assertEqual( defaultValues[i], sopPrims[ i ].attribValue( "stringPrim" ) )
		
		sopVerts = []
		for i in range( 0, len(sopPrims) ) :
			verts = list(sopPrims[i].vertices())
			verts.reverse()
			sopVerts.extend( verts )
			if i > origNumPrims :
				self.assertEqual( len(verts), prim.verticesPerCurve()[i-origNumPrims] )
		
		self.assertEqual( len(sopVerts), origSopPrim["P"].data.size() + prim["P"].data.size() )
		
		result = IECoreHoudini.FromHoudiniCurvesConverter( sop ).convert()
		self.assertEqual( result.verticesPerCurve()[origNumPrims:], prim.verticesPerCurve() )
		for key in prim.keys() :
			self.assert_( key in result.keys() )