Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *

 * This file is part of GEL, http://www.imm.dtu.dk/GEL

 * Copyright (C) the authors and DTU Informatics

 * For license and list of authors, see ../../doc/intro.pdf

 * ----------------------------------------------------------------------- */

/**

 * @file ConnectivityKernel.h

 * @brief The data structure under HMesh.

 */

#ifndef __HMESH_CONNECTIVITY_KERNEL_H__

#define __HMESH_CONNECTIVITY_KERNEL_H__

#include <vector>

#include <map>

#include "ItemVector.h"

#include "ItemID.h"

#include "Iterators.h"

namespace HMesh

{

    struct Vertex;

    struct Face;

    struct HalfEdge;

    typedef ItemVector<Vertex>::IDType VertexID;

    typedef ItemVector<Face>::IDType FaceID;

    typedef ItemVector<HalfEdge>::IDType HalfEdgeID;

    /// The vertex struct. This contains just a single outgoing halfedge.

    struct Vertex

    { 

        HalfEdgeID out; 

    };

    /// The face struct. Contains a single halfedge

    struct Face

    { 

        HalfEdgeID last; 

    };

    /// The halfedge struct. Contains IDs of next, previous, and opposite edges as well as incident face and vertex.

    struct HalfEdge

    {

        HalfEdgeID next;

        HalfEdgeID prev;

        HalfEdgeID opp;

        VertexID vert;

        FaceID face;

    };

    typedef IDIterator<Vertex> VertexIDIterator;

    typedef IDIterator<Face> FaceIDIterator;

    typedef IDIterator<HalfEdge> HalfEdgeIDIterator;

    static const VertexID InvalidVertexID;

    static const FaceID InvalidFaceID;

    static const HalfEdgeID InvalidHalfEdgeID;

    typedef std::map<VertexID, VertexID> VertexIDRemap;

    typedef std::map<FaceID, FaceID> FaceIDRemap;

    typedef std::map<HalfEdgeID, HalfEdgeID> HalfEdgeIDRemap;

    /// The IDRemap struct is just used for garbage collection.

    struct IDRemap

    {

        VertexIDRemap vmap;

        FaceIDRemap fmap;

        HalfEdgeIDRemap hmap;

    };

    /** The connectivity kernel is basically an aggregate of ItemVectors for vertices, faces, and halfedges.

     This class contains no geometry information - only information about connectivitiy. Arguably it abstracts

     away the implementation from the ConnectivityKernel class making it possible, for instance, to use a different kernel. */

    class ConnectivityKernel

    {

    public:

        /// number of active vertices in kernel

        size_t no_vertices() const;

        /// number of active faces in kernel

        size_t no_faces() const;

        /// number of active halfedges in kernel

        size_t no_halfedges() const;

        /// number of total vertices in kernel

        size_t allocated_vertices() const;

        /// number of total faces in kernel

        size_t allocated_faces() const;

        /// number of total halfedges in kernel

        size_t allocated_halfedges() const;

        /// check if ID of vertex is in use

        bool in_use(VertexID id) const;

        /// check if ID of face is in use

        bool in_use(FaceID id) const;

        /// check if ID of halfedge is in use

        bool in_use(HalfEdgeID id) const;

        /// Iterator to first VertexID, optional argument defines if unused items should be skipped

        VertexIDIterator vertices_begin(bool skip = true) const;

        /// Iterator to first FaceID, optional argument defines if unused items should be skipped

        FaceIDIterator faces_begin(bool skip = true) const;

        /// Iterator to first HalfEdgeID, optional argument defines if unused items should be skipped

        HalfEdgeIDIterator halfedges_begin(bool skip = true) const;

        /// Iterator to past the end VertexID

        VertexIDIterator vertices_end() const;

        /// Iterator topast the end FaceID

        FaceIDIterator faces_end() const;

        /// Iterator to past the end HalfEdgeID

        HalfEdgeIDIterator halfedges_end() const;

        /// get the ID of next halfedge, given by current halfedge ID

        HalfEdgeID next(HalfEdgeID current) const;

        /// get the ID of previous halfedge, given by current halfedge ID

        HalfEdgeID prev(HalfEdgeID current) const;

        /// get the ID of opposite halfedge, given by current halfedge ID

        HalfEdgeID opp(HalfEdgeID current) const;

        /// get the ID of outgoing halfedge, given by current vertex ID

        HalfEdgeID out(VertexID current) const;

        /// get the ID of last halfedge of current face ID

        HalfEdgeID last(FaceID current) const;

        /// get the ID of vertex pointed to by current halfedge ID

        VertexID vert(HalfEdgeID id) const;

        /// get the ID of face owning current halfedge ID

        FaceID face(HalfEdgeID id) const;

        /// add vertex to kernel

        VertexID add_vertex();

        /// add face to kernel

        FaceID add_face();

        /// add halfedge to kernel

        HalfEdgeID add_halfedge();

        /// remove vertex from kernel, given by ID

        void remove_vertex(VertexID id);

        /// remove face from kernel, given by ID

        void remove_face(FaceID id);

        /// remove halfedge from kernel, given by ID

        void remove_halfedge(HalfEdgeID id);

        /// set the ID of next halfedge of current halfedge to next

        void set_next(HalfEdgeID current, HalfEdgeID next);

        /// set the ID of previous halfedge of current halfedge to prev

