Merge pull request #1357 from danieldresser-ie/weightedNormals

Add calculateUniformNormals/VertexNormals/FaceVaryingNormals

Author: johnhaddon

include/IECoreScene/MeshAlgo.h

@@ -54,14 +54,43 @@ namespace MeshAlgo
 /// If provided, this will be periodically checked, and cancel the calculation with an exception
 /// if the canceller has been triggered ( indicating the result is no longer needed )
 
-/// Calculate the normals of a mesh primitive.
+// Enum for specifying how to weight normal calculation
+enum class NormalWeighting
+{
+	Equal, // Equal weight to each vertex, simple, not very good
+	Angle, // Weight based on angle where each face touches vertex - best consistent results
+	Area   // Weight based on area of each face connected to vertex - may yield good results on hard
+			// surface models with edge bevels, where you want to preserve the flatness of large faces
+};
+
+/// Calculate the normals of a mesh primitive, based on a given position primitive variable.
+///
+/// NOTE : Uses tbb internally - in order to integrate with a program using tbb, should be placed inside a
+/// this_task_arena::isolate or other mechanism to protect from stealing outer tasks.
+
+/// Uniform normals are simple - just compute the average normal across the face.
+IECORESCENE_API PrimitiveVariable calculateUniformNormals( const MeshPrimitive *mesh, const std::string &position = "P", const IECore::Canceller *canceller = nullptr );
+
+/// Vertex normals require averaging the normals of all adjacent faces, so we take "weighting" to determine
+/// how they are averaged.
+IECORESCENE_API PrimitiveVariable calculateVertexNormals( const MeshPrimitive *mesh, NormalWeighting weighting, const std::string &position = "P", const IECore::Canceller *canceller = nullptr );
+
+/// With face varying normals, we can average adjacent faces to produce a smooth corner, or create a faceted
+/// corner. So we take both a weighting mode, and "thresholdAngle", which give a cutoff in degrees - faces
+/// which meet at less than this angle will be treated as faceted instead of smooth.
+IECORESCENE_API PrimitiveVariable calculateFaceVaryingNormals( const MeshPrimitive *mesh, NormalWeighting weighting, float thresholdAngle, const std::string &position = "P", const IECore::Canceller *canceller = nullptr );
+
+/// Old form where no weighting method is specified - computes vertex normals using fast but inaccurate method
+/// Deprecated.
 IECORESCENE_API PrimitiveVariable calculateNormals( const MeshPrimitive *mesh, PrimitiveVariable::Interpolation interpolation = PrimitiveVariable::Vertex, const std::string &position = "P", const IECore::Canceller *canceller = nullptr );
 
 /// TODO: remove this compatibility function:
 IECORESCENE_API std::pair<PrimitiveVariable, PrimitiveVariable> calculateTangents( const MeshPrimitive *mesh, const std::string &uvSet = "uv", bool orthoTangents = true, const std::string &position = "P" );
 /// Calculate the surface tangent vectors of a mesh primitive based on UV information
 IECORESCENE_API std::pair<PrimitiveVariable, PrimitiveVariable> calculateTangentsFromUV( const MeshPrimitive *mesh, const std::string &uvSet = "uv", const std::string &position = "P", bool orthoTangents = true, bool leftHanded = false, const IECore::Canceller *canceller = nullptr );
-/// Calculate the surface tangent vectors of a mesh primitive based on the first neighbor edge
+/// Calculate the surface tangent vectors of a mesh primitive based on the first neighbor edge.
+/// Note that "first" is defined by the edge that comes first in the vertexIds list:
+/// if a tri is stored as [ 0, 1, 2 ], then this is interpreted as the edges <0,1>, <1,2> and <2,0>, in that order.
 IECORESCENE_API std::pair<PrimitiveVariable, PrimitiveVariable> calculateTangentsFromFirstEdge( const MeshPrimitive *mesh, const std::string &position = "P", const std::string &normal = "N", bool orthoTangents = true, bool leftHanded = false, const IECore::Canceller *canceller = nullptr );
 /// Calculate the surface tangent vectors of a mesh primitive based on the primitives centroid
 IECORESCENE_API std::pair<PrimitiveVariable, PrimitiveVariable> calculateTangentsFromPrimitiveCentroid( const MeshPrimitive *mesh, const std::string &position = "P", const std::string &normal = "N", bool orthoTangents = true, bool leftHanded = false, const IECore::Canceller *canceller = nullptr );
