Merge pull request #173 from andrewkaufman/geometryTypes

goddardl · goddardl · commit fe78f8fe87ce · 2013-11-08T14:16:34.000-08:00
Houdini SceneCache Geometry Types
diff --git a/include/IECoreHoudini/SceneCacheNode.h b/include/IECoreHoudini/SceneCacheNode.h
@@ -98,6 +98,8 @@ class SceneCacheNode : public BaseType
 		{
 			Cortex,
 			Houdini,
+			BoundingBox,
+			PointCloud
 		};
 		
 		/// convenience methods for the common parameters;
diff --git a/src/IECoreHoudini/SOP_SceneCacheSource.cpp b/src/IECoreHoudini/SOP_SceneCacheSource.cpp
@@ -40,6 +40,8 @@
 
 #include "IECore/CoordinateSystem.h"
 #include "IECore/Group.h"
+#include "IECore/MeshPrimitive.h"
+#include "IECore/PointsPrimitive.h"
 #include "IECore/TransformOp.h"
 #include "IECore/VisibleRenderable.h"
 
@@ -268,24 +270,8 @@ void SOP_SceneCacheSource::loadObjects( const IECore::SceneInterface *scene, Ima
 	
 	if ( scene->hasObject() && UT_String( scene->name() ).multiMatch( params.shapeFilter ) && tagged( scene, params.tagFilter ) )
 	{
-		ConstObjectPtr object = scene->readObject( time );
 		std::string name = relativePath( scene, rootSize );
 		
-		params.hasAnimatedTopology = scene->hasAttribute( SceneCache::animatedObjectTopologyAttribute );
-		params.hasAnimatedPrimVars = scene->hasAttribute( SceneCache::animatedObjectPrimVarsAttribute );
-		if ( params.hasAnimatedPrimVars )
-		{
-			const ConstObjectPtr animatedPrimVarObj = scene->readAttribute( SceneCache::animatedObjectPrimVarsAttribute, 0 );
-			const InternedStringVectorData *animatedPrimVarData = IECore::runTimeCast<const InternedStringVectorData>( animatedPrimVarObj );
-			if ( animatedPrimVarData )
-			{
-				const std::vector<InternedString> &values = animatedPrimVarData->readable();
-				params.animatedPrimVars.clear();
-				params.animatedPrimVars.resize( values.size() );
-				std::copy( values.begin(), values.end(), params.animatedPrimVars.begin() );
-			}
-		}
-		
 		Imath::M44d currentTransform;
 		if ( space == Local )
 		{
@@ -296,6 +282,58 @@ void SOP_SceneCacheSource::loadObjects( const IECore::SceneInterface *scene, Ima
 			currentTransform = transform;
 		}
 		
+		ConstObjectPtr object = 0;
+		if ( params.geometryType == BoundingBox )
+		{
+			Imath::Box3d bound = scene->readBound( time );
+			object = MeshPrimitive::createBox( Imath::Box3f( bound.min, bound.max ) );
+			
+			params.hasAnimatedTopology = false;
+			params.hasAnimatedPrimVars = true;
+			params.animatedPrimVars.clear();
+			params.animatedPrimVars.push_back( "P" );
+		}
+		else if ( params.geometryType == PointCloud )
+		{
+			std::vector<Imath::V3f> point( 1, scene->readBound( time ).center() );
+			PointsPrimitivePtr points = new PointsPrimitive( new V3fVectorData( point ) );
+			std::vector<Imath::V3f> basis1( 1, Imath::V3f( currentTransform[0][0], currentTransform[0][1], currentTransform[0][2] ) );
+			std::vector<Imath::V3f> basis2( 1, Imath::V3f( currentTransform[1][0], currentTransform[1][1], currentTransform[1][2] ) );
+			std::vector<Imath::V3f> basis3( 1, Imath::V3f( currentTransform[2][0], currentTransform[2][1], currentTransform[2][2] ) );
+			points->variables["basis1"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis1 ) );
+			points->variables["basis2"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis2 ) );
+			points->variables["basis3"] = PrimitiveVariable( PrimitiveVariable::Vertex, new V3fVectorData( basis3 ) );
+			
+			params.hasAnimatedTopology = false;
+			params.hasAnimatedPrimVars = true;
+			params.animatedPrimVars.clear();
+			params.animatedPrimVars.push_back( "P" );
+			params.animatedPrimVars.push_back( "basis1" );
+			params.animatedPrimVars.push_back( "basis2" );
+			params.animatedPrimVars.push_back( "basis3" );
+			
+			object = points;
+		}
+		else
+		{
+			object = scene->readObject( time );
+			
+			params.hasAnimatedTopology = scene->hasAttribute( SceneCache::animatedObjectTopologyAttribute );
+			params.hasAnimatedPrimVars = scene->hasAttribute( SceneCache::animatedObjectPrimVarsAttribute );
+			if ( params.hasAnimatedPrimVars )
+			{
+				const ConstObjectPtr animatedPrimVarObj = scene->readAttribute( SceneCache::animatedObjectPrimVarsAttribute, 0 );
+				const InternedStringVectorData *animatedPrimVarData = IECore::runTimeCast<const InternedStringVectorData>( animatedPrimVarObj );
+				if ( animatedPrimVarData )
+				{
+					const std::vector<InternedString> &values = animatedPrimVarData->readable();
+					params.animatedPrimVars.clear();
+					params.animatedPrimVars.resize( values.size() );
+					std::copy( values.begin(), values.end(), params.animatedPrimVars.begin() );
+				}
+			}
+		}
+		
 		// modify the object if necessary
 		object = modifyObject( object, params );
 		
@@ -449,10 +487,31 @@ bool SOP_SceneCacheSource::convertObject( const IECore::Object *object, const st
 		return false;
 	}
 	
-	// attempt to optimize the conversion by re-using animated primitive variables
 	const Primitive *primitive = IECore::runTimeCast<const Primitive>( object );
+	
+	// attempt to optimize the conversion by re-using animated primitive variables
+	/// \todo: This offset loop is only used because GU_Detail::getRangeByValue is
+	/// terribly slow. Replace this if SideFx improves that function.
+	GA_OffsetList offsets;
 	GA_ROAttributeRef nameAttrRef = gdp->findStringTuple( GA_ATTRIB_PRIMITIVE, "name" );
-	GA_Range primRange = gdp->getRangeByValue( nameAttrRef, name.c_str() );
+	if ( nameAttrRef.isValid() )
+	{
+		const GA_Attribute *nameAttr = nameAttrRef.getAttribute();
+		const GA_AIFSharedStringTuple *tuple = nameAttr->getAIFSharedStringTuple();
+		
+		GA_Range range = gdp->getPrimitiveRange();
+		for ( GA_Iterator it = range.begin(); !it.atEnd(); ++it )
+		{
+			const char *currentName = tuple->getString( nameAttr, it.getOffset(), 0 );
+			if ( UT_String( currentName ).equal( name.c_str() ) )
+			{
+				offsets.append( it.getOffset() );
+			}
+		}
+	}
+	
+	GA_Range primRange( gdp->getPrimitiveMap(), offsets );
+	
 	if ( primitive && !params.hasAnimatedTopology && params.hasAnimatedPrimVars && nameAttrRef.isValid() && !primRange.isEmpty() )
 	{
 		// this means constant topology and primitive variables, even though multiple samples were written
diff --git a/src/IECoreHoudini/SceneCacheNode.cpp b/src/IECoreHoudini/SceneCacheNode.cpp
@@ -116,6 +116,8 @@ static PRM_Name spaceNames[] = {
 static PRM_Name geometryTypes[] = {
 	PRM_Name( "0", "Cortex Primitives" ),
 	PRM_Name( "1", "Houdini Geometry" ),
+	PRM_Name( "2", "Bounding Boxes" ),
+	PRM_Name( "3", "Point Cloud" ),
 	PRM_Name( 0 ) // sentinal
 };
 
diff --git a/src/IECoreHoudini/bindings/SceneCacheNodeBinding.cpp b/src/IECoreHoudini/bindings/SceneCacheNodeBinding.cpp
@@ -133,6 +133,8 @@ void IECoreHoudini::bindSceneCacheNode()
 	enum_<SceneCacheNode<OP_Node>::GeometryType>( "GeometryType" )
 		.value( "Cortex", SceneCacheNode<OP_Node>::Cortex )
 		.value( "Houdini", SceneCacheNode<OP_Node>::Houdini )
+		.value( "BoundingBox", SceneCacheNode<OP_Node>::BoundingBox )
+		.value( "PointCloud", SceneCacheNode<OP_Node>::PointCloud )
 	;
 	
 	enum_<OBJ_SceneCacheTransform::Hierarchy>( "Hierarchy" )
diff --git a/test/IECoreHoudini/SceneCacheTest.py b/test/IECoreHoudini/SceneCacheTest.py
@@ -1447,7 +1447,7 @@ def testNode( node ) :
 		testNode( self.xform() )
 		testNode( self.geometry() )
 	
-	def writeAnimSCC( self ) :
+	def writeAnimSCC( self, rotate = False ) :
 		
 		scene = self.writeSCC()
 		sc1 = scene.child( str( 1 ) )
@@ -1458,14 +1458,20 @@ def writeAnimSCC( self ) :
 		for time in [ 0.5, 1, 1.5, 2, 5, 10 ] :
 			
 			matrix = IECore.M44d.createTranslated( IECore.V3d( 1, time, 0 ) )
+			if rotate :
+				matrix.rotate( IECore.V3d( time, 0, 0 ) )
 			sc1.writeTransform( IECore.M44dData( matrix ), time )
 			
 			mesh["Cs"] = IECore.PrimitiveVariable( IECore.PrimitiveVariable.Interpolation.Uniform, IECore.V3fVectorData( [ IECore.V3f( time, 1, 0 ) ] * 6 ) )
 			sc2.writeObject( mesh, time )
 			matrix = IECore.M44d.createTranslated( IECore.V3d( 2, time, 0 ) )
+			if rotate :
+				matrix.rotate( IECore.V3d( time, 0, 0 ) )
 			sc2.writeTransform( IECore.M44dData( matrix ), time )
 			
 			matrix = IECore.M44d.createTranslated( IECore.V3d( 3, time, 0 ) )
+			if rotate :
+				matrix.rotate( IECore.V3d( time, 0, 0 ) )
 			sc3.writeTransform( IECore.M44dData( matrix ), time )
 		
 		return scene
@@ -2575,6 +2581,108 @@ def testTransformOverride( self ) :
 			self.assertEqual( IECore.M44d( list(b.parmTransform().asTuple()) ), IECore.M44d.createTranslated( IECore.V3d( 2, time, 0 ) ) )
 			self.assertEqual( IECore.M44d( list(c.parmTransform().asTuple()) ), IECore.M44d.createTranslated( IECore.V3d( time, 0, 0 ) ) )
 	
+	def testGeometryTypes( self ) :
+		
+		self.writeAnimSCC()
+		times = range( 0, 10 )
+		halves = [ x + 0.5 for x in times ]
+		quarters = [ x + 0.25 for x in times ]
+		times.extend( [ x + 0.75 for x in times ] )
+		times.extend( halves )
+		times.extend( quarters )
+		times.sort()
+		
+		spf = 1.0 / hou.fps()
+		
+		node = self.sop()
+		node.parm( "geometryType" ).set( IECoreHoudini.SceneCacheNode.GeometryType.Cortex )
+		for time in times :
+			hou.setTime( time - spf )
+			prims = node.geometry().prims()
+			self.assertEqual( len(prims), 3 )
+			nameAttr = node.geometry().findPrimAttrib( "name" )
+			self.assertEqual( nameAttr.strings(), tuple( [ '/1', '/1/2', '/1/2/3' ] ) )
+			for name in nameAttr.strings() :
+				self.assertEqual( len([ x for x in prims if x.attribValue( "name" ) == name ]), 1 )
+			self.assertEqual( prims[0].vertices()[0].point().position(), hou.Vector3( 1.5, time + 0.5, 0.5 ) )
+			self.assertEqual( prims[1].vertices()[0].point().position(), hou.Vector3( 3.5, time*2 + 0.5, 0.5 ) )
+			self.assertEqual( prims[2].vertices()[0].point().position(), hou.Vector3( 6.5, time*3 + 0.5, 0.5 ) )
+		
+		node.parm( "geometryType" ).set( IECoreHoudini.SceneCacheNode.GeometryType.Houdini )
+		for time in times :
+			hou.setTime( time - spf )
+			prims = node.geometry().prims()
+			self.assertEqual( len(prims), 18 )
+			nameAttr = node.geometry().findPrimAttrib( "name" )
+			self.assertEqual( nameAttr.strings(), tuple( [ '/1', '/1/2', '/1/2/3' ] ) )
+			for name in nameAttr.strings() :
+				self.assertEqual( len([ x for x in prims if x.attribValue( "name" ) == name ]), 6 )
+			self.assertEqual( prims[0].vertex( 0 ).point().position(), hou.Vector3( 1, time, 0 ) )
+			self.assertEqual( prims[4].vertex( 0 ).point().position(), hou.Vector3( 2, time + 1, 1 ) )
+			self.assertEqual( prims[6].vertex( 0 ).point().position(), hou.Vector3( 3, time*2, 0 ) )
+			self.assertEqual( prims[10].vertex( 0 ).point().position(), hou.Vector3( 4, time*2 + 1, 1 ) )
+			self.assertEqual( prims[12].vertex( 0 ).point().position(), hou.Vector3( 6, time*3, 0 ) )
+			self.assertEqual( prims[16].vertex( 0 ).point().position(), hou.Vector3( 7, time*3 + 1, 1 ) )
+		
+		node.parm( "geometryType" ).set( IECoreHoudini.SceneCacheNode.GeometryType.BoundingBox )
+		for time in times :
+			hou.setTime( time - spf )
+			prims = node.geometry().prims()
+			self.assertEqual( len(prims), 18 )
+			nameAttr = node.geometry().findPrimAttrib( "name" )
+			self.assertEqual( nameAttr.strings(), tuple( [ '/1', '/1/2', '/1/2/3' ] ) )
+			for name in nameAttr.strings() :
+				self.assertEqual( len([ x for x in prims if x.attribValue( "name" ) == name ]), 6 )
+			self.assertEqual( prims[0].vertex( 0 ).point().position(), hou.Vector3( 1, time, 0 ) )
+			self.assertEqual( prims[4].vertex( 0 ).point().position(), hou.Vector3( 7, time*3 + 1, 1 ) )
+			self.assertEqual( prims[6].vertex( 0 ).point().position(), hou.Vector3( 3, time*2, 0 ) )
+			self.assertEqual( prims[10].vertex( 0 ).point().position(), hou.Vector3( 7, time*3 + 1, 1 ) )
+			self.assertEqual( prims[12].vertex( 0 ).point().position(), hou.Vector3( 6, time*3, 0 ) )
+			self.assertEqual( prims[16].vertex( 0 ).point().position(), hou.Vector3( 7, time*3 + 1, 1 ) )
+		
+		# re-write with rotation to prove point cloud basis vectors are accurate
+		self.writeAnimSCC( rotate = True )
+		
+		scene = IECore.SharedSceneInterfaces.get( TestSceneCache.__testFile )
+		a = scene.child( "1" )
+		b = a.child( "2" )
+		c = b.child( "3" )
+		
+		node.parm( "reload" ).pressButton()
+		node.parm( "geometryType" ).set( IECoreHoudini.SceneCacheNode.GeometryType.PointCloud )
+		for time in times :
+			hou.setTime( time - spf )
+			prims = node.geometry().prims()
+			self.assertEqual( len(prims), 3 )
+			nameAttr = node.geometry().findPrimAttrib( "name" )
+			self.assertEqual( nameAttr.strings(), tuple( [ '/1', '/1/2', '/1/2/3' ] ) )
+			for name in nameAttr.strings() :
+				self.assertEqual( len([ x for x in prims if x.attribValue( "name" ) == name ]), 1 )
+			
+			aPoint = prims[0].vertices()[0].point()
+			bPoint = prims[1].vertices()[0].point()
+			cPoint = prims[2].vertices()[0].point()
+			
+			aWorld = scene.readTransformAsMatrix( time ) * a.readTransformAsMatrix( time )
+			bWorld = aWorld * b.readTransformAsMatrix( time )
+			cWorld = bWorld * c.readTransformAsMatrix( time )
+			
+			self.assertTrue( IECore.V3d( list(aPoint.position()) ).equalWithAbsError( aWorld.multVecMatrix( a.readBound( time ).center() ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(bPoint.position()) ).equalWithAbsError( bWorld.multVecMatrix( b.readBound( time ).center() ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(cPoint.position()) ).equalWithAbsError( cWorld.multVecMatrix( c.readBound( time ).center() ), 1e-6 ) )
+			
+			self.assertTrue( IECore.V3d( list(aPoint.attribValue( "basis1" )) ).equalWithAbsError( IECore.V3d( aWorld[(0,0)], aWorld[(0,1)], aWorld[(0,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(aPoint.attribValue( "basis2" )) ).equalWithAbsError( IECore.V3d( aWorld[(1,0)], aWorld[(1,1)], aWorld[(1,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(aPoint.attribValue( "basis3" )) ).equalWithAbsError( IECore.V3d( aWorld[(2,0)], aWorld[(2,1)], aWorld[(2,2)] ), 1e-6 ) )
+			
+			self.assertTrue( IECore.V3d( list(bPoint.attribValue( "basis1" )) ).equalWithAbsError( IECore.V3d( bWorld[(0,0)], bWorld[(0,1)], bWorld[(0,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(bPoint.attribValue( "basis2" )) ).equalWithAbsError( IECore.V3d( bWorld[(1,0)], bWorld[(1,1)], bWorld[(1,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(bPoint.attribValue( "basis3" )) ).equalWithAbsError( IECore.V3d( bWorld[(2,0)], bWorld[(2,1)], bWorld[(2,2)] ), 1e-6 ) )
+			
+			self.assertTrue( IECore.V3d( list(cPoint.attribValue( "basis1" )) ).equalWithAbsError( IECore.V3d( cWorld[(0,0)], cWorld[(0,1)], cWorld[(0,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(cPoint.attribValue( "basis2" )) ).equalWithAbsError( IECore.V3d( cWorld[(1,0)], cWorld[(1,1)], cWorld[(1,2)] ), 1e-6 ) )
+			self.assertTrue( IECore.V3d( list(cPoint.attribValue( "basis3" )) ).equalWithAbsError( IECore.V3d( cWorld[(2,0)], cWorld[(2,1)], cWorld[(2,2)] ), 1e-6 ) )
+	
 	def tearDown( self ) :
 		
 		for f in [ TestSceneCache.__testFile, TestSceneCache.__testOutFile, TestSceneCache.__testLinkedOutFile, TestSceneCache.__testHip, TestSceneCache.__testBgeo, TestSceneCache.__testBgeoGz, TestSceneCache.__testGeo ] :

Original file line number	Diff line number	Diff line change
`@@ -98,6 +98,8 @@ class SceneCacheNode : public BaseType`
`98`	`98`	`{`
`99`	`99`	`Cortex,`
`100`	`100`	`Houdini,`
	`101`	`+ BoundingBox,`
	`102`	`+ PointCloud`
`101`	`103`	`};`
`102`	`104`
`103`	`105`	`/// convenience methods for the common parameters;`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,8 @@ void IECoreHoudini::bindSceneCacheNode()`
`133`	`133`	`enum_<SceneCacheNode<OP_Node>::GeometryType>( "GeometryType" )`
`134`	`134`	`.value( "Cortex", SceneCacheNode<OP_Node>::Cortex )`
`135`	`135`	`.value( "Houdini", SceneCacheNode<OP_Node>::Houdini )`
	`136`	`+ .value( "BoundingBox", SceneCacheNode<OP_Node>::BoundingBox )`
	`137`	`+ .value( "PointCloud", SceneCacheNode<OP_Node>::PointCloud )`
`136`	`138`	`;`
`137`	`139`
`138`	`140`	`enum_<OBJ_SceneCacheTransform::Hierarchy>( "Hierarchy" )`