TriangleMesh* DebugGeometryBuilder::createArrow( float size, const Vector& start, const Vector& end )
{
Vector dir;
dir.setSub( end, start );
dir.normalize();
Vector perpVec1, perpVec2;
VectorUtil::calculatePerpendicularVector( dir, perpVec1 );
perpVec1.normalize();
perpVec2.setCross( dir, perpVec1 );
FastFloat simdSize; simdSize.setFromFloat( size );
perpVec1.mul( simdSize );
perpVec2.mul( simdSize );
// the line
std::vector<LitVertex> vertices;
std::vector<Face> faces;
addCuboid( simdSize, start, end, vertices, faces );
// the cone tip
FastFloat tipSize; tipSize.setFromFloat( 1.3f * size );
Vector tipEnd;
tipEnd.setMulAdd( dir, tipSize, end );
addCone( tipSize, end, tipEnd, vertices, faces );
TriangleMesh* mesh = new TriangleMesh( FilePath(), vertices, faces );
return mesh;
}
void convexHull3 (Points &points, vector<int> &hull)
{
if (points.size() < 4) {
return;
}
Arrangement arr;
// add vertices
for (int i = 0; i < points.size(); ++i) {
Vertex *v = arr.addVertex(points[i]);
v->id = vertex_id++;
}
init(arr);
// Compute a random permutation p5, p6, . . . , pn of the remaining points.
int n = points.size() - 4;
int *p = new int [n];
randomPermutation (n, p);
for (int i = 4; i < arr.vertices.size(); ++i) {
int r = p[i - 4] + 4;
// Fconflict(Pr) is empty (that is, Pr lies inside C), nothing changes.
if (arr.vertices[r]->visibleFaces.size() == 0) continue;
// Compute the horizon
Edges horizon;
findHorizon(arr, arr.vertices[r], horizon);
// list up all the vertices that have to be tested for the conflict graph
Vertices vertices;
listUpdateVertices(arr, arr.vertices[r], horizon, vertices);
// delete all the visible faces and edges except the horizon
deleteVisibleCone(arr, arr.vertices[r]);
// add all the outgoing edges from Pr, and all the new faces
addCone(arr, arr.vertices[r], horizon, vertices);
}
// build the return values
buildHull(arr, hull);
// debug
std::ofstream ofs("test.vtk");
outputVTK(points, hull, ofs);
}
void NGLScene::keyPressEvent(QKeyEvent *_event)
{
// this method is called every time the main window recives a key event.
// we then switch on the key value and set the camera in the NGLScene
switch (_event->key())
{
// escape key to quite
case Qt::Key_Escape : QGuiApplication::exit(EXIT_SUCCESS); break;
// turn on wirframe rendering
case Qt::Key_W : glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); break;
// turn off wire frame
case Qt::Key_S : glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); break;
// show full screen
case Qt::Key_F : showFullScreen(); break;
// show windowed
case Qt::Key_N : showNormal(); break;
case Qt::Key_Space : m_car->reset(); break;
case Qt::Key_X : stepAnimation(); break;
case Qt::Key_1 : addCube(); break;
case Qt::Key_2 : addSphere(); break;
case Qt::Key_3 : addCapsule(); break;
case Qt::Key_4 : addCylinder(); break;
case Qt::Key_5 : addCone(); break;
case Qt::Key_6 : addMesh(TEAPOT); break;
case Qt::Key_7 : addMesh(APPLE); break;
/* case Qt::Key_Left : m_physics->addImpulse(ngl::Vec3(-5,0.0f,0.0f)); break;
case Qt::Key_Right : m_physics->addImpulse(ngl::Vec3(5.0f,0.0f,0.0f)); break;
case Qt::Key_Up : m_physics->addImpulse(ngl::Vec3(0.0f,5.0f,0.0f)); break;
case Qt::Key_Down : m_physics->addImpulse(ngl::Vec3(0.0f,-5.0f,0.0f)); break;
*/
case Qt::Key_Left : m_car->left(); break;
case Qt::Key_Right : m_car->right(); break;
case Qt::Key_Up : m_car->accelerate(); break;
case Qt::Key_Down : m_car->stop(); break;
case Qt::Key_B : toggleBBox(); break;
case Qt::Key_R : toggleRandomPlace(); break;
case Qt::Key_0 : resetSim(); break;
default : break;
}
// finally update the GLWindow and re-draw
//if (isExposed())
renderNow();
}
/**
* Delaunay triangulation using the same algorithm as convexHull3.
*/
void triangulate (Points2D &points2D, vector<int> &triangles)
{
if (points2D.size() < 4) {
triangles.push_back(0);
triangles.push_back(1);
triangles.push_back(2);
return;
}
Arrangement arr;
// arrange the 3D points
Points points;
for (int i = 0; i < points2D.size(); ++i) {
double x = points2D[i]->getP().getX().mid();
double y = points2D[i]->getP().getY().mid();
double z = x * x + y * y;
points.push_back(new InputPoint(x * 2, y * 2, z));
}
// add vertices
for (int i = 0; i < points.size(); ++i) {
Vertex *v = arr.addVertex(points[i]);
v->id = vertex_id++;
}
init(arr);
// Compute a random permutation p5, p6, . . . , pn of the remaining points.
int n = points.size() - 4;
int *p = new int [n];
randomPermutation (n, p);
for (int i = 4; i < arr.vertices.size(); ++i) {
int r = p[i - 4] + 4;
// Fconflict(Pr) is empty (that is, Pr lies inside C), nothing changes.
if (arr.vertices[r]->visibleFaces.size() == 0) continue;
// compute the horizon
Edges horizon;
findHorizon(arr, arr.vertices[r], horizon);
// list up all the vertices that have to be tested for the conflict graph
Vertices vertices;
listUpdateVertices(arr, arr.vertices[r], horizon, vertices);
// delete all the visible faces and edges except the horizon
deleteVisibleCone(arr, arr.vertices[r]);
// add all the outgoing edges from Pr, and all the new faces
addCone(arr, arr.vertices[r], horizon, vertices);
}
// list up all the faces that are visible from (0, 0, -oo)
for (Faces::iterator f = arr.faces.begin(); f != arr.faces.end(); ++f) {
Vertex *v0 = (*f)->edge->tail;
Vertex *v1 = (*f)->edge->twin->next->tail;
Vertex *v2 = (*f)->edge->twin->next->twin->next->tail;
// if it is not visible, then skip it.
PV3 u = v1->p->getP() - v0->p->getP();
PV3 v = v2->p->getP() - v0->p->getP();
PV3 w(0, 0, -1);
if (w.tripleProduct(u, v).sign() <= 0) continue;
// if it is visible, then copy the indices to the result.
// Note that since the triangle is in counter-clockwise order viewed from the bottom,
// we have to reverse the order to get the counter-clockwise order viewed from the top.
triangles.push_back(v0->id);
triangles.push_back(v2->id);
triangles.push_back(v1->id);
}
}