@@ -95,6 +124,9 @@ IECORESCENE_API void reorderVertices( MeshPrimitive *mesh, int id0, int id1, int
 /// Distributes points over a mesh using an IECore::PointDistribution in UV space
 /// and mapping it to 3d space. It gives a fairly even distribution regardless of
 /// vertex spacing, provided the UVs are well layed out.
+///
+/// NOTE : Uses tbb internally - in order to integrate with a program using tbb, should be placed inside a
+/// this_task_arena::isolate or other mechanism to protect from stealing outer tasks.
 IECORESCENE_API PointsPrimitivePtr distributePoints( const MeshPrimitive *mesh, float density = 100.0, const Imath::V2f &offset = Imath::V2f( 0 ), const std::string &densityMask = "density", const std::string &uvSet = "uv", const std::string &refPosition = "P", const IECore::StringAlgo::MatchPattern &primitiveVariables = "", const IECore::Canceller *canceller = nullptr );
 
 /// Split the input mesh in to N meshes based on the N unique values contained in a segment primitive variable.
@@ -163,16 +195,32 @@ IECORESCENE_API std::vector<MeshPrimitivePtr> segment( const MeshPrimitive *mesh
 
 /// Merge the input meshes into a single mesh.
 /// Any PrimitiveVariables that exist will be combined or extended using a default value.
+///
+/// NOTE : Uses tbb internally - in order to integrate with a program using tbb, should be placed inside a
+/// this_task_arena::isolate or other mechanism to protect from stealing outer tasks.
 IECORESCENE_API MeshPrimitivePtr merge( const std::vector<const MeshPrimitive *> &meshes, const IECore::Canceller *canceller = nullptr );
 
 /// Generate a new triangulated MeshPrimitive
+///
+/// NOTE : Uses tbb internally - in order to integrate with a program using tbb, should be placed inside a
+/// this_task_arena::isolate or other mechanism to protect from stealing outer tasks.
 IECORESCENE_API MeshPrimitivePtr triangulate( const MeshPrimitive *mesh, const IECore::Canceller *canceller = nullptr );
 
 /// Generate a list of connected vertices per vertex
 /// The first vector contains a flat list of all the indices of the connected neighbor vertices.
-///	The second one holds an offset index for every vertex. Note that the offset indices vector skips the first offset index (since it's 0)
+///	The second one holds an offset index for every vertex. Note that the offset indices vector skips the
+/// first offset index (since it's 0).
+/// Note also that the resulting data vector has a capacity larger than it's size ( due to the storage required
+/// for the implementation of this function ). If you are keeping this result persistently, you may want to call
+/// result.second->writable().shrink_to_fit() in order to reduce long term memory use, however this reallocation
+/// is just a waste of time if you are using the result to compute something else and then discarding it.
 IECORESCENE_API	std::pair<IECore::IntVectorDataPtr, IECore::IntVectorDataPtr> connectedVertices( const IECoreScene::MeshPrimitive *mesh, const IECore::Canceller *canceller = nullptr );
 
+/// Generate a list of face vertices which point to each vertex
+/// The first vector contains a flat list of all the indices of the connected face vertices.
+///	The second one holds offset indices for every vertex, as above.
+IECORESCENE_API	std::pair<IECore::IntVectorDataPtr, IECore::IntVectorDataPtr> correspondingFaceVertices( const IECoreScene::MeshPrimitive *mesh, const IECore::Canceller *canceller = nullptr );
+
 } // namespace MeshAlgo
 
 } // namespace IECoreScene

include/IECoreScene/PolygonVertexIterator.h

@@ -53,10 +53,10 @@ class PolygonVertexIterator
 	public :
 
 		typedef std::forward_iterator_tag iterator_category;
