MeshAlgo::segment : Reimplement using MeshSplitter

Author: danieldresser-ie

include/IECoreScene/MeshAlgo.h

@@ -157,7 +157,8 @@ class IECORESCENE_API MeshSplitter
 /// If segmentValues isn't supplied then primitive is split into the unique values contained in the primitiveVariable.
 /// The primitiveVariable must have 'Uniform' iterpolation and match the base type of the VectorTypedData in the segmentValues.
 /// Specifying the two parameters segmentValues & primitiveVariable allows for a subset of meshes to be created, rather than
-/// completely segmenting the mesh based on the unique values in a primitive variable.
+/// completely segmenting the mesh based on the unique values in a primitive variable. If one of the values specified by
+/// segmentValues does not occur in the primitiveVariable, the corresponding mesh will be a nullptr.
 IECORESCENE_API std::vector<MeshPrimitivePtr> segment( const MeshPrimitive *mesh, const PrimitiveVariable &primitiveVariable, const IECore::Data *segmentValues = nullptr, const IECore::Canceller *canceller = nullptr );
 
 /// Merge the input meshes into a single mesh.

src/IECoreScene/MeshAlgoSegment.cpp

@@ -34,48 +34,67 @@
 
 #include "boost/format.hpp"
 
-#include "IECore/DespatchTypedData.h"
 #include "IECore/DataAlgo.h"
 
-
 #include "IECoreScene/MeshAlgo.h"
 #include "IECoreScene/private/PrimitiveAlgoUtils.h"
 
-
 using namespace Imath;
 using namespace IECore;
 using namespace IECoreScene;
 
-
 std::vector<MeshPrimitivePtr> IECoreScene::MeshAlgo::segment( const MeshPrimitive *mesh, const PrimitiveVariable &primitiveVariable, const IECore::Data *segmentValues, const Canceller *canceller )
 {
+	MeshSplitter ms( mesh, primitiveVariable, canceller );
+	int numMeshes = ms.numMeshes();
+	std::vector<MeshPrimitivePtr> ret;
+	ret.reserve( numMeshes );
 
-	DataPtr data;
 	if( !segmentValues )
 	{
-		Canceller::check( canceller );
-		data = IECore::uniqueValues( primitiveVariable.data.get() );
-		segmentValues = data.get();
-	}
-
-	Canceller::check( canceller );
-	std::string primitiveVariableName;
-	for (const auto &pv : mesh->variables )
-	{
-		if ( pv.second == primitiveVariable )
+		for( int i = 0; i < numMeshes; i++ )
 		{
-			primitiveVariableName = pv.first;
+			ret.push_back( ms.mesh( i ) );
 		}
 	}
-
-	if( primitiveVariableName == "" )
+	else
 	{
-		throw IECore::InvalidArgumentException( "IECoreScene::MeshAlgo::segment : Primitive variable not found on Mesh Primitive " );
-	}
+		IECore::dispatch( segmentValues,
+			[ ms, numMeshes, &ret, canceller ]( auto *typedSegmentValues )
+			{
+				using DataType = typename std::remove_pointer_t< decltype( typedSegmentValues ) >;
+				if constexpr ( TypeTraits::IsVectorTypedData<DataType>::value )
+				{
+					using ElementType = typename DataType::ValueType::value_type;
 
-	auto f = MeshAlgo::deleteFaces;
+					std::unordered_map< ElementType, int > idMap;
+					Canceller::check( canceller );
+					for( int i = 0; i < numMeshes; i++ )
+					{
+						idMap[ ms.value<ElementType>( i ) ] = i;
+					}
 
-	IECoreScene::Detail::TaskSegmenter<IECoreScene::MeshPrimitive, decltype(f) > taskSegmenter( mesh, const_cast<IECore::Data*> (segmentValues), primitiveVariableName, f, canceller );
+					Canceller::check( canceller );
+					for( const auto &i : typedSegmentValues->readable() )
+					{
+						auto f = idMap.find( i );
+						if( f == idMap.end() )
+						{
+							ret.push_back( nullptr );
+						}
+						else
+						{
+							ret.push_back( ms.mesh( idMap[i] ) );
+						}
+					}
+				}
+				else
+				{
+					throw IECore::Exception( "Invalid Primitive Variable with non-vector typed data." );
+				}
+			}
+		);
+	}
 
-	return dispatch( primitiveVariable.data.get(), taskSegmenter );
+	return ret;
 }

test/IECoreScene/MeshAlgoSegmentTest.py