        void set_prev(HalfEdgeID current, HalfEdgeID prev);

        /// set the ID of opposite halfedge of current halfedge to opp

        void set_opp(HalfEdgeID current, HalfEdgeID opp);

        /// set the ID of outgoing halfedge of current vertex to out

        void set_out(VertexID current, HalfEdgeID out);

        /// set the ID of last halfedge of current face to last

        void set_last(FaceID current, HalfEdgeID last);

        /// set the ID of vertex pointed to by current halfedge to vert

        void set_vert(HalfEdgeID current, VertexID vert);

        /// set the ID of face owning current halfedge to face

        void set_face(HalfEdgeID current, FaceID face);

        /// Clean up unused space in vectors - WARNING! Invalidates existing handles!

        void cleanup(IDRemap& map);

        /// clear the kernel

        void clear();

    private:

        ItemVector<Vertex> vertices;

        ItemVector<Face> faces;

        ItemVector<HalfEdge> halfedges;

    };

    inline VertexID ConnectivityKernel::add_vertex()

    { return vertices.add(Vertex()); }

    inline FaceID ConnectivityKernel::add_face()

    { return faces.add(Face()); }

    inline HalfEdgeID ConnectivityKernel::add_halfedge()

    { return halfedges.add(HalfEdge()); }

    inline void ConnectivityKernel::remove_vertex(VertexID id)

    { vertices.remove(id); }

    inline void ConnectivityKernel::remove_face(FaceID id)

    { faces.remove(id); }

    inline void ConnectivityKernel::remove_halfedge(HalfEdgeID id)

    { halfedges.remove(id); }

    inline HalfEdgeID ConnectivityKernel::next(HalfEdgeID id) const

    { return halfedges[id].next; }

    inline HalfEdgeID ConnectivityKernel::prev(HalfEdgeID id) const

    { return halfedges[id].prev; }

    inline HalfEdgeID ConnectivityKernel::opp(HalfEdgeID id) const

    { return halfedges[id].opp; }

    inline HalfEdgeID ConnectivityKernel::out(VertexID id) const

    { return vertices[id].out; }

    inline HalfEdgeID ConnectivityKernel::last(FaceID id) const

    { return faces[id].last; }

    inline VertexID ConnectivityKernel::vert(HalfEdgeID id) const

    { return halfedges[id].vert; }

    inline FaceID ConnectivityKernel::face(HalfEdgeID id) const

    { return halfedges[id].face; }

    inline void ConnectivityKernel::set_next(HalfEdgeID id, HalfEdgeID next)

    { halfedges[id].next = next; }

    inline void ConnectivityKernel::set_prev(HalfEdgeID id, HalfEdgeID prev)

    { halfedges[id].prev = prev; }

    inline void ConnectivityKernel::set_opp(HalfEdgeID id, HalfEdgeID opp)

    {halfedges[id].opp = opp; }

    inline void ConnectivityKernel::set_out(VertexID id, HalfEdgeID out)

    { vertices[id].out = out; }

    inline void ConnectivityKernel::set_last(FaceID id, HalfEdgeID last)

    { faces[id].last = last; }

    inline void ConnectivityKernel::set_vert(HalfEdgeID id, VertexID vert)

    { halfedges[id].vert = vert; }

    inline void ConnectivityKernel::set_face(HalfEdgeID id, FaceID face)

    { halfedges[id].face = face; }

    inline size_t ConnectivityKernel::no_vertices() const

    { return vertices.size(); }

    inline size_t ConnectivityKernel::no_faces() const

    { return faces.size(); }

    inline size_t ConnectivityKernel::no_halfedges() const

    { return halfedges.size(); }

    inline size_t ConnectivityKernel::allocated_vertices() const

    { return vertices.allocated_size(); }

    inline size_t ConnectivityKernel::allocated_faces() const

    { return faces.allocated_size(); }

    inline size_t ConnectivityKernel::allocated_halfedges() const

    { return halfedges.allocated_size(); }

    inline bool ConnectivityKernel::in_use(VertexID id) const

    { return vertices.in_use(id); }

    inline bool ConnectivityKernel::in_use(FaceID id) const

    { return faces.in_use(id); }

    inline bool ConnectivityKernel::in_use(HalfEdgeID id) const

    { return halfedges.in_use(id); }

    inline VertexIDIterator ConnectivityKernel::vertices_begin(bool skip) const

    { return VertexIDIterator(vertices, vertices.index_begin(skip), skip); }

    inline  FaceIDIterator ConnectivityKernel::faces_begin(bool skip) const

    { return FaceIDIterator(faces, faces.index_begin(skip), skip); }

    inline HalfEdgeIDIterator ConnectivityKernel:: halfedges_begin(bool skip) const

    { return HalfEdgeIDIterator(halfedges, halfedges.index_begin(skip), skip); }

    inline VertexIDIterator ConnectivityKernel::vertices_end() const

    { return VertexIDIterator(vertices, vertices.index_end()); }

    inline FaceIDIterator ConnectivityKernel::faces_end() const

    { return FaceIDIterator(faces, faces.index_end()); }

    inline HalfEdgeIDIterator ConnectivityKernel::halfedges_end() const

    { return HalfEdgeIDIterator(halfedges, halfedges.index_end()); }

    inline void ConnectivityKernel::clear()

    {

        vertices.clear();

        faces.clear();

        halfedges.clear();

    }

}

#endif