poly2tri/testbed/main.cc

461 lines
12 KiB
C++
Raw Normal View History

2010-04-25 18:40:54 +02:00
/*
2010-01-22 21:03:43 +01:00
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
2010-01-17 17:41:09 +01:00
* http://code.google.com/p/poly2tri/
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Poly2Tri nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <cstdlib>
#include <GL/glfw.h>
#include <time.h>
#include <fstream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
#include <iostream>
using namespace std;
#include "../poly2tri/poly2tri.h"
2010-01-23 01:50:35 +01:00
using namespace p2t;
2010-01-17 17:41:09 +01:00
void Init();
void ShutDown(int return_code);
2010-01-19 23:23:38 +01:00
void MainLoop(const double zoom);
void Draw(const double zoom);
2010-01-20 18:25:10 +01:00
void DrawMap(const double zoom);
2010-01-20 18:10:58 +01:00
void ConstrainedColor(bool constrain);
2010-01-23 04:18:36 +01:00
double StringToDouble(const std::string& s);
2010-02-08 00:58:36 +01:00
double Random(double (*fun)(double), double xmin, double xmax);
double Fun(double x);
2010-01-23 04:18:36 +01:00
/// Dude hole examples
2010-01-23 03:52:44 +01:00
vector<Point*> CreateHeadHole();
2010-01-23 04:18:36 +01:00
vector<Point*> CreateChestHole();
2010-01-20 18:10:58 +01:00
2010-01-17 17:41:09 +01:00
float rotate_y = 0,
rotate_z = 0;
const float rotations_per_tick = .2;
2010-01-22 20:52:28 +01:00
/// Screen center x
double cx = 0.0;
/// Screen center y
double cy = 0.0;
2010-01-20 18:25:10 +01:00
/// Constrained triangles
2010-01-20 18:10:58 +01:00
vector<Triangle*> triangles;
2010-01-20 18:25:10 +01:00
/// Triangle map
list<Triangle*> map;
2010-01-23 04:18:36 +01:00
/// Polylines
vector< vector<Point*> > polylines;
2010-01-17 17:41:09 +01:00
2010-01-23 04:18:36 +01:00
/// Draw the entire triangle map?
2010-01-22 20:52:28 +01:00
bool draw_map = false;
/// Create a random distribution of points?
bool random_distribution = false;
2010-01-20 18:25:10 +01:00
template <class C> void FreeClear( C & cntr ) {
for ( typename C::iterator it = cntr.begin();
it != cntr.end(); ++it ) {
delete * it;
}
cntr.clear();
}
2010-01-21 15:00:09 +01:00
int main(int argc, char* argv[])
{
2010-04-25 18:40:54 +02:00
2010-02-08 00:58:36 +01:00
int num_points = 0;
double max, min;
double zoom;
2010-04-25 18:40:54 +02:00
2010-01-22 20:52:28 +01:00
if (argc != 5) {
cout << "-== USAGE ==-" << endl;
cout << "Load Data File: p2t filename center_x center_y zoom" << endl;
cout << " Random Points: p2t random num_points width zoom" << endl;
2010-01-19 23:23:38 +01:00
return 1;
}
2010-04-25 18:40:54 +02:00
if(string(argv[1]) == "random") {
num_points = atoi(argv[2]);
random_distribution = true;
2010-02-08 00:58:36 +01:00
char* pEnd;
max = strtod(argv[3], &pEnd);
min = -max;
cx = cy = 0;
zoom = atof(argv[4]);
} else {
zoom = atof(argv[4]);
cx = atof(argv[2]);
cy = atof(argv[3]);
2010-04-25 18:40:54 +02:00
}
vector<p2t::Point*> polyline;
2010-04-25 18:40:54 +02:00
if(random_distribution) {
// Create a simple bounding box
polyline.push_back(new Point(min,min));
polyline.push_back(new Point(min,max));
polyline.push_back(new Point(max,max));
polyline.push_back(new Point(max,min));
} else {
// Load pointset from file
2010-04-25 18:40:54 +02:00
// Parse and tokenize data file
string line;
ifstream myfile(argv[1]);
if (myfile.is_open()) {
while (!myfile.eof()) {
getline(myfile, line);
if (line.size() == 0) {
break;
}
istringstream iss(line);
vector<string> tokens;
copy(istream_iterator<string>(iss), istream_iterator<string>(),
back_inserter<vector<string> >(tokens));
double x = StringToDouble(tokens[0]);
double y = StringToDouble(tokens[1]);
polyline.push_back(new Point(x, y));
num_points++;
2010-01-17 17:41:09 +01:00
}
myfile.close();
} else {
cout << "File not opened" << endl;
2010-01-17 17:41:09 +01:00
}
}
2010-01-21 15:00:09 +01:00
cout << "Number of constrained edges = " << polyline.size() << endl;
polylines.push_back(polyline);
2010-04-25 18:40:54 +02:00
2010-01-17 17:41:09 +01:00
Init();
2010-01-21 15:00:09 +01:00
2010-04-25 18:40:54 +02:00
/*
* Perform triangulation!
2010-04-25 18:40:54 +02:00
*/
2010-01-17 17:41:09 +01:00
double init_time = glfwGetTime();
2010-04-25 18:40:54 +02:00
/*
* STEP 1: Create CDT and add primary polyline
* NOTE: polyline must be a simple polygon. The polyline's points
2010-02-10 13:52:12 +01:00
* constitute constrained edges. No repeat points!!!
2010-04-25 18:40:54 +02:00
*/
CDT* cdt = new CDT(polyline);
2010-04-25 18:40:54 +02:00
2010-01-30 19:10:18 +01:00
/*
* STEP 2: Add holes or Steiner points if necessary
2010-04-25 18:40:54 +02:00
*/
2010-01-23 04:18:36 +01:00
string s(argv[1]);
if(s.find("dude.dat", 0) != string::npos) {
// Add head hole
vector<Point*> head_hole = CreateHeadHole();
num_points += head_hole.size();
2010-01-23 04:18:36 +01:00
cdt->AddHole(head_hole);
// Add chest hole
vector<Point*> chest_hole = CreateChestHole();
num_points += chest_hole.size();
2010-01-23 04:18:36 +01:00
cdt->AddHole(chest_hole);
polylines.push_back(head_hole);
polylines.push_back(chest_hole);
} else if (random_distribution) {
2010-02-08 00:58:36 +01:00
max-=(1e-4);
min+=(1e-4);
for(int i = 0; i < num_points; i++) {
2010-02-08 00:58:36 +01:00
double x = Random(Fun, min, max);
double y = Random(Fun, min, max);
cdt->AddPoint(new Point(x, y));
}
2010-01-23 03:52:44 +01:00
}
2010-04-25 18:40:54 +02:00
/*
* STEP 3: Triangulate!
*/
2010-01-17 17:41:09 +01:00
cdt->Triangulate();
2010-04-25 18:40:54 +02:00
2010-01-17 17:41:09 +01:00
double dt = glfwGetTime() - init_time;
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
triangles = cdt->GetTriangles();
2010-01-20 18:25:10 +01:00
map = cdt->GetMap();
2010-01-21 15:00:09 +01:00
cout << "Number of points = " << num_points << endl;
cout << "Number of triangles = " << triangles.size() << endl;
cout << "Elapsed time (ms) = " << dt*1000.0 << endl;
2010-01-21 15:00:09 +01:00
2010-04-25 18:40:54 +02:00
MainLoop(zoom);
// Cleanup
2010-04-25 18:40:54 +02:00
delete cdt;
// Free points
for(int i = 0; i < polylines.size(); i++) {
vector<Point*> poly = polylines[i];
FreeClear(poly);
}
2010-01-17 17:41:09 +01:00
ShutDown(0);
return 0;
}
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
void Init()
{
const int window_width = 800,
window_height = 600;
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
if (glfwInit() != GL_TRUE)
ShutDown(1);
// 800 x 600, 16 bit color, no depth, alpha or stencil buffers, windowed
if (glfwOpenWindow(window_width, window_height, 5, 6, 5, 0, 0, 0, GLFW_WINDOW) != GL_TRUE)
2010-01-21 15:00:09 +01:00
ShutDown(1);
2010-01-20 21:36:05 +01:00
glfwSetWindowTitle("Poly2Tri - C++");
2010-01-30 19:10:18 +01:00
glfwSwapInterval(1);
2010-04-25 18:40:54 +02:00
2010-01-17 17:41:09 +01:00
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.0, 0.0, 0.0);
2010-01-21 15:00:09 +01:00
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
2010-01-17 17:41:09 +01:00
}
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
void ShutDown(int return_code)
{
glfwTerminate();
exit(return_code);
}
2010-01-21 15:00:09 +01:00
2010-01-19 23:23:38 +01:00
void MainLoop(const double zoom)
2010-01-17 17:41:09 +01:00
{
// the time of the previous frame
double old_time = glfwGetTime();
// this just loops as long as the program runs
bool running = true;
2010-01-21 15:00:09 +01:00
while (running) {
2010-01-17 17:41:09 +01:00
// calculate time elapsed, and the amount by which stuff rotates
double current_time = glfwGetTime(),
2010-01-21 15:00:09 +01:00
delta_rotate = (current_time - old_time) * rotations_per_tick * 360;
2010-01-17 17:41:09 +01:00
old_time = current_time;
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
// escape to quit, arrow keys to rotate view
// Check if ESC key was pressed or window was closed
2010-01-21 15:00:09 +01:00
running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
2010-01-17 17:41:09 +01:00
if (glfwGetKey(GLFW_KEY_LEFT) == GLFW_PRESS)
rotate_y += delta_rotate;
if (glfwGetKey(GLFW_KEY_RIGHT) == GLFW_PRESS)
rotate_y -= delta_rotate;
// z axis always rotates
rotate_z += delta_rotate;
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
// Draw the scene
2010-01-21 15:00:09 +01:00
if (draw_map) {
2010-01-20 18:25:10 +01:00
DrawMap(zoom);
} else {
Draw(zoom);
}
2010-01-21 15:00:09 +01:00
2010-01-17 17:41:09 +01:00
// swap back and front buffers
glfwSwapBuffers();
}
}
2010-01-21 15:00:09 +01:00
void ResetZoom(double zoom, double cx, double cy, double width, double height)
{
double left = -width / zoom;
double right = width / zoom;
double bottom = -height / zoom;
double top = height / zoom;
// Reset viewport
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Reset ortho view
glOrtho(left, right, bottom, top, 1, -1);
glTranslatef(-cx, -cy, 0);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_DEPTH_TEST);
glLoadIdentity();
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT);
2010-01-17 17:41:09 +01:00
}
2010-01-20 18:25:10 +01:00
2010-01-21 15:00:09 +01:00
void Draw(const double zoom)
{
2010-01-17 17:41:09 +01:00
// reset zoom
2010-01-22 20:52:28 +01:00
Point center = Point(cx, cy);
2010-01-21 15:00:09 +01:00
2010-01-19 23:23:38 +01:00
ResetZoom(zoom, center.x, center.y, 800, 600);
2010-01-21 15:00:09 +01:00
2010-01-20 18:10:58 +01:00
for (int i = 0; i < triangles.size(); i++) {
Triangle& t = *triangles[i];
Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1);
Point& c = *t.GetPoint(2);
2010-01-21 15:00:09 +01:00
2010-01-20 21:36:05 +01:00
// Red
glColor3f(1, 0, 0);
2010-01-20 18:10:58 +01:00
2010-01-21 15:00:09 +01:00
glBegin(GL_LINE_LOOP);
glVertex2f(a.x, a.y);
glVertex2f(b.x, b.y);
glVertex2f(c.x, c.y);
glEnd();
2010-01-20 18:10:58 +01:00
}
2010-04-25 18:40:54 +02:00
2010-01-23 04:18:36 +01:00
// green
glColor3f(0, 1, 0);
2010-04-25 18:40:54 +02:00
2010-01-23 04:18:36 +01:00
for(int i = 0; i < polylines.size(); i++) {
vector<Point*> poly = polylines[i];
glBegin(GL_LINE_LOOP);
for(int j = 0; j < poly.size(); j++) {
glVertex2f(poly[j]->x, poly[j]->y);
}
glEnd();
}
2010-01-20 18:10:58 +01:00
}
2010-01-21 15:00:09 +01:00
void DrawMap(const double zoom)
{
2010-01-20 18:25:10 +01:00
// reset zoom
2010-01-22 20:52:28 +01:00
Point center = Point(cx, cy);
2010-01-21 15:00:09 +01:00
2010-01-20 18:25:10 +01:00
ResetZoom(zoom, center.x, center.y, 800, 600);
2010-01-21 15:00:09 +01:00
list<Triangle*>::iterator it;
2010-01-20 18:25:10 +01:00
for (it = map.begin(); it != map.end(); it++) {
Triangle& t = **it;
Point& a = *t.GetPoint(0);
Point& b = *t.GetPoint(1);
Point& c = *t.GetPoint(2);
2010-01-21 15:00:09 +01:00
ConstrainedColor(t.constrained_edge[2]);
glBegin(GL_LINES);
glVertex2f(a.x, a.y);
glVertex2f(b.x, b.y);
2010-01-20 21:36:05 +01:00
glEnd( );
2010-01-21 15:00:09 +01:00
ConstrainedColor(t.constrained_edge[0]);
2010-01-20 21:36:05 +01:00
glBegin(GL_LINES);
2010-01-21 15:00:09 +01:00
glVertex2f(b.x, b.y);
glVertex2f(c.x, c.y);
2010-01-20 21:36:05 +01:00
glEnd( );
2010-01-21 15:00:09 +01:00
ConstrainedColor(t.constrained_edge[1]);
2010-01-20 21:36:05 +01:00
glBegin(GL_LINES);
2010-01-21 15:00:09 +01:00
glVertex2f(c.x, c.y);
glVertex2f(a.x, a.y);
2010-01-20 21:36:05 +01:00
glEnd( );
2010-01-20 18:25:10 +01:00
}
}
2010-01-21 15:00:09 +01:00
void ConstrainedColor(bool constrain)
{
if (constrain) {
2010-01-20 18:10:58 +01:00
// Green
glColor3f(0, 1, 0);
} else {
2010-01-17 17:41:09 +01:00
// Red
glColor3f(1, 0, 0);
}
}
2010-01-23 03:52:44 +01:00
vector<Point*> CreateHeadHole() {
vector<Point*> head_hole;
head_hole.push_back(new Point(325, 437));
head_hole.push_back(new Point(320, 423));
head_hole.push_back(new Point(329, 413));
head_hole.push_back(new Point(332, 423));
2010-04-25 18:40:54 +02:00
2010-01-23 03:52:44 +01:00
return head_hole;
2010-01-23 04:18:36 +01:00
}
vector<Point*> CreateChestHole() {
vector<Point*> chest_hole;
chest_hole.push_back(new Point(320.72342,480));
chest_hole.push_back(new Point(338.90617,465.96863));
chest_hole.push_back(new Point(347.99754,480.61584));
chest_hole.push_back(new Point(329.8148,510.41534));
chest_hole.push_back(new Point(339.91632,480.11077));
chest_hole.push_back(new Point(334.86556,478.09046));
2010-04-25 18:40:54 +02:00
2010-01-23 04:18:36 +01:00
return chest_hole;
2010-01-23 03:52:44 +01:00
}
2010-01-23 04:18:36 +01:00
double StringToDouble(const std::string& s)
{
std::istringstream i(s);
double x;
if (!(i >> x))
return 0;
return x;
}
2010-02-08 00:58:36 +01:00
double Fun(double x)
{
return 2.5 + sin(10 * x) / x;
}
double Random(double (*fun)(double), double xmin = 0, double xmax = 1)
{
static double (*Fun)(double) = NULL, YMin, YMax;
static bool First = true;
// Initialises random generator for first call
if (First)
{
First = false;
srand((unsigned) time(NULL));
}
// Evaluates maximum of function
if (fun != Fun)
{
Fun = fun;
YMin = 0, YMax = Fun(xmin);
for (int iX = 1; iX < RAND_MAX; iX++)
{
double X = xmin + (xmax - xmin) * iX / RAND_MAX;
double Y = Fun(X);
YMax = Y > YMax ? Y : YMax;
}
}
// Gets random values for X & Y
double X = xmin + (xmax - xmin) * rand() / RAND_MAX;
double Y = YMin + (YMax - YMin) * rand() / RAND_MAX;
// Returns if valid and try again if not valid
return Y < fun(X) ? X : Random(Fun, xmin, xmax);
}