-		typedef typename VertexValueIterator::value_type value_type;
-		typedef typename VertexValueIterator::difference_type difference_type;
-		typedef typename VertexValueIterator::pointer pointer;
-		typedef typename VertexValueIterator::reference reference;
+		typedef typename std::iterator_traits<VertexValueIterator>::value_type value_type;
+		typedef typename std::iterator_traits<VertexValueIterator>::difference_type difference_type;
+		typedef typename std::iterator_traits<VertexValueIterator>::pointer pointer;
+		typedef typename std::iterator_traits<VertexValueIterator>::reference reference;
 
 		/// Uninitialised.
 		PolygonVertexIterator();

src/IECoreScene/MeshAlgoConnectedVertices.cpp

@@ -38,62 +38,145 @@ using namespace std;
 using namespace IECore;
 using namespace IECoreScene;
 
+namespace {
+
+inline void linearInsert( int *list, int val )
+{
+	while( *list != -1 )
+	{
+		if( *list == val )
+		{
+			return;
+		}
+		list++;
+	}
+	*list = val;
+}
+
+} // namespace
+
 pair<IntVectorDataPtr, IntVectorDataPtr> MeshAlgo::connectedVertices( const MeshPrimitive *mesh, const Canceller *canceller )
 {
 	size_t numVertices = mesh->variableData< V3fVectorData >( "P", PrimitiveVariable::Vertex )->readable().size();
 	const vector<int> &numVerticesPerFace = mesh->verticesPerFace()->readable();
 	const vector<int> &vertexIds = mesh->vertexIds()->readable();
 
-	vector< set<int> > neighbors( numVertices );
+	IntVectorDataPtr offsetsData = new IntVectorData();
+	vector<int> &offsets = offsetsData->writable();
+	offsets.resize( numVertices, 0 );
 
-	int currentVertOffset = 0;
+	Canceller::check( canceller );
+
+	// Start initializing the offsets vector by storing the maximum number of possible neighbours each
+	// vertex could have. Every time a vertex appears in the vertex id list, that means it's part of
+	// a polygon, and has two more edges connecting it to two other vertices. In the common case,
+	// the number we arrive at by this method is twice as high as needed, because in a manifold mesh,
+	// every edge appears in the face list twice.
+	for( int i : vertexIds )
+	{
+		offsets[ i ] += 2;
+	}
+
+	Canceller::check( canceller );
+
+	// Convert the neighbour counts into offsets to the start of each list of possible neighbours,
+	// by storing a running total
+	int totalPossibleNeighbours = 0;
+	for( int &o : offsets )
+	{
+		int count = o;
+		o = totalPossibleNeighbours;
+		totalPossibleNeighbours += count;
+	}
+
+	// Allocate storage for all possible neighbours, and collect neighbours from every face.
+	// On a manifold mesh, only half the storage for each vertex will be used, because every
+	// vertex pair occurs in two separate faces. ( Unused element will be left at -1 )
+	Canceller::check( canceller );
+	IntVectorDataPtr neighbourListData = new IntVectorData();
+	std::vector<int> &neighbourList = neighbourListData->writable();
+	neighbourList.resize( totalPossibleNeighbours, -1 );
+	int faceStart = 0;
 	for ( auto &vertsPerFace : numVerticesPerFace )
 	{
 		Canceller::check( canceller );
 
 		for ( int i = 0; i < vertsPerFace; ++i)
 		{
-			const int &faceVert = vertexIds[ currentVertOffset + i ];
-			const int &faceVertNext = vertexIds[ currentVertOffset + ( i + 1 ) % vertsPerFace ];
-			neighbors[ faceVert ].insert( faceVertNext );
-			neighbors[ faceVertNext ].insert( faceVert );
+			int faceVert = vertexIds[ faceStart + i ];
+			int faceVertNext = vertexIds[ faceStart + ( i + 1 ) % vertsPerFace ];
+			linearInsert( &neighbourList[ offsets[faceVert] ], faceVertNext );
+			linearInsert( &neighbourList[ offsets[faceVertNext] ], faceVert );
 		}
-		currentVertOffset += vertsPerFace;
+		faceStart += vertsPerFace;
 	}
 
-	int neighborCount = 0;
-	int cancelTestCounter = 0;
-	for ( auto &n : neighbors )
+	// Compact the neighbourList to contain only used vertices by removing any -1 values,
+	// and update offsets accordingly - we also convert the offsets from pointing to the
+	// start of the lists to the end of the lists at the same time.
+	int usedOutputIndex = 0;
+	for( int i = 0; i < (int)offsets.size(); i++ )
 	{
-		if( cancelTestCounter++ == 1000 )
+		Canceller::check( canceller );
+		int end = i < (int)offsets.size() - 1 ? offsets[i + 1] : totalPossibleNeighbours;
+		int neighbourIndex = offsets[i];
+		while( neighbourIndex < end && neighbourList[neighbourIndex] != -1 )
 		{
-			Canceller::check( canceller );
-			cancelTestCounter = 0;
+			neighbourList[usedOutputIndex++] = neighbourList[neighbourIndex++];
 		}
-		neighborCount += n.size();
+		offsets[i] = usedOutputIndex;
 	}
+	neighbourList.resize( usedOutputIndex );
 
-	IntVectorDataPtr offsets = new IntVectorData();
-	IntVectorDataPtr neighborList = new IntVectorData();
-	vector<int> &offsetsW = offsets->writable();
-	vector<int> &neighborListW = neighborList->writable();
+	// It would be a little simpler to just call neighbourList.shrink_to_fit() here so the output would always
+	// be exactly sized right, but this reallocation costs about 10% of our performance, so instead I guess
+	// we'll just document that you may want to call shrink_to_fit() if you're keeping this data around.
+	
+	return pair<IntVectorDataPtr, IntVectorDataPtr>( neighbourListData, offsetsData );
+}
+
+pair<IntVectorDataPtr, IntVectorDataPtr> MeshAlgo::correspondingFaceVertices( const MeshPrimitive *mesh, const Canceller *canceller )
+{
+	size_t numVertices = mesh->variableData< V3fVectorData >( "P", PrimitiveVariable::Vertex )->readable().size();
+	const vector<int> &vertexIds = mesh->vertexIds()->readable();
 
-	neighborListW.resize( neighborCount, -1 );
-	offsetsW.resize( neighbors.size(), -1 );
+	IntVectorDataPtr offsetsData = new IntVectorData();
+	vector<int> &offsets = offsetsData->writable();
+	Canceller::check( canceller );
+	offsets.resize( numVertices, 0 );
 
-	int ix = 0;
-	for ( size_t i = 0; i < neighbors.size(); ++i )
+	// Start initializing the offsets vector by storing the number of face vertices
+	for( int i : vertexIds )
 	{
-		if( i % 1000 == 0 )
-		{
-			Canceller::check( canceller );
-		}
-		for ( auto &n : neighbors[ i ] )
-		{
-			neighborListW[ ix++ ] = n;
-		}
-		offsetsW[ i ] = ix;
+		offsets[ i ]++;
+	}
+
+	Canceller::check( canceller );
+
+	// Convert the counts into offsets to the start of each list of face vertices
+	int countFaceVertices = 0;
+	for( int &o : offsets )
+	{
+		int count = o;
+		o = countFaceVertices;
+		countFaceVertices += count;
+	}
+
+	Canceller::check( canceller );
+	IntVectorDataPtr faceVerticesData = new IntVectorData();
+	vector<int> &faceVertices = faceVerticesData->writable();
+	Canceller::check( canceller );
+	faceVertices.resize( countFaceVertices );
+
+	// Now run through all faces, storing face vertex indices in the new list. We increment the offset
+	// for each face vertex we store, meaning that the indices start out pointing to the beginning of the
+	// list for each vertex, and end up pointing at the end of the list for each vertex.
+	for( unsigned int i = 0; i < vertexIds.size(); i++ )
+	{
+		int vert = vertexIds[ i ];
+		faceVertices[ offsets[ vert ] ] = i;
+		offsets[ vert ] ++;
 	}
 
-	return pair<IntVectorDataPtr, IntVectorDataPtr>( neighborList, offsets );
+	return pair<IntVectorDataPtr, IntVectorDataPtr>( faceVerticesData, offsetsData );
 }