@@ -66,8 +66,8 @@ def testCanSegmentUsingIntegerPrimvar( self ) :
 		p12 = imath.V3f( 1, 2, 0 )
 		p22 = imath.V3f( 2, 2, 0 )
 
-		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p00, p10, p20, p01, p11, p21], IECore.GeometricData.Interpretation.Point ) )
-		self.assertEqual( segments[1]["P"].data, IECore.V3fVectorData( [p01, p11, p21, p02, p12, p22], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p00, p10, p11, p01, p20, p21], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( segments[1]["P"].data, IECore.V3fVectorData( [p01, p11, p12, p02, p21, p22], IECore.GeometricData.Interpretation.Point ) )
 
 	def testCanSegmentUsingStringPrimvar( self ) :
 		mesh = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 2 ) ), imath.V2i( 2 ) )
@@ -95,8 +95,8 @@ def testCanSegmentUsingStringPrimvar( self ) :
 		p12 = imath.V3f( 1, 2, 0 )
 		p22 = imath.V3f( 2, 2, 0 )
 
-		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p00, p10, p01, p11, p21, p12, p22], IECore.GeometricData.Interpretation.Point ) )
-		self.assertEqual( segments[1]["P"].data, IECore.V3fVectorData( [p10, p20, p01, p11, p21, p02, p12], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p00, p10, p11, p01, p21, p22, p12], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( segments[1]["P"].data, IECore.V3fVectorData( [p10, p20, p21, p11, p01, p12, p02], IECore.GeometricData.Interpretation.Point ) )
 
 	def testSegmentsFullyIfNoSegmentValuesGiven( self ) :
 		mesh = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 2 ) ), imath.V2i( 2 ) )
@@ -130,8 +130,8 @@ def testSegmentsFullyIfNoSegmentValuesGiven( self ) :
 			s0 = segments[1]
 			s1 = segments[0]
 
-		self.assertEqual( s0["P"].data, IECore.V3fVectorData( [p00, p10, p01, p11, p21, p12, p22], IECore.GeometricData.Interpretation.Point ) )
-		self.assertEqual( s1["P"].data, IECore.V3fVectorData( [p10, p20, p01, p11, p21, p02, p12], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( s0["P"].data, IECore.V3fVectorData( [p00, p10, p11, p01, p21, p22, p12], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( s1["P"].data, IECore.V3fVectorData( [p10, p20, p21, p11, p01, p12, p02], IECore.GeometricData.Interpretation.Point ) )
 
 
 	def testRaisesExceptionIfSegmentKeysNotSameTypeAsPrimvar( self ) :
@@ -146,7 +146,11 @@ def t() :
 
 		self.assertRaises( RuntimeError, t )
 
-	def testEmptyPrimitiveIfNotMatching( self ) :
+	def testNullPrimitiveIfNotMatching( self ) :
+
+		# Now that we've reimplemented on top of MeshSplitter, this has now changed from the old version
+		# of segment.  We now return a null pointer for primitive variable values that don't exist, instead
+		# of a mesh with zero faces
 		mesh = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 2 ) ), imath.V2i( 2 ) )
 
 		mesh["s"] = IECoreScene.PrimitiveVariable( IECoreScene.PrimitiveVariable.Interpolation.Uniform, IECore.StringVectorData( ["a", "b", "a", "b"] ) )
@@ -156,8 +160,8 @@ def testEmptyPrimitiveIfNotMatching( self ) :
 
 		self.assertEqual( len( segments ), 2 )
 
-		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [], IECore.GeometricData.Interpretation.Point ) )
-		self.assertEqual( segments[1]["P"].data, IECore.V3fVectorData( [], IECore.GeometricData.Interpretation.Point ) )
+		self.assertTrue( segments[0] is None )
+		self.assertTrue( segments[1] is None )
 
 	def testSegmentSubset( self ) :
 		mesh = IECoreScene.MeshPrimitive.createPlane( imath.Box2f( imath.V2f( 0 ), imath.V2f( 2 ) ), imath.V2i( 2 ) )
@@ -180,7 +184,7 @@ def testSegmentSubset( self ) :
 		p22 = imath.V3f( 2, 2, 0 )
 
 		self.assertEqual( len( segments ), 1 )
-		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p11, p21, p12, p22], IECore.GeometricData.Interpretation.Point ) )
+		self.assertEqual( segments[0]["P"].data, IECore.V3fVectorData( [p11, p21, p22, p12], IECore.GeometricData.Interpretation.Point ) )
 		self.assertEqual( segments[0]["s"].data, IECore.StringVectorData( ["b"] ) )