Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *
 * 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_CONNECTIVITY_KERNEL_H__
#define __HMESH_CONNECTIVITY_KERNEL_H__

#include <vector>
#include <map>
#include "ItemVector.h"
#include "ItemID.h"

namespace HMesh
{
    typedef std::map<VertexID, VertexID> VertexIDRemap;
    typedef std::map<FaceID, FaceID> FaceIDRemap;
    typedef std::map<HalfEdgeID, HalfEdgeID> HalfEdgeIDRemap;

    struct IDRemap
    {
        VertexIDRemap vmap;
        FaceIDRemap fmap;
        HalfEdgeIDRemap hmap;
    };

    struct Vertex
    { 
        HalfEdgeID out; 
    };

    struct Face
    { 
        HalfEdgeID last; 
    };

    struct HalfEdge
    {
        HalfEdgeID next;
        HalfEdgeID prev;
        HalfEdgeID opp;
        VertexID vert;
        FaceID face;
    };

    class ConnectivityKernel
    {
    public:
        VertexID add_vertex();
        FaceID add_face();
        HalfEdgeID add_halfedge();


        void remove_vertex(VertexID id);
        void remove_face(FaceID id);
        void remove_halfedge(HalfEdgeID id);

        void resize_vertices(size_t size);
        void resize_faces(size_t size);
        void resize_halfedges(size_t size);

        HalfEdgeID next(HalfEdgeID id) const;
        HalfEdgeID prev(HalfEdgeID id) const;
        HalfEdgeID opp(HalfEdgeID id) const;
        HalfEdgeID out(VertexID id) const;
        HalfEdgeID last(FaceID id) const;
        VertexID vert(HalfEdgeID id) const;
        FaceID face(HalfEdgeID id) const;

        void set_next(HalfEdgeID id, HalfEdgeID next);
        void set_prev(HalfEdgeID id, HalfEdgeID prev);
        void set_opp(HalfEdgeID id, HalfEdgeID opp);
        void set_out(VertexID id, HalfEdgeID out);
        void set_last(FaceID id, HalfEdgeID last);
        void set_vert(HalfEdgeID id, VertexID vert);
        void set_face(HalfEdgeID id, FaceID face);

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

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

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


        VertexID vertices_next(VertexID id, bool skip = true) const;
        HalfEdgeID halfedges_next(HalfEdgeID id, bool skip = true) const;
        FaceID faces_next(FaceID id, bool skip = true) const;

        VertexID vertices_prev(VertexID id, bool skip = true) const;
        HalfEdgeID halfedges_prev(HalfEdgeID id, bool skip = true) const;
        FaceID faces_prev(FaceID id, bool skip = true) const;

        VertexID vertices_begin(bool skip = true) const;
        HalfEdgeID halfedges_begin(bool skip = true) const;
        FaceID faces_begin(bool skip = true) const;

        VertexID vertices_end() const;
        HalfEdgeID halfedges_end() const;
        FaceID faces_end() const;

        /// Clean up unused space in vectors - WARNING! Invalidates existing handles!
        void cleanup(IDRemap& map);

        void clear();

    private:
        ItemVector<Vertex> vertices;
        ItemVector<Face> faces;
        ItemVector<HalfEdge> halfedges;
    };

    inline VertexID ConnectivityKernel::add_vertex()
    {
        vertices.add(Vertex());
        return VertexID(vertices.total_size() - 1);
    }

    inline FaceID ConnectivityKernel::add_face()
    {
        faces.add(Face());
        return FaceID(faces.total_size() - 1);
    }

    inline HalfEdgeID ConnectivityKernel::add_halfedge()
    {
        halfedges.add(HalfEdge());
        return HalfEdgeID(halfedges.total_size() - 1);
    }




    inline void ConnectivityKernel::remove_vertex(VertexID id)
    { vertices.remove(id.index); }

    inline void ConnectivityKernel::remove_face(FaceID id)
    { faces.remove(id.index); }

    inline void ConnectivityKernel::remove_halfedge(HalfEdgeID id)
    { halfedges.remove(id.index); }



    inline void ConnectivityKernel::resize_vertices(size_t size)
    {  vertices.resize(size); }

    inline void ConnectivityKernel::resize_faces(size_t size)
    {  faces.resize(size); }

    inline void ConnectivityKernel::resize_halfedges(size_t size)
    {  halfedges.resize(size); }


    inline HalfEdgeID ConnectivityKernel::next(HalfEdgeID id) const
    { return HalfEdgeID(halfedges[id.index].next); }

