3rd-party/poly2tri
1
0
Fork 0
mirror of https://github.com/jhasse/poly2tri.git synced 2025-01-07 10:23:29 +01:00
Code Issues Projects Releases Wiki Activity

uncrustified code

Browse Source
This commit is contained in:
zzzzrrr 2010-01-21 09:00:09 -05:00
parent 9202d205df
commit 732e0791e8
14 changed files with 1454 additions and 1406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
poly2tri/common/shapes.cc
View File

@ -30,8 +30,8 @@
*/ */
#include "shapes.h" #include "shapes.h"
Triangle::Triangle(Point& a, Point& b, Point& c) { Triangle::Triangle(Point& a, Point& b, Point& c)
{
points_[0] = &a; points_[1] = &b; points_[2] = &c; points_[0] = &a; points_[1] = &b; points_[2] = &c;
neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL; neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false; constrained_edge[0] = constrained_edge[1] = constrained_edge[2] = false;
@ -40,25 +40,25 @@ Triangle::Triangle(Point& a, Point& b, Point& c) {
} }
// Update neighbor pointers // Update neighbor pointers
void Triangle::MarkNeighbor(Point* p1, Point* p2, Triangle* t) { void Triangle::MarkNeighbor(Point* p1, Point* p2, Triangle* t)
{
if((p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2])) if ((p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2]))
neighbors_[0] = t; neighbors_[0] = t;
else if((p1 == points_[0] && p2 == points_[2]) || (p1 == points_[2] && p2 == points_[0])) else if ((p1 == points_[0] && p2 == points_[2]) || (p1 == points_[2] && p2 == points_[0]))
neighbors_[1] = t; neighbors_[1] = t;
else if((p1 == points_[0] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[0])) else if ((p1 == points_[0] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[0]))
neighbors_[2] = t; neighbors_[2] = t;
else else
assert(0); assert(0);
} }
// Exhaustive search to update neighbor pointers // Exhaustive search to update neighbor pointers
void Triangle::MarkNeighbor(Triangle& t) { void Triangle::MarkNeighbor(Triangle& t)
{
if (t.Contains(points_[1], points_[2])) { if (t.Contains(points_[1], points_[2])) {
neighbors_[0] = &t; neighbors_[0] = &t;
t.MarkNeighbor(points_[1], points_[2], this); t.MarkNeighbor(points_[1], points_[2], this);
} else if(t.Contains(points_[0], points_[2])) { } else if (t.Contains(points_[0], points_[2])) {
neighbors_[1] = &t; neighbors_[1] = &t;
t.MarkNeighbor(points_[0], points_[2], this); t.MarkNeighbor(points_[0], points_[2], this);
} else if (t.Contains(points_[0], points_[1])) { } else if (t.Contains(points_[0], points_[1])) {
@ -67,18 +67,20 @@ void Triangle::MarkNeighbor(Triangle& t) {
} }
} }
void Triangle::ClearNeighbors() { void Triangle::ClearNeighbors()
{
neighbors_[0] = NULL; neighbors_[0] = NULL;
neighbors_[1] = NULL; neighbors_[1] = NULL;
neighbors_[2] = NULL; neighbors_[2] = NULL;
} }
void Triangle::ClearDelunayEdges() { void Triangle::ClearDelunayEdges()
{
delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false; delaunay_edge[0] = delaunay_edge[1] = delaunay_edge[2] = false;
} }
Point* Triangle::OppositePoint(Triangle& t, Point& p) { Point* Triangle::OppositePoint(Triangle& t, Point& p)
{
Point *cw = t.PointCW(p); Point *cw = t.PointCW(p);
double x = cw->x; double x = cw->x;
double y = cw->y; double y = cw->y;
@ -89,17 +91,17 @@ Point* Triangle::OppositePoint(Triangle& t, Point& p) {
} }
// Legalized triangle by rotating clockwise around point(0) // Legalized triangle by rotating clockwise around point(0)
void Triangle::Legalize(Point& point) { void Triangle::Legalize(Point& point)
{
points_[1] = points_[0]; points_[1] = points_[0];
points_[0] = points_[2]; points_[0] = points_[2];
points_[2] = &point; points_[2] = &point;
} }
// Legalize triagnle by rotating clockwise around oPoint // Legalize triagnle by rotating clockwise around oPoint
void Triangle::Legalize(Point& opoint, Point& npoint) { void Triangle::Legalize(Point& opoint, Point& npoint)
{
if(&opoint == points_[0]) { if (&opoint == points_[0]) {
points_[1] = points_[0]; points_[1] = points_[0];
points_[0] = points_[2]; points_[0] = points_[2];
points_[2] = &npoint; points_[2] = &npoint;
@ -116,189 +118,190 @@ void Triangle::Legalize(Point& opoint, Point& npoint) {
} }
} }
int Triangle::Index(const Point* p) { int Triangle::Index(const Point* p)
{
if(p == points_[0]) { if (p == points_[0]) {
return 0; return 0;
} else if(p == points_[1]) { } else if (p == points_[1]) {
return 1; return 1;
} else if(p == points_[2]) { } else if (p == points_[2]) {
return 2; return 2;
} }
assert(0); assert(0);
} }
int Triangle::EdgeIndex(const Point* p1, const Point* p2) { int Triangle::EdgeIndex(const Point* p1, const Point* p2)
{
if(points_[0] == p1) { if (points_[0] == p1) {
if(points_[1] == p2){ if (points_[1] == p2) {
return 2; return 2;
} else if(points_[2] == p2){ } else if (points_[2] == p2) {
return 1; return 1;
} }
} else if(points_[1] == p1) { } else if (points_[1] == p1) {
if(points_[2] == p2) { if (points_[2] == p2) {
return 0; return 0;
} else if(points_[0] == p2) { } else if (points_[0] == p2) {
return 2; return 2;
} }
} else if(points_[2] == p1) { } else if (points_[2] == p1) {
if(points_[0] == p2 ) { if (points_[0] == p2) {
return 1; return 1;
} else if(points_[1] == p2) { } else if (points_[1] == p2) {
return 0; return 0;
} }
} }
return -1; return -1;
} }
void Triangle::MarkConstrainedEdge(const int index) { void Triangle::MarkConstrainedEdge(const int index)
{
constrained_edge[index] = true; constrained_edge[index] = true;
} }
void Triangle::MarkConstrainedEdge(Edge& edge) { void Triangle::MarkConstrainedEdge(Edge& edge)
{
MarkConstrainedEdge(edge.p, edge.q); MarkConstrainedEdge(edge.p, edge.q);
} }
// Mark edge as constrained // Mark edge as constrained
void Triangle::MarkConstrainedEdge(Point* p, Point* q) { void Triangle::MarkConstrainedEdge(Point* p, Point* q)
{
if((q == points_[0] && p == points_[1] ) || (q == points_[1] && p == points_[0])) { if ((q == points_[0] && p == points_[1]) || (q == points_[1] && p == points_[0])) {
constrained_edge[2] = true; constrained_edge[2] = true;
} else if((q == points_[0] && p == points_[2] ) || (q == points_[2] && p == points_[0])) { } else if ((q == points_[0] && p == points_[2]) || (q == points_[2] && p == points_[0])) {
constrained_edge[1] = true; constrained_edge[1] = true;
} else if((q == points_[1] && p == points_[2] ) || (q == points_[2] && p == points_[1])) { } else if ((q == points_[1] && p == points_[2]) || (q == points_[2] && p == points_[1])) {
constrained_edge[0] = true; constrained_edge[0] = true;
} }
} }
// The point counter-clockwise to given point // The point counter-clockwise to given point
Point* Triangle::PointCW(Point& point) { Point* Triangle::PointCW(Point& point)
{
if(&point == points_[0]) { if (&point == points_[0]) {
return points_[2]; return points_[2];
} else if(&point == points_[1]) { } else if (&point == points_[1]) {
return points_[0]; return points_[0];
} else if(&point == points_[2]) { } else if (&point == points_[2]) {
return points_[1]; return points_[1];
} }
assert(0); assert(0);
} }
// The point counter-clockwise to given point // The point counter-clockwise to given point
Point* Triangle::PointCCW(Point& point) { Point* Triangle::PointCCW(Point& point)
{
if(&point == points_[0]) { if (&point == points_[0]) {
return points_[1]; return points_[1];
} else if(&point == points_[1]) { } else if (&point == points_[1]) {
return points_[2]; return points_[2];
} else if(&point == points_[2]) { } else if (&point == points_[2]) {
return points_[0]; return points_[0];
} }
assert(0); assert(0);
} }
// The neighbor clockwise to given point // The neighbor clockwise to given point
Triangle* Triangle::NeighborCW(Point& point) { Triangle* Triangle::NeighborCW(Point& point)
{
if(&point == points_[0]) { if (&point == points_[0]) {
return neighbors_[1]; return neighbors_[1];
} else if(&point == points_[1]) { } else if (&point == points_[1]) {
return neighbors_[2]; return neighbors_[2];
} }
return neighbors_[0]; return neighbors_[0];
} }
// The neighbor counter-clockwise to given point // The neighbor counter-clockwise to given point
Triangle* Triangle::NeighborCCW(Point& point) { Triangle* Triangle::NeighborCCW(Point& point)
{
if(&point == points_[0]) { if (&point == points_[0]) {
return neighbors_[2]; return neighbors_[2];
} else if(&point == points_[1]) { } else if (&point == points_[1]) {
return neighbors_[0]; return neighbors_[0];
} }
return neighbors_[1]; return neighbors_[1];
} }
bool Triangle::GetConstrainedEdgeCCW(Point& p) { bool Triangle::GetConstrainedEdgeCCW(Point& p)
{
if(&p == points_[0]) { if (&p == points_[0]) {
return constrained_edge[2]; return constrained_edge[2];
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
return constrained_edge[0]; return constrained_edge[0];
} }
return constrained_edge[1]; return constrained_edge[1];
} }
bool Triangle::GetConstrainedEdgeCW(Point& p) { bool Triangle::GetConstrainedEdgeCW(Point& p)
{
if(&p == points_[0]) { if (&p == points_[0]) {
return constrained_edge[1]; return constrained_edge[1];
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
return constrained_edge[2]; return constrained_edge[2];
} }
return constrained_edge[0]; return constrained_edge[0];
} }
void Triangle::SetConstrainedEdgeCCW(Point& p, bool ce) { void Triangle::SetConstrainedEdgeCCW(Point& p, bool ce)
{
if(&p == points_[0]) { if (&p == points_[0]) {
constrained_edge[2] = ce; constrained_edge[2] = ce;
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
constrained_edge[0] = ce; constrained_edge[0] = ce;
} else { } else {
constrained_edge[1] = ce; constrained_edge[1] = ce;
} }
} }
void Triangle::SetConstrainedEdgeCW(Point& p, bool ce) { void Triangle::SetConstrainedEdgeCW(Point& p, bool ce)
{
if(&p == points_[0]) { if (&p == points_[0]) {
constrained_edge[1] = ce; constrained_edge[1] = ce;
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
constrained_edge[2] = ce; constrained_edge[2] = ce;
} else { } else {
constrained_edge[0] = ce; constrained_edge[0] = ce;
} }
} }
bool Triangle::GetDelunayEdgeCCW(Point& p) { bool Triangle::GetDelunayEdgeCCW(Point& p)
{
if(&p == points_[0]){ if (&p == points_[0]) {
return delaunay_edge[2]; return delaunay_edge[2];
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
return delaunay_edge[0]; return delaunay_edge[0];
} }
return delaunay_edge[1]; return delaunay_edge[1];
} }
bool Triangle::GetDelunayEdgeCW(Point& p) { bool Triangle::GetDelunayEdgeCW(Point& p)
{
if(&p == points_[0]) { if (&p == points_[0]) {
return delaunay_edge[1]; return delaunay_edge[1];
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
return delaunay_edge[2]; return delaunay_edge[2];
} }
return delaunay_edge[0]; return delaunay_edge[0];
} }
void Triangle::SetDelunayEdgeCCW(Point& p, bool e) { void Triangle::SetDelunayEdgeCCW(Point& p, bool e)
{
if(&p == points_[0]) { if (&p == points_[0]) {
delaunay_edge[2] = e; delaunay_edge[2] = e;
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
delaunay_edge[0] = e; delaunay_edge[0] = e;
} else { } else {
delaunay_edge[1] = e; delaunay_edge[1] = e;
} }
} }
void Triangle::SetDelunayEdgeCW(Point& p, bool e) { void Triangle::SetDelunayEdgeCW(Point& p, bool e)
{
if(&p == points_[0]) { if (&p == points_[0]) {
delaunay_edge[1] = e; delaunay_edge[1] = e;
} else if(&p == points_[1]) { } else if (&p == points_[1]) {
delaunay_edge[2] = e; delaunay_edge[2] = e;
} else { } else {
delaunay_edge[0] = e; delaunay_edge[0] = e;
@ -306,16 +309,18 @@ void Triangle::SetDelunayEdgeCW(Point& p, bool e) {
} }
// The neighbor across to given point // The neighbor across to given point
Triangle& Triangle::NeighborAcross(Point& opoint) { Triangle& Triangle::NeighborAcross(Point& opoint)
if(&opoint == points_[0]) { {
if (&opoint == points_[0]) {
return *neighbors_[0]; return *neighbors_[0];
} else if(&opoint == points_[1]) { } else if (&opoint == points_[1]) {
return *neighbors_[1]; return *neighbors_[1];
} }
return *neighbors_[2]; return *neighbors_[2];
} }
void Triangle::DebugPrint() { void Triangle::DebugPrint()
{
using namespace std; using namespace std;
cout << points_[0]->x << "," << points_[0]->y << " "; cout << points_[0]->x << "," << points_[0]->y << " ";
cout << points_[1]->x << "," << points_[1]->y << " "; cout << points_[1]->x << "," << points_[1]->y << " ";

204
poly2tri/common/shapes.h
View File

@ -43,163 +43,177 @@ struct Node;
struct Edge; struct Edge;
struct Point { struct Point {
double x, y; double x, y;
/// Default constructor does nothing (for performance). /// Default constructor does nothing (for performance).
Point() { x = 0.0; y = 0.0; } Point()
{
x = 0.0; y = 0.0;
}
/// The edges this point constitutes an upper ending point /// The edges this point constitutes an upper ending point
std::vector<Edge*> edge_list; std::vector<Edge*> edge_list;
/// Construct using coordinates. /// Construct using coordinates.
Point(double x, double y) : x(x), y(y) {} Point(double x, double y) : x(x), y(y)
{
}
/// Set this point to all zeros. /// Set this point to all zeros.
void set_zero() { x = 0.0f; y = 0.0f; } void set_zero()
{
x = 0.0f; y = 0.0f;
}
/// Set this point to some specified coordinates. /// Set this point to some specified coordinates.
void set(double x_, double y_) { x = x_; y = y_; } void set(double x_, double y_)
{
x = x_; y = y_;
}
/// Negate this point. /// Negate this point.
Point operator -() const { Point v; v.set(-x, -y); return v; } Point operator -() const
{
Point v; v.set(-x, -y); return v;
}
/// Add a point to this point. /// Add a point to this point.
void operator += (const Point& v) { void operator +=(const Point& v)
{
x += v.x; y += v.y; x += v.x; y += v.y;
} }
/// Subtract a point from this point. /// Subtract a point from this point.
void operator -= (const Point& v) { void operator -=(const Point& v)
{
x -= v.x; y -= v.y; x -= v.x; y -= v.y;
} }
/// Multiply this point by a scalar. /// Multiply this point by a scalar.
void operator *= (double a) { void operator *=(double a)
{
x *= a; y *= a; x *= a; y *= a;
} }
/// Get the length of this point (the norm). /// Get the length of this point (the norm).
double Length() const { double Length() const
{
return sqrt(x * x + y * y); return sqrt(x * x + y * y);
} }
/// Convert this point into a unit point. Returns the Length. /// Convert this point into a unit point. Returns the Length.
double Normalize() { double Normalize()
{
double len = Length(); double len = Length();
x /= len; x /= len;
y /= len; y /= len;
return len; return len;
} }
void DebugPrint() { void DebugPrint()
{
printf("%f,%f ", x, y); printf("%f,%f ", x, y);
} }
}; };
// Represents a simple polygon's edge // Represents a simple polygon's edge
struct Edge { struct Edge {
Point* p, *q; Point* p, *q;
/// Constructor /// Constructor
Edge(Point& p1, Point& p2) : p(&p1), q(&p2) { Edge(Point& p1, Point& p2) : p(&p1), q(&p2)
{
if(p1.y > p2.y) { if (p1.y > p2.y) {
q = &p1; q = &p1;
p = &p2; p = &p2;
} else if(p1.y == p2.y) { } else if (p1.y == p2.y) {
if(p1.x > p2.x) { if (p1.x > p2.x) {
q = &p1; q = &p1;
p = &p2; p = &p2;
} else if(p1.x == p2.x) { } else if (p1.x == p2.x) {
// Repeat points // Repeat points
assert(false); assert(false);
} }
} }
q->edge_list.push_back(this); q->edge_list.push_back(this);
} }
}; };
// Triangle-based data structures are know to have better performance than quad-edge structures // Triangle-based data structures are know to have better performance than quad-edge structures
// See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator" // See: J. Shewchuk, "Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator"
// "Triangulations in CGAL" // "Triangulations in CGAL"
class Triangle { class Triangle {
public: public:
/// Constructor /// Constructor
Triangle(Point& a, Point& b, Point& c); Triangle(Point& a, Point& b, Point& c);
/// Flags to determine if an edge is a Constrained edge /// Flags to determine if an edge is a Constrained edge
bool constrained_edge[3]; bool constrained_edge[3];
/// Flags to determine if an edge is a Delauney edge /// Flags to determine if an edge is a Delauney edge
bool delaunay_edge[3]; bool delaunay_edge[3];
Point* GetPoint(const int& index); Point* GetPoint(const int& index);
Point* PointCW(Point& point); Point* PointCW(Point& point);
Point* PointCCW(Point& point); Point* PointCCW(Point& point);
Point* OppositePoint(Triangle& t, Point& p); Point* OppositePoint(Triangle& t, Point& p);
Triangle* GetNeighbor(const int& index); Triangle* GetNeighbor(const int& index);
void MarkNeighbor(Point* p1, Point* p2, Triangle* t); void MarkNeighbor(Point* p1, Point* p2, Triangle* t);
void MarkNeighbor(Triangle& t); void MarkNeighbor(Triangle& t);
void MarkConstrainedEdge(const int index); void MarkConstrainedEdge(const int index);
void MarkConstrainedEdge(Edge& edge); void MarkConstrainedEdge(Edge& edge);
void MarkConstrainedEdge(Point* p, Point* q); void MarkConstrainedEdge(Point* p, Point* q);
int Index(const Point* p); int Index(const Point* p);
int EdgeIndex(const Point* p1, const Point* p2); int EdgeIndex(const Point* p1, const Point* p2);
Triangle* NeighborCW(Point& point); Triangle* NeighborCW(Point& point);
Triangle* NeighborCCW(Point& point); Triangle* NeighborCCW(Point& point);
bool GetConstrainedEdgeCCW(Point& p); bool GetConstrainedEdgeCCW(Point& p);
bool GetConstrainedEdgeCW(Point& p); bool GetConstrainedEdgeCW(Point& p);
void SetConstrainedEdgeCCW(Point& p, bool ce); void SetConstrainedEdgeCCW(Point& p, bool ce);
void SetConstrainedEdgeCW(Point& p, bool ce); void SetConstrainedEdgeCW(Point& p, bool ce);
bool GetDelunayEdgeCCW(Point& p); bool GetDelunayEdgeCCW(Point& p);
bool GetDelunayEdgeCW(Point& p); bool GetDelunayEdgeCW(Point& p);
void SetDelunayEdgeCCW(Point& p, bool e); void SetDelunayEdgeCCW(Point& p, bool e);
void SetDelunayEdgeCW(Point& p, bool e); void SetDelunayEdgeCW(Point& p, bool e);
bool Contains(Point* p); bool Contains(Point* p);
bool Contains(const Edge& e); bool Contains(const Edge& e);
bool Contains(Point* p, Point* q); bool Contains(Point* p, Point* q);
void Legalize(Point& point); void Legalize(Point& point);
void Legalize(Point& opoint, Point& npoint); void Legalize(Point& opoint, Point& npoint);
void ClearNeighbors(); void ClearNeighbors();
void ClearDelunayEdges(); void ClearDelunayEdges();
inline bool IsInterior(); inline bool IsInterior();
inline void IsInterior(bool b); inline void IsInterior(bool b);
Triangle& NeighborAcross(Point& opoint); Triangle& NeighborAcross(Point& opoint);
void DebugPrint(); void DebugPrint();
private: private:
/// Triangle points /// Triangle points
Point* points_[3]; Point* points_[3];
/// Neighbor list /// Neighbor list
Triangle* neighbors_[3]; Triangle* neighbors_[3];
/// Has this triangle been marked as an interior triangle?
bool interior_;
/// Has this triangle been marked as an interior triangle?
bool interior_;
}; };
inline bool cmp (const Point* a, const Point* b) { inline bool cmp(const Point* a, const Point* b)
{
if (a->y < b->y) { if (a->y < b->y) {
return true; return true;
} else if (a->y == b->y) { } else if (a->y == b->y) {
// Make sure q is point with greater x value // Make sure q is point with greater x value
if(a->x < b->x) { if (a->x < b->x) {
return true; return true;
} }
} }
@ -207,75 +221,91 @@ inline bool cmp (const Point* a, const Point* b) {
} }
/// Add two points_ component-wise. /// Add two points_ component-wise.
inline Point operator + (const Point& a, const Point& b) { inline Point operator +(const Point& a, const Point& b)
{
return Point(a.x + b.x, a.y + b.y); return Point(a.x + b.x, a.y + b.y);
} }
/// Subtract two points_ component-wise. /// Subtract two points_ component-wise.
inline Point operator - (const Point& a, const Point& b) { inline Point operator -(const Point& a, const Point& b)
{
return Point(a.x - b.x, a.y - b.y); return Point(a.x - b.x, a.y - b.y);
} }
/// Multiply point by scalar /// Multiply point by scalar
inline Point operator * (double s, const Point& a) { inline Point operator *(double s, const Point& a)
{
return Point(s * a.x, s * a.y); return Point(s * a.x, s * a.y);
} }
inline bool operator == (const Point& a, const Point& b) { inline bool operator ==(const Point& a, const Point& b)
{
return a.x == b.x && a.y == b.y; return a.x == b.x && a.y == b.y;
} }
inline bool operator != (const Point& a, const Point& b) { inline bool operator !=(const Point& a, const Point& b)
{
return a.x != b.x && a.y != b.y; return a.x != b.x && a.y != b.y;
} }
/// Peform the dot product on two vectors. /// Peform the dot product on two vectors.
inline double Dot(const Point& a, const Point& b) { inline double Dot(const Point& a, const Point& b)
{
return a.x * b.x + a.y * b.y; return a.x * b.x + a.y * b.y;
} }
/// Perform the cross product on two vectors. In 2D this produces a scalar. /// Perform the cross product on two vectors. In 2D this produces a scalar.
inline double Cross(const Point& a, const Point& b) { inline double Cross(const Point& a, const Point& b)
{
return a.x * b.y - a.y * b.x; return a.x * b.y - a.y * b.x;
} }
/// Perform the cross product on a point and a scalar. In 2D this produces /// Perform the cross product on a point and a scalar. In 2D this produces
/// a point. /// a point.
inline Point Cross(const Point& a, double s) { inline Point Cross(const Point& a, double s)
{
return Point(s * a.y, -s * a.x); return Point(s * a.y, -s * a.x);
} }
/// Perform the cross product on a scalar and a point. In 2D this produces /// Perform the cross product on a scalar and a point. In 2D this produces
/// a point. /// a point.
inline Point Cross(const double s, const Point& a) { inline Point Cross(const double s, const Point& a)
{
return Point(-s * a.y, s * a.x); return Point(-s * a.y, s * a.x);
} }
inline Point* Triangle::GetPoint(const int& index) { inline Point* Triangle::GetPoint(const int& index)
{
return points_[index]; return points_[index];
} }
inline Triangle* Triangle::GetNeighbor(const int& index) { inline Triangle* Triangle::GetNeighbor(const int& index)
{
return neighbors_[index]; return neighbors_[index];
} }
inline bool Triangle::Contains(Point* p) { inline bool Triangle::Contains(Point* p)
{
return p == points_[0] || p == points_[1] || p == points_[2]; return p == points_[0] || p == points_[1] || p == points_[2];
} }
inline bool Triangle::Contains(const Edge& e) { inline bool Triangle::Contains(const Edge& e)
{
return Contains(e.p) && Contains(e.q); return Contains(e.p) && Contains(e.q);
} }
inline bool Triangle::Contains(Point* p, Point* q) { inline bool Triangle::Contains(Point* p, Point* q)
{
return Contains(p) && Contains(q); return Contains(p) && Contains(q);
} }
inline bool Triangle::IsInterior() { inline bool Triangle::IsInterior()
{
return interior_; return interior_;
} }
inline void Triangle::IsInterior(bool b) { inline void Triangle::IsInterior(bool b)
{
interior_ = b; interior_ = b;
} }

25
poly2tri/common/utils.h
View File

@ -35,9 +35,12 @@
#include <math.h> #include <math.h>
template<typename T, int size> template<typename T, int size>
int array_length(T(&)[size]){return size;} int array_length(T(&)[size])
{
return size;
}
const double PI_3div4 = 3*M_PI/4; const double PI_3div4 = 3 * M_PI / 4;
const double EPSILON = 1e-12; const double EPSILON = 1e-12;
enum Orientation { CW, CCW, COLLINEAR }; enum Orientation { CW, CCW, COLLINEAR };
@ -52,22 +55,21 @@ enum Orientation { CW, CCW, COLLINEAR };
* = (x1-x3)*(y2-y3) - (y1-y3)*(x2-x3) * = (x1-x3)*(y2-y3) - (y1-y3)*(x2-x3)
* </pre> * </pre>
*/ */
Orientation Orient2d(Point& pa, Point& pb, Point& pc ) { Orientation Orient2d(Point& pa, Point& pb, Point& pc)
{
double detleft = (pa.x - pc.x) * (pb.y - pc.y); double detleft = (pa.x - pc.x) * (pb.y - pc.y);
double detright = (pa.y - pc.y) * (pb.x - pc.x); double detright = (pa.y - pc.y) * (pb.x - pc.x);
double val = detleft - detright; double val = detleft - detright;
if( val > -EPSILON && val < EPSILON ) { if (val > -EPSILON && val < EPSILON) {
return COLLINEAR; return COLLINEAR;
} else if( val > 0 ) { } else if (val > 0) {
return CCW; return CCW;
} }
return CW; return CW;
} }
bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) { bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd)
{
double pdx = pd.x; double pdx = pd.x;
double pdy = pd.y; double pdy = pd.y;
double adx = pa.x - pdx; double adx = pa.x - pdx;
@ -79,7 +81,7 @@ bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) {
double bdxady = bdx * ady; double bdxady = bdx * ady;
double oabd = adxbdy - bdxady; double oabd = adxbdy - bdxady;
if(oabd <= EPSILON) { if (oabd <= EPSILON) {
return false; return false;
} }
@ -90,12 +92,11 @@ bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) {
double adxcdy = adx * cdy; double adxcdy = adx * cdy;
double ocad = cdxady - adxcdy; double ocad = cdxady - adxcdy;
if(ocad <= EPSILON) { if (ocad <= EPSILON) {
return false; return false;
} }
return true; return true;
} }
#endif #endif

47
poly2tri/sweep/advancing_front.cc
View File

@ -30,18 +30,19 @@
*/ */
#include "advancing_front.h" #include "advancing_front.h"
AdvancingFront::AdvancingFront() { AdvancingFront::AdvancingFront()
{
head_ = tail_ = search_node_ = NULL; head_ = tail_ = search_node_ = NULL;
} }
Node* AdvancingFront::Locate(const double& x) { Node* AdvancingFront::Locate(const double& x)
{
Node* node = search_node_; Node* node = search_node_;
if(x < node->value) { if (x < node->value) {
//printf("<: - %f,%f - %p\n", x, node->value, node->next); //printf("<: - %f,%f - %p\n", x, node->value, node->next);
while((node = node->prev) != NULL) { while ((node = node->prev) != NULL) {
if(x >= node->value) { if (x >= node->value) {
search_node_ = node; search_node_ = node;
return node; return node;
} }
@ -49,8 +50,8 @@ Node* AdvancingFront::Locate(const double& x) {
} else { } else {
//printf("%p - %p\n", node, node->next); //printf("%p - %p\n", node, node->next);
//printf(">: %f - %f\n", x, node->value); //printf(">: %f - %f\n", x, node->value);
while((node = node->next) != NULL) { while ((node = node->next) != NULL) {
if(x < node->value) { if (x < node->value) {
search_node_ = node->prev; search_node_ = node->prev;
return node->prev; return node->prev;
} }
@ -59,45 +60,47 @@ Node* AdvancingFront::Locate(const double& x) {
return NULL; return NULL;
} }
Node* AdvancingFront::FindSearchNode(const double& x) { Node* AdvancingFront::FindSearchNode(const double& x)
{
// TODO: implement BST index // TODO: implement BST index
return search_node_; return search_node_;
} }
Node* AdvancingFront::LocatePoint(Point* point) { Node* AdvancingFront::LocatePoint(Point* point)
{
const double px = point->x; const double px = point->x;
Node* node = FindSearchNode(px); Node* node = FindSearchNode(px);
const double nx = node->point->x; const double nx = node->point->x;
if(px == nx) { if (px == nx) {
if(point != node->point) { if (point != node->point) {
// We might have two nodes with same x value for a short time // We might have two nodes with same x value for a short time
if(point == node->prev->point) { if (point == node->prev->point) {
node = node->prev; node = node->prev;
} else if(point == node->next->point) { } else if (point == node->next->point) {
node = node->next; node = node->next;
} else { } else {
assert(0); assert(0);
} }
} }
} else if(px < nx) { } else if (px < nx) {
while((node = node->prev) != NULL) { while ((node = node->prev) != NULL) {
if(point == node->point) { if (point == node->point) {
break; break;
} }
} }
} else { } else {
while((node = node->next) != NULL) { while ((node = node->next) != NULL) {
if(point == node->point) if (point == node->point)
break; break;
} }
} }
if(node) search_node_ = node; if (node) search_node_ = node;
return node; return node;
} }
AdvancingFront::~AdvancingFront() { AdvancingFront::~AdvancingFront()
{
delete head_; delete head_;
delete search_node_; delete search_node_;
delete tail_; delete tail_;

70
poly2tri/sweep/advancing_front.h
View File

@ -34,7 +34,6 @@ struct Node;
// Advancing front node // Advancing front node
struct Node { struct Node {
Point* point; Point* point;
Triangle* triangle; Triangle* triangle;
@ -43,10 +42,14 @@ struct Node {
double value; double value;
Node(Point& p) : point(&p), triangle(NULL), value(p.x), next(NULL), prev(NULL) {} Node(Point& p) : point(&p), triangle(NULL), value(p.x), next(NULL), prev(NULL)
{
}
Node(Point& p, Triangle& t) : point(&p), triangle(&t), value(p.x), Node(Point& p, Triangle& t) : point(&p), triangle(&t), value(p.x),
next(NULL), prev(NULL) {} next(NULL), prev(NULL)
{
}
/* /*
~Node() { ~Node() {
@ -55,45 +58,60 @@ struct Node {
printf(" ... gone!\n"); printf(" ... gone!\n");
} }
*/ */
}; };
// Advancing front // Advancing front
class AdvancingFront { class AdvancingFront {
public: public:
AdvancingFront(); AdvancingFront();
// Destructor // Destructor
~AdvancingFront(); ~AdvancingFront();
Node* head(); Node* head();
void set_head(Node* node); void set_head(Node* node);
Node* tail(); Node* tail();
void set_tail(Node* node); void set_tail(Node* node);
Node* search(); Node* search();
void set_search(Node* node); void set_search(Node* node);
/// Locate insertion point along advancing front /// Locate insertion point along advancing front
Node* Locate(const double& x); Node* Locate(const double& x);
Node* LocatePoint(Point* point); Node* LocatePoint(Point* point);
private: private:
Node* head_, *tail_, *search_node_; Node* head_, *tail_, *search_node_;
Node* FindSearchNode(const double& x);
Node* FindSearchNode(const double& x);
}; };
inline Node* AdvancingFront::head() { return head_; } inline Node* AdvancingFront::head()
inline void AdvancingFront::set_head(Node* node) { head_ = node; } {
return head_;
}
inline void AdvancingFront::set_head(Node* node)
{
head_ = node;
}
inline Node* AdvancingFront::tail() { return tail_; } inline Node* AdvancingFront::tail()
inline void AdvancingFront::set_tail(Node* node) { tail_ = node; } {
return tail_;
}
inline void AdvancingFront::set_tail(Node* node)
{
tail_ = node;
}
inline Node* AdvancingFront::search() { return search_node_; } inline Node* AdvancingFront::search()
{
return search_node_;
}
inline void AdvancingFront::set_search(Node* node) { search_node_ = node; } inline void AdvancingFront::set_search(Node* node)
{
search_node_ = node;
}

19
poly2tri/sweep/cdt.cc
View File

@ -30,28 +30,33 @@
*/ */
#include "cdt.h" #include "cdt.h"
CDT::CDT(Point** polyline, const int& point_count) { CDT::CDT(Point** polyline, const int& point_count)
{
sweep_context_ = new SweepContext(polyline, point_count); sweep_context_ = new SweepContext(polyline, point_count);
sweep_ = new Sweep; sweep_ = new Sweep;
} }
void CDT::AddHole(const Point poly_line[], const int point_count) { void CDT::AddHole(const Point poly_line[], const int point_count)
{
} }
void CDT::Triangulate() { void CDT::Triangulate()
{
sweep_->Triangulate(*sweep_context_); sweep_->Triangulate(*sweep_context_);
} }
std::vector<Triangle*> CDT::GetTriangles() { std::vector<Triangle*> CDT::GetTriangles()
{
return sweep_context_->GetTriangles(); return sweep_context_->GetTriangles();
} }
std::list<Triangle*> CDT::GetMap() { std::list<Triangle*> CDT::GetMap()
{
return sweep_context_->GetMap(); return sweep_context_->GetMap();
} }
CDT::~CDT() { CDT::~CDT()
{
delete sweep_context_; delete sweep_context_;
delete sweep_; delete sweep_;
} }

30
poly2tri/sweep/cdt.h
View File

@ -35,26 +35,24 @@
class CDT class CDT
{ {
public: public:
/// Constructor /// Constructor
CDT(Point** poly_line, const int& point_count); CDT(Point** poly_line, const int& point_count);
/// Add a hole /// Add a hole
void AddHole(const Point poly_line[], const int point_count); void AddHole(const Point poly_line[], const int point_count);
/// Triangulate points /// Triangulate points
void Triangulate(); void Triangulate();
/// Get Delaunay triangles /// Get Delaunay triangles
std::vector<Triangle*> GetTriangles(); std::vector<Triangle*> GetTriangles();
/// Get triangle map /// Get triangle map
std::list<Triangle*> CDT::GetMap(); std::list<Triangle*> CDT::GetMap();
private: private:
SweepContext* sweep_context_; SweepContext* sweep_context_;
Sweep* sweep_; Sweep* sweep_;
/// Destructor
~CDT();
/// Destructor
~CDT();
}; };

14
poly2tri/sweep/mesh.h
View File

@ -35,16 +35,14 @@ class Triangle;
class Mesh class Mesh
{ {
public: public:
/// Triangles that constitute the mesh /// Triangles that constitute the mesh
vector<Triangle> map; vector<Triangle> map;
// Debug triangles // Debug triangles
//val debug = new ArrayBuffer[Triangle] //val debug = new ArrayBuffer[Triangle]
//val triangles = new ArrayBuffer[Triangle] //val triangles = new ArrayBuffer[Triangle]
void clean(Triangle& triangle);
void clean(Triangle& triangle);
}; };

367
poly2tri/sweep/sweep.cc
View File

@ -33,40 +33,36 @@
#include "advancing_front.h" #include "advancing_front.h"
#include "../common/utils.h" #include "../common/utils.h"
// Triangulate simple polygon with holes // Triangulate simple polygon with holes
void Sweep::Triangulate(SweepContext& tcx) { void Sweep::Triangulate(SweepContext& tcx)
{
tcx.CreateAdvancingFront(); tcx.CreateAdvancingFront();
// Sweep points; build mesh // Sweep points; build mesh
SweepPoints(tcx); SweepPoints(tcx);
// Clean up // Clean up
//FinalizationPolygon(tcx); //FinalizationPolygon(tcx);
} }
void Sweep::SweepPoints(SweepContext& tcx) { void Sweep::SweepPoints(SweepContext& tcx)
{
for(int i = 1; i < tcx.point_count(); i++ ) { for (int i = 1; i < tcx.point_count(); i++) {
printf("%i = ", i);
//printf("%i = ",i);
Point& point = *tcx.GetPoint(i); Point& point = *tcx.GetPoint(i);
//printf("size = %i\n", point.edge_list.size()); printf("%f,%f\n", point.x, point.y);
Node& node = PointEvent(tcx, point); Node& node = PointEvent(tcx, point);
for(int i = 0; i < point.edge_list.size(); i++) { for (int i = 0; i < point.edge_list.size(); i++) {
EdgeEvent(tcx, point.edge_list[i], node); EdgeEvent(tcx, point.edge_list[i], node);
} }
} }
} }
void Sweep::FinalizationPolygon(SweepContext& tcx) { void Sweep::FinalizationPolygon(SweepContext& tcx)
{
// Get an Internal triangle to start with // Get an Internal triangle to start with
Triangle* t = tcx.front()->head()->next->triangle; Triangle* t = tcx.front()->head()->next->triangle;
Point* p = tcx.front()->head()->next->point; Point* p = tcx.front()->head()->next->point;
while(!t->GetConstrainedEdgeCW(*p)) { while (!t->GetConstrainedEdgeCW(*p)) {
t = t->NeighborCCW(*p); t = t->NeighborCCW(*p);
} }
@ -83,14 +79,14 @@ void Sweep::FinalizationPolygon(SweepContext& tcx) {
* @param point * @param point
* @return * @return
*/ */
Node& Sweep::PointEvent(SweepContext& tcx, Point& point) { Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
{
Node& node = tcx.LocateNode(point); Node& node = tcx.LocateNode(point);
Node& new_node = NewFrontTriangle(tcx, point, node); Node& new_node = NewFrontTriangle(tcx, point, node);
// Only need to check +epsilon since point never have smaller // Only need to check +epsilon since point never have smaller
// x value than node due to how we fetch nodes from the front // x value than node due to how we fetch nodes from the front
if(point.x <= node.point->x + EPSILON) { if (point.x <= node.point->x + EPSILON) {
Fill(tcx, node); Fill(tcx, node);
} }
@ -100,12 +96,12 @@ Node& Sweep::PointEvent(SweepContext& tcx, Point& point) {
return new_node; return new_node;
} }
void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
tcx.edge_event.constrained_edge = edge; tcx.edge_event.constrained_edge = edge;
tcx.edge_event.right = edge->p->x > edge->q->x; tcx.edge_event.right = edge->p->x > edge->q->x;
if(IsEdgeSideOfTriangle(*node.triangle, *edge->p, *edge->q)){ if (IsEdgeSideOfTriangle(*node.triangle, *edge->p, *edge->q)) {
return; return;
} }
@ -113,36 +109,35 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
// TODO: integrate with flip process might give some better performance // 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 // but for now this avoid the issue with cases that needs both flips and fills
FillEdgeEvent(tcx, edge, node); FillEdgeEvent(tcx, edge, node);
EdgeEvent(tcx, *edge->p, *edge->q , node.triangle, *edge->q); EdgeEvent(tcx, *edge->p, *edge->q, node.triangle, *edge->q);
} }
void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point) { void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point)
{
if(IsEdgeSideOfTriangle(*triangle, ep, eq)) { if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
return; return;
} }
Point* p1 = triangle->PointCCW(point); Point* p1 = triangle->PointCCW(point);
Orientation o1 = Orient2d(eq, *p1, ep); Orientation o1 = Orient2d(eq, *p1, ep);
if(o1 == COLLINEAR) { if (o1 == COLLINEAR) {
//throw new RuntimeException( "EdgeEvent - Collinear not supported" ); //throw new RuntimeException( "EdgeEvent - Collinear not supported" );
assert(false); assert(false);
} }
Point* p2 = triangle->PointCW(point); Point* p2 = triangle->PointCW(point);
Orientation o2 = Orient2d(eq, *p2, ep); Orientation o2 = Orient2d(eq, *p2, ep);
if(o2 == COLLINEAR) { if (o2 == COLLINEAR) {
//throw new RuntimeException( "EdgeEvent - Collinear not supported" ); //throw new RuntimeException( "EdgeEvent - Collinear not supported" );
assert(false); assert(false);
} }
if(o1 == o2) { if (o1 == o2) {
// Need to decide if we are rotating CW or CCW to get to a triangle // Need to decide if we are rotating CW or CCW to get to a triangle
// that will cross edge // that will cross edge
if(o1 == CW) { if (o1 == CW) {
triangle = triangle->NeighborCCW(point); triangle = triangle->NeighborCCW(point);
} else { } else{
triangle = triangle->NeighborCW(point); triangle = triangle->NeighborCW(point);
} }
EdgeEvent(tcx, ep, eq, triangle, point); EdgeEvent(tcx, ep, eq, triangle, point);
@ -150,17 +145,16 @@ void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangl
// This triangle crosses constraint so lets flippin start! // This triangle crosses constraint so lets flippin start!
FlipEdgeEvent(tcx, ep, eq, *triangle, point); FlipEdgeEvent(tcx, ep, eq, *triangle, point);
} }
} }
bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq) { bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq)
{
int index = triangle.EdgeIndex(&ep, &eq); int index = triangle.EdgeIndex(&ep, &eq);
if(index != -1) { if (index != -1) {
triangle.MarkConstrainedEdge(index); triangle.MarkConstrainedEdge(index);
Triangle* t = triangle.GetNeighbor(index); Triangle* t = triangle.GetNeighbor(index);
if(t){ if (t) {
t->MarkConstrainedEdge(&ep, &eq); t->MarkConstrainedEdge(&ep, &eq);
} }
return true; return true;
@ -168,8 +162,8 @@ bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq) {
return false; return false;
} }
Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node ) { Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node)
{
Triangle* triangle = new Triangle(point, *node.point, *node.next->point); Triangle* triangle = new Triangle(point, *node.point, *node.next->point);
triangle->MarkNeighbor(*node.triangle); triangle->MarkNeighbor(*node.triangle);
@ -181,7 +175,7 @@ Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node ) {
node.next->prev = new_node; node.next->prev = new_node;
node.next = new_node; node.next = new_node;
if(!Legalize(tcx, *triangle)) { if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle); tcx.MapTriangleToNodes(*triangle);
} }
@ -193,10 +187,9 @@ Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node ) {
* @param tcx * @param tcx
* @param node - middle node, that is the bottom of the hole * @param node - middle node, that is the bottom of the hole
*/ */
void Sweep::Fill(SweepContext& tcx, Node& node) { void Sweep::Fill(SweepContext& tcx, Node& node)
{
Triangle* triangle = new Triangle(*node.prev->point, *node.point, Triangle* triangle = new Triangle(*node.prev->point, *node.point, *node.next->point);
*node.next->point);
// TODO: should copy the constrained_edge value from neighbor triangles // TODO: should copy the constrained_edge value from neighbor triangles
// for now constrained_edge values are copied during the legalize // for now constrained_edge values are copied during the legalize
@ -210,13 +203,12 @@ void Sweep::Fill(SweepContext& tcx, Node& node) {
node.next->prev = node.prev; node.next->prev = node.prev;
// If it was legalized the triangle has already been mapped // If it was legalized the triangle has already been mapped
if(!Legalize(tcx, *triangle)) { if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle); tcx.MapTriangleToNodes(*triangle);
} }
// TODO: delete node from memory // TODO: delete node from memory
//tcx.RemoveNode(node); //tcx.RemoveNode(node);
} }
/** /**
@ -226,14 +218,14 @@ void Sweep::Fill(SweepContext& tcx, Node& node) {
* @param tcx * @param tcx
* @param n * @param n
*/ */
void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n) { void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
{
// Fill right holes // Fill right holes
Node* node = n.next; Node* node = n.next;
while(node->next) { while (node->next) {
double angle = HoleAngle(*node); double angle = HoleAngle(*node);
if(angle > M_PI_2 || angle < -M_PI_2) break; if (angle > M_PI_2 || angle < -M_PI_2) break;
Fill(tcx, *node); Fill(tcx, *node);
node = node->next; node = node->next;
} }
@ -241,24 +233,24 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n) {
// Fill left holes // Fill left holes
node = n.prev; node = n.prev;
while(node->prev) { while (node->prev) {
double angle = HoleAngle(*node); double angle = HoleAngle(*node);
if(angle > M_PI_2 || angle < -M_PI_2) break; if (angle > M_PI_2 || angle < -M_PI_2) break;
Fill(tcx, *node); Fill(tcx, *node);
node = node->prev; node = node->prev;
} }
// Fill right basins // Fill right basins
if(n.next && n.next->next) { if (n.next && n.next->next) {
double angle = BasinAngle(n); double angle = BasinAngle(n);
if(angle < PI_3div4) { if (angle < PI_3div4) {
FillBasin(tcx, n); FillBasin(tcx, n);
} }
} }
} }
double Sweep::BasinAngle(Node& node) { double Sweep::BasinAngle(Node& node)
{
double ax = node.point->x - node.next->next->point->x; double ax = node.point->x - node.next->next->point->x;
double ay = node.point->y - node.next->next->point->y; double ay = node.point->y - node.next->next->point->y;
return atan2(ay, ax); return atan2(ay, ax);
@ -269,8 +261,8 @@ double Sweep::BasinAngle(Node& node) {
* @param node - middle node * @param node - middle node
* @return the angle between 3 front nodes * @return the angle between 3 front nodes
*/ */
double Sweep::HoleAngle(Node& node) { double Sweep::HoleAngle(Node& node)
{
/* Complex plane /* Complex plane
* ab = cosA +i*sinA * ab = cosA +i*sinA
* ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx) * ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
@ -289,34 +281,31 @@ double Sweep::HoleAngle(Node& node) {
/** /**
* Returns true if triangle was legalized * Returns true if triangle was legalized
*/ */
bool Sweep::Legalize(SweepContext& tcx, Triangle& t) { bool Sweep::Legalize(SweepContext& tcx, Triangle& t)
{
// To legalize a triangle we start by finding if any of the three edges // To legalize a triangle we start by finding if any of the three edges
// violate the Delaunay condition // violate the Delaunay condition
for(int i=0; i<3; i++) { for (int i = 0; i < 3; i++) {
if (t.delaunay_edge[i])
if(t.delaunay_edge[i])
continue; continue;
Triangle* ot = t.GetNeighbor(i); Triangle* ot = t.GetNeighbor(i);
if(ot) { if (ot) {
Point* p = t.GetPoint(i); Point* p = t.GetPoint(i);
Point* op = ot->OppositePoint(t, *p); Point* op = ot->OppositePoint(t, *p);
int oi = ot->Index(op); int oi = ot->Index(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization) // If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// then we should not try to legalize // then we should not try to legalize
if(ot->constrained_edge[oi] || ot->delaunay_edge[oi]) { if (ot->constrained_edge[oi] || ot->delaunay_edge[oi]) {
t.constrained_edge[i] = ot->constrained_edge[oi]; t.constrained_edge[i] = ot->constrained_edge[oi];
continue; continue;
} }
bool inside = Incircle(*p, *t.PointCCW(*p), *t.PointCW(*p), *op); bool inside = Incircle(*p, *t.PointCCW(*p), *t.PointCW(*p), *op);
if(inside) { if (inside) {
// Lets mark this shared edge as Delaunay // Lets mark this shared edge as Delaunay
t.delaunay_edge[i] = true; t.delaunay_edge[i] = true;
ot->delaunay_edge[oi] = true; ot->delaunay_edge[oi] = true;
@ -329,12 +318,12 @@ bool Sweep::Legalize(SweepContext& tcx, Triangle& t) {
// Make sure that triangle to node mapping is done only one time for a specific triangle // Make sure that triangle to node mapping is done only one time for a specific triangle
bool not_legalized = !Legalize(tcx, t); bool not_legalized = !Legalize(tcx, t);
if(not_legalized) { if (not_legalized) {
tcx.MapTriangleToNodes(t); tcx.MapTriangleToNodes(t);
} }
not_legalized = !Legalize(tcx, *ot); not_legalized = !Legalize(tcx, *ot);
if(not_legalized) if (not_legalized)
tcx.MapTriangleToNodes(*ot); tcx.MapTriangleToNodes(*ot);
// Reset the Delaunay edges, since they only are valid Delaunay edges // Reset the Delaunay edges, since they only are valid Delaunay edges
@ -377,8 +366,8 @@ bool Sweep::Legalize(SweepContext& tcx, Triangle& t) {
* @param d - point opposite a * @param d - point opposite a
* @return true if d is inside circle, false if on circle edge * @return true if d is inside circle, false if on circle edge
*/ */
bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) { bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd)
{
double adx = pa.x - pd.x; double adx = pa.x - pd.x;
double ady = pa.y - pd.y; double ady = pa.y - pd.y;
double bdx = pb.x - pd.x; double bdx = pb.x - pd.x;
@ -388,7 +377,7 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) {
double bdxady = bdx * ady; double bdxady = bdx * ady;
double oabd = adxbdy - bdxady; double oabd = adxbdy - bdxady;
if( oabd <= 0 ) if (oabd <= 0)
return false; return false;
double cdx = pc.x - pd.x; double cdx = pc.x - pd.x;
@ -398,7 +387,7 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) {
double adxcdy = adx * cdy; double adxcdy = adx * cdy;
double ocad = cdxady - adxcdy; double ocad = cdxady - adxcdy;
if( ocad <= 0 ) if (ocad <= 0)
return false; return false;
double bdxcdy = bdx * cdy; double bdxcdy = bdx * cdy;
@ -408,7 +397,7 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) {
double blift = bdx * bdx + bdy * bdy; double blift = bdx * bdx + bdy * bdy;
double clift = cdx * cdx + cdy * cdy; double clift = cdx * cdx + cdy * cdy;
double det = alift * ( bdxcdy - cdxbdy ) + blift * ocad + clift * oabd; double det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
return det > 0; return det > 0;
} }
@ -427,21 +416,21 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) {
* n4 n4 * n4 n4
* </pre> * </pre>
*/ */
void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op) { void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op)
{
Triangle* n1, *n2, *n3, *n4; Triangle* n1, *n2, *n3, *n4;
n1 = t.NeighborCCW(p); n1 = t.NeighborCCW(p);
n2 = t.NeighborCW(p); n2 = t.NeighborCW(p);
n3 = ot.NeighborCCW(op); n3 = ot.NeighborCCW(op);
n4 = ot.NeighborCW(op); n4 = ot.NeighborCW(op);
bool ce1,ce2,ce3,ce4; bool ce1, ce2, ce3, ce4;
ce1 = t.GetConstrainedEdgeCCW(p); ce1 = t.GetConstrainedEdgeCCW(p);
ce2 = t.GetConstrainedEdgeCW(p); ce2 = t.GetConstrainedEdgeCW(p);
ce3 = ot.GetConstrainedEdgeCCW(op); ce3 = ot.GetConstrainedEdgeCCW(op);
ce4 = ot.GetConstrainedEdgeCW(op); ce4 = ot.GetConstrainedEdgeCW(op);
bool de1,de2,de3,de4; bool de1, de2, de3, de4;
de1 = t.GetDelunayEdgeCCW(p); de1 = t.GetDelunayEdgeCCW(p);
de2 = t.GetDelunayEdgeCW(p); de2 = t.GetDelunayEdgeCW(p);
de3 = ot.GetDelunayEdgeCCW(op); de3 = ot.GetDelunayEdgeCCW(op);
@ -469,25 +458,25 @@ void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op) {
// the right side. // the right side.
t.ClearNeighbors(); t.ClearNeighbors();
ot.ClearNeighbors(); ot.ClearNeighbors();
if(n1 != NULL) ot.MarkNeighbor(*n1); if (n1 != NULL) ot.MarkNeighbor(*n1);
if(n2 != NULL) t.MarkNeighbor(*n2); if (n2 != NULL) t.MarkNeighbor(*n2);
if(n3 != NULL) t.MarkNeighbor(*n3); if (n3 != NULL) t.MarkNeighbor(*n3);
if(n4 != NULL) ot.MarkNeighbor(*n4); if (n4 != NULL) ot.MarkNeighbor(*n4);
t.MarkNeighbor(ot); t.MarkNeighbor(ot);
} }
/** /**
* Fills a basin that has formed on the Advancing Front to the right * Fills a basin that has formed on the Advancing Front to the right
* of given node.<br> * of given node.<br>
* First we decide a left,bottom and right node that forms the * First we decide a left,bottom and right node that forms the
* boundaries of the basin. Then we do a reqursive fill. * boundaries of the basin. Then we do a reqursive fill.
* *
* @param tcx * @param tcx
* @param node - starting node, this or next node will be left node * @param node - starting node, this or next node will be left node
*/ */
void Sweep::FillBasin(SweepContext& tcx, Node& node) { void Sweep::FillBasin(SweepContext& tcx, Node& node)
{
if(Orient2d(*node.point, *node.next->point, *node.next->next->point ) == CCW) { if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
tcx.basin.left_node = node.next->next; tcx.basin.left_node = node.next->next;
} else { } else {
tcx.basin.left_node = node.next; tcx.basin.left_node = node.next;
@ -495,21 +484,21 @@ void Sweep::FillBasin(SweepContext& tcx, Node& node) {
// Find the bottom and right node // Find the bottom and right node
tcx.basin.bottom_node = tcx.basin.left_node; tcx.basin.bottom_node = tcx.basin.left_node;
while(tcx.basin.bottom_node->next while (tcx.basin.bottom_node->next
&& tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y) { && tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y) {
tcx.basin.bottom_node = tcx.basin.bottom_node->next; tcx.basin.bottom_node = tcx.basin.bottom_node->next;
} }
if(tcx.basin.bottom_node == tcx.basin.left_node) { if (tcx.basin.bottom_node == tcx.basin.left_node) {
// No valid basin // No valid basin
return; return;
} }
tcx.basin.right_node = tcx.basin.bottom_node; tcx.basin.right_node = tcx.basin.bottom_node;
while(tcx.basin.right_node->next while (tcx.basin.right_node->next
&& tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y) { && tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y) {
tcx.basin.right_node = tcx.basin.right_node->next; tcx.basin.right_node = tcx.basin.right_node->next;
} }
if(tcx.basin.right_node == tcx.basin.bottom_node) { if (tcx.basin.right_node == tcx.basin.bottom_node) {
// No valid basins // No valid basins
return; return;
} }
@ -518,42 +507,41 @@ void Sweep::FillBasin(SweepContext& tcx, Node& node) {
tcx.basin.left_highest = tcx.basin.left_node->point->y > tcx.basin.right_node->point->y; tcx.basin.left_highest = tcx.basin.left_node->point->y > tcx.basin.right_node->point->y;
FillBasinReq(tcx, *tcx.basin.bottom_node); FillBasinReq(tcx, *tcx.basin.bottom_node);
} }
/** /**
* Recursive algorithm to fill a Basin with triangles * Recursive algorithm to fill a Basin with triangles
* *
* @param tcx * @param tcx
* @param node - bottom_node * @param node - bottom_node
* @param cnt - counter used to alternate on even and odd numbers * @param cnt - counter used to alternate on even and odd numbers
*/ */
void Sweep::FillBasinReq(SweepContext& tcx, Node& node) { void Sweep::FillBasinReq(SweepContext& tcx, Node& node)
{
// if shallow stop filling // if shallow stop filling
if(IsShallow(tcx, node)) { if (IsShallow(tcx, node)) {
return; return;
} }
Fill(tcx, node); Fill(tcx, node);
if(node.prev == tcx.basin.left_node && node.next == tcx.basin.right_node) { if (node.prev == tcx.basin.left_node && node.next == tcx.basin.right_node) {
return; return;
} else if(node.prev == tcx.basin.left_node) { } else if (node.prev == tcx.basin.left_node) {
Orientation o = Orient2d(*node.point, *node.next->point, *node.next->next->point ); Orientation o = Orient2d(*node.point, *node.next->point, *node.next->next->point);
if(o == CW) { if (o == CW) {
return; return;
} }
node = *node.next; node = *node.next;
} else if(node.next == tcx.basin.right_node) { } else if (node.next == tcx.basin.right_node) {
Orientation o = Orient2d(*node.point, *node.prev->point, *node.prev->prev->point); Orientation o = Orient2d(*node.point, *node.prev->point, *node.prev->prev->point);
if(o == CCW) { if (o == CCW) {
return; return;
} }
node = *node.prev; node = *node.prev;
} else { } else {
// Continue with the neighbor node with lowest Y value // Continue with the neighbor node with lowest Y value
if(node.prev->point->y < node.next->point->y) { if (node.prev->point->y < node.next->point->y) {
node = *node.prev; node = *node.prev;
} else { } else {
node = *node.next; node = *node.next;
@ -561,73 +549,69 @@ void Sweep::FillBasinReq(SweepContext& tcx, Node& node) {
} }
FillBasinReq(tcx, node); FillBasinReq(tcx, node);
} }
bool Sweep::IsShallow(SweepContext& tcx, Node& node) { bool Sweep::IsShallow(SweepContext& tcx, Node& node)
{
double height; double height;
if(tcx.basin.left_highest) { if (tcx.basin.left_highest) {
height = tcx.basin.left_node->point->y - node.point->y; height = tcx.basin.left_node->point->y - node.point->y;
} else { } else {
height = tcx.basin.right_node->point->y - node.point->y; height = tcx.basin.right_node->point->y - node.point->y;
} }
// if shallow stop filling // if shallow stop filling
if(tcx.basin.width > height) { if (tcx.basin.width > height) {
return true; return true;
} }
return false; return false;
} }
void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if(tcx.edge_event.right) { if (tcx.edge_event.right) {
FillRightAboveEdgeEvent(tcx, edge, node); FillRightAboveEdgeEvent(tcx, edge, node);
} else { } else {
FillLeftAboveEdgeEvent(tcx, edge, node); FillLeftAboveEdgeEvent(tcx, edge, node);
} }
} }
void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
while(node.next->point->x < edge->p->x) { while (node.next->point->x < edge->p->x) {
// Check if next node is below the edge // Check if next node is below the edge
if(Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) { if (Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) {
FillRightBelowEdgeEvent(tcx, edge, node); FillRightBelowEdgeEvent(tcx, edge, node);
} else { } else {
node = *node.next; node = *node.next;
} }
} }
} }
void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if(node.point->x < edge->p->x) { if (node.point->x < edge->p->x) {
if(Orient2d(*node.point, *node.next->point, *node.next->next->point ) == CCW ) { if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
// Concave // Concave
FillRightConcaveEdgeEvent(tcx, edge, node ); FillRightConcaveEdgeEvent(tcx, edge, node);
} else { } else{
// Convex // Convex
FillRightConvexEdgeEvent(tcx, edge, node ); FillRightConvexEdgeEvent(tcx, edge, node);
// Retry this one // Retry this one
FillRightBelowEdgeEvent(tcx, edge, node ); FillRightBelowEdgeEvent(tcx, edge, node);
} }
} }
} }
void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.next); Fill(tcx, *node.next);
if(node.next->point != edge->p) { if (node.next->point != edge->p) {
// Next above or below edge? // Next above or below edge?
if(Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) { if (Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) {
// Below // Below
if(Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) { if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
// Next is concave // Next is concave
FillRightConcaveEdgeEvent(tcx, edge, node); FillRightConcaveEdgeEvent(tcx, edge, node);
} else { } else {
@ -635,45 +619,42 @@ void Sweep::FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
} }
} }
} }
} }
void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
// Next concave or convex? // Next concave or convex?
if(Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point ) == CCW) { if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) {
// Concave // Concave
FillRightConcaveEdgeEvent(tcx, edge, *node.next); FillRightConcaveEdgeEvent(tcx, edge, *node.next);
} else{ } else{
// Convex // Convex
// Next above or below edge? // Next above or below edge?
if(Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) { if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) {
// Below // Below
FillRightConvexEdgeEvent(tcx, edge, *node.next); FillRightConvexEdgeEvent(tcx, edge, *node.next);
} else{ } else{
// Above // Above
} }
} }
} }
void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
while(node.prev->point->x > edge->p->x) { while (node.prev->point->x > edge->p->x) {
// Check if next node is below the edge // Check if next node is below the edge
if(Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) { if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) {
FillLeftBelowEdgeEvent(tcx, edge, node); FillLeftBelowEdgeEvent(tcx, edge, node);
} else { } else {
node = *node.prev; node = *node.prev;
} }
} }
} }
void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if( node.point->x > edge->p->x) { if (node.point->x > edge->p->x) {
if(Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW ) { if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
// Concave // Concave
FillLeftConcaveEdgeEvent(tcx, edge, node); FillLeftConcaveEdgeEvent(tcx, edge, node);
} else { } else {
@ -682,66 +663,64 @@ void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
// Retry this one // Retry this one
FillLeftBelowEdgeEvent(tcx, edge, node); FillLeftBelowEdgeEvent(tcx, edge, node);
} }
} }
} }
void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
// Next concave or convex? // Next concave or convex?
if(Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) { if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) {
// Concave // Concave
FillLeftConcaveEdgeEvent(tcx, edge, *node.prev); FillLeftConcaveEdgeEvent(tcx, edge, *node.prev);
} else { } else{
// Convex // Convex
// Next above or below edge? // Next above or below edge?
if(Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) { if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) {
// Below // Below
FillLeftConvexEdgeEvent(tcx, edge, *node.prev); FillLeftConvexEdgeEvent(tcx, edge, *node.prev);
} else { } else{
// Above // Above
} }
} }
} }
void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) { void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.prev); Fill(tcx, *node.prev);
if(node.prev->point != edge->p) { if (node.prev->point != edge->p) {
// Next above or below edge? // Next above or below edge?
if(Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) { if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) {
// Below // Below
if(Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) { if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
// Next is concave // Next is concave
FillLeftConcaveEdgeEvent(tcx, edge, node); FillLeftConcaveEdgeEvent(tcx, edge, node);
} else { } else{
// Next is convex // Next is convex
} }
} }
} }
} }
void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t, Point& p) { void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t, Point& p)
{
Triangle& ot = t.NeighborAcross(p); Triangle& ot = t.NeighborAcross(p);
Point& op = *ot.OppositePoint(t, p); Point& op = *ot.OppositePoint(t, p);
if(&t.NeighborAcross(p) == NULL) { if (&t.NeighborAcross(p) == NULL) {
// If we want to integrate the fillEdgeEvent do it here // If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here // With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle"); //throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
assert(0); assert(0);
} }
if(InScanArea(p, *t.PointCCW(p), *t.PointCW(p), op)) { if (InScanArea(p, *t.PointCCW(p), *t.PointCW(p), op)) {
// Lets rotate shared edge one vertex CW // Lets rotate shared edge one vertex CW
RotateTrianglePair(t, p, ot, op); RotateTrianglePair(t, p, ot, op);
tcx.MapTriangleToNodes(t); tcx.MapTriangleToNodes(t);
tcx.MapTriangleToNodes(ot); tcx.MapTriangleToNodes(ot);
if( p == eq && op == ep ) { if (p == eq && op == ep) {
if(eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) { if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) {
t.MarkConstrainedEdge(&ep, &eq); t.MarkConstrainedEdge(&ep, &eq);
ot.MarkConstrainedEdge(&ep, &eq); ot.MarkConstrainedEdge(&ep, &eq);
Legalize(tcx, t); Legalize(tcx, t);
@ -751,19 +730,19 @@ void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t,
} }
} else { } else {
Orientation o = Orient2d(eq, op, ep); Orientation o = Orient2d(eq, op, ep);
t = NextFlipTriangle(tcx, (int) o, t, ot, p, op); t = NextFlipTriangle(tcx, (int)o, t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p); FlipEdgeEvent(tcx, ep, eq, t, p);
} }
} else { } else {
Point& newP = NextFlipPoint( ep, eq, ot, op); Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP); FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, &t, p); EdgeEvent(tcx, ep, eq, &t, p);
} }
} }
Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op) { Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op)
{
if(o == CCW) { if (o == CCW) {
// ot is not crossing edge after flip // ot is not crossing edge after flip
int edge_index = ot.EdgeIndex(&p, &op); int edge_index = ot.EdgeIndex(&p, &op);
ot.delaunay_edge[edge_index] = true; ot.delaunay_edge[edge_index] = true;
@ -780,36 +759,35 @@ Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triang
return ot; return ot;
} }
Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op) { Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op)
{
Orientation o2d = Orient2d(eq, op, ep); Orientation o2d = Orient2d(eq, op, ep);
if(o2d == CW) { if (o2d == CW) {
// Right // Right
return *ot.PointCCW(op); return *ot.PointCCW(op);
} else if(o2d == CCW) { } else if (o2d == CCW) {
// Left // Left
return *ot.PointCW(op); return *ot.PointCW(op);
} else { } else{
//throw new RuntimeException("[Unsupported] Opposing point on constrained edge"); //throw new RuntimeException("[Unsupported] Opposing point on constrained edge");
assert(0); assert(0);
} }
} }
void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle,
Triangle& t, Point& p ) { Triangle& t, Point& p)
{
Triangle& ot = t.NeighborAcross(p); Triangle& ot = t.NeighborAcross(p);
Point& op = *ot.OppositePoint(t, p); Point& op = *ot.OppositePoint(t, p);
if(&t.NeighborAcross(p) == NULL) { if (&t.NeighborAcross(p) == NULL) {
// If we want to integrate the fillEdgeEvent do it here // If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here // With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle"); //throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
assert(0); assert(0);
} }
if(InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW( eq ), op)) { if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) {
// flip with new edge op->eq // flip with new edge op->eq
FlipEdgeEvent(tcx, eq, op, ot, op); FlipEdgeEvent(tcx, eq, op, ot, op);
// TODO: Actually I just figured out that it should be possible to // TODO: Actually I just figured out that it should be possible to
@ -819,11 +797,10 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
// also need to set a new flip_triangle first // also need to set a new flip_triangle first
// Turns out at first glance that this is somewhat complicated // Turns out at first glance that this is somewhat complicated
// so it will have to wait. // so it will have to wait.
} else { } else{
Point& newP = NextFlipPoint(ep, eq, ot, op); Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP); FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
} }
} }

