3rd-party
/
poly2tri
mirror of https://github.com/jhasse/poly2tri.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fixed more pointer bugs

This commit is contained in:
zzzzrrr 2010-01-20 12:10:58 -05:00
parent d776b54e57
commit 0bb55b95b8
11 changed files with 145 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
poly2tri/common/shapes.cc
View File

@ -36,11 +36,7 @@ Triangle::Triangle(Point& a, Point& b, Point& c) {
neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
interior = false;
}
Triangle::~Triangle() {
printf("bye triangle\n");
interior_ = false;
}
// Update neighbor pointers
@ -140,8 +136,7 @@ int Triangle::EdgeIndex(const Point* p1, const Point* p2) {
} else if(points_[2] == p2){
return 1;
}
}
else if(points_[1] == p1) {
} else if(points_[1] == p1) {
if(points_[2] == p2) {
return 0;
} else if(points_[0] == p2) {
@ -162,16 +157,7 @@ void Triangle::MarkConstrainedEdge(const int index) {
}
void Triangle::MarkConstrainedEdge(Edge& edge) {
MarkConstrainedEdge(edge.p, edge.q);
if((edge.q == points_[0] && edge.p == points_[1]) || (edge.q == points_[1] && edge.p == points_[0])) {
constrained_edge[2] = true;
} else if((edge.q == points_[0] && edge.p == points_[2]) || (edge.q == points_[2] && edge.p == points_[0])) {
constrained_edge[1] = true;
} else if(( edge.q == points_[1] && edge.p == points_[2]) || (edge.q == points_[2] && edge.p == points_[1])) {
constrained_edge[0] = true;
}
}
// Mark edge as constrained

44
poly2tri/common/shapes.h
View File

@ -91,18 +91,6 @@ struct Point {
y /= len;
return len;
}
bool operator < (Point& b) {
if (y < b.y) {
return true;
} else if (y == b.y) {
// Make sure q is point with greater x value
if(x < b.x) {
return true;
}
}
return false;
}
};
@ -128,7 +116,7 @@ struct Edge {
}
q->edge_list.push_back(*this);
//printf("%i\n", q->edge_list.size());
}
};
@ -142,15 +130,11 @@ public:
/// Constructor
Triangle(Point& a, Point& b, Point& c);
// Destroctor
~Triangle();
/// Flags to determine if an edge is a Constrained edge
bool constrained_edge[3];
/// Flags to determine if an edge is a Delauney edge
bool delaunay_edge[3];
/// Has this triangle been marked as an interior triangle?
bool interior;
Point* GetPoint(const int& index);
Point* PointCW(Point& point);
@ -187,6 +171,9 @@ public:
void ClearNeighbors();
void ClearDelunayEdges();
inline bool IsInterior();
inline void IsInterior(bool b);
Triangle& NeighborAcross(Point& opoint);
void DebugPrint();
@ -197,15 +184,18 @@ private:
Point* points_[3];
/// Neighbor list
Triangle* neighbors_[3];
/// Has this triangle been marked as an interior triangle?
bool interior_;
};
inline bool operator < (const Point& a, const Point& b) {
if (a.y < b.y) {
inline bool cmp (const Point* a, const Point* b) {
if (a->y < b->y) {
return true;
} else if (a.y == b.y) {
} else if (a->y == b->y) {
// Make sure q is point with greater x value
if(a.x < b.x) {
if(a->x < b->x) {
return true;
}
}
@ -235,10 +225,6 @@ inline bool operator != (const Point& a, const Point& b) {
return a.x != b.x && a.y != b.y;
}
inline bool operator != (const Node& a, const Node& b) {
return a != b;
}
/// Peform the dot product on two vectors.
inline double Dot(const Point& a, const Point& b) {
return a.x * b.x + a.y * b.y;
@ -281,5 +267,13 @@ inline bool Triangle::Contains(Point* p, Point* q) {
return Contains(p) && Contains(q);
}
inline bool Triangle::IsInterior() {
return interior_;
}
inline void Triangle::IsInterior(bool b) {
interior_ = b;
}
#endif

2
poly2tri/sweep/cdt.cc
View File

@ -43,7 +43,7 @@ void CDT::Triangulate() {
sweep_->Triangulate(*sweep_context_);
}
std::list<Triangle*> CDT::GetTriangles() {
std::vector<Triangle*> CDT::GetTriangles() {
return sweep_context_->GetTriangles();
}

2
poly2tri/sweep/cdt.h
View File

@ -45,7 +45,7 @@ public:
/// Triangulate points
void Triangulate();
/// Get Delaunay triangles
std::list<Triangle*> GetTriangles();
std::vector<Triangle*> GetTriangles();
private:

40
poly2tri/sweep/sweep.cc
View File

@ -35,31 +35,22 @@
// Triangulate simple polygon with holes
void Sweep::Triangulate(SweepContext& tcx) {
tcx.CreateAdvancingFront();
// Sweep points; build mesh
SweepPoints(tcx);
/*
// Finalize triangulation
if( tcx.getTriangulationMode() == TriangulationMode.Polygon ) {
finalizationPolygon( tcx );
} else {
finalizationConvexHull( tcx );
}
*/
// Clean up
FinalizationPolygon(tcx);
}
void Sweep::SweepPoints(SweepContext& tcx ) {
void Sweep::SweepPoints(SweepContext& tcx) {
for(int i = 1; i < tcx.point_count(); i++ ) {
Point& point = *tcx.GetPoint(i);
Node& node = PointEvent(tcx, point);
Node& node = PointEvent(tcx, point);
for(int i = 0; i < point.edge_list.size(); i++) {
EdgeEvent(tcx, point.edge_list[i], node);
}
@ -68,6 +59,19 @@ void Sweep::SweepPoints(SweepContext& tcx ) {
}
void Sweep::FinalizationPolygon(SweepContext& tcx) {
// Get an Internal triangle to start with
Triangle* t = tcx.front()->head()->next->triangle;
Point* p = tcx.front()->head()->next->point;
while(!t->GetConstrainedEdgeCW(*p)) {
t = t->NeighborCCW(*p);
}
// Collect interior triangles constrained by edges
tcx.MeshClean(*t);
}
/**
* Find closes node to the left of the new point and
* create a new triangle. If needed new holes and basins
@ -102,7 +106,7 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge& edge, Node& node) {
if(IsEdgeSideOfTriangle(*node.triangle, *edge.p, *edge.q)){
return;
}
// For now we will do all needed filling
// TODO: integrate with flip process might give some better performance
// but for now this avoid the issue with cases that needs both flips and fills
@ -615,7 +619,7 @@ void Sweep::TurnAdvancingFrontConvex(SweepContext& tcx, Node& b, Node& c) {
Node& first = b;
while(c != *tcx.front()->tail()) {
while(&c != tcx.front()->tail()) {
if(Orient2d(*b.point, *c.point, *c.next->point) == CCW) {
// [b,c,d] Concave - fill around c
@ -623,7 +627,7 @@ void Sweep::TurnAdvancingFrontConvex(SweepContext& tcx, Node& b, Node& c) {
c = *c.next;
} else {
// [b,c,d] Convex
if(b != first && Orient2d(*b.prev->point, *b.point, *c.point) == CCW) {
if(&b != &first && Orient2d(*b.prev->point, *b.point, *c.point) == CCW) {
// [a,b,c] Concave - fill around b
Fill(tcx, b);
b = *b.prev;

4
poly2tri/sweep/sweep.h
View File

@ -111,6 +111,8 @@ private:
Point& NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op );
void FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p);
void FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p);
void FinalizationPolygon(SweepContext& tcx);
};

95
poly2tri/sweep/sweep_context.cc
View File

@ -9,27 +9,26 @@ SweepContext::SweepContext(Point** polyline, const int& point_count) {
basin = Basin();
edge_event = EdgeEvent();
for(int i = 0; i < point_count; i++) {
points_.push_back(**&polyline[i]);
}
points_ = polyline;
point_count_ = point_count;
InitEdges(polyline, point_count);
InitEdges(points_, point_count_);
InitTriangulation();
}
std::list<Triangle*> SweepContext::GetTriangles() {
return tri_list_;
std::vector<Triangle*> SweepContext::GetTriangles() {
return triangles_;
}
void SweepContext::InitTriangulation() {
double xmax(points_[0].x), xmin(points_[0].x);
double ymax(points_[0].y), ymin(points_[0].y);
double xmax(points_[0]->x), xmin(points_[0]->x);
double ymax(points_[0]->y), ymin(points_[0]->y);
// Calculate bounds.
for(int i = 0; i < points_.size(); i++) {
Point p = points_[i];
for(int i = 0; i < point_count_; i++) {
Point p = *points_[i];
if(p.x > xmax)
xmax = p.x;
if(p.x < xmin)
@ -47,26 +46,46 @@ void SweepContext::InitTriangulation() {
// Sort points along y-axis
double init_time = glfwGetTime();
std::sort(points_.begin(), points_.end());
std::sort(points_, points_ + point_count_, cmp);
double dt = glfwGetTime() - init_time;
printf("Sort time (secs) = %f\n", dt);
/*
printf("*************************\n");
for(int i = 0; i < point_count_; i++) {
printf("%p ", points_[i]);
printf("%f,%f\n", points_[i]->x, points_[i]->y);
}
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
for(int i = 0; i < edge_list.size(); i++) {
printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q);
}
*/
}
void SweepContext::InitEdges(Point** polyline, const int& point_count) {
for(int i = 0; i < point_count; i++) {
int j = i < points_.size() - 1 ? i + 1 : 0;
edge_list.push_back(new Edge(**&polyline[i], **&polyline[j]));
int j = i < point_count - 1 ? i + 1 : 0;
edge_list.push_back(new Edge(*polyline[i], *polyline[j]));
}
/*
for(int i = 0; i < edge_list.size(); i++) {
printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q);
}
*/
}
Point* SweepContext::GetPoint(const int& index) {
return &points_[index];
return points_[index];
}
void SweepContext::AddToMap(Triangle* triangle ) {
tri_list_.push_back(triangle);
map_.push_back(triangle);
}
Node& SweepContext::LocateNode(Point& point) {
@ -77,9 +96,9 @@ Node& SweepContext::LocateNode(Point& point) {
void SweepContext::CreateAdvancingFront() {
// Initial triangle
Triangle* triangle = new Triangle(points_[0], *tail_, *head_);
Triangle* triangle = new Triangle(*points_[0], *tail_, *head_);
tri_list_.push_back(triangle);
map_.push_back(triangle);
front_ = new AdvancingFront;
@ -114,46 +133,22 @@ void SweepContext::MapTriangleToNodes(Triangle& t) {
}
void SweepContext::RemoveFromMap(Triangle* triangle) {
tri_list_.remove(triangle);
map_.remove(triangle);
}
/*
void SweepContext::MeshClean(Triangle& triangle) {
pointset_.ClearTriangulation();
MeshCleanReq(triangle);
}
void SweepContext::MeshClean(Triangle& triangle ) {
AFront SweepContext::front_() {
return front_;
}
void SweepContext::Clear() {
super.clear();
tri_list_.Clear();
}
Node* SweepContext::LocateNode(Point& point) {
// TODO implement tree
return front_.Locate(point.x);
}
/*
void SweepContext::MeshCleanReq(Triangle& triangle ) {
if(triangle != NULL && !triangle.isInterior()) {
if(&triangle != NULL && !triangle.IsInterior()) {
triangle.IsInterior(true);
pointset_.AddTriangle(triangle);
triangles_.push_back(&triangle);
for(int i = 0; i < 3; i++) {
if(!triangle.cEdge[i])
MeshCleanReq(triangle.neighbors[i]);
}
}
if(!triangle.constrained_edge[i])
MeshClean(*triangle.GetNeighbor(i));
}
}
}
*/
SweepContext::~SweepContext() {
//delete [] points_;
delete head_;
delete tail_;
delete front_;

13
poly2tri/sweep/sweep_context.h
View File

@ -80,7 +80,9 @@ public:
AdvancingFront* front();
std::list<Triangle*> GetTriangles();
void MeshClean(Triangle& triangle);
std::vector<Triangle*> GetTriangles();
std::vector<Edge*> edge_list;
@ -119,8 +121,11 @@ public:
private:
std::list<Triangle*> tri_list_;
std::vector<Point> points_;
std::vector<Triangle*> triangles_;
std::list<Triangle*> map_;
Point** points_;
int point_count_;
// Advancing front
AdvancingFront* front_;
@ -147,7 +152,7 @@ private:
inline AdvancingFront* SweepContext::front() { return front_; }
inline int SweepContext::point_count() { return points_.size(); }
inline int SweepContext::point_count() { return point_count_; }
inline void SweepContext::set_head(Point* p1) { head_ = p1; }

2
testbed/data/bird.dat
View File

@ -272,4 +272,4 @@
6.20462 5.25418
5.72617 4.80159
5.13134 4.41366
4.87271 4.16797
4.87271 4.16797

2
testbed/data/dude.dat
View File

@ -91,4 +91,4 @@
254.28571 604.50504
251.07143 621.11218
250.53571 649.1479
268.1955 654.36208
268.1955 654.36208

71
testbed/main.cc
View File

@ -46,12 +46,13 @@ void Init();
void ShutDown(int return_code);
void MainLoop(const double zoom);
void Draw(const double zoom);
void ConstrainedColor(bool constrain);
float rotate_y = 0,
rotate_z = 0;
const float rotations_per_tick = .2;
list<Triangle*> triangles;
vector<Triangle*> triangles;
double StringToDouble(const std::string& s) {
std::istringstream i(s);
@ -80,21 +81,12 @@ int main(int argc, char* argv[]) {
double y = rand() % (b - a - 1) + a + 1;
polyline[i] = Point(x, y);
}
polyline[0] = Point(5, 5);
polyline[1] = Point(-5, 5);
polyline[2] = Point(-5, -5);
polyline[3] = Point(5, -5);
//Point foo[] = {Point(5, 5.1), Point(-5, 5.2), Point(-5, -5.3), Point(5, -5.4), Point(5.1, 5.5), Point(5, 5.5),
// Point(-5, 5.6), Point(-5, -5.7), Point(5, -5.8), Point(5, 5.9), Point(-5, 5.1),
// Point(-5, -5.11), Point(5, -5.12), Point(5, 5.13), Point(-5, 5.14), Point(-5, -5.15), Point(5, -5.16)};
*/
string line;
ifstream myfile (argv[1]);
vector<Point> points;
vector<Point*> points;
if (myfile.is_open()) {
while (!myfile.eof()) {
getline (myfile,line);
@ -107,7 +99,7 @@ int main(int argc, char* argv[]) {
back_inserter<vector<string> >(tokens));
double x = StringToDouble(tokens[0]);
double y = StringToDouble(tokens[1]);
points.push_back(Point(x, y));
points.push_back(new Point(x, y));
}
myfile.close();
} else {
@ -119,7 +111,7 @@ int main(int argc, char* argv[]) {
Point** polyline = new Point *[num_points];
for(int i = 0; i < num_points; i++) {
polyline[i] = &points[i];
polyline[i] = points[i];
}
Init();
@ -229,22 +221,41 @@ void Draw(const double zoom)
ResetZoom(zoom, center.x, center.y, 800, 600);
list<Triangle*>::iterator it;
for (it = triangles.begin(); it != triangles.end(); it++) {
Triangle* t = *it;
Point* a = t->GetPoint(0);
Point* b = t->GetPoint(1);
Point* c = t->GetPoint(2);
// Red
glColor3f(1, 0, 0);
glBegin(GL_LINE_LOOP); // Drawing Using Triangles
glVertex2f(a->x, a->y); // Top
glVertex2f(b->x, b->y); // Bottom Left
glVertex2f(c->x, c->y); // Bottom Right
glEnd();
for (int i = 0; i < triangles.size(); i++) {
Triangle& t = *triangles[i];
Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1);
Point& c = *t.GetPoint(2);
ConstrainedColor(t.constrained_edge[2]);
glBegin(GL_LINES);
glVertex2f(a.x, a.y);
glVertex2f(b.x, b.y);
glEnd( );
ConstrainedColor(t.constrained_edge[0]);
glBegin(GL_LINES);
glVertex2f(b.x, b.y);
glVertex2f(c.x, c.y);
glEnd( );
ConstrainedColor(t.constrained_edge[1]);
glBegin(GL_LINES);
glVertex2f(c.x, c.y);
glVertex2f(a.x, a.y);
glEnd( );
}
}
void ConstrainedColor(bool constrain) {
if(constrain) {
// Green
glColor3f(0, 1, 0);
} else {
// Red
glColor3f(1, 0, 0);
}
}