Ignore:
Timestamp:
Aug 20, 2014, 1:06:16 PM (11 years ago)
Author:
Frederik Heber <heber@…>
Children:
ef3885
Parents:
1cde4e8
git-author:
Frederik Heber <heber@…> (07/09/14 22:08:37)
git-committer:
Frederik Heber <heber@…> (08/20/14 13:06:16)
Message:

Added calculation of center of minimum distance by bisection.

  • this will give us a unique a definite point independent of the (rotational) position of the point set on the unit sphere.
  • added unit test.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Fragmentation/Exporters/unittests/SphericalPointDistributionUnitTest.cpp

    r1cde4e8 ra2f8a9  
    6868CPPUNIT_TEST_SUITE_REGISTRATION( SphericalPointDistributionTest );
    6969
     70/** due to root-taking in function we only have limited numerical precision,
     71 * basically half of the double range.
     72 */
     73const double CenterAccuracy = sqrt(std::numeric_limits<double>::epsilon()*1e2);
    7074
    7175void SphericalPointDistributionTest::setUp()
    … …  
    8286}
    8387
    84 
    85 /** UnitTest for matchSphericalPointDistributions() with two points
     88/** UnitTest for calculateCenterOfMinimumDistance()
    8689 */
    87 void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_2()
     90void SphericalPointDistributionTest::calculateCenterOfMinimumDistanceTest()
    8891{
    89   SphericalPointDistribution SPD(1.);
    90   // test with one point, matching trivially
    91   {
    92     SphericalPointDistribution::WeightedPolygon_t polygon;
    93     polygon += std::make_pair(Vector(1.,0.,0.), 1);
    94     SphericalPointDistribution::Polygon_t newpolygon =
    95         SPD.get<2>();
    96     SphericalPointDistribution::Polygon_t expected;
    97     expected += Vector(-1.,0.,0.);
    98     SphericalPointDistribution::Polygon_t remaining =
    99         SphericalPointDistribution::matchSphericalPointDistributions(
    100             polygon,
    101             newpolygon);
    102     CPPUNIT_ASSERT_EQUAL( expected, remaining );
    103   }
    104 
    105   // test with one point, just a flip of axis
    106   {
    107     SphericalPointDistribution::WeightedPolygon_t polygon;
    108     polygon += std::make_pair( Vector(0.,1.,0.), 1);
    109     SphericalPointDistribution::Polygon_t newpolygon =
    110         SPD.get<2>();
    111     SphericalPointDistribution::Polygon_t expected;
    112     expected += Vector(0.,-1.,0.);
    113     SphericalPointDistribution::Polygon_t remaining =
    114         SphericalPointDistribution::matchSphericalPointDistributions(
    115             polygon,
    116             newpolygon);
    117     CPPUNIT_ASSERT_EQUAL( expected, remaining );
    118   }
    119 
    120   // test with one point, just a flip to another axis
    121   {
    122     SphericalPointDistribution::WeightedPolygon_t polygon;
    123     polygon += std::make_pair( Vector(0.,0.,-1.), 1);
    124     SphericalPointDistribution::Polygon_t newpolygon =
    125         SPD.get<2>();
    126     SphericalPointDistribution::Polygon_t expected;
    127     expected += Vector(0.,0.,1.);
    128     SphericalPointDistribution::Polygon_t remaining =
    129         SphericalPointDistribution::matchSphericalPointDistributions(
    130             polygon,
    131             newpolygon);
    132     CPPUNIT_ASSERT_EQUAL( expected, remaining );
    133   }
    134 
    135   // test with one point, full rotation
    136   {
    137     Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
    138     SphericalPointDistribution::WeightedPolygon_t polygon;
    139     polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
    140     SphericalPointDistribution::Polygon_t newpolygon =
    141         SPD.get<2>();
    142     SphericalPointDistribution::Polygon_t expected;
    143     expected += RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
    144     SphericalPointDistribution::Polygon_t remaining =
    145         SphericalPointDistribution::matchSphericalPointDistributions(
    146             polygon,
    147             newpolygon);
    148     CPPUNIT_ASSERT_EQUAL( expected, remaining );
    149   }
    150 }
    151 
    152 void perturbPolygon(
    153     SphericalPointDistribution::WeightedPolygon_t &_polygon,
    154     double _amplitude
    155     )
    156 {
    157   for (SphericalPointDistribution::WeightedPolygon_t::iterator iter = _polygon.begin();
    158       iter != _polygon.end(); ++iter) {
    159     Vector perturber;
    160     perturber.GetOneNormalVector(iter->first);
    161     perturber.Scale(_amplitude);
    162     iter->first = iter->first + perturber;
    163     (iter->first).Normalize();
     92  // single point
     93  {
     94    SphericalPointDistribution::VectorArray_t points;
     95    points +=
     96        Vector(1.,0.,0.);
     97    SphericalPointDistribution::IndexList_t indices;
     98    indices += 0;
     99    const Vector expected = points[0];
     100    const Vector center =
     101        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     102//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     103//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     104    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
     105  }
     106
     107  // single point, rotated
     108  {
     109    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
     110    SphericalPointDistribution::VectorArray_t points;
     111    points +=
     112        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI);
     113    SphericalPointDistribution::IndexList_t indices;
     114    indices += 0;
     115    const Vector expected = points[0];
     116    const Vector center =
     117        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     118//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     119//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     120    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
     121  }
     122
     123  // two points
     124  {
     125    SphericalPointDistribution::VectorArray_t points;
     126    points +=
     127        Vector(1.,0.,0.),
     128        Vector(0.,1.,0.);
     129    SphericalPointDistribution::IndexList_t indices;
     130    indices += 0,1;
     131    const Vector expected = Vector(M_SQRT1_2,M_SQRT1_2,0.);
     132    const Vector center =
     133        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     134//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     135//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     136    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
     137  }
     138
     139  // two points, rotated
     140  {
     141    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
     142    SphericalPointDistribution::VectorArray_t points;
     143    points +=
     144        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
     145        RotationAxis.rotateVector(Vector(0.,1.,0.), 47.6/180*M_PI);
     146    SphericalPointDistribution::IndexList_t indices;
     147    indices += 0,1;
     148    const Vector expected = RotationAxis.rotateVector(Vector(M_SQRT1_2,M_SQRT1_2,0.), 47.6/180*M_PI);
     149    const Vector center =
     150        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     151//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     152//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     153    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
     154  }
     155
     156  // three points in line
     157  {
     158    SphericalPointDistribution::VectorArray_t points;
     159    points +=
     160        Vector(1.,0.,0.),
     161        Vector(0.,1.,0.),
     162        Vector(-1.,0.,0.);
     163    SphericalPointDistribution::IndexList_t indices;
     164    indices += 0,1,2;
     165    const Vector expected = points[1];
     166    const Vector center =
     167        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     168//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     169//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     170    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
     171  }
     172
     173  // three points in line, rotated
     174  {
     175    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
     176    SphericalPointDistribution::VectorArray_t points;
     177    points +=
     178        RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI),
     179        RotationAxis.rotateVector(Vector(0.,1.,0.), 47.6/180*M_PI),
     180        RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
     181    SphericalPointDistribution::IndexList_t indices;
     182    indices += 0,1,2;
     183    const Vector expected = points[1];
     184    const Vector center =
     185        SphericalPointDistribution::calculateCenterOfMinimumDistance(points, indices);
     186//    std::cout << " Difference is " << (expected - center).Norm() << std::endl;
     187//    CPPUNIT_ASSERT_EQUAL ( expected, center );
     188    CPPUNIT_ASSERT( expected.IsEqualTo(center, CenterAccuracy));
    164189  }
    165190}
    … …  
    180205  SphericalPointDistribution::Polygon_t::const_iterator otheriter = _otherpolygon.begin();
    181206  for (; iter != _polygon.end(); ++iter, ++otheriter) {
    182     status &= (*iter - *otheriter).Norm() < _amplitude;
     207    status &= (*iter).IsEqualTo(*otheriter, _amplitude);
    183208  }
    184209  return status;
    … …  
    242267    expected += Vector(0.,1.,0.);
    243268    CPPUNIT_ASSERT( !areEqualToWithinBounds(polygon, expected, 0.05) );
     269  }
     270}
     271
     272/** UnitTest for matchSphericalPointDistributions() with two points
     273 */
     274void SphericalPointDistributionTest::matchSphericalPointDistributionsTest_2()
     275{
     276  SphericalPointDistribution SPD(1.);
     277  // test with one point, matching trivially
     278  {
     279    SphericalPointDistribution::WeightedPolygon_t polygon;
     280    polygon += std::make_pair(Vector(1.,0.,0.), 1);
     281    SphericalPointDistribution::Polygon_t newpolygon =
     282        SPD.get<2>();
     283    SphericalPointDistribution::Polygon_t expected;
     284    expected += Vector(-1.,0.,0.);
     285    SphericalPointDistribution::Polygon_t remaining =
     286        SphericalPointDistribution::matchSphericalPointDistributions(
     287            polygon,
     288            newpolygon);
     289//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     290    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
     291  }
     292
     293  // test with one point, just a flip of axis
     294  {
     295    SphericalPointDistribution::WeightedPolygon_t polygon;
     296    polygon += std::make_pair( Vector(0.,1.,0.), 1);
     297    SphericalPointDistribution::Polygon_t newpolygon =
     298        SPD.get<2>();
     299    SphericalPointDistribution::Polygon_t expected;
     300    expected += Vector(0.,-1.,0.);
     301    SphericalPointDistribution::Polygon_t remaining =
     302        SphericalPointDistribution::matchSphericalPointDistributions(
     303            polygon,
     304            newpolygon);
     305//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     306    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
     307  }
     308
     309  // test with one point, just a flip to another axis
     310  {
     311    SphericalPointDistribution::WeightedPolygon_t polygon;
     312    polygon += std::make_pair( Vector(0.,0.,-1.), 1);
     313    SphericalPointDistribution::Polygon_t newpolygon =
     314        SPD.get<2>();
     315    SphericalPointDistribution::Polygon_t expected;
     316    expected += Vector(0.,0.,1.);
     317    SphericalPointDistribution::Polygon_t remaining =
     318        SphericalPointDistribution::matchSphericalPointDistributions(
     319            polygon,
     320            newpolygon);
     321//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     322    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
     323  }
     324
     325  // test with one point, full rotation
     326  {
     327    Line RotationAxis(zeroVec, Vector(0.2, 0.43, 0.6893248));
     328    SphericalPointDistribution::WeightedPolygon_t polygon;
     329    polygon += std::make_pair(RotationAxis.rotateVector(Vector(1.,0.,0.), 47.6/180*M_PI), 1);
     330    SphericalPointDistribution::Polygon_t newpolygon =
     331        SPD.get<2>();
     332    SphericalPointDistribution::Polygon_t expected;
     333    expected += RotationAxis.rotateVector(Vector(-1.,0.,0.), 47.6/180*M_PI);
     334    SphericalPointDistribution::Polygon_t remaining =
     335        SphericalPointDistribution::matchSphericalPointDistributions(
     336            polygon,
     337            newpolygon);
     338//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     339    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
     340  }
     341}
     342
     343void perturbPolygon(
     344    SphericalPointDistribution::WeightedPolygon_t &_polygon,
     345    double _amplitude
     346    )
     347{
     348  for (SphericalPointDistribution::WeightedPolygon_t::iterator iter = _polygon.begin();
     349      iter != _polygon.end(); ++iter) {
     350    Vector perturber;
     351    perturber.GetOneNormalVector(iter->first);
     352    perturber.Scale(_amplitude);
     353    iter->first = iter->first + perturber;
     354    (iter->first).Normalize();
    244355  }
    245356}
    … …  
    367478            polygon,
    368479            newpolygon);
    369     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     480//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     481    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    370482  }
    371483
    … …  
    387499            polygon,
    388500            newpolygon);
    389     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     501//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     502    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    390503  }
    391504
    … …  
    404517            polygon,
    405518            newpolygon);
    406     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     519//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     520    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    407521    // also slightly perturbed
    408522    const double amplitude = 0.05;
    … …  
    429543            polygon,
    430544            newpolygon);
    431     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     545//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     546    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    432547    // also slightly perturbed
    433548    const double amplitude = 0.05;
    … …  
    449564            polygon,
    450565            newpolygon);
    451     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     566//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     567    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    452568    // also slightly perturbed
    453569    const double amplitude = 0.05;
    … …  
    471587            polygon,
    472588            newpolygon);
    473     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     589//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     590    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    474591    // also slightly perturbed
    475592    const double amplitude = 0.05;
    … …  
    497614            polygon,
    498615            newpolygon);
    499     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     616    //    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     617        CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    500618  }
    501619
    … …  
    517635            polygon,
    518636            newpolygon);
    519     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     637//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     638    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    520639  }
    521640
    … …  
    534653            polygon,
    535654            newpolygon);
    536     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     655//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     656    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    537657    // also slightly perturbed
    538658    const double amplitude = 0.05;
    … …  
    555675            polygon,
    556676            newpolygon);
    557     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     677//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     678    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    558679    // also slightly perturbed
    559680    const double amplitude = 0.05;
    … …  
    580701            polygon,
    581702            newpolygon);
    582     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     703//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     704    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    583705    // also slightly perturbed
    584706    const double amplitude = 0.05;
    … …  
    603725            polygon,
    604726            newpolygon);
    605     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     727//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     728    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    606729    // also slightly perturbed
    607730    const double amplitude = 0.05;
    … …  
    630753            polygon,
    631754            newpolygon);
    632     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     755//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     756    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    633757    // also slightly perturbed
    634758    const double amplitude = 0.05;
    … …  
    659783            newpolygon);
    660784//    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
    661     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     785//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     786    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    662787  }
    663788
    … …  
    677802            newpolygon);
    678803//    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
    679     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     804//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     805    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    680806  }
    681807
    … …  
    696822            newpolygon);
    697823//    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
    698     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     824//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     825    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    699826  }
    700827
    … …  
    714841            newpolygon);
    715842//    std::cout << std::setprecision(13) << "Matched polygon is " << remaining << std::endl;
    716     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     843//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     844    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    717845  }
    718846}
    … …  
    736864            polygon,
    737865            newpolygon);
    738     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     866//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     867    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    739868  }
    740869
    … …  
    756885            polygon,
    757886            newpolygon);
    758     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     887//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     888    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    759889  }
    760890
    … …  
    773903            polygon,
    774904            newpolygon);
    775     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     905//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     906    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    776907    // also slightly perturbed
    777908    const double amplitude = 0.05;
    … …  
    827958            polygon,
    828959            newpolygon);
    829     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     960//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     961    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    830962    // also slightly perturbed
    831963    const double amplitude = 0.05;
    … …  
    854986            polygon,
    855987            newpolygon);
    856     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     988//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     989    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    857990    // also slightly perturbed
    858991    const double amplitude = 0.05;
    … …  
    8801013            polygon,
    8811014            newpolygon);
    882     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1015//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1016    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    8831017  }
    8841018
    … …  
    9001034            polygon,
    9011035            newpolygon);
    902     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1036//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1037    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    9031038  }
    9041039
    … …  
    9171052            polygon,
    9181053            newpolygon);
    919     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1054//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1055    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    9201056    // also slightly perturbed
    9211057    const double amplitude = 0.05;
    … …  
    9711107            polygon,
    9721108            newpolygon);
    973     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1109//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1110    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    9741111    // also slightly perturbed
    9751112    const double amplitude = 0.05;
    … …  
    9981135            polygon,
    9991136            newpolygon);
    1000     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1137//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1138    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    10011139    // also slightly perturbed
    10021140    const double amplitude = 0.05;
    … …  
    10241162            polygon,
    10251163            newpolygon);
    1026     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1164//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1165    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    10271166  }
    10281167
    … …  
    10441183            polygon,
    10451184            newpolygon);
    1046     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1185//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1186    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    10471187  }
    10481188
    … …  
    10611201            polygon,
    10621202            newpolygon);
    1063     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1203//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1204    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    10641205    // also slightly perturbed
    10651206    const double amplitude = 0.05;
    … …  
    11151256            polygon,
    11161257            newpolygon);
    1117     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1258//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1259    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    11181260    // also slightly perturbed
    11191261    const double amplitude = 0.05;
    … …  
    11421284            polygon,
    11431285            newpolygon);
    1144     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1286//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1287    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    11451288    // also slightly perturbed
    11461289    const double amplitude = 0.05;
    … …  
    11681311            polygon,
    11691312            newpolygon);
    1170     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1313//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1314    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    11711315  }
    11721316
    … …  
    11881332            polygon,
    11891333            newpolygon);
    1190     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1334//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1335    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    11911336  }
    11921337
    … …  
    12051350            polygon,
    12061351            newpolygon);
    1207     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1352//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1353    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    12081354    // also slightly perturbed
    12091355    const double amplitude = 0.05;
    … …  
    12631409            polygon,
    12641410            newpolygon);
    1265     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1411//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1412    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    12661413    // also slightly perturbed
    12671414    const double amplitude = 0.05;
    … …  
    12901437            polygon,
    12911438            newpolygon);
    1292     CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1439//    CPPUNIT_ASSERT_EQUAL( expected, remaining );
     1440    CPPUNIT_ASSERT( areEqualToWithinBounds(expected, remaining, CenterAccuracy) );
    12931441    // also slightly perturbed
    12941442    const double amplitude = 0.05;
Note: See TracChangeset for help on using the changeset viewer.