64
poly2tri/sweep/sweep.h
View File

@ -44,71 +44,69 @@ struct Edge;
class Triangle; class Triangle;
class Sweep { class Sweep {
public: public:
void Triangulate(SweepContext& tcx); void Triangulate(SweepContext& tcx);
private: private:
void SweepPoints(SweepContext& tcx); void SweepPoints(SweepContext& tcx);
Node& PointEvent(SweepContext& tcx, Point& point); Node& PointEvent(SweepContext& tcx, Point& point);
void EdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void EdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point); void EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point);
Node& NewFrontTriangle(SweepContext& tcx, Point& point, Node& node); Node& NewFrontTriangle(SweepContext& tcx, Point& point, Node& node);
void Fill(SweepContext& tcx, Node& node); void Fill(SweepContext& tcx, Node& node);
bool Legalize(SweepContext& tcx, Triangle& t); bool Legalize(SweepContext& tcx, Triangle& t);
bool Incircle(Point& pa, Point& pb, Point& pc, Point& pd); bool Incircle(Point& pa, Point& pb, Point& pc, Point& pd);
void RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op); void RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op);
void FillAdvancingFront(SweepContext& tcx, Node& n); void FillAdvancingFront(SweepContext& tcx, Node& n);
double HoleAngle(Node& node); double HoleAngle(Node& node);
double BasinAngle(Node& node); double BasinAngle(Node& node);
void FillBasin(SweepContext& tcx, Node& node); void FillBasin(SweepContext& tcx, Node& node);
void FillBasinReq(SweepContext& tcx, Node& node); void FillBasinReq(SweepContext& tcx, Node& node);
bool IsShallow(SweepContext& tcx, Node& node); bool IsShallow(SweepContext& tcx, Node& node);
bool IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq); bool IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq);
void FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillRightConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node); void FillLeftConvexEdgeEvent(SweepContext& tcx, Edge* edge, Node& node);
void FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t, Point& p); void FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t, Point& p);
Triangle& NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op); Triangle& NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op);
Point& NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op ); 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);
void FinalizationPolygon(SweepContext& tcx);
}; };

