Index: src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp
===================================================================
--- src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp	(revision 2ccdf49fa7924501a200bf60554980a4c13a1b34)
+++ src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp	(revision fe90ab76a0488cae2c9dc4e5dbf47938334d5839)
@@ -736,7 +736,7 @@
 }
 
-/** UnitTest for matchSphericalPointDistributions() with two points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_2()
+/** UnitTest for getRemainingPoints() with two points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_2()
 {
   SphericalPointDistribution SPD(1.);
@@ -745,12 +745,8 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair(Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
     SphericalPointDistribution::Polygon_t expected;
     expected += Vector(-1.,0.,0.);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 2);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -761,12 +757,8 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
     SphericalPointDistribution::Polygon_t expected;
     expected += Vector(0.,-1.,0.);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 2);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -777,12 +769,8 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,0.,-1.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
     SphericalPointDistribution::Polygon_t expected;
     expected += Vector(0.,0.,1.);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 2);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -794,20 +782,16 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
-        SPD.get<2>();
     SphericalPointDistribution::Polygon_t expected;
     expected += RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with three points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_3()
+        SPD.getRemainingPoints(polygon, 2);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with three points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_3()
 {
   SphericalPointDistribution SPD(1.);
@@ -817,12 +801,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<3>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 3);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -833,7 +814,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<3>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -843,7 +823,5 @@
     }
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 3);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -855,13 +833,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-0.5, sqrt(3)*0.5,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<3>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 3);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -878,7 +853,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-0.5, sqrt(3)*0.5,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<3>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -887,7 +861,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 3);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -908,7 +880,5 @@
     SphericalPointDistribution::Polygon_t expected; // empty cause none are vacant
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 3);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -931,19 +901,17 @@
     SphericalPointDistribution::Polygon_t expected; // empty cause none are vacant
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with four points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_4()
+        SPD.getRemainingPoints(polygon, 3);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with four points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_4()
 {
   SphericalPointDistribution SPD(1.);
@@ -953,12 +921,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 4);
     //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
         CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -969,7 +934,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -979,7 +943,5 @@
     }
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 4);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -991,13 +953,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 4);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1013,13 +972,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 4);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1036,7 +992,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1045,7 +1000,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 4);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1062,14 +1015,11 @@
     polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 1);
     polygon += std::make_pair( Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3)), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
     expected.pop_front(); // remove third point
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 4);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1087,7 +1037,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, -M_SQRT2/3.0, M_SQRT2/sqrt(3)), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<4>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1097,20 +1046,18 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with four points and weights
+        SPD.getRemainingPoints(polygon, 4);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with four points and weights
  * not all equal to one.
  */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_multiple()
+void SphericalPointDistributionTest::getRemainingPointsTest_multiple()
 {
   SphericalPointDistribution SPD(1.);
@@ -1126,7 +1073,5 @@
     expected += Vector(-0.5773502691896,-5.551115123126e-17,-0.8164965809277);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 4);
 //    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
@@ -1145,8 +1090,6 @@
     expected += Vector(-0.3535533905933,-0.3535533905933,-0.8660254037844);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
+        SPD.getRemainingPoints(polygon, 5);
+    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1165,7 +1108,5 @@
     expected += Vector(0.3535534025157,-0.3535533856548,0.8660254009332);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 5);
 //    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
@@ -1181,10 +1122,8 @@
         SPD.get<6>();
     SphericalPointDistribution::Polygon_t expected;
+    expected += Vector(0.,0.,1.);
     expected += Vector(0.,0.,-1.);
-    expected += Vector(0.,0.,1.);
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 6);
 //    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
@@ -1193,7 +1132,7 @@
 }
 
