3rd-party/poly2tri
1
0
Fork 0
mirror of https://github.com/jhasse/poly2tri.git synced 2024-12-02 02:03:30 +01:00
Code Issues Projects Releases Wiki Activity

update testbed and unittest to adapt to span changes

Browse Source
This commit is contained in:
Tom Hulton-Harrop 2023-04-23 20:02:13 +01:00
parent 4a5d11548c
commit 567f5ffd0a
2 changed files with 121 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
testbed/main.cc
View File

@ -51,13 +51,13 @@
using namespace std; using namespace std;
using namespace p2t; using namespace p2t;
bool ParseFile(string filename, vector<Point*>& out_polyline, vector<vector<Point*>>& out_holes, bool ParseFile(string filename, vector<Point>& out_polyline, vector<vector<Point>>& out_holes,
vector<Point*>& out_steiner); vector<Point>& out_steiner);
std::pair<Point, Point> BoundingBox(const std::vector<Point*>& polyline); std::pair<Point, Point> BoundingBox(gsl::span<const Point> polyline);
void GenerateRandomPointDistribution(size_t num_points, double min, double max, void GenerateRandomPointDistribution(size_t num_points, double min, double max,
vector<Point*>& out_polyline, vector<Point>& out_polyline,
vector<vector<Point*>>& out_holes, vector<vector<Point>>& out_holes,
vector<Point*>& out_steiner); vector<Point>& out_steiner);
void Init(int window_width, int window_height); void Init(int window_width, int window_height);
void ShutDown(int return_code); void ShutDown(int return_code);
void MainLoop(const double zoom); void MainLoop(const double zoom);
@ -89,24 +89,16 @@ vector<Triangle*> triangles;
/// Triangle map /// Triangle map
list<Triangle*> map; list<Triangle*> map;
/// Polylines /// Polylines
vector<Point*> polyline; vector<Point> polyline;
vector<vector<Point*>> holes; vector<vector<Point>> holes;
vector<Point*> steiner; vector<Point> steiner;
/// Draw the entire triangle map? /// Draw the entire triangle map?
bool draw_map = false; bool draw_map = false;
/// Create a random distribution of points? /// Create a random distribution of points?
bool random_distribution = false; bool random_distribution = false;
GLFWwindow* window = NULL; GLFWwindow* window = nullptr;
template <class C> void FreeClear(C& cntr)
{
for (typename C::iterator it = cntr.begin(); it != cntr.end(); ++it) {
delete *it;
}
cntr.clear();
}
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
@ -187,12 +179,12 @@ int main(int argc, char* argv[])
/* /*
* STEP 2: Add holes or Steiner points * STEP 2: Add holes or Steiner points
*/ */
for (const auto& hole : holes) { for (auto& hole : holes) {
assert(!hole.empty()); assert(!hole.empty());
cdt->AddHole(hole); cdt->AddHole(hole);
} }
for (const auto& s : steiner) { for (auto& s : steiner) {
cdt->AddPoint(s); cdt->AddPoint(&s);
} }
/* /*
@ -206,7 +198,7 @@ int main(int argc, char* argv[])
map = cdt->GetMap(); map = cdt->GetMap();
const size_t points_in_holes = const size_t points_in_holes =
std::accumulate(holes.cbegin(), holes.cend(), size_t(0), std::accumulate(holes.cbegin(), holes.cend(), size_t(0),
[](size_t cumul, const vector<Point*>& hole) { return cumul + hole.size(); }); [](size_t cumul, const vector<Point>& hole) { return cumul + hole.size(); });
cout << "Number of primary constrained edges = " << polyline.size() << endl; cout << "Number of primary constrained edges = " << polyline.size() << endl;
cout << "Number of holes = " << holes.size() << endl; cout << "Number of holes = " << holes.size() << endl;
@ -222,18 +214,18 @@ int main(int argc, char* argv[])
// Cleanup // Cleanup
delete cdt; delete cdt;
FreeClear(polyline); polyline.clear();
for (vector<Point*>& hole : holes) { for (vector<Point>& hole : holes) {
FreeClear(hole); hole.clear();
} }
FreeClear(steiner); steiner.clear();
ShutDown(0); ShutDown(0);
return 0; return 0;
} }
bool ParseFile(string filename, vector<Point*>& out_polyline, vector<vector<Point*>>& out_holes, bool ParseFile(string filename, vector<Point>& out_polyline, vector<vector<Point>>& out_holes,
vector<Point*>& out_steiner) vector<Point>& out_steiner)
{ {
enum ParserState { enum ParserState {
Polyline, Polyline,
@ -241,7 +233,7 @@ bool ParseFile(string filename, vector<Point*>& out_polyline, vector<vector<Poin
Steiner, Steiner,
}; };
ParserState state = Polyline; ParserState state = Polyline;
vector<Point*>* hole = nullptr; vector<Point>* hole = nullptr;
try { try {
string line; string line;
ifstream myfile(filename); ifstream myfile(filename);
@ -272,14 +264,14 @@ bool ParseFile(string filename, vector<Point*>& out_polyline, vector<vector<Poin
double y = StringToDouble(tokens[1]); double y = StringToDouble(tokens[1]);
switch (state) { switch (state) {
case Polyline: case Polyline:
out_polyline.push_back(new Point(x, y)); out_polyline.push_back(Point(x, y));
break; break;
case Hole: case Hole:
assert(hole != nullptr); assert(hole != nullptr);
hole->push_back(new Point(x, y)); hole->push_back(Point(x, y));
break; break;
case Steiner: case Steiner:
out_steiner.push_back(new Point(x, y)); out_steiner.push_back(Point(x, y));
break; break;
default: default:
assert(0); assert(0);
@ -296,36 +288,36 @@ bool ParseFile(string filename, vector<Point*>& out_polyline, vector<vector<Poin
return true; return true;
} }
std::pair<Point, Point> BoundingBox(const std::vector<Point*>& polyline) std::pair<Point, Point> BoundingBox(gsl::span<const Point> polyline)
{ {
assert(polyline.size() > 0); assert(polyline.size() > 0);
using Scalar = decltype(p2t::Point::x); using Scalar = decltype(p2t::Point::x);
Point min(std::numeric_limits<Scalar>::max(), std::numeric_limits<Scalar>::max()); Point min(std::numeric_limits<Scalar>::max(), std::numeric_limits<Scalar>::max());
Point max(std::numeric_limits<Scalar>::min(), std::numeric_limits<Scalar>::min()); Point max(std::numeric_limits<Scalar>::min(), std::numeric_limits<Scalar>::min());
for (const Point* point : polyline) { for (const Point& point : polyline) {
min.x = std::min(min.x, point->x); min.x = std::min(min.x, point.x);
min.y = std::min(min.y, point->y); min.y = std::min(min.y, point.y);
max.x = std::max(max.x, point->x); max.x = std::max(max.x, point.x);
max.y = std::max(max.y, point->y); max.y = std::max(max.y, point.y);
} }
return std::make_pair(min, max); return std::make_pair(min, max);
} }
void GenerateRandomPointDistribution(size_t num_points, double min, double max, void GenerateRandomPointDistribution(size_t num_points, double min, double max,
vector<Point*>& out_polyline, vector<Point>& out_polyline,
vector<vector<Point*>>& out_holes, vector<Point*>& out_steiner) vector<vector<Point>>& out_holes, vector<Point>& out_steiner)
{ {
out_polyline.push_back(new Point(min, min)); out_polyline.push_back(Point(min, min));
out_polyline.push_back(new Point(min, max)); out_polyline.push_back(Point(min, max));
out_polyline.push_back(new Point(max, max)); out_polyline.push_back(Point(max, max));
out_polyline.push_back(new Point(max, min)); out_polyline.push_back(Point(max, min));
max -= (1e-4); max -= (1e-4);
min += (1e-4); min += (1e-4);
for (int i = 0; i < num_points; i++) { for (int i = 0; i < num_points; i++) {
double x = Random(Fun, min, max); double x = Random(Fun, min, max);
double y = Random(Fun, min, max); double y = Random(Fun, min, max);
out_steiner.push_back(new Point(x, y)); out_steiner.push_back(Point(x, y));
} }
} }
@ -440,16 +432,16 @@ void Draw(const double zoom)
// green // green
glColor3f(0, 1, 0); glColor3f(0, 1, 0);
vector<vector<Point*>*> polylines; vector<vector<Point>*> polylines;
polylines.push_back(&polyline); polylines.push_back(&polyline);
for (vector<Point*>& hole : holes) { for (vector<Point>& hole : holes) {
polylines.push_back(&hole); polylines.push_back(&hole);
} }
for(int i = 0; i < polylines.size(); i++) { for(int i = 0; i < polylines.size(); i++) {
const vector<Point*>& poly = *polylines[i]; const vector<Point>& poly = *polylines[i];
glBegin(GL_LINE_LOOP); glBegin(GL_LINE_LOOP);
for(int j = 0; j < poly.size(); j++) { for(int j = 0; j < poly.size(); j++) {
glVertex2d(poly[j]->x, poly[j]->y); glVertex2d(poly[j].x, poly[j].y);
} }
glEnd(); glEnd();
} }

193
unittest/main.cpp
View File

@ -15,56 +15,47 @@
BOOST_AUTO_TEST_CASE(BasicTest) BOOST_AUTO_TEST_CASE(BasicTest)
{ {
std::vector<p2t::Point*> polyline{ std::vector<p2t::Point> polyline{
new p2t::Point(0, 0), p2t::Point(0, 0),
new p2t::Point(1, 0), p2t::Point(1, 0),
new p2t::Point(1, 1), p2t::Point(1, 1),
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 1); BOOST_REQUIRE_EQUAL(result.size(), 1);
BOOST_CHECK_EQUAL(*result[0]->GetPoint(0), *polyline[0]); BOOST_CHECK_EQUAL(*result[0]->GetPoint(0), polyline[0]);
BOOST_CHECK_EQUAL(*result[0]->GetPoint(1), *polyline[1]); BOOST_CHECK_EQUAL(*result[0]->GetPoint(1), polyline[1]);
BOOST_CHECK_EQUAL(*result[0]->GetPoint(2), *polyline[2]); BOOST_CHECK_EQUAL(*result[0]->GetPoint(2), polyline[2]);
BOOST_CHECK(p2t::IsDelaunay(result)); BOOST_CHECK(p2t::IsDelaunay(result));
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(QuadTest) BOOST_AUTO_TEST_CASE(QuadTest)
{ {
std::vector<p2t::Point*> polyline{ new p2t::Point(0, 0), new p2t::Point(0, 1), std::vector<p2t::Point> polyline{ p2t::Point(0, 0), p2t::Point(0, 1),
new p2t::Point(1, 1), new p2t::Point(1, 0) }; p2t::Point(1, 1), p2t::Point(1, 0) };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 2); BOOST_REQUIRE_EQUAL(result.size(), 2);
BOOST_CHECK(p2t::IsDelaunay(result)); BOOST_CHECK(p2t::IsDelaunay(result));
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(NarrowQuadTest) BOOST_AUTO_TEST_CASE(NarrowQuadTest)
{ {
// Very narrow quad that used to demonstrate a failure case during // Very narrow quad that used to demonstrate a failure case during
// triangulation // triangulation
std::vector<p2t::Point*> polyline { std::vector<p2t::Point> polyline {
new p2t::Point(0.0, 0.0), p2t::Point(0.0, 0.0),
new p2t::Point(1.0e-05, 0.0), p2t::Point(1.0e-05, 0.0),
new p2t::Point(1.1e-04, 3.0e-07), p2t::Point(1.1e-04, 3.0e-07),
new p2t::Point(1.0e-04, 3.0e-07) p2t::Point(1.0e-04, 3.0e-07)
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 2); BOOST_REQUIRE_EQUAL(result.size(), 2);
BOOST_CHECK(p2t::IsDelaunay(result)); BOOST_CHECK(p2t::IsDelaunay(result));
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(ConcaveBoundaryTest) BOOST_AUTO_TEST_CASE(ConcaveBoundaryTest)
@ -72,23 +63,23 @@ BOOST_AUTO_TEST_CASE(ConcaveBoundaryTest)
// Concave-by-less-than-epsilon boundaries used to potentially fail // Concave-by-less-than-epsilon boundaries used to potentially fail
// during triangulation // during triangulation
const double eps = 1e-15; // This gave EdgeEvent - null triangle const double eps = 1e-15; // This gave EdgeEvent - null triangle
std::vector<p2t::Point*> polyline { std::vector<p2t::Point> polyline {
new p2t::Point(0,0), p2t::Point(0,0),
new p2t::Point(0.5,eps), p2t::Point(0.5,eps),
new p2t::Point(1,0), p2t::Point(1,0),
new p2t::Point(1-eps,0.836541), p2t::Point(1-eps,0.836541),
new p2t::Point(1,2), p2t::Point(1,2),
new p2t::Point(.46,1.46+eps), p2t::Point(.46,1.46+eps),
new p2t::Point(0,1), p2t::Point(0,1),
new p2t::Point(eps,0.5) p2t::Point(eps,0.5)
}; };
const double r2o4 = std::sqrt(2.)/4; const double r2o4 = std::sqrt(2.)/4;
std::vector<p2t::Point*> hole { std::vector<p2t::Point> hole {
new p2t::Point(0.5+r2o4,0.5), p2t::Point(0.5+r2o4,0.5),
new p2t::Point(0.5,0.5+r2o4), p2t::Point(0.5,0.5+r2o4),
new p2t::Point(0.5-r2o4,0.5), p2t::Point(0.5-r2o4,0.5),
new p2t::Point(0.5-eps,0.5-r2o4) p2t::Point(0.5-eps,0.5-r2o4)
}; };
std::vector<p2t::Point> interior_points std::vector<p2t::Point> interior_points
@ -104,109 +95,94 @@ BOOST_AUTO_TEST_CASE(ConcaveBoundaryTest)
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 18); BOOST_REQUIRE_EQUAL(result.size(), 18);
BOOST_CHECK(p2t::IsDelaunay(result)); BOOST_CHECK(p2t::IsDelaunay(result));
for (const auto p : polyline) {
delete p;
}
for (const auto p : hole) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(PolygonTest01) BOOST_AUTO_TEST_CASE(PolygonTest01)
{ {
// Reported in issue #10 // Reported in issue #10
std::vector<p2t::Point*> polyline = { std::vector<p2t::Point> polyline = {
new p2t::Point(-0.388419120000000006598384061363, 0.0368141516905975269002837535481), p2t::Point(-0.388419120000000006598384061363, 0.0368141516905975269002837535481),
new p2t::Point(-0.388419120000000006598384061363, 0.0104235565411950892311665484158), p2t::Point(-0.388419120000000006598384061363, 0.0104235565411950892311665484158),
new p2t::Point(-0.611580879999999993401615938637, 0.0104235565411950892311665484158), p2t::Point(-0.611580879999999993401615938637, 0.0104235565411950892311665484158),
new p2t::Point(-0.611580879999999993401615938637, 0.1483950316905975341796875), p2t::Point(-0.611580879999999993401615938637, 0.1483950316905975341796875),
new p2t::Point(-0.578899596898762469621146919962, 0.227294628589359948289683188705), p2t::Point(-0.578899596898762469621146919962, 0.227294628589359948289683188705),
new p2t::Point(-0.500000000000000000000000000000, 0.259975911690597527581303438637), p2t::Point(-0.500000000000000000000000000000, 0.259975911690597527581303438637),
new p2t::Point(+0.500000000000000000000000000000, 0.259975911690597527581303438637), p2t::Point(+0.500000000000000000000000000000, 0.259975911690597527581303438637),
new p2t::Point(+0.578899596898762469621146919962, 0.227294628589359948289683188705), p2t::Point(+0.578899596898762469621146919962, 0.227294628589359948289683188705),
new p2t::Point(+0.611580879999999993401615938637, 0.1483950316905975341796875), p2t::Point(+0.611580879999999993401615938637, 0.1483950316905975341796875),
new p2t::Point(+0.611580879999999993401615938637, 0.0104235565411950614755909327869), p2t::Point(+0.611580879999999993401615938637, 0.0104235565411950614755909327869),
new p2t::Point(+0.388419120000000006598384061363, 0.0104235565411950892311665484158), p2t::Point(+0.388419120000000006598384061363, 0.0104235565411950892311665484158),
new p2t::Point(+0.388419120000000006598384061363, 0.0368141516905975130224959457337) p2t::Point(+0.388419120000000006598384061363, 0.0368141516905975130224959457337)
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 10); BOOST_REQUIRE_EQUAL(result.size(), 10);
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(PolygonTest02) BOOST_AUTO_TEST_CASE(PolygonTest02)
{ {
// Reported in issue #10 // Reported in issue #10
std::vector<p2t::Point*> polyline = { std::vector<p2t::Point> polyline = {
new p2t::Point(0.9636984967276516, 0.7676550649687783), p2t::Point(0.9636984967276516, 0.7676550649687783),
new p2t::Point(0.9636984967276516, -0.7676550649687641), p2t::Point(0.9636984967276516, -0.7676550649687641),
new p2t::Point(-0.3074475690811459, -0.7676550649687641), p2t::Point(-0.3074475690811459, -0.7676550649687641),
new p2t::Point(0.09401654924378076, -0.2590574983578904), p2t::Point(0.09401654924378076, -0.2590574983578904),
new p2t::Point(0.10567230819363671, -0.09864698028880525), p2t::Point(0.10567230819363671, -0.09864698028880525),
new p2t::Point(-0.03901177977841874, -0.028405214140875046), p2t::Point(-0.03901177977841874, -0.028405214140875046),
new p2t::Point(-0.428964921810446, -0.08483619470406722), p2t::Point(-0.428964921810446, -0.08483619470406722),
new p2t::Point(-0.5128305980156834, -0.12847817634298053), p2t::Point(-0.5128305980156834, -0.12847817634298053),
new p2t::Point(-0.5512747518916774, -0.2148501697175078), p2t::Point(-0.5512747518916774, -0.2148501697175078),
new p2t::Point(-0.5917836778064418, -0.7037530067555622), p2t::Point(-0.5917836778064418, -0.7037530067555622),
new p2t::Point(-0.5520451065921502, -0.7676550649687641), p2t::Point(-0.5520451065921502, -0.7676550649687641),
new p2t::Point(-0.9636984967276516, -0.7676550649687641), p2t::Point(-0.9636984967276516, -0.7676550649687641),
new p2t::Point(-0.9636984967276516, 0.767655064968778) p2t::Point(-0.9636984967276516, 0.767655064968778)
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 11); BOOST_REQUIRE_EQUAL(result.size(), 11);
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(PolygonTest03) BOOST_AUTO_TEST_CASE(PolygonTest03)
{ {
// Reported in issue #10 // Reported in issue #10
std::vector<p2t::Point*> polyline = { std::vector<p2t::Point> polyline = {
new p2t::Point(0.9776422201600001, 0.9776422201599928), p2t::Point(0.9776422201600001, 0.9776422201599928),
new p2t::Point(0.9776422201599999, -0.977642220160007), p2t::Point(0.9776422201599999, -0.977642220160007),
new p2t::Point(-0.12788518519240472, -0.9776422201599928), p2t::Point(-0.12788518519240472, -0.9776422201599928),
new p2t::Point(-0.3913394510746002, -0.33861494064331055), p2t::Point(-0.3913394510746002, -0.33861494064331055),
new p2t::Point(-0.47812835166211676, -0.9776422201599928), p2t::Point(-0.47812835166211676, -0.9776422201599928),
new p2t::Point(-0.9776422201600001, -0.9776422201599928), p2t::Point(-0.9776422201600001, -0.9776422201599928),
new p2t::Point(-0.9776422201600001, 0.977642220160007) p2t::Point(-0.9776422201600001, 0.977642220160007)
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 5); BOOST_REQUIRE_EQUAL(result.size(), 5);
for (const auto p : polyline) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(PolygonTest04) BOOST_AUTO_TEST_CASE(PolygonTest04)
{ {
std::vector<p2t::Point*> polyline { std::vector<p2t::Point> polyline {
new p2t::Point(450, 2250), p2t::Point(450, 2250),
new p2t::Point(450, 1750), p2t::Point(450, 1750),
new p2t::Point(400, 1700), p2t::Point(400, 1700),
new p2t::Point(350, 1650), p2t::Point(350, 1650),
new p2t::Point(350, 500), p2t::Point(350, 500),
new p2t::Point(1050, 1700) p2t::Point(1050, 1700)
}; };
std::vector<p2t::Point*> hole { std::vector<p2t::Point> hole {
new p2t::Point(980, 1636), p2t::Point(980, 1636),
new p2t::Point(950, 1600), p2t::Point(950, 1600),
new p2t::Point(650, 1230), p2t::Point(650, 1230),
new p2t::Point(625, 1247), p2t::Point(625, 1247),
new p2t::Point(600, 1250), p2t::Point(600, 1250),
new p2t::Point(591, 1350), p2t::Point(591, 1350),
new p2t::Point(550, 2050) p2t::Point(550, 2050)
}; };
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
@ -215,18 +191,12 @@ BOOST_AUTO_TEST_CASE(PolygonTest04)
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE_EQUAL(result.size(), 13); BOOST_REQUIRE_EQUAL(result.size(), 13);
for (const auto p : polyline) {
delete p;
}
for (const auto p : hole) {
delete p;
}
} }
BOOST_AUTO_TEST_CASE(TestbedFilesTest) BOOST_AUTO_TEST_CASE(TestbedFilesTest)
{ {
for (const auto& filename : { "custom.dat", "diamond.dat", "star.dat", "test.dat" }) { for (const auto& filename : { "custom.dat", "diamond.dat", "star.dat", "test.dat" }) {
std::vector<p2t::Point*> polyline; std::vector<p2t::Point> polyline;
// Load pointset from file // Load pointset from file
// Parse and tokenize data file // Parse and tokenize data file
std::string line; std::string line;
@ -249,15 +219,12 @@ BOOST_AUTO_TEST_CASE(TestbedFilesTest)
std::back_inserter<std::vector<std::string>>(tokens)); std::back_inserter<std::vector<std::string>>(tokens));
double x = std::stod(tokens[0]); double x = std::stod(tokens[0]);
double y = std::stod(tokens[1]); double y = std::stod(tokens[1]);
polyline.push_back(new p2t::Point(x, y)); polyline.push_back(p2t::Point(x, y));
} }
p2t::CDT cdt{ polyline }; p2t::CDT cdt{ polyline };
BOOST_CHECK_NO_THROW(cdt.Triangulate()); BOOST_CHECK_NO_THROW(cdt.Triangulate());
const auto result = cdt.GetTriangles(); const auto result = cdt.GetTriangles();
BOOST_REQUIRE(result.size() * 3 > polyline.size()); BOOST_REQUIRE(result.size() * 3 > polyline.size());
BOOST_CHECK_MESSAGE(p2t::IsDelaunay(result), filename + std::to_string(polyline.size())); BOOST_CHECK_MESSAGE(p2t::IsDelaunay(result), filename + std::to_string(polyline.size()));
for (const auto p : polyline) {
delete p;
}
} }
} }