Subversion Repositories gelsvn

/*

* Written by Christian Thode Larsen 2009-2010

* Contact: thode2d@gmail.com

* Based on original work by J. Andreas Baerentzen

* Inspired by OpenMesh (www.openmesh.org)

*/

#ifndef __HMESH_CONNECTIVITY_KERNEL_H__

#define __HMESH_CONNECTIVITY_KERNEL_H__

#include <vector>

#include "ItemVector.h"

#include "Items.h"

namespace HMesh

{

	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(IndexType size);

		void resize_faces(IndexType size);

		void resize_halfedges(IndexType 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);

		IndexType no_vertices(bool active = true) const;

		IndexType no_faces(bool active = true) const;

		IndexType no_halfedges(bool active = true) 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;

		void cleanup();

		void clear();

	private:

		ItemVector<Vertex> vertices;

		ItemVector<Face> faces;

		ItemVector<HalfEdge> halfedges;

	};

	inline VertexID ConnectivityKernel::add_vertex()

	{

		vertices.add(Vertex());

		return VertexID(vertices.size());

	}

	inline FaceID ConnectivityKernel::add_face()

	{

		faces.add(Face());

		return FaceID(faces.size());

	}

	inline HalfEdgeID ConnectivityKernel::add_halfedge()

	{

		halfedges.add(HalfEdge());

		return HalfEdgeID(halfedges.size());

	}

	inline void ConnectivityKernel::remove_vertex(VertexID id)

	{ vertices.remove(id.idx()); }

	inline void ConnectivityKernel::remove_face(FaceID id)

	{ faces.remove(id.idx()); }

	inline void ConnectivityKernel::remove_halfedge(HalfEdgeID id)

	{ halfedges.remove(id.idx()); }

	inline void ConnectivityKernel::resize_vertices(IndexType size)

	{  vertices.resize(size); }

	inline void ConnectivityKernel::resize_faces(IndexType size)

	{  faces.resize(size); }

	inline void ConnectivityKernel::resize_halfedges(IndexType size)

	{  halfedges.resize(size); }

	inline HalfEdgeID ConnectivityKernel::next(HalfEdgeID id) const

	{ return HalfEdgeID(halfedges[id.idx()].next); }

	inline HalfEdgeID ConnectivityKernel::prev(HalfEdgeID id) const

	{ return HalfEdgeID(halfedges[id.idx()].prev); }

	inline HalfEdgeID ConnectivityKernel::opp(HalfEdgeID id) const

	{ return HalfEdgeID(halfedges[id.idx()].opp); }

	inline HalfEdgeID ConnectivityKernel::out(VertexID id) const

	{ return HalfEdgeID(vertices[id.idx()].out); }

	inline HalfEdgeID ConnectivityKernel::last(FaceID id) const

	{ return HalfEdgeID(faces[id.idx()].last); }

	inline VertexID ConnectivityKernel::vert(HalfEdgeID id) const

	{ return VertexID(halfedges[id.idx()].vert); }

	inline FaceID ConnectivityKernel::face(HalfEdgeID id) const

	{ return FaceID(halfedges[id.idx()].face); }

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

	{ halfedges[id.idx()].next = next; }

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

	{ halfedges[id.idx()].prev = prev; }

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

	{halfedges[id.idx()].opp = opp; }

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

	{ vertices[id.idx()].out = out; }

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

	{ faces[id.idx()].last = last; }

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

	{ halfedges[id.idx()].vert = vert; }

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

	{ halfedges[id.idx()].face = face; }

	inline IndexType ConnectivityKernel::no_vertices(bool active) const

	{ return vertices.size(active); }

	inline IndexType ConnectivityKernel::no_faces(bool active) const

	{ return faces.size(active); }

	inline IndexType ConnectivityKernel::no_halfedges(bool active) const

	{ return halfedges.size(active); }

	inline bool ConnectivityKernel::in_use(VertexID id) const

	{ return vertices.in_use(id.idx()); }

	inline bool ConnectivityKernel::in_use(FaceID id) const

	{ return faces.in_use(id.idx()); }

	inline bool ConnectivityKernel::in_use(HalfEdgeID id) const

	{ return halfedges.in_use(id.idx()); }

	inline VertexID ConnectivityKernel::vertices_next(VertexID id, bool skip) const

	{ return vertices.index_next(id.idx(), skip); }

	inline HalfEdgeID ConnectivityKernel::halfedges_next(HalfEdgeID id, bool skip) const

	{ return halfedges.index_next(id.idx(), skip); }

	inline FaceID ConnectivityKernel::faces_next(FaceID id, bool skip) const

	{ return faces.index_next(id.idx(), skip); }

	inline VertexID ConnectivityKernel::vertices_prev(VertexID id, bool skip) const

	{ return vertices.index_prev(id.idx(), skip); }

	inline HalfEdgeID ConnectivityKernel::halfedges_prev(HalfEdgeID id, bool skip) const

	{ return halfedges.index_prev(id.idx(), skip); }

	inline FaceID ConnectivityKernel::faces_prev(FaceID id, bool skip) const

	{ return faces.index_prev(id.idx(), 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();

	}

	inline void ConnectivityKernel::cleanup()

	{

		vertices.cleanup();

		faces.cleanup();

		halfedges.cleanup();

	}

}

#endif