83
poly2tri/sweep/sweep_context.cc
View File

@ -4,8 +4,8 @@
#include <GL/glfw.h> #include <GL/glfw.h>
#include "advancing_front.h" #include "advancing_front.h"
SweepContext::SweepContext(Point** polyline, const int& point_count) { SweepContext::SweepContext(Point** polyline, const int& point_count)
{
basin = Basin(); basin = Basin();
edge_event = EdgeEvent(); edge_event = EdgeEvent();
@ -14,37 +14,38 @@ SweepContext::SweepContext(Point** polyline, const int& point_count) {
InitEdges(points_, point_count_); InitEdges(points_, point_count_);
InitTriangulation(); InitTriangulation();
} }
std::vector<Triangle*> SweepContext::GetTriangles() { std::vector<Triangle*> SweepContext::GetTriangles()
{
return triangles_; return triangles_;
} }
std::list<Triangle*> SweepContext::GetMap() { std::list<Triangle*> SweepContext::GetMap()
{
return map_; return map_;
} }
void SweepContext::InitTriangulation() { void SweepContext::InitTriangulation()
{
double xmax(points_[0]->x), xmin(points_[0]->x); double xmax(points_[0]->x), xmin(points_[0]->x);
double ymax(points_[0]->y), ymin(points_[0]->y); double ymax(points_[0]->y), ymin(points_[0]->y);
// Calculate bounds. // Calculate bounds.
for(int i = 0; i < point_count_; i++) { for (int i = 0; i < point_count_; i++) {
Point p = *points_[i]; Point p = *points_[i];
if(p.x > xmax) if (p.x > xmax)
xmax = p.x; xmax = p.x;
if(p.x < xmin) if (p.x < xmin)
xmin = p.x; xmin = p.x;
if(p.y > ymax) if (p.y > ymax)
ymax = p.y; ymax = p.y;
if(p.y < ymin) if (p.y < ymin)
ymin = p.y; ymin = p.y;
} }
double dx = kAlpha * ( xmax - xmin ); double dx = kAlpha * (xmax - xmin);
double dy = kAlpha * ( ymax - ymin ); double dy = kAlpha * (ymax - ymin);
head_ = new Point(xmax + dx, ymin - dy); head_ = new Point(xmax + dx, ymin - dy);
tail_ = new Point(xmin - dx, ymin - dy); tail_ = new Point(xmin - dx, ymin - dy);
@ -54,25 +55,24 @@ void SweepContext::InitTriangulation() {
double dt = glfwGetTime() - init_time; double dt = glfwGetTime() - init_time;
printf("Sort time (secs) = %f\n", dt); printf("Sort time (secs) = %f\n", dt);
/*
printf("*************************\n"); printf("*************************\n");
for(int i = 0; i < point_count_; i++) { for (int i = 0; i < point_count_; i++) {
printf("%f,%f ", points_[i]->x, points_[i]->y); printf("%f,%f ", points_[i]->x, points_[i]->y);
printf("%p\n", points_[i]); printf("%p\n", points_[i]);
} }
/*
printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
for(int i = 0; i < edge_list.size(); i++) { for(int i = 0; i < edge_list.size(); i++) {
edge_list[i]->p->DebugPrint(); edge_list[i]->q->DebugPrint(); edge_list[i]->p->DebugPrint(); edge_list[i]->q->DebugPrint();
printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q); printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q);
} }
*/ */
} }
void SweepContext::InitEdges(Point** polyline, const int& point_count) { void SweepContext::InitEdges(Point** polyline, const int& point_count)
{
for(int i = 0; i < point_count; i++) { for (int i = 0; i < point_count; i++) {
int j = i < point_count - 1 ? i + 1 : 0; int j = i < point_count - 1 ? i + 1 : 0;
edge_list.push_back(new Edge(*polyline[i], *polyline[j])); edge_list.push_back(new Edge(*polyline[i], *polyline[j]));
} }
@ -83,24 +83,26 @@ void SweepContext::InitEdges(Point** polyline, const int& point_count) {
printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q); printf("%p, %p\n", edge_list[i]->p, edge_list[i]->q);
} }
*/ */
} }
Point* SweepContext::GetPoint(const int& index) { Point* SweepContext::GetPoint(const int& index)
{
return points_[index]; return points_[index];
} }
void SweepContext::AddToMap(Triangle* triangle ) { void SweepContext::AddToMap(Triangle* triangle)
{
map_.push_back(triangle); map_.push_back(triangle);
} }
Node& SweepContext::LocateNode(Point& point) { Node& SweepContext::LocateNode(Point& point)
{
// TODO implement search tree // TODO implement search tree
return *front_->Locate(point.x); return *front_->Locate(point.x);
} }
void SweepContext::CreateAdvancingFront() { void SweepContext::CreateAdvancingFront()
{
// Initial triangle // Initial triangle
Triangle* triangle = new Triangle(*points_[0], *tail_, *head_); Triangle* triangle = new Triangle(*points_[0], *tail_, *head_);
@ -121,40 +123,43 @@ void SweepContext::CreateAdvancingFront() {
middle->next = front_->tail(); middle->next = front_->tail();
middle->prev = front_->head(); middle->prev = front_->head();
front_->tail()->prev = middle; front_->tail()->prev = middle;
} }
void SweepContext::RemoveNode(Node* node) { void SweepContext::RemoveNode(Node* node)
{
delete node; delete node;
} }
void SweepContext::MapTriangleToNodes(Triangle& t) { void SweepContext::MapTriangleToNodes(Triangle& t)
for(int i=0; i<3; i++) { {
if(t.GetNeighbor(i) == NULL) { for (int i = 0; i < 3; i++) {
if (t.GetNeighbor(i) == NULL) {
Node* n = front_->LocatePoint(t.PointCW(*t.GetPoint(i))); Node* n = front_->LocatePoint(t.PointCW(*t.GetPoint(i)));
if(n) if (n)
n->triangle = &t; n->triangle = &t;
} }
} }
} }
void SweepContext::RemoveFromMap(Triangle* triangle) { void SweepContext::RemoveFromMap(Triangle* triangle)
{
map_.remove(triangle); map_.remove(triangle);
} }
void SweepContext::MeshClean(Triangle& triangle ) { void SweepContext::MeshClean(Triangle& triangle)
{
if(&triangle != NULL && !triangle.IsInterior()) { if (&triangle != NULL && !triangle.IsInterior()) {
triangle.IsInterior(true); triangle.IsInterior(true);
triangles_.push_back(&triangle); triangles_.push_back(&triangle);
for(int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
if(!triangle.constrained_edge[i]) if (!triangle.constrained_edge[i])
MeshClean(*triangle.GetNeighbor(i)); MeshClean(*triangle.GetNeighbor(i));
} }
} }
} }
SweepContext::~SweepContext() { SweepContext::~SweepContext()
{
delete head_; delete head_;
delete tail_; delete tail_;
delete front_; delete front_;

141
poly2tri/sweep/sweep_context.h
View File

@ -43,52 +43,50 @@ class AdvancingFront;
class SweepContext { class SweepContext {
public: public:
// Constructor // Constructor
SweepContext(Point** polyline, const int& point_count); SweepContext(Point** polyline, const int& point_count);
// Destructor // Destructor
~SweepContext(); ~SweepContext();
//void MeshClean(Triangle& triangle); //void MeshClean(Triangle& triangle);
// Get Advancing Front // Get Advancing Front
//AdvancingFront front(); //AdvancingFront front();
void set_head(Point* p1); void set_head(Point* p1);
Point* head(); Point* head();
void set_tail(Point* p1 ); void set_tail(Point* p1);
Point* tail(); Point* tail();
int point_count(); int point_count();
Node& LocateNode(Point& point); Node& LocateNode(Point& point);
void RemoveNode(Node* node); void RemoveNode(Node* node);
void CreateAdvancingFront(); void CreateAdvancingFront();
// Try to map a node to all sides of this triangle that don't have a neighbor // Try to map a node to all sides of this triangle that don't have a neighbor
void MapTriangleToNodes(Triangle& t); void MapTriangleToNodes(Triangle& t);
void AddToMap(Triangle* triangle); void AddToMap(Triangle* triangle);
Point* GetPoint(const int& index); Point* GetPoint(const int& index);
Point* GetPoints(); Point* GetPoints();
void RemoveFromMap(Triangle* triangle); void RemoveFromMap(Triangle* triangle);
AdvancingFront* front(); AdvancingFront* front();
void MeshClean(Triangle& triangle); void MeshClean(Triangle& triangle);
std::vector<Triangle*> GetTriangles(); std::vector<Triangle*> GetTriangles();
std::list<Triangle*> GetMap(); std::list<Triangle*> GetMap();
std::vector<Edge*> edge_list; std::vector<Edge*> edge_list;
struct Basin {
struct Basin {
Node* left_node; Node* left_node;
Node* bottom_node; Node* bottom_node;
Node* right_node; Node* right_node;
@ -96,69 +94,88 @@ public:
bool left_highest; bool left_highest;
Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL),
width(0.0), left_highest(false) {} width(0.0), left_highest(false)
{
}
void Clear() { void Clear()
{
left_node = NULL; left_node = NULL;
bottom_node = NULL; bottom_node = NULL;
right_node = NULL; right_node = NULL;
width = 0.0; width = 0.0;
left_highest = false; left_highest = false;
} }
};
}; struct EdgeEvent {
struct EdgeEvent {
Edge* constrained_edge; Edge* constrained_edge;
bool right; bool right;
EdgeEvent() : constrained_edge(NULL), right(false) {} EdgeEvent() : constrained_edge(NULL), right(false)
{
}
};
}; Basin basin;
EdgeEvent edge_event;
Basin basin;
EdgeEvent edge_event;
private: private:
std::vector<Triangle*> triangles_; std::vector<Triangle*> triangles_;
std::list<Triangle*> map_; std::list<Triangle*> map_;
Point** points_; Point** points_;
int point_count_; int point_count_;
// Advancing front // Advancing front
AdvancingFront* front_; AdvancingFront* front_;
// head point used with advancing front // head point used with advancing front
Point* head_; Point* head_;
// tail point used with advancing front // tail point used with advancing front
Point* tail_; Point* tail_;
//EdgeEvent edgeEvent = new EdgeEvent(); //EdgeEvent edgeEvent = new EdgeEvent();
void InitTriangulation(); void InitTriangulation();
void InitEdges(Point** polyline, const int& point_count); void InitEdges(Point** polyline, const int& point_count);
//void MeshCleanReq(Triangle& triangle ) //void MeshCleanReq(Triangle& triangle )
/* /*
class EdgeEvent { class EdgeEvent {
Edge* constrainedEdge; Edge* constrainedEdge;
bool right; bool right;
}; };
*/ */
}; };
inline AdvancingFront* SweepContext::front() { return front_; } inline AdvancingFront* SweepContext::front()
{
return front_;
}
inline int SweepContext::point_count() { return point_count_; } inline int SweepContext::point_count()
{
return point_count_;
}
inline void SweepContext::set_head(Point* p1) { head_ = p1; } inline void SweepContext::set_head(Point* p1)
{
head_ = p1;
}
inline Point* SweepContext::head() { return head_; } inline Point* SweepContext::head()
{
return head_;
}
inline void SweepContext::set_tail(Point* p1) { tail_ = p1; } inline void SweepContext::set_tail(Point* p1)
{
tail_ = p1;
}
inline Point* SweepContext::tail() { return tail_; } inline Point* SweepContext::tail()
{
return tail_;
}

49
testbed/main.cc
View File

@ -58,7 +58,8 @@ vector<Triangle*> triangles;
/// Triangle map /// Triangle map
list<Triangle*> map; list<Triangle*> map;
double StringToDouble(const std::string& s) { double StringToDouble(const std::string& s)
{
std::istringstream i(s); std::istringstream i(s);
double x; double x;
if (!(i >> x)) if (!(i >> x))
@ -68,8 +69,8 @@ double StringToDouble(const std::string& s) {
bool draw_map = true; bool draw_map = true;
int main(int argc, char* argv[]) { int main(int argc, char* argv[])
{
if (argc != 3) { if (argc != 3) {
cout << "Usage: p2t filename zoom" << endl; cout << "Usage: p2t filename zoom" << endl;
return 1; return 1;
@ -91,12 +92,12 @@ int main(int argc, char* argv[]) {
*/ */
string line; string line;
ifstream myfile (argv[1]); ifstream myfile(argv[1]);
vector<Point*> points; vector<Point*> points;
if (myfile.is_open()) { if (myfile.is_open()) {
while (!myfile.eof()) { while (!myfile.eof()) {
getline (myfile,line); getline(myfile, line);
if(line.size() == 0) { if (line.size() == 0) {
break; break;
} }
istringstream iss(line); istringstream iss(line);
@ -116,7 +117,7 @@ int main(int argc, char* argv[]) {
cout << "Number of points = " << num_points << endl; cout << "Number of points = " << num_points << endl;
Point** polyline = new Point *[num_points]; Point** polyline = new Point *[num_points];
for(int i = 0; i < num_points; i++) { for (int i = 0; i < num_points; i++) {
polyline[i] = points[i]; polyline[i] = points[i];
} }
@ -155,8 +156,7 @@ void Init()
glEnable(GL_BLEND); glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.0, 0.0, 0.0); glClearColor(0.0, 0.0, 0.0, 0.0);
glHint (GL_LINE_SMOOTH_HINT, GL_NICEST); glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
} }
void ShutDown(int return_code) void ShutDown(int return_code)
@ -172,8 +172,7 @@ void MainLoop(const double zoom)
// this just loops as long as the program runs // this just loops as long as the program runs
bool running = true; bool running = true;
while(running) while (running) {
{
// calculate time elapsed, and the amount by which stuff rotates // calculate time elapsed, and the amount by which stuff rotates
double current_time = glfwGetTime(), double current_time = glfwGetTime(),
delta_rotate = (current_time - old_time) * rotations_per_tick * 360; delta_rotate = (current_time - old_time) * rotations_per_tick * 360;
@ -181,7 +180,7 @@ void MainLoop(const double zoom)
// escape to quit, arrow keys to rotate view // escape to quit, arrow keys to rotate view
// Check if ESC key was pressed or window was closed // Check if ESC key was pressed or window was closed
running = !glfwGetKey( GLFW_KEY_ESC ) && glfwGetWindowParam( GLFW_OPENED ); running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
if (glfwGetKey(GLFW_KEY_LEFT) == GLFW_PRESS) if (glfwGetKey(GLFW_KEY_LEFT) == GLFW_PRESS)
rotate_y += delta_rotate; rotate_y += delta_rotate;
@ -191,7 +190,7 @@ void MainLoop(const double zoom)
rotate_z += delta_rotate; rotate_z += delta_rotate;
// Draw the scene // Draw the scene
if(draw_map) { if (draw_map) {
DrawMap(zoom); DrawMap(zoom);
} else { } else {
Draw(zoom); Draw(zoom);
@ -202,8 +201,8 @@ void MainLoop(const double zoom)
} }
} }
void ResetZoom(double zoom, double cx, double cy, double width, double height) { void ResetZoom(double zoom, double cx, double cy, double width, double height)
{
double left = -width / zoom; double left = -width / zoom;
double right = width / zoom; double right = width / zoom;
double bottom = -height / zoom; double bottom = -height / zoom;
@ -223,18 +222,16 @@ void ResetZoom(double zoom, double cx, double cy, double width, double height) {
// Clear the screen // Clear the screen
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
} }
void Draw(const double zoom) { void Draw(const double zoom)
{
// reset zoom // reset zoom
Point center = Point(0, 0); Point center = Point(0, 0);
ResetZoom(zoom, center.x, center.y, 800, 600); ResetZoom(zoom, center.x, center.y, 800, 600);
for (int i = 0; i < triangles.size(); i++) { for (int i = 0; i < triangles.size(); i++) {
Triangle& t = *triangles[i]; Triangle& t = *triangles[i];
Point& a = *t.GetPoint(0); Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1); Point& b = *t.GetPoint(1);
@ -248,13 +245,11 @@ void Draw(const double zoom) {
glVertex2f(b.x, b.y); glVertex2f(b.x, b.y);
glVertex2f(c.x, c.y); glVertex2f(c.x, c.y);
glEnd(); glEnd();
} }
} }
void DrawMap(const double zoom) { void DrawMap(const double zoom)
{
// reset zoom // reset zoom
Point center = Point(0, 0); Point center = Point(0, 0);
@ -262,7 +257,6 @@ void DrawMap(const double zoom) {
list<Triangle*>::iterator it; list<Triangle*>::iterator it;
for (it = map.begin(); it != map.end(); it++) { for (it = map.begin(); it != map.end(); it++) {
Triangle& t = **it; Triangle& t = **it;
Point& a = *t.GetPoint(0); Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1); Point& b = *t.GetPoint(1);
@ -285,13 +279,12 @@ void DrawMap(const double zoom) {
glVertex2f(c.x, c.y); glVertex2f(c.x, c.y);
glVertex2f(a.x, a.y); glVertex2f(a.x, a.y);
glEnd( ); glEnd( );
} }
} }
void ConstrainedColor(bool constrain) { void ConstrainedColor(bool constrain)
if(constrain) { {
if (constrain) {
// Green // Green
glColor3f(0, 1, 0); glColor3f(0, 1, 0);
} else { } else {