MeshSimplification.h

// MeshSimplification.h:
// ---------
//

#ifndef __IPSDKGEOMETRY_MESHSIMPLIFICATION_H__
#define __IPSDKGEOMETRY_MESHSIMPLIFICATION_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Mesh3d<T>::_mesh3dType': class 'ipsdk::geom::eMesh3dType' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Mesh3d<T>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3d.h>
#include <IPSDKGeometry/Entity/3d/Mesh/SymmetricMatrix.h>

namespace ipsdk {
namespace geom {



template <typename T>
class IPSDKGEOMETRY_API MeshSimplification
{


public:
    MeshSimplification();
    ~MeshSimplification();

    // Types
    typedef ipUInt64* FaceData;

    typedef FaceData* FaceDataArray;

    typedef ipReal64* VertexData;

    typedef VertexData* VertexDataArray;


// Structures
protected:
            
    struct vector3
    {
        double x, y, z;
    };

    struct vec3f
    {
        double x, y, z;

        inline vec3f(void) {}

        //inline vec3f operator =( vector3 a )
        // { vec3f b ; b.x = a.x; b.y = a.y; b.z = a.z; return b;}

        inline vec3f(vector3 a)
        {
            x = a.x; y = a.y; z = a.z;
        }

        inline vec3f(const double X, const double Y, const double Z)
        {
            x = X; y = Y; z = Z;
        }

        inline vec3f operator + (const vec3f& a) const
        {
            return vec3f(x + a.x, y + a.y, z + a.z);
        }

        inline vec3f operator += (const vec3f& a) const
        {
            return vec3f(x + a.x, y + a.y, z + a.z);
        }

        inline vec3f operator * (const double a) const
        {
            return vec3f(x * a, y * a, z * a);
        }

        inline vec3f operator * (const vec3f a) const
        {
            return vec3f(x * a.x, y * a.y, z * a.z);
        }

        inline vec3f v3() const
        {
            return vec3f(x, y, z);
        }

        inline vec3f operator = (const vector3 a)
        {
            x = a.x; y = a.y; z = a.z; return *this;
        }

        inline vec3f operator = (const vec3f a)
        {
            x = a.x; y = a.y; z = a.z; return *this;
        }

        inline vec3f operator / (const vec3f a) const
        {
            return vec3f(x / a.x, y / a.y, z / a.z);
        }

        inline vec3f operator - (const vec3f& a) const
        {
            return vec3f(x - a.x, y - a.y, z - a.z);
        }

        inline vec3f operator / (const double a) const
        {
            return vec3f(x / a, y / a, z / a);
        }

        inline double dot(const vec3f& a) const
        {
            return a.x * x + a.y * y + a.z * z;
        }

        inline vec3f cross(const vec3f& a, const vec3f& b)
        {
            x = a.y * b.z - a.z * b.y;
            y = a.z * b.x - a.x * b.z;
            z = a.x * b.y - a.y * b.x;
            return *this;
        }

        inline double angle(const vec3f& v)
        {
            vec3f a = v, b = *this;
            double dot = v.x * x + v.y * y + v.z * z;
            double len = a.length() * b.length();
            if (len == 0)len = 0.00001f;
            double input = dot / len;
            if (input < -1) input = -1;
            if (input > 1) input = 1;
            return (double)acos(input);
        }

        inline double angle2(const vec3f& v, const vec3f& w)
        {
            vec3f a = v, b = *this;
            double dot = a.x * b.x + a.y * b.y + a.z * b.z;
            double len = a.length() * b.length();
            if (len == 0)len = 1;

            vec3f plane; plane.cross(b, w);

            if (plane.x * a.x + plane.y * a.y + plane.z * a.z > 0)
                return (double)-acos(dot / len);

            return (double)acos(dot / len);
        }

        inline vec3f rot_x(double a)
        {
            double yy = cos(a) * y + sin(a) * z;
            double zz = cos(a) * z - sin(a) * y;
            y = yy; z = zz;
            return *this;
        }
        inline vec3f rot_y(double a)
        {
            double xx = cos(-a) * x + sin(-a) * z;
            double zz = cos(-a) * z - sin(-a) * x;
            x = xx; z = zz;
            return *this;
        }
        inline void clamp(double min, double max)
        {
            if (x < min) x = min;
            if (y < min) y = min;
            if (z < min) z = min;
            if (x > max) x = max;
            if (y > max) y = max;
            if (z > max) z = max;
        }
        inline vec3f rot_z(double a)
        {
            double yy = cos(a) * y + sin(a) * x;
            double xx = cos(a) * x - sin(a) * y;
            y = yy; x = xx;
            return *this;
        }
        inline vec3f invert()
        {
            x = -x; y = -y; z = -z; return *this;
        }
        inline vec3f frac()
        {
            return vec3f(
                x - double(int(x)),
                y - double(int(y)),
                z - double(int(z))
            );
        }