-/** UnitTest for matchSphericalPointDistributions() with five points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_5()
+/** UnitTest for getRemainingPoints() with five points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_5()
 {
   SphericalPointDistribution SPD(1.);
@@ -1203,12 +1142,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 5);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1219,7 +1155,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -1229,7 +1164,5 @@
     }
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 5);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1241,13 +1174,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 5);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1264,7 +1194,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180.*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180.*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1273,7 +1202,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180.*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 5);
     // the three remaining points sit on a plane that may be rotated arbitrarily
     // so we cannot simply check for equality between expected and remaining
@@ -1295,14 +1222,11 @@
     polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
     polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
     expected.pop_front(); // remove third point
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 5);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1320,7 +1244,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<5>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1330,19 +1253,17 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with six points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_6()
+        SPD.getRemainingPoints(polygon, 5);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with six points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_6()
 {
   SphericalPointDistribution SPD(1.);
@@ -1352,12 +1273,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 6);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1368,7 +1286,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -1378,7 +1295,5 @@
     }
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 6);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1390,13 +1305,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second spoint
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 6);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1413,7 +1325,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second spoint
@@ -1422,7 +1333,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 6);
     // the four remaining points sit on a plane that may have been rotated arbitrarily
     // so we cannot simply check for equality between expected and remaining
@@ -1444,14 +1353,11 @@
     polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
     polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
     expected.pop_front(); // remove third point
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 6);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1469,7 +1375,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<6>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1479,19 +1384,17 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with seven points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_7()
+        SPD.getRemainingPoints(polygon, 6);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with seven points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_7()
 {
   SphericalPointDistribution SPD(1.);
@@ -1501,12 +1404,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 7);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1517,7 +1417,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -1527,7 +1426,5 @@
     }
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 7);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1539,13 +1436,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 7);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1562,7 +1456,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1571,7 +1464,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 7);
     // the five remaining points sit on a plane that may have been rotated arbitrarily
     // so we cannot simply check for equality between expected and remaining
@@ -1593,14 +1484,11 @@
     polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
     polygon += std::make_pair( Vector(0.0, 1., 0.0), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
     expected.pop_front(); // remove third point
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 7);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1618,7 +1506,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(0.0, 1., 0.0), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<7>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1628,19 +1515,17 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
-
-/** UnitTest for matchSphericalPointDistributions() with eight points
- */
-void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_8()
+        SPD.getRemainingPoints(polygon, 7);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
+
+/** UnitTest for getRemainingPoints() with eight points
+ */
+void SphericalPointDistributionTest::getRemainingPointsTest_8()
 {
   SphericalPointDistribution SPD(1.);
@@ -1650,12 +1535,9 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 8);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1666,7 +1548,6 @@
     SphericalPointDistribution::WeightedPolygon_t polygon;
     polygon += std::make_pair( Vector(0.,1.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     for (SphericalPointDistribution::Polygon_t::iterator iter = expected.begin();
@@ -1675,8 +1556,6 @@
       (*iter)[0] *= -1.;
     }
-   SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 8);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1688,13 +1567,10 @@
     polygon += std::make_pair( Vector(1.,0.,0.), 1);
     polygon += std::make_pair( Vector(-1.,0.,0.), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
-    expected.pop_front(); // remove first point
-    expected.pop_front(); // remove second point
-    SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+    expected.pop_front(); // remove first point
+    expected.pop_front(); // remove second point
+    SphericalPointDistribution::Polygon_t remaining =
+        SPD.getRemainingPoints(polygon, 8);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1711,7 +1587,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1720,7 +1595,5 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 8);
     // the six remaining points sit on two planes that may have been rotated arbitrarily
     // so we cannot simply check for equality between expected and remaining
@@ -1746,14 +1619,11 @@
     polygon += std::make_pair( Vector(-1., 0.0, 0.0), 1);
     polygon += std::make_pair( Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
     expected.pop_front(); // remove third point
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
+        SPD.getRemainingPoints(polygon, 8);
 //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
@@ -1771,7 +1641,6 @@
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1., 0.0, 0.0), 47.6/180*M_PI), 1);
     polygon += std::make_pair(RotationAxis.rotateVector(Vector(-1./3.0, 2.0*M_SQRT2/3.0, 0.0), 47.6/180*M_PI), 1);
-    SphericalPointDistribution::Polygon_t newpolygon =
+    SphericalPointDistribution::Polygon_t expected =
         SPD.get<8>();
-    SphericalPointDistribution::Polygon_t expected = newpolygon;
     expected.pop_front(); // remove first point
     expected.pop_front(); // remove second point
@@ -1781,13 +1650,11 @@
       *iter = RotationAxis.rotateVector(*iter, 47.6/180*M_PI);
     SphericalPointDistribution::Polygon_t remaining =
-        SphericalPointDistribution::matchSphericalPointDistributions(
-            polygon,
-            newpolygon);
-//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
-    // also slightly perturbed
-    const double amplitude = 0.05;
-    perturbPolygon(polygon, amplitude);
-    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
-  }
-}
+        SPD.getRemainingPoints(polygon, 8);
+//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
+    // also slightly perturbed
+    const double amplitude = 0.05;
+    perturbPolygon(polygon, amplitude);
+    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, amplitude) );
+  }
+}
Index: src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.hpp
===================================================================
--- src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.hpp	(revision 2ccdf49fa7924501a200bf60554980a4c13a1b34)
+++ src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.hpp	(revision fe90ab76a0488cae2c9dc4e5dbf47938334d5839)
@@ -65,12 +65,12 @@
     CPPUNIT_TEST ( getConnectionTest<12> );
     CPPUNIT_TEST ( getConnectionTest<14> );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_2 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_3 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_4 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_5 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_6 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_7 );
-    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_8 );
-//    CPPUNIT_TEST ( matchSphericalPointDistributionsTest_multiple );
+    CPPUNIT_TEST ( getRemainingPointsTest_2 );
+    CPPUNIT_TEST ( getRemainingPointsTest_3 );
+    CPPUNIT_TEST ( getRemainingPointsTest_4 );
+    CPPUNIT_TEST ( getRemainingPointsTest_5 );
+    CPPUNIT_TEST ( getRemainingPointsTest_6 );
+    CPPUNIT_TEST ( getRemainingPointsTest_7 );
+    CPPUNIT_TEST ( getRemainingPointsTest_8 );
+    CPPUNIT_TEST ( getRemainingPointsTest_multiple );
     CPPUNIT_TEST_SUITE_END();
 
@@ -81,12 +81,12 @@
       void areEqualToWithinBoundsTest();
       void joinPointsTest();
-      void matchSphericalPointDistributionsTest_2();
-      void matchSphericalPointDistributionsTest_3();
-      void matchSphericalPointDistributionsTest_4();
-      void matchSphericalPointDistributionsTest_5();
-      void matchSphericalPointDistributionsTest_6();
-      void matchSphericalPointDistributionsTest_7();
-      void matchSphericalPointDistributionsTest_8();
-      void matchSphericalPointDistributionsTest_multiple();
+      void getRemainingPointsTest_2();
+      void getRemainingPointsTest_3();
+      void getRemainingPointsTest_4();
+      void getRemainingPointsTest_5();
+      void getRemainingPointsTest_6();
+      void getRemainingPointsTest_7();
+      void getRemainingPointsTest_8();
+      void getRemainingPointsTest_multiple();
 
 private:
