m_mesh.h

#ifndef M_GEOMETRY_H
#define M_GEOMETRY_H

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cmath>

#include <QtCore/qmath.h>
#include <QVector3D>
#include <QVector>
#include <QFile>
#include <QTextStream>
#include <QMap>
#include <QQueue>
#include <QList>

#include <GL/gl.h>
//#include <GL/glut.h>

#include "predicate.h"
#include "it_faceiterator.h"
#include "it_vertexcirculator.h"
#include "it_convexhullcirculator.h"

/*
 * TODO
 * - les plusieurs passes de crust pour sauvegarder plusieurs éventuels contours
 * - repérer les circulateurs, manque un passage, cf begin() et end()?
 *     - remplacer tout ce qui est getFacesContainingPoint par un circulateur de sommets
 *
 */

class g_Point : public QVector3D {

public:
    g_Point() : QVector3D() {}
    g_Point(const float &_x, const float &_y, const float &_z) : QVector3D(_x, _y, _z) {}
    friend std::ostream& operator<< (std::ostream& os, const g_Point &p) {
        os << "[" << p.x() << ", " << p.y() << ", " << p.z() << "]";
        return os;
    }
};

// Forward declaration of iterator
class FaceIterator;
// Forward declaration of circulator
class ConvexHullCirculator;
// Forward declaration of circulator
class VertexCirculator;

class Mesh {
    
public:
    typedef Mesh Self;
    typedef QVector<int> g_Face;
    typedef QVector<int> t_Face;
    typedef QVector<int> g_Edge;

    friend class FaceIterator;
    FaceIterator fbegin();
    FaceIterator fend();

    friend class VertexCirculator;
    VertexCirculator vcbegin(int v);
    VertexCirculator vcend(int v);

    friend class ConvexHullCirculator;
    ConvexHullCirculator chbegin();
    ConvexHullCirculator chend();

    Mesh();
    void clear();

    void load_off(const QString &filename);
    bool load_tri(const QString &filename);
    bool load_ctri(const QString &filename);
    void save_off(const QString &name);


    void draw();

    void show();
    void swapDisplayCrust() { b_crusted = !b_crusted; }
    void swapDisplayCircles() { b_circles = !b_circles; }
    void swapAddVertexMode() { b_add_vertex_mode = !b_add_vertex_mode; }
    bool getAddVertexMode() { return b_add_vertex_mode; }


    // GEOMETRY -> m_geometry.cpp
    bool contains(int triangle, const QVector3D &point);
    bool contains(int triangle, int point);
    QVector<FaceIterator> getFacesContainingPoint(int ind);
    int add_voronoi_centers();
    g_Point center_of_gravity(const g_Point &a, const g_Point &b, const g_Point &c);
    g_Point center_of_gravity(const g_Face &f);
    g_Point center_of_circumscribed_circle(const g_Face & f, float &r);
    g_Point center_of_circumscribed_circle(const g_Face & f);
    g_Point center_of_circumscribed_circle(const g_Point & a, const g_Point & b, const g_Point & c, float &r);
    g_Point center_of_circumscribed_circle(const g_Point & a, const g_Point & b, const g_Point & c);
    float radius_of_circumscribed_circle(const g_Face & f);


    // TOPOLOGY -> m_topology.cpp
    void make_topology();
    g_Edge getCommonEdge(const FaceIterator &f1, const FaceIterator &f2);
    bool need_flip(const FaceIterator &f1, const FaceIterator &f2);
    void flip(const FaceIterator &f1, const FaceIterator &f2);
    int the_walking_face(const QVector3D &v);
    bool isInfiniteFace(const int &i);
    bool isInfiniteFace(const g_Face &f);
    QVector<int>getNeighborVertices(const FaceIterator &f);
    void Crust();
    void Lawson();


    // NAIVE TRIANGULATION -> m_topology_naive.cpp
    void triangulation_naive();
    void add_vertex_naive(const g_Point &v);
    void add_vertex_naive(const int &ind_vertex);
    void add_point_in_face_naive(const int &v, const int &f);


    // INCREMENTAL TRIANGULATION -> m_topology_inc.cpp
    void triangulation_delaunay();
    void add_vertex_inc(const g_Point &v);
    void add_vertex_inc(const int &ind_vertex);
    void add_point_in_face_inc(const int &v, const int &f);
    void full_flip(const QVector<QVector<FaceIterator>> & to_flip);


    // CONSTRAINED TRIANGULATION -> m_topology_con.cpp
    void setConstrainedTriangulation();
    void refine();
    void Ruppert();
    void splitSeg(const g_Edge &edge);
    bool isConstrainedEdge(const g_Edge &e);
    bool isConstrainedEdge(const FaceIterator &f1, const FaceIterator &f2);
    void removeConstrainedEdge(const g_Edge &e);
    bool isWellFormed(const g_Face &f, const float &angle = 20);

    QVector<g_Point> getVertices() { return vertices; }
    QVector<g_Face> getFaces() { return faces; }

protected:
    QVector<g_Point> vertices;
    QVector<g_Face> faces;
    QVector<t_Face> topology;
    
    QVector<g_Point> voronoi_center;
    QVector<QVector<int>> crust_lines;
    QVector<QVector<int>> crust_border;
    QVector<QVector<int>> constrained_edges;

    bool b_crusted;
    bool b_circles;
    bool b_constrained;
    bool b_add_vertex_mode;
};

#endif