        inline vec3f integer()
        {
            return vec3f(
                double(int(x)),
                double(int(y)),
                double(int(z))
            );
        }

        inline double length() const
        {
            return (double)sqrt(x * x + y * y + z * z);
        }

        inline vec3f normalize(double desired_length = 1)
        {
            double square = sqrt(x * x + y * y + z * z);

            x /= square; y /= square; z /= square;

            return *this;
        }

        //static vec3f normalize(vec3f a);

        //static vec3f random();

        //static void random_init();

        //static double random_double();

        //static int random_number;

        double random_double_01(double a) {
            double rnf = a * 14.434252 + a * 364.2343 + a * 4213.45352 + a * 2341.43255 + a * 254341.43535 + a * 223454341.3523534245 + 23453.423412;
            int rni = ((int)rnf) % 100000;
            return double(rni) / (100000.0f - 1.0f);
        }

        vec3f random01_fxyz() {
            x = (double)random_double_01(x);
            y = (double)random_double_01(y);
            z = (double)random_double_01(z);
            return *this;
        }
    };


    struct Triangle {

        ipUInt32                                    _v[3];           //Triangle indices

        ipReal64                                    _err[4];         //Edge error and triangle vertices errors

        ipUInt32                                    _deleted;

        ipUInt32                                    _dirty;          //An edge is marked dirty if one of his neighbors edge is collapsed,
                                                                     //And put in a queue to be processed when at the top of the queue.       
        
        vec3f                                       _n;              //Face normal
    };

    struct Vertex {

        vec3f                                       _p;

        ipUInt64                                    _tstart;        

        ipUInt64                                    _tcount;        //Number of neighbouring triangles to the vertex

        SymmetricMatrix                             _q;             //Quadric matrix error

        ipUInt64                                    _border;
    };

    struct Ref {

        ipUInt64                                    _tid;           //index of triangle

        ipUInt64                                    _tvertex;       //index of one of the bounding vertices of the triangle
    };


// methods
protected:

    ipReal64                min(const ipReal64 v1,
                                const ipReal64 v2);

    void                    simplification(const ipUInt64 target_count,
                                           const ipReal64 agressiveness = 7, 
                                           const ipBool bVerbose = false);

    const ipBool            flipped(const vec3f& p,
                                    const ipUInt32 i0,
                                    const ipUInt32 i1,
                                    const Vertex& v0,
                                    const Vertex& v1,
                                    std::vector<ipUInt32>& deleted);

    void                    update_triangles(const ipUInt32 i0,
                                             const Vertex& v,
                                             const std::vector<ipUInt32>& deleted,
                                             ipUInt32& deleted_triangles);

    void                    update_mesh(const ipUInt32 iteration);

    void                    compact_data();

    void                    compact_mesh(Mesh3d<T>& mesh);

    void                    compact_arrays(const ipReal32* pVertexArray,
                                           const ipUInt32* pFaceArray,
                                           std::vector<ipReal32>& vVerticesArray,
                                           std::vector<ipUInt32>& vFacesArray);

    ipReal64                vertex_error(const SymmetricMatrix& q,
                                         const ipReal64 x, 
                                         const ipReal64 y,
                                         const ipReal64 z);

    ipReal64                calculate_error(const ipUInt32 id_v1,
                                            const ipUInt32 id_v2, 
                                            vec3f& pResult);
            
//methods
public:

    void                    simplify_mesh_inSitu(Mesh3d<T>& mesh,
                                          const ipUInt64 target_count,
                                          const ipReal64 agressiveness = 7,
                                          const ipBool bVerbose = false);

    boost::shared_ptr<Mesh3d<T>> simplify_mesh(const Mesh3d<T>& mesh,
                                               const ipUInt64 target_count,
                                               const ipReal64 agressiveness = 7,
                                               const ipBool bVerbose = false);


    void                    simplify_arrays(const ipReal32* pVerticesArray,
                                            const ipUInt32* pTrianglesArray,
                                            const ipUInt64 nbVertices,
                                            const ipUInt64 nbTriangles,
                                            const ipUInt64 target_count,
                                            const ipReal64 agressiveness,
                                            const ipBool bVerbose,
                                            std::vector<ipReal32>& vVerticesArray,
                                            std::vector<ipUInt32>& vFacesArray);

    void                    clear();


// attributes
protected:

    //triangles list
    std::vector<Triangle>               _triangles;

    //vertices list
    std::vector<Vertex>                 _vertices;

    //references list
    std::vector<Ref>                    _refs;
    
    //edge collapsed list
    std::vector<std::vector<ipBool>>    _collapses;
};



    } // end of namespace geom
} // end of namespace ipsdk

//#pragma warning (pop)

#endif // __IPSDKGEOMETRY_MESHSIMPLIFICATION_H__