3rd-party/poly2tri
1
0
Fork 0
mirror of https://github.com/jhasse/poly2tri.git synced 2025-01-06 01:43:31 +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"
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;
neighbors_[0] = NULL; neighbors_[1] = NULL; neighbors_[2] = NULL;
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
void Triangle::MarkNeighbor(Point* p1, Point* p2, Triangle* t) {
if((p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2]))
void Triangle::MarkNeighbor(Point* p1, Point* p2, Triangle* t)
{
if ((p1 == points_[2] && p2 == points_[1]) || (p1 == points_[1] && p2 == points_[2]))
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;
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;
else
assert(0);
}
// Exhaustive search to update neighbor pointers
void Triangle::MarkNeighbor(Triangle& t) {
void Triangle::MarkNeighbor(Triangle& t)
{
if (t.Contains(points_[1], points_[2])) {
neighbors_[0] = &t;
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;
t.MarkNeighbor(points_[0], points_[2], this);
} 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_[1] = NULL;
neighbors_[2] = NULL;
}
void Triangle::ClearDelunayEdges() {
void Triangle::ClearDelunayEdges()
{
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);
double x = cw->x;
double y = cw->y;
@ -89,17 +91,17 @@ Point* Triangle::OppositePoint(Triangle& t, Point& p) {
}
// Legalized triangle by rotating clockwise around point(0)
void Triangle::Legalize(Point& point) {
void Triangle::Legalize(Point& point)
{
points_[1] = points_[0];
points_[0] = points_[2];
points_[2] = &point;
}
// Legalize triagnle by rotating clockwise around oPoint
void Triangle::Legalize(Point& opoint, Point& npoint) {
if(&opoint == points_[0]) {
void Triangle::Legalize(Point& opoint, Point& npoint)
{
if (&opoint == points_[0]) {
points_[1] = points_[0];
points_[0] = points_[2];
points_[2] = &npoint;
@ -116,189 +118,190 @@ void Triangle::Legalize(Point& opoint, Point& npoint) {
}
}
int Triangle::Index(const Point* p) {
if(p == points_[0]) {
int Triangle::Index(const Point* p)
{
if (p == points_[0]) {
return 0;
} else if(p == points_[1]) {
} else if (p == points_[1]) {
return 1;
} else if(p == points_[2]) {
} else if (p == points_[2]) {
return 2;
}
assert(0);
}
int Triangle::EdgeIndex(const Point* p1, const Point* p2) {
if(points_[0] == p1) {
if(points_[1] == p2){
int Triangle::EdgeIndex(const Point* p1, const Point* p2)
{
if (points_[0] == p1) {
if (points_[1] == p2) {
return 2;
} else if(points_[2] == p2){
} else if (points_[2] == p2) {
return 1;
}
} else if(points_[1] == p1) {
if(points_[2] == p2) {
} else if (points_[1] == p1) {
if (points_[2] == p2) {
return 0;
} else if(points_[0] == p2) {
} else if (points_[0] == p2) {
return 2;
}
} else if(points_[2] == p1) {
if(points_[0] == p2 ) {
} else if (points_[2] == p1) {
if (points_[0] == p2) {
return 1;
} else if(points_[1] == p2) {
} else if (points_[1] == p2) {
return 0;
}
}
return -1;
}
void Triangle::MarkConstrainedEdge(const int index) {
void Triangle::MarkConstrainedEdge(const int index)
{
constrained_edge[index] = true;
}
void Triangle::MarkConstrainedEdge(Edge& edge) {
void Triangle::MarkConstrainedEdge(Edge& edge)
{
MarkConstrainedEdge(edge.p, edge.q);
}
// Mark edge as constrained
void Triangle::MarkConstrainedEdge(Point* p, Point* q) {
if((q == points_[0] && p == points_[1] ) || (q == points_[1] && p == points_[0])) {
void Triangle::MarkConstrainedEdge(Point* p, Point* q)
{
if ((q == points_[0] && p == points_[1]) || (q == points_[1] && p == points_[0])) {
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;
} 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;
}
}
// The point counter-clockwise to given point
Point* Triangle::PointCW(Point& point) {
if(&point == points_[0]) {
Point* Triangle::PointCW(Point& point)
{
if (&point == points_[0]) {
return points_[2];
} else if(&point == points_[1]) {
} else if (&point == points_[1]) {
return points_[0];
} else if(&point == points_[2]) {
} else if (&point == points_[2]) {
return points_[1];
}
assert(0);
}
// The point counter-clockwise to given point
Point* Triangle::PointCCW(Point& point) {
if(&point == points_[0]) {
Point* Triangle::PointCCW(Point& point)
{
if (&point == points_[0]) {
return points_[1];
} else if(&point == points_[1]) {
} else if (&point == points_[1]) {
return points_[2];
} else if(&point == points_[2]) {
} else if (&point == points_[2]) {
return points_[0];
}
assert(0);
}
// The neighbor clockwise to given point
Triangle* Triangle::NeighborCW(Point& point) {
if(&point == points_[0]) {
Triangle* Triangle::NeighborCW(Point& point)
{
if (&point == points_[0]) {
return neighbors_[1];
} else if(&point == points_[1]) {
} else if (&point == points_[1]) {
return neighbors_[2];
}
return neighbors_[0];
}
// The neighbor counter-clockwise to given point
Triangle* Triangle::NeighborCCW(Point& point) {
if(&point == points_[0]) {
Triangle* Triangle::NeighborCCW(Point& point)
{
if (&point == points_[0]) {
return neighbors_[2];
} else if(&point == points_[1]) {
} else if (&point == points_[1]) {
return neighbors_[0];
}
return neighbors_[1];
}
bool Triangle::GetConstrainedEdgeCCW(Point& p) {
if(&p == points_[0]) {
bool Triangle::GetConstrainedEdgeCCW(Point& p)
{
if (&p == points_[0]) {
return constrained_edge[2];
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
return constrained_edge[0];
}
return constrained_edge[1];
}
bool Triangle::GetConstrainedEdgeCW(Point& p) {
if(&p == points_[0]) {
bool Triangle::GetConstrainedEdgeCW(Point& p)
{
if (&p == points_[0]) {
return constrained_edge[1];
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
return constrained_edge[2];
}
return constrained_edge[0];
}
void Triangle::SetConstrainedEdgeCCW(Point& p, bool ce) {
if(&p == points_[0]) {
void Triangle::SetConstrainedEdgeCCW(Point& p, bool ce)
{
if (&p == points_[0]) {
constrained_edge[2] = ce;
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
constrained_edge[0] = ce;
} else {
constrained_edge[1] = ce;
}
}
void Triangle::SetConstrainedEdgeCW(Point& p, bool ce) {
if(&p == points_[0]) {
void Triangle::SetConstrainedEdgeCW(Point& p, bool ce)
{
if (&p == points_[0]) {
constrained_edge[1] = ce;
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
constrained_edge[2] = ce;
} else {
constrained_edge[0] = ce;
}
}
bool Triangle::GetDelunayEdgeCCW(Point& p) {
if(&p == points_[0]){
bool Triangle::GetDelunayEdgeCCW(Point& p)
{
if (&p == points_[0]) {
return delaunay_edge[2];
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
return delaunay_edge[0];
}
return delaunay_edge[1];
}
bool Triangle::GetDelunayEdgeCW(Point& p) {
if(&p == points_[0]) {
bool Triangle::GetDelunayEdgeCW(Point& p)
{
if (&p == points_[0]) {
return delaunay_edge[1];
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
return delaunay_edge[2];
}
return delaunay_edge[0];
}
void Triangle::SetDelunayEdgeCCW(Point& p, bool e) {
if(&p == points_[0]) {
void Triangle::SetDelunayEdgeCCW(Point& p, bool e)
{
if (&p == points_[0]) {
delaunay_edge[2] = e;
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
delaunay_edge[0] = e;
} else {
delaunay_edge[1] = e;
}
}
void Triangle::SetDelunayEdgeCW(Point& p, bool e) {
if(&p == points_[0]) {
void Triangle::SetDelunayEdgeCW(Point& p, bool e)
{
if (&p == points_[0]) {
delaunay_edge[1] = e;
} else if(&p == points_[1]) {
} else if (&p == points_[1]) {
delaunay_edge[2] = e;
} else {
delaunay_edge[0] = e;
@ -306,16 +309,18 @@ void Triangle::SetDelunayEdgeCW(Point& p, bool e) {
}
// The neighbor across to given point
Triangle& Triangle::NeighborAcross(Point& opoint) {
if(&opoint == points_[0]) {
Triangle& Triangle::NeighborAcross(Point& opoint)
{
if (&opoint == points_[0]) {
return *neighbors_[0];
} else if(&opoint == points_[1]) {
} else if (&opoint == points_[1]) {
return *neighbors_[1];
}
return *neighbors_[2];
}
void Triangle::DebugPrint() {
void Triangle::DebugPrint()
{
using namespace std;
cout << points_[0]->x << "," << points_[0]->y << " ";
cout << points_[1]->x << "," << points_[1]->y << " ";

204
poly2tri/common/shapes.h
View File

@ -43,163 +43,177 @@ struct Node;
struct Edge;
struct Point {
double x, y;
/// 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
std::vector<Edge*> edge_list;
/// 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.
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.
void set(double x_, double y_) { x = x_; y = y_; }
void set(double x_, double y_)
{
x = x_; y = y_;
}
/// 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.
void operator += (const Point& v) {
void operator +=(const Point& v)
{
x += v.x; y += v.y;
}
/// Subtract a point from this point.
void operator -= (const Point& v) {
void operator -=(const Point& v)
{
x -= v.x; y -= v.y;
}
/// Multiply this point by a scalar.
void operator *= (double a) {
void operator *=(double a)
{
x *= a; y *= a;
}
/// Get the length of this point (the norm).
double Length() const {
double Length() const
{
return sqrt(x * x + y * y);
}
/// Convert this point into a unit point. Returns the Length.
double Normalize() {
double Normalize()
{
double len = Length();
x /= len;
y /= len;
return len;
}
void DebugPrint() {
void DebugPrint()
{
printf("%f,%f ", x, y);
}
};
// Represents a simple polygon's edge
struct Edge {
Point* p, *q;
/// Constructor
Edge(Point& p1, Point& p2) : p(&p1), q(&p2) {
if(p1.y > p2.y) {
Edge(Point& p1, Point& p2) : p(&p1), q(&p2)
{
if (p1.y > p2.y) {
q = &p1;
p = &p2;
} else if(p1.y == p2.y) {
if(p1.x > p2.x) {
} else if (p1.y == p2.y) {
if (p1.x > p2.x) {
q = &p1;
p = &p2;
} else if(p1.x == p2.x) {
} else if (p1.x == p2.x) {
// Repeat points
assert(false);
}
}
q->edge_list.push_back(this);
}
};
// 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"
// "Triangulations in CGAL"
class Triangle {
public:
/// Constructor
Triangle(Point& a, Point& b, Point& c);
/// Constructor
Triangle(Point& a, Point& b, Point& c);
/// 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];
/// 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];
Point* GetPoint(const int& index);
Point* PointCW(Point& point);
Point* PointCCW(Point& point);
Point* OppositePoint(Triangle& t, Point& p);
Point* GetPoint(const int& index);
Point* PointCW(Point& point);
Point* PointCCW(Point& point);
Point* OppositePoint(Triangle& t, Point& p);
Triangle* GetNeighbor(const int& index);
void MarkNeighbor(Point* p1, Point* p2, Triangle* t);
void MarkNeighbor(Triangle& t);
Triangle* GetNeighbor(const int& index);
void MarkNeighbor(Point* p1, Point* p2, Triangle* t);
void MarkNeighbor(Triangle& t);
void MarkConstrainedEdge(const int index);
void MarkConstrainedEdge(Edge& edge);
void MarkConstrainedEdge(Point* p, Point* q);
void MarkConstrainedEdge(const int index);
void MarkConstrainedEdge(Edge& edge);
void MarkConstrainedEdge(Point* p, Point* q);
int Index(const Point* p);
int EdgeIndex(const Point* p1, const Point* p2);
int Index(const Point* p);
int EdgeIndex(const Point* p1, const Point* p2);
Triangle* NeighborCW(Point& point);
Triangle* NeighborCCW(Point& point);
bool GetConstrainedEdgeCCW(Point& p);
bool GetConstrainedEdgeCW(Point& p);
void SetConstrainedEdgeCCW(Point& p, bool ce);
void SetConstrainedEdgeCW(Point& p, bool ce);
bool GetDelunayEdgeCCW(Point& p);
bool GetDelunayEdgeCW(Point& p);
void SetDelunayEdgeCCW(Point& p, bool e);
void SetDelunayEdgeCW(Point& p, bool e);
Triangle* NeighborCW(Point& point);
Triangle* NeighborCCW(Point& point);
bool GetConstrainedEdgeCCW(Point& p);
bool GetConstrainedEdgeCW(Point& p);
void SetConstrainedEdgeCCW(Point& p, bool ce);
void SetConstrainedEdgeCW(Point& p, bool ce);
bool GetDelunayEdgeCCW(Point& p);
bool GetDelunayEdgeCW(Point& p);
void SetDelunayEdgeCCW(Point& p, bool e);
void SetDelunayEdgeCW(Point& p, bool e);
bool Contains(Point* p);
bool Contains(const Edge& e);
bool Contains(Point* p, Point* q);
void Legalize(Point& point);
void Legalize(Point& opoint, Point& npoint);
void ClearNeighbors();
void ClearDelunayEdges();
bool Contains(Point* p);
bool Contains(const Edge& e);
bool Contains(Point* p, Point* q);
void Legalize(Point& point);
void Legalize(Point& opoint, Point& npoint);
void ClearNeighbors();
void ClearDelunayEdges();
inline bool IsInterior();
inline void IsInterior(bool b);
inline bool IsInterior();
inline void IsInterior(bool b);
Triangle& NeighborAcross(Point& opoint);
Triangle& NeighborAcross(Point& opoint);
void DebugPrint();
void DebugPrint();
private:
/// Triangle points
Point* points_[3];
/// Neighbor list
Triangle* neighbors_[3];
/// Has this triangle been marked as an interior triangle?
bool interior_;
/// Triangle points
Point* points_[3];
/// Neighbor list
Triangle* neighbors_[3];
/// 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) {
return true;
} 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;
}
}
@ -207,75 +221,91 @@ inline bool cmp (const Point* a, const Point* b) {
}
/// 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);
}
/// 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);
}
/// 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);
}
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;
}
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;
}
/// 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;
}
/// 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;
}
/// Perform the cross product on a point and a scalar. In 2D this produces
/// 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);
}
/// Perform the cross product on a scalar and a point. In 2D this produces
/// 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);
}
inline Point* Triangle::GetPoint(const int& index) {
inline Point* Triangle::GetPoint(const int& index)
{
return points_[index];
}
inline Triangle* Triangle::GetNeighbor(const int& index) {
inline Triangle* Triangle::GetNeighbor(const int& 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];
}
inline bool Triangle::Contains(const Edge& e) {
inline bool Triangle::Contains(const Edge& e)
{
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);
}
inline bool Triangle::IsInterior() {
inline bool Triangle::IsInterior()
{
return interior_;
}
inline void Triangle::IsInterior(bool b) {
inline void Triangle::IsInterior(bool b)
{
interior_ = b;
}

25
poly2tri/common/utils.h
View File

@ -35,9 +35,12 @@
#include <math.h>
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;
enum Orientation { CW, CCW, COLLINEAR };
@ -52,22 +55,21 @@ enum Orientation { CW, CCW, COLLINEAR };
* = (x1-x3)*(y2-y3) - (y1-y3)*(x2-x3)
* </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 detright = (pa.y - pc.y) * (pb.x - pc.x);
double val = detleft - detright;
if( val > -EPSILON && val < EPSILON ) {
if (val > -EPSILON && val < EPSILON) {
return COLLINEAR;
} else if( val > 0 ) {
} else if (val > 0) {
return CCW;
}
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 pdy = pd.y;
double adx = pa.x - pdx;
@ -79,7 +81,7 @@ bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) {
double bdxady = bdx * ady;
double oabd = adxbdy - bdxady;
if(oabd <= EPSILON) {
if (oabd <= EPSILON) {
return false;
}
@ -90,12 +92,11 @@ bool InScanArea(Point& pa, Point& pb, Point& pc, Point& pd) {
double adxcdy = adx * cdy;
double ocad = cdxady - adxcdy;
if(ocad <= EPSILON) {
if (ocad <= EPSILON) {
return false;
}
return true;
}
#endif

47
poly2tri/sweep/advancing_front.cc
View File

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

70
poly2tri/sweep/advancing_front.h
View File

@ -34,7 +34,6 @@ struct Node;
// Advancing front node
struct Node {
Point* point;
Triangle* triangle;
@ -43,10 +42,14 @@ struct Node {
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),
next(NULL), prev(NULL) {}
next(NULL), prev(NULL)
{
}
/*
~Node() {
@ -55,45 +58,60 @@ struct Node {
printf(" ... gone!\n");
}
*/
};
// Advancing front
class AdvancingFront {
public:
AdvancingFront();
// Destructor
~AdvancingFront();
AdvancingFront();
// Destructor
~AdvancingFront();
Node* head();
void set_head(Node* node);
Node* tail();
void set_tail(Node* node);
Node* search();
void set_search(Node* node);
Node* head();
void set_head(Node* node);
Node* tail();
void set_tail(Node* node);
Node* search();
void set_search(Node* node);
/// Locate insertion point along advancing front
Node* Locate(const double& x);
/// Locate insertion point along advancing front
Node* Locate(const double& x);
Node* LocatePoint(Point* point);
Node* LocatePoint(Point* point);
private:
Node* head_, *tail_, *search_node_;
Node* FindSearchNode(const double& x);
Node* head_, *tail_, *search_node_;
Node* FindSearchNode(const double& x);
};
inline Node* AdvancingFront::head() { return head_; }
inline void AdvancingFront::set_head(Node* node) { head_ = node; }
inline Node* AdvancingFront::head()
{
return head_;
}
inline void AdvancingFront::set_head(Node* node)
{
head_ = node;
}
inline Node* AdvancingFront::tail() { return tail_; }
inline void AdvancingFront::set_tail(Node* node) { tail_ = node; }
inline Node* AdvancingFront::tail()
{
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"
CDT::CDT(Point** polyline, const int& point_count) {
CDT::CDT(Point** polyline, const int& point_count)
{
sweep_context_ = new SweepContext(polyline, point_count);
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_);
}
std::vector<Triangle*> CDT::GetTriangles() {
std::vector<Triangle*> CDT::GetTriangles()
{
return sweep_context_->GetTriangles();
}
std::list<Triangle*> CDT::GetMap() {
std::list<Triangle*> CDT::GetMap()
{
return sweep_context_->GetMap();
}
CDT::~CDT() {
CDT::~CDT()
{
delete sweep_context_;
delete sweep_;
}

30
poly2tri/sweep/cdt.h
View File

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

14
poly2tri/sweep/mesh.h
View File

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

367
poly2tri/sweep/sweep.cc
View File

@ -33,40 +33,36 @@
#include "advancing_front.h"
#include "../common/utils.h"
// Triangulate simple polygon with holes
void Sweep::Triangulate(SweepContext& tcx) {
// Triangulate simple polygon with holes
void Sweep::Triangulate(SweepContext& tcx)
{
tcx.CreateAdvancingFront();
// Sweep points; build mesh
SweepPoints(tcx);
// Clean up
//FinalizationPolygon(tcx);
}
void Sweep::SweepPoints(SweepContext& tcx) {
for(int i = 1; i < tcx.point_count(); i++ ) {
//printf("%i = ",i);
void Sweep::SweepPoints(SweepContext& tcx)
{
for (int i = 1; i < tcx.point_count(); i++) {
printf("%i = ", 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);
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);
}
}
}
void Sweep::FinalizationPolygon(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)) {
while (!t->GetConstrainedEdgeCW(*p)) {
t = t->NeighborCCW(*p);
}
@ -83,14 +79,14 @@ void Sweep::FinalizationPolygon(SweepContext& tcx) {
* @param point
* @return
*/
Node& Sweep::PointEvent(SweepContext& tcx, Point& point) {
Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
{
Node& node = tcx.LocateNode(point);
Node& new_node = NewFrontTriangle(tcx, point, node);
// Only need to check +epsilon since point never have smaller
// 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);
}
@ -100,12 +96,12 @@ Node& Sweep::PointEvent(SweepContext& tcx, Point& point) {
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.right = edge->p->x > edge->q->x;
if(IsEdgeSideOfTriangle(*node.triangle, *edge->p, *edge->q)){
if (IsEdgeSideOfTriangle(*node.triangle, *edge->p, *edge->q)) {
return;
}
@ -113,36 +109,35 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
// 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
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) {
if(IsEdgeSideOfTriangle(*triangle, ep, eq)) {
void Sweep::EdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point)
{
if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
return;
}
Point* p1 = triangle->PointCCW(point);
Orientation o1 = Orient2d(eq, *p1, ep);
if(o1 == COLLINEAR) {
if (o1 == COLLINEAR) {
//throw new RuntimeException( "EdgeEvent - Collinear not supported" );
assert(false);
}
Point* p2 = triangle->PointCW(point);
Orientation o2 = Orient2d(eq, *p2, ep);
if(o2 == COLLINEAR) {
if (o2 == COLLINEAR) {
//throw new RuntimeException( "EdgeEvent - Collinear not supported" );
assert(false);
}
if(o1 == o2) {
if (o1 == o2) {
// Need to decide if we are rotating CW or CCW to get to a triangle
// that will cross edge
if(o1 == CW) {
if (o1 == CW) {
triangle = triangle->NeighborCCW(point);
} else {
} else{
triangle = triangle->NeighborCW(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!
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);
if(index != -1) {
if (index != -1) {
triangle.MarkConstrainedEdge(index);
Triangle* t = triangle.GetNeighbor(index);
if(t){
if (t) {
t->MarkConstrainedEdge(&ep, &eq);
}
return true;
@ -168,8 +162,8 @@ bool Sweep::IsEdgeSideOfTriangle(Triangle& triangle, Point& ep, Point& eq) {
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->MarkNeighbor(*node.triangle);
@ -181,7 +175,7 @@ Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node ) {
node.next->prev = new_node;
node.next = new_node;
if(!Legalize(tcx, *triangle)) {
if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle);
}
@ -193,10 +187,9 @@ Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node ) {
* @param tcx
* @param node - middle node, that is the bottom of the hole
*/
void Sweep::Fill(SweepContext& tcx, Node& node) {
Triangle* triangle = new Triangle(*node.prev->point, *node.point,
*node.next->point);
void Sweep::Fill(SweepContext& tcx, Node& node)
{
Triangle* triangle = new Triangle(*node.prev->point, *node.point, *node.next->point);
// TODO: should copy the constrained_edge value from neighbor triangles
// 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;
// If it was legalized the triangle has already been mapped
if(!Legalize(tcx, *triangle)) {
if (!Legalize(tcx, *triangle)) {
tcx.MapTriangleToNodes(*triangle);
}
// TODO: delete node from memory
//tcx.RemoveNode(node);
}
/**
@ -226,14 +218,14 @@ void Sweep::Fill(SweepContext& tcx, Node& node) {
* @param tcx
* @param n
*/
void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n) {
void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
{
// Fill right holes
Node* node = n.next;
while(node->next) {
while (node->next) {
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);
node = node->next;
}
@ -241,24 +233,24 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n) {
// Fill left holes
node = n.prev;
while(node->prev) {
while (node->prev) {
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);
node = node->prev;
}
// Fill right basins
if(n.next && n.next->next) {
if (n.next && n.next->next) {
double angle = BasinAngle(n);
if(angle < PI_3div4) {
if (angle < PI_3div4) {
FillBasin(tcx, n);
}
}
}
double Sweep::BasinAngle(Node& node) {
double Sweep::BasinAngle(Node& node)
{
double ax = node.point->x - node.next->next->point->x;
double ay = node.point->y - node.next->next->point->y;
return atan2(ay, ax);
@ -269,8 +261,8 @@ double Sweep::BasinAngle(Node& node) {
* @param node - middle node
* @return the angle between 3 front nodes
*/
double Sweep::HoleAngle(Node& node) {
double Sweep::HoleAngle(Node& node)
{
/* Complex plane
* ab = cosA +i*sinA
* 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
*/
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
// violate the Delaunay condition
for(int i=0; i<3; i++) {
if(t.delaunay_edge[i])
for (int i = 0; i < 3; i++) {
if (t.delaunay_edge[i])
continue;
Triangle* ot = t.GetNeighbor(i);
if(ot) {
if (ot) {
Point* p = t.GetPoint(i);
Point* op = ot->OppositePoint(t, *p);
int oi = ot->Index(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// 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];
continue;
}
bool inside = Incircle(*p, *t.PointCCW(*p), *t.PointCW(*p), *op);
if(inside) {
if (inside) {
// Lets mark this shared edge as Delaunay
t.delaunay_edge[i] = 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
bool not_legalized = !Legalize(tcx, t);
if(not_legalized) {
if (not_legalized) {
tcx.MapTriangleToNodes(t);
}
not_legalized = !Legalize(tcx, *ot);
if(not_legalized)
if (not_legalized)
tcx.MapTriangleToNodes(*ot);
// 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
* @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 ady = pa.y - pd.y;
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 oabd = adxbdy - bdxady;
if( oabd <= 0 )
if (oabd <= 0)
return false;
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 ocad = cdxady - adxcdy;
if( ocad <= 0 )
if (ocad <= 0)
return false;
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 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;
}
@ -427,21 +416,21 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd) {
* n4 n4
* </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;
n1 = t.NeighborCCW(p);
n2 = t.NeighborCW(p);
n3 = ot.NeighborCCW(op);
n4 = ot.NeighborCW(op);
bool ce1,ce2,ce3,ce4;
bool ce1, ce2, ce3, ce4;
ce1 = t.GetConstrainedEdgeCCW(p);
ce2 = t.GetConstrainedEdgeCW(p);
ce3 = ot.GetConstrainedEdgeCCW(op);
ce4 = ot.GetConstrainedEdgeCW(op);
bool de1,de2,de3,de4;
bool de1, de2, de3, de4;
de1 = t.GetDelunayEdgeCCW(p);
de2 = t.GetDelunayEdgeCW(p);
de3 = ot.GetDelunayEdgeCCW(op);
@ -469,25 +458,25 @@ void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op) {
// the right side.
t.ClearNeighbors();
ot.ClearNeighbors();
if(n1 != NULL) ot.MarkNeighbor(*n1);
if(n2 != NULL) t.MarkNeighbor(*n2);
if(n3 != NULL) t.MarkNeighbor(*n3);
if(n4 != NULL) ot.MarkNeighbor(*n4);
if (n1 != NULL) ot.MarkNeighbor(*n1);
if (n2 != NULL) t.MarkNeighbor(*n2);
if (n3 != NULL) t.MarkNeighbor(*n3);
if (n4 != NULL) ot.MarkNeighbor(*n4);
t.MarkNeighbor(ot);
}
/**
* Fills a basin that has formed on the Advancing Front to the right
* of given node.<br>
* First we decide a left,bottom and right node that forms the
* boundaries of the basin. Then we do a reqursive fill.
*
* @param tcx
* @param node - starting node, this or next node will be left node
*/
void Sweep::FillBasin(SweepContext& tcx, Node& node) {
if(Orient2d(*node.point, *node.next->point, *node.next->next->point ) == CCW) {
* Fills a basin that has formed on the Advancing Front to the right
* of given node.<br>
* First we decide a left,bottom and right node that forms the
* boundaries of the basin. Then we do a reqursive fill.
*
* @param tcx
* @param node - starting node, this or next node will be left node
*/
void Sweep::FillBasin(SweepContext& tcx, Node& node)
{
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
tcx.basin.left_node = node.next->next;
} else {
tcx.basin.left_node = node.next;
@ -495,21 +484,21 @@ void Sweep::FillBasin(SweepContext& tcx, Node& node) {
// Find the bottom and right 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 = 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
return;
}
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 = 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
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;
FillBasinReq(tcx, *tcx.basin.bottom_node);
}
/**
* Recursive algorithm to fill a Basin with triangles
*
* @param tcx
* @param node - bottom_node
* @param cnt - counter used to alternate on even and odd numbers
*/
void Sweep::FillBasinReq(SweepContext& tcx, Node& node) {
* Recursive algorithm to fill a Basin with triangles
*
* @param tcx
* @param node - bottom_node
* @param cnt - counter used to alternate on even and odd numbers
*/
void Sweep::FillBasinReq(SweepContext& tcx, Node& node)
{
// if shallow stop filling
if(IsShallow(tcx, node)) {
if (IsShallow(tcx, node)) {
return;
}
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;
} else if(node.prev == tcx.basin.left_node) {
Orientation o = Orient2d(*node.point, *node.next->point, *node.next->next->point );
if(o == CW) {
} else if (node.prev == tcx.basin.left_node) {
Orientation o = Orient2d(*node.point, *node.next->point, *node.next->next->point);
if (o == CW) {
return;
}
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);
if(o == CCW) {
if (o == CCW) {
return;
}
node = *node.prev;
} else {
// 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;
} else {
node = *node.next;
@ -561,73 +549,69 @@ void Sweep::FillBasinReq(SweepContext& tcx, Node& node) {
}
FillBasinReq(tcx, node);
}
bool Sweep::IsShallow(SweepContext& tcx, Node& node) {
bool Sweep::IsShallow(SweepContext& tcx, Node& node)
{
double height;
if(tcx.basin.left_highest) {
if (tcx.basin.left_highest) {
height = tcx.basin.left_node->point->y - node.point->y;
} else {
height = tcx.basin.right_node->point->y - node.point->y;
}
// if shallow stop filling
if(tcx.basin.width > height) {
if (tcx.basin.width > height) {
return true;
}
return false;
}
void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
if(tcx.edge_event.right) {
void Sweep::FillEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if (tcx.edge_event.right) {
FillRightAboveEdgeEvent(tcx, edge, node);
} else {
FillLeftAboveEdgeEvent(tcx, edge, node);
}
}
void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
while(node.next->point->x < edge->p->x) {
void Sweep::FillRightAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
while (node.next->point->x < edge->p->x) {
// 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);
} else {
node = *node.next;
}
}
}
void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
if(node.point->x < edge->p->x) {
if(Orient2d(*node.point, *node.next->point, *node.next->next->point ) == CCW ) {
void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if (node.point->x < edge->p->x) {
if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
// Concave
FillRightConcaveEdgeEvent(tcx, edge, node );
} else {
FillRightConcaveEdgeEvent(tcx, edge, node);
} else{
// Convex
FillRightConvexEdgeEvent(tcx, edge, node );
FillRightConvexEdgeEvent(tcx, edge, node);
// 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);
if(node.next->point != edge->p) {
if (node.next->point != edge->p) {
// 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
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
FillRightConcaveEdgeEvent(tcx, edge, node);
} 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?
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
FillRightConcaveEdgeEvent(tcx, edge, *node.next);
} else{
// Convex
// 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
FillRightConvexEdgeEvent(tcx, edge, *node.next);
} else{
// Above
}
}
}
void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
while(node.prev->point->x > edge->p->x) {
void Sweep::FillLeftAboveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
while (node.prev->point->x > edge->p->x) {
// 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);
} else {
node = *node.prev;
}
}
}
void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
if( node.point->x > edge->p->x) {
if(Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW ) {
void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
if (node.point->x > edge->p->x) {
if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
// Concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
} else {
@ -682,66 +663,64 @@ void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
// Retry this one
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?
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
FillLeftConcaveEdgeEvent(tcx, edge, *node.prev);
} else {
} else{
// Convex
// 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
FillLeftConvexEdgeEvent(tcx, edge, *node.prev);
} else {
} else{
// Above
}
}
}
void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node) {
void Sweep::FillLeftConcaveEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
{
Fill(tcx, *node.prev);
if(node.prev->point != edge->p) {
if (node.prev->point != edge->p) {
// 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
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
FillLeftConcaveEdgeEvent(tcx, edge, node);
} else {
} else{
// 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);
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
// With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
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
RotateTrianglePair(t, p, ot, op);
tcx.MapTriangleToNodes(t);
tcx.MapTriangleToNodes(ot);
if( p == eq && op == ep ) {
if(eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) {
if (p == eq && op == ep) {
if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) {
t.MarkConstrainedEdge(&ep, &eq);
ot.MarkConstrainedEdge(&ep, &eq);
Legalize(tcx, t);
@ -751,19 +730,19 @@ void Sweep::FlipEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& t,
}
} else {
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);
}
} else {
Point& newP = NextFlipPoint( ep, eq, ot, op);
Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, &t, p);
}
}
Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op) {
if(o == CCW) {
Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op)
{
if (o == CCW) {
// ot is not crossing edge after flip
int edge_index = ot.EdgeIndex(&p, &op);
ot.delaunay_edge[edge_index] = true;
@ -780,36 +759,35 @@ Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triang
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);
if(o2d == CW) {
if (o2d == CW) {
// Right
return *ot.PointCCW(op);
} else if(o2d == CCW) {
} else if (o2d == CCW) {
// Left
return *ot.PointCW(op);
} else {
} else{
//throw new RuntimeException("[Unsupported] Opposing point on constrained edge");
assert(0);
}
}
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);
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
// With current implementation we should never get here
//throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
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
FlipEdgeEvent(tcx, eq, op, ot, op);
// 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
// Turns out at first glance that this is somewhat complicated
// so it will have to wait.
} else {
} else{
Point& newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, flip_triangle, ot, newP);
}
}

64
poly2tri/sweep/sweep.h
View File

@ -44,71 +44,69 @@ struct Edge;
class Triangle;
class Sweep {
public:
void Triangulate(SweepContext& tcx);
void Triangulate(SweepContext& tcx);
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 FinalizationPolygon(SweepContext& tcx);
void FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle, Triangle& t, Point& p);
void FinalizationPolygon(SweepContext& tcx);
};

83
poly2tri/sweep/sweep_context.cc
View File

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

141
poly2tri/sweep/sweep_context.h
View File

@ -43,52 +43,50 @@ class AdvancingFront;
class SweepContext {
public:
// Constructor
SweepContext(Point** polyline, const int& point_count);
// Destructor
~SweepContext();
// Constructor
SweepContext(Point** polyline, const int& point_count);
// Destructor
~SweepContext();
//void MeshClean(Triangle& triangle);
// Get Advancing Front
//AdvancingFront front();
//void MeshClean(Triangle& triangle);
// Get Advancing Front
//AdvancingFront front();
void set_head(Point* p1);
Point* head();
void set_head(Point* p1);
Point* head();
void set_tail(Point* p1 );
Point* tail();
void set_tail(Point* p1);
Point* tail();
int point_count();
int point_count();
Node& LocateNode(Point& point);
void RemoveNode(Node* node);
Node& LocateNode(Point& point);
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
void MapTriangleToNodes(Triangle& t);
// Try to map a node to all sides of this triangle that don't have a neighbor
void MapTriangleToNodes(Triangle& t);
void AddToMap(Triangle* triangle);
void AddToMap(Triangle* triangle);
Point* GetPoint(const int& index);
Point* GetPoints();
Point* GetPoint(const int& index);
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::list<Triangle*> GetMap();
std::vector<Triangle*> GetTriangles();
std::list<Triangle*> GetMap();
std::vector<Edge*> edge_list;
struct Basin {
std::vector<Edge*> edge_list;
struct Basin {
Node* left_node;
Node* bottom_node;
Node* right_node;
@ -96,69 +94,88 @@ public:
bool left_highest;
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;
bottom_node = NULL;
right_node = NULL;
width = 0.0;
left_highest = false;
}
};
};
struct EdgeEvent {
struct EdgeEvent {
Edge* constrained_edge;
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:
std::vector<Triangle*> triangles_;
std::list<Triangle*> map_;
std::vector<Triangle*> triangles_;
std::list<Triangle*> map_;
Point** points_;
int point_count_;
Point** points_;
int point_count_;
// Advancing front
AdvancingFront* front_;
// head point used with advancing front
Point* head_;
// tail point used with advancing front
Point* tail_;
// Advancing front
AdvancingFront* front_;
// head point used with advancing front
Point* head_;
// tail point used with advancing front
Point* tail_;
//EdgeEvent edgeEvent = new EdgeEvent();
//EdgeEvent edgeEvent = new EdgeEvent();
void InitTriangulation();
void InitEdges(Point** polyline, const int& point_count);
void InitTriangulation();
void InitEdges(Point** polyline, const int& point_count);
//void MeshCleanReq(Triangle& triangle )
//void MeshCleanReq(Triangle& triangle )
/*
/*
class EdgeEvent {
Edge* constrainedEdge;
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
list<Triangle*> map;
double StringToDouble(const std::string& s) {
double StringToDouble(const std::string& s)
{
std::istringstream i(s);
double x;
if (!(i >> x))
@ -68,8 +69,8 @@ double StringToDouble(const std::string& s) {
bool draw_map = true;
int main(int argc, char* argv[]) {
int main(int argc, char* argv[])
{
if (argc != 3) {
cout << "Usage: p2t filename zoom" << endl;
return 1;
@ -91,12 +92,12 @@ int main(int argc, char* argv[]) {
*/
string line;
ifstream myfile (argv[1]);
ifstream myfile(argv[1]);
vector<Point*> points;
if (myfile.is_open()) {
while (!myfile.eof()) {
getline (myfile,line);
if(line.size() == 0) {
getline(myfile, line);
if (line.size() == 0) {
break;
}
istringstream iss(line);
@ -116,7 +117,7 @@ int main(int argc, char* argv[]) {
cout << "Number of points = " << num_points << endl;
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];
}
@ -155,8 +156,7 @@ void Init()
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
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)
@ -172,8 +172,7 @@ void MainLoop(const double zoom)
// this just loops as long as the program runs
bool running = true;
while(running)
{
while (running) {
// calculate time elapsed, and the amount by which stuff rotates
double current_time = glfwGetTime(),
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
// 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)
rotate_y += delta_rotate;
@ -191,7 +190,7 @@ void MainLoop(const double zoom)
rotate_z += delta_rotate;
// Draw the scene
if(draw_map) {
if (draw_map) {
DrawMap(zoom);
} else {
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 right = width / zoom;
double bottom = -height / zoom;
@ -223,18 +222,16 @@ void ResetZoom(double zoom, double cx, double cy, double width, double height) {
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT);
}
void Draw(const double zoom) {
void Draw(const double zoom)
{
// reset zoom
Point center = Point(0, 0);
ResetZoom(zoom, center.x, center.y, 800, 600);
for (int i = 0; i < triangles.size(); i++) {
Triangle& t = *triangles[i];
Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1);
@ -248,13 +245,11 @@ void Draw(const double zoom) {
glVertex2f(b.x, b.y);
glVertex2f(c.x, c.y);
glEnd();
}
}
void DrawMap(const double zoom) {
void DrawMap(const double zoom)
{
// reset zoom
Point center = Point(0, 0);
@ -262,7 +257,6 @@ void DrawMap(const double zoom) {
list<Triangle*>::iterator it;
for (it = map.begin(); it != map.end(); it++) {
Triangle& t = **it;
Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1);
@ -285,13 +279,12 @@ void DrawMap(const double zoom) {
glVertex2f(c.x, c.y);
glVertex2f(a.x, a.y);
glEnd( );
}
}
void ConstrainedColor(bool constrain) {
if(constrain) {
void ConstrainedColor(bool constrain)
{
if (constrain) {
// Green
glColor3f(0, 1, 0);
} else {