partition: Adjust group scoring to normalize shared counts

Instead of applying a group size bias, which is somewhat arbitrary as it
conflates the dimensions (of cluster counts and vertex counts), we now
normalize the shared count by inverse square root of group sizes. Since
we, ideally, expect the boundary of a cluster group to have sqrt(V)
vertices, this results in a normalized account of shared vertex count;
while it is a little redundant to use rsqrt for the group we're merging,
this keeps the scoring mostly symmetric.

We can also use the product of rsqrt's which matches the metric used in
KaPPa ["Engineering a Scalable High Quality Graph Partitioner" (2010)].
It doesn't seem to strongly matter one way or the other, and the weights
are a little easier to debug and understand with + so we'll use that for now.

Author: zeux

src/partition.cpp

@@ -2,13 +2,12 @@
 #include "meshoptimizer.h"
 
 #include <assert.h>
+#include <math.h>
 #include <string.h>
 
 namespace meshopt
 {
 
-static const unsigned int kGroupSizeBias = 3;
-
 struct ClusterAdjacency
 {
 	unsigned int* offsets;
@@ -264,12 +263,14 @@ static unsigned int countShared(const ClusterGroup* groups, int group1, int grou
 	return total;
 }
 
-static int pickGroupToMerge(const ClusterGroup* groups, int id, const ClusterAdjacency& adjacency, size_t max_group_size)
+static int pickGroupToMerge(const ClusterGroup* groups, int id, const ClusterAdjacency& adjacency, size_t max_partition_size)
 {
 	assert(groups[id].size > 0);
 
+	float group_rsqrt = 1.f / sqrtf(float(int(groups[id].vertices)));
+
 	int best_group = -1;
-	unsigned int best_score = 0;
+	float best_score = 0;
 
 	for (int ci = id; ci >= 0; ci = groups[ci].next)
 	{
@@ -280,13 +281,14 @@ static int pickGroupToMerge(const ClusterGroup* groups, int id, const ClusterAdj
 				continue;
 
 			assert(groups[other].size > 0);
-			if (groups[id].size + groups[other].size > max_group_size)
+			if (groups[id].size + groups[other].size > max_partition_size)
 				continue;
 
-			unsigned int score = countShared(groups, id, other, adjacency);
+			unsigned int shared = countShared(groups, id, other, adjacency);
+			float other_rsqrt = 1.f / sqrtf(float(int(groups[other].vertices)));
 
-			// favor smaller target groups
-			score += (unsigned(max_group_size) - groups[other].size) * kGroupSizeBias;
+			// normalize shared count by the expected boundary of each group (+ keeps scoring symmetric)
+			float score = float(int(shared)) * (group_rsqrt + other_rsqrt);
 
 			if (score > best_score)
 			{
@@ -395,7 +397,7 @@ size_t meshopt_partitionClusters(unsigned int* destination, const unsigned int*
 		// update group sizes; note, the vertex update is an approximation which avoids recomputing the true size via countTotal
 		groups[top.id].size += groups[best_group].size;
 		groups[top.id].vertices += groups[best_group].vertices;
-		groups[top.id].vertices -= shared;
+		groups[top.id].vertices = (groups[top.id].vertices > shared) ? groups[top.id].vertices - shared : 1;
 
 		groups[best_group].size = 0;
 		groups[best_group].vertices = 0;