    inline HalfEdgeID ConnectivityKernel::prev(HalfEdgeID id) const
    { return HalfEdgeID(halfedges[id.index].prev); }

    inline HalfEdgeID ConnectivityKernel::opp(HalfEdgeID id) const
    { return HalfEdgeID(halfedges[id.index].opp); }

    inline HalfEdgeID ConnectivityKernel::out(VertexID id) const
    { return HalfEdgeID(vertices[id.index].out); }

    inline HalfEdgeID ConnectivityKernel::last(FaceID id) const
    { return HalfEdgeID(faces[id.index].last); }

    inline VertexID ConnectivityKernel::vert(HalfEdgeID id) const
    { return VertexID(halfedges[id.index].vert); }

    inline FaceID ConnectivityKernel::face(HalfEdgeID id) const
    { return FaceID(halfedges[id.index].face); }

    inline void ConnectivityKernel::set_next(HalfEdgeID id, HalfEdgeID next)
    { halfedges[id.index].next = next; }

    inline void ConnectivityKernel::set_prev(HalfEdgeID id, HalfEdgeID prev)
    { halfedges[id.index].prev = prev; }

    inline void ConnectivityKernel::set_opp(HalfEdgeID id, HalfEdgeID opp)
    {halfedges[id.index].opp = opp; }

    inline void ConnectivityKernel::set_out(VertexID id, HalfEdgeID out)
    { vertices[id.index].out = out; }

    inline void ConnectivityKernel::set_last(FaceID id, HalfEdgeID last)
    { faces[id.index].last = last; }

    inline void ConnectivityKernel::set_vert(HalfEdgeID id, VertexID vert)
    { halfedges[id.index].vert = vert; }

    inline void ConnectivityKernel::set_face(HalfEdgeID id, FaceID face)
    { halfedges[id.index].face = face; }



    inline size_t ConnectivityKernel::active_vertices() const
    { return vertices.active_size(); }

    inline size_t ConnectivityKernel::active_faces() const
    { return faces.active_size(); }

    inline size_t ConnectivityKernel::active_halfedges() const
    { return halfedges.active_size(); }



    inline size_t ConnectivityKernel::total_vertices() const
    { return vertices.total_size(); }

    inline size_t ConnectivityKernel::total_faces() const
    { return faces.total_size(); }

    inline size_t ConnectivityKernel::total_halfedges() const
    { return halfedges.total_size(); }



    inline bool ConnectivityKernel::in_use(VertexID id) const
    { return vertices.in_use(id.index); }

    inline bool ConnectivityKernel::in_use(FaceID id) const
    { return faces.in_use(id.index); }

    inline bool ConnectivityKernel::in_use(HalfEdgeID id) const
    { return halfedges.in_use(id.index); }



    inline VertexID ConnectivityKernel::vertices_next(VertexID id, bool skip) const
    { return vertices.index_next(id.index, skip); }

    inline HalfEdgeID ConnectivityKernel::halfedges_next(HalfEdgeID id, bool skip) const
    { return halfedges.index_next(id.index, skip); }

    inline FaceID ConnectivityKernel::faces_next(FaceID id, bool skip) const
    { return faces.index_next(id.index, skip); }

    inline VertexID ConnectivityKernel::vertices_prev(VertexID id, bool skip) const
    { return vertices.index_prev(id.index, skip); }

    inline HalfEdgeID ConnectivityKernel::halfedges_prev(HalfEdgeID id, bool skip) const
    { return halfedges.index_prev(id.index, skip); }

    inline FaceID ConnectivityKernel::faces_prev(FaceID id, bool skip) const
    { return faces.index_prev(id.index, skip); }

    inline VertexID ConnectivityKernel::vertices_begin(bool skip) const
    { return vertices.index_begin(skip); }

    inline HalfEdgeID ConnectivityKernel::halfedges_begin(bool skip) const
    { return halfedges.index_begin(skip); }

    inline FaceID ConnectivityKernel::faces_begin(bool skip) const
    { return faces.index_begin(skip); }

    inline VertexID ConnectivityKernel::vertices_end() const
    { return vertices.index_end(); }

    inline HalfEdgeID ConnectivityKernel::halfedges_end() const
    { return halfedges.index_end(); }

    inline FaceID ConnectivityKernel::faces_end() const
    { return faces.index_end(); }

    inline void ConnectivityKernel::clear()
    {
        vertices.clear();
        faces.clear();
        halfedges.clear();
    }
}

#endif