/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/HMesh/Manifold.h

/* ----------------------------------------------------------------------- *
 * This file is part of GEL, www.imm.dtu.dk/GEL
 * Copyright (C) the authors (see AUTHORS.txt) and DTU Informatics
 *
 * Principal authors:
 *  Christian Thode Larsen (thode2d@gmail.com)
 *  J. Andreas Baerentzen (jab@imm.dtu.dk)
 *
 * See LICENSE.txt for licensing information
 * ----------------------------------------------------------------------- */

#ifndef __HMESH_MANIFOLD_H__
#define __HMESH_MANIFOLD_H__

#include <algorithm>
#include <CGLA/Vec3f.h>

#include "ConnectivityKernel.h"
#include "Iterators.h"
#include "HalfEdgeWalker.h"
#include "AttributeVector.h"


namespace Geometry
{
    // forward declaration
    class TriMesh;
    class IndexedFaceSet;
}

namespace HMesh
{       
    class Manifold
    {
    public:
        Manifold();

        void build( size_t no_vertices,
                    const float* vertvec,
                    size_t no_faces,
                    const int* facevec,
                    const int* indices);

        void build(const Geometry::TriMesh& mesh);
                
                std::vector<HalfEdgeID> bridge_faces(FaceID f0, FaceID f1, const std::vector<std::pair<VertexID, VertexID> >& pairs);


        void collapse_edge(HalfEdgeID h, bool avg_vertices = false);

        FaceID split_face_by_edge(FaceID f, VertexID v0, VertexID v1);

        VertexID split_face_by_vertex(FaceID f);
       // VertexID split_face_by_vertex(HalfEdgeID h);

        VertexID split_edge(HalfEdgeID h);

        bool merge_faces(FaceID f, HalfEdgeID h);
                
                FaceID merge_one_ring(VertexID v, float max_loop_length = FLT_MAX);

        void close_hole(HalfEdgeID h);

        void flip_edge(HalfEdgeID h);

        size_t active_vertices() const;
        size_t active_halfedges() const;
        size_t active_faces() const;

        size_t total_vertices() const;
        size_t total_halfedges() const;
        size_t total_faces() const;

        bool in_use(VertexID id) const;
        bool in_use(FaceID id) const;
        bool in_use(HalfEdgeID id) const;

        VertexIDIterator vertices_begin(bool skip = true) const;
        FaceIDIterator faces_begin(bool skip = true) const;
        HalfEdgeIDIterator halfedges_begin(bool skip = true) const;

        VertexIDIterator vertices_end() const;
        FaceIDIterator faces_end() const;
        HalfEdgeIDIterator halfedges_end() const;

        HalfEdgeWalker halfedgewalker(VertexID id) const;
        HalfEdgeWalker halfedgewalker(FaceID id) const;
        HalfEdgeWalker halfedgewalker(HalfEdgeID id) const;

        CGLA::Vec3f& pos(VertexID id);
        const CGLA::Vec3f& pos(VertexID id) const;

        void clear();

        void cleanup(IDRemap& map);
        void cleanup();
    private:
        ConnectivityKernel ck;
        VertexAttributeVector<CGLA::Vec3f> positions;

        // private template for building the manifold from various types
        template<typename size_type, typename float_type, typename int_type>
        void build_template(size_type no_vertices,
                            const float_type* vertvec,
                            size_type no_faces,
                            const int_type* facevec,
                            const int_type* indices);

        void link(HalfEdgeID h0, HalfEdgeID h1);

        void glue(HalfEdgeID h0, HalfEdgeID h1);

        void remove_face_if_degenerate(HalfEdgeID h);

        void ensure_boundary_consistency(VertexID v);
    };

    bool valid(const Manifold& m);

    void bbox(const Manifold& m, CGLA::Vec3f& pmin, CGLA::Vec3f& pmax);

    void bsphere(const Manifold& m, CGLA::Vec3f& c, float& r);

    bool precond_collapse_edge(const Manifold& m, HalfEdgeID h);

    bool precond_flip_edge(const Manifold& m, HalfEdgeID h);

    bool boundary(const Manifold& m, HalfEdgeID h);

    float length(const Manifold& m, HalfEdgeID h);

    bool boundary(const Manifold& m, VertexID v);

    int valency(const Manifold& m, VertexID v);

    CGLA::Vec3f normal(const Manifold& m, VertexID v);

    bool connected(const Manifold& m, VertexID v0, VertexID v1);

    int no_edges(const Manifold& m, FaceID f);

    CGLA::Vec3f normal(const Manifold& m, FaceID f);

    float area(const Manifold& m, FaceID f);

    float perimeter(const Manifold& m, FaceID f);

    CGLA::Vec3f centre(const Manifold& m, FaceID f);

    /*******************************************************************
    * Manifold code
    *******************************************************************/

    inline Manifold::Manifold(){}


    inline size_t Manifold::active_vertices() const
    { return ck.active_vertices(); }
    inline size_t Manifold::active_halfedges() const
    { return ck.active_halfedges(); }
    inline size_t Manifold::active_faces() const
    { return ck.active_faces(); }

    inline size_t Manifold::total_vertices() const
    { return ck.total_vertices(); }
    inline size_t Manifold::total_halfedges() const
    { return ck.total_halfedges(); }
    inline size_t Manifold::total_faces() const
    { return ck.total_faces(); }

    inline bool Manifold::in_use(VertexID id) const
    { return ck.in_use(id); }
    inline bool Manifold::in_use(FaceID id) const
    { return ck.in_use(id); }
    inline bool Manifold::in_use(HalfEdgeID id) const
    { return ck.in_use(id); }

    inline VertexIDIterator Manifold::vertices_begin(bool skip) const
    { return VertexIDIterator(ck, ck.vertices_begin(skip), skip); }
    inline  FaceIDIterator Manifold::faces_begin(bool skip) const
    { return FaceIDIterator(ck, ck.faces_begin(skip), skip); }
    inline HalfEdgeIDIterator Manifold:: halfedges_begin(bool skip) const
    { return HalfEdgeIDIterator(ck, ck.halfedges_begin(skip), skip); }


    inline VertexIDIterator Manifold::vertices_end() const
    { return VertexIDIterator(ck, ck.vertices_end()); }
    inline FaceIDIterator Manifold::faces_end() const
    { return FaceIDIterator(ck, ck.faces_end()); }
    inline HalfEdgeIDIterator Manifold::halfedges_end() const
    { return HalfEdgeIDIterator(ck, ck.halfedges_end()); }


    inline HalfEdgeWalker Manifold::halfedgewalker(VertexID id) const
    { return HalfEdgeWalker(ck, ck.out(id)); }
    inline HalfEdgeWalker Manifold::halfedgewalker(FaceID id) const
    { return HalfEdgeWalker(ck, ck.last(id)); }
    inline HalfEdgeWalker Manifold::halfedgewalker(HalfEdgeID id) const
    { return HalfEdgeWalker(ck, id); }


    inline CGLA::Vec3f& Manifold::pos(VertexID id)
    { return positions[id]; }
    inline const CGLA::Vec3f& Manifold::pos(VertexID id) const
    { return positions[id]; }


    inline void Manifold::clear()
    { 
        ck.clear();
        positions.clear();
    }


    inline void Manifold::cleanup(IDRemap& map)
    {   
        ck.cleanup(map);
        positions.cleanup(map.vmap);
    }
    inline void Manifold::cleanup()
    {
        IDRemap map;
        cleanup(map);
    }
}


#endif __HMESH_MANIFOLD_H__