de.jtem.halfedge

Class HalfEdgeDataStructure<V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>>

java.lang.Object

de.jtem.halfedge.HalfEdgeDataStructure<V,E,F>

Type Parameters:

E - the edge class of this half-edge data structure

F - the face class of this half-edge data structure

V - the vertex class of this half-edge data structure

public class HalfEdgeDataStructure<V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>>
extends Object

Class representing a half-edge data structure.

Author:

Stefan Sechelmann, Boris Springborn

Constructor Summary

Constructors

Constructor and Description
HalfEdgeDataStructure(Class<V> vClass, Class<E> eClass, Class<F> fClass) Instantiate a new half-edge data structure with given vertex, edge, and face classes.

Method Summary

Modifier and Type	Method and Description
E	addNewEdge() Add a new edge to this half-edge data structure.
List<E>	addNewEdges(int n) Add n new edges to this half-edge data structure.
F	addNewFace() Add a new face to this half-edge data structure.
List<F>	addNewFaces(int n) Add n new faces to this half-edge data structure.
V	addNewVertex() Add a new vertex to this half-edge data structure.
List<V>	addNewVertices(int n) Add n new vertices to this half-edge data structure.
void	clear()
<VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>> HalfEdgeDataStructure<VV,EE,FF>	createCombinatoriallyEquivalentCopy(Class<VV> vC, Class<EE> eC, Class<FF> fC) Create a combinatorially equivalent copy of this half-edge data structure.
<VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>,HEDS extends HalfEdgeDataStructure<VV,EE,FF>> HEDS	createCombinatoriallyEquivalentCopy(HEDS heds) Create a combinatorially equivalent copy of this half-edge data structure.
E	getEdge(int index) Return edge with given index from edge list.
Class<E>	getEdgeClass() Return edge class of this half-edge data structure.
List<E>	getEdges() Return the edge list.
F	getFace(int index) Return face with given index from face list.
Class<F>	getFaceClass() Return face class of this half-edge data structure.
List<F>	getFaces() Return the face list.
Iterable<E>	getNegativeEdges() Return an Iterable for iterating over the positive edges.
Iterable<E>	getPositiveEdges() Return an Iterable for iterating over the positive edges.
V	getVertex(int index) Return vertex with given index from vertex list.
Class<V>	getVertexClass() Return vertex class of this half-edge data structure.
List<V>	getVertices() Return the vertex list.
int	numEdges() Return number of edge.
int	numFaces() Return number of faces.
int	numVertices() Return number of vertices.
void	removeEdge(Edge<?,?,?> edge) Remove an edge from this halfedge data structure.
void	removeFace(Face<?,?,?> face) Remove a face from this halfedge data structure.
void	removeVertex(Vertex<?,?,?> vertex) Remove a vertex from this half-edge data structure.
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

HalfEdgeDataStructure

public HalfEdgeDataStructure(Class<V> vClass,
                             Class<E> eClass,
                             Class<F> fClass)

Instantiate a new half-edge data structure with given vertex, edge, and face classes. The parameters serve as runtime type tokens.

Parameters:

vClass - the half-edge data structure's vertex class

eClass - the half-edge data structure's edge class

fClass - the half-edge data structure's face class

Method Detail

addNewEdge

public final E addNewEdge()

Add a new edge to this half-edge data structure.

Returns:

the newly created edge

Throws:

RuntimeException - if an instance of the edge class cannot be instantiated

addNewEdges

public final List<E> addNewEdges(int n)
                          throws RuntimeException

Add n new edges to this half-edge data structure.

Parameters:

n - the number of edges to create and add.

Returns:

the list (with size n) of new edges

Throws:

RuntimeException - if instances of the edge class cannot be instantiated

addNewFace

public final F addNewFace()

Add a new face to this half-edge data structure.

Returns:

the newly created face

Throws:

RuntimeException - if an instance of the face class cannot be instantiated

addNewFaces

public final List<F> addNewFaces(int n)
                          throws RuntimeException

Add n new faces to this half-edge data structure.

Parameters:

n - the number of faces to create and add.

Returns:

the list (with size n) of new faces

Throws:

RuntimeException - if instances of the face class cannot be instantiated

addNewVertex

public final V addNewVertex()
                     throws RuntimeException

Add a new vertex to this half-edge data structure.

Returns:

the newly created vertex

Throws:

RuntimeException - if an instance of the vertex class cannot be instantiated

addNewVertices

public final List<V> addNewVertices(int n)
                             throws RuntimeException

Add n new vertices to this half-edge data structure.

Parameters:

n - the number of vertices to create and add.

Returns:

the list (with size n) of new vertices

Throws:

RuntimeException - if instances of the vertex class cannot be instantiated

clear

public void clear()

createCombinatoriallyEquivalentCopy

public final <VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>> HalfEdgeDataStructure<VV,EE,FF> createCombinatoriallyEquivalentCopy(Class<VV> vC,
                                                                                                                                                                   Class<EE> eC,
                                                                                                                                                                   Class<FF> fC)

Create a combinatorially equivalent copy of this half-edge data structure.

Type Parameters:

VV - the vertex type of the copy

EE - the edge type of the copy

FF - the face type of the copy

Parameters:

vC - the vertex class, used as runtime type token

eC - the edge class, used as runtime type token

fC - the face class, used as runtime type token

Returns:

a combinatorially equivalent copy

createCombinatoriallyEquivalentCopy

public final <VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>,HEDS extends HalfEdgeDataStructure<VV,EE,FF>> HEDS createCombinatoriallyEquivalentCopy(HEDS heds)

Create a combinatorially equivalent copy of this half-edge data structure. This method takes a half-edge data structure object and overwrites its content.

Parameters:

heds - The half-edge data structure to fill.

Returns:

heds

getEdge

public final E getEdge(int index)

Return edge with given index from edge list.

Parameters:

index - the index

Returns:

the edge

getEdgeClass

public final Class<E> getEdgeClass()

Return edge class of this half-edge data structure.

Returns:

the edge class

getEdges

public final List<E> getEdges()

Return the edge list.

Returns:

an unmodifiable view of the edge list

getFace

public final F getFace(int index)

Return face with given index from face list.

Parameters:

index - the index

Returns:

the face

getFaceClass

public final Class<F> getFaceClass()

Return face class of this half-edge data structure.

Returns:

the face class

getFaces

public final List<F> getFaces()

Return the face list.

Returns:

an unmodifiable view of the face list

getNegativeEdges

public final Iterable<E> getNegativeEdges()

Return an Iterable for iterating over the positive edges.

Returns:

the Iterable

See Also:

getPositiveEdges()

getPositiveEdges

public final Iterable<E> getPositiveEdges()

Return an Iterable for iterating over the positive edges. If you want to loop over those edges in the edge list for which Edge.isPositive returns true, you may do like this:

for (E e : mySuface.getPositiveEdges()) { ... }

Returns:

the Iterable

getVertex

public final V getVertex(int index)
                  throws IndexOutOfBoundsException

Return vertex with given index from vertex list.

Parameters:

index - the index

Returns:

the vertex

Throws:

IndexOutOfBoundsException - if the index is out of range

getVertexClass

public final Class<V> getVertexClass()

Return vertex class of this half-edge data structure.

Returns:

the vertex class

getVertices

public final List<V> getVertices()

Return the vertex list.

Returns:

an unmodifiable view of the vertex list

numEdges

public final int numEdges()

Return number of edge.

Returns:

size of the edge list

numFaces

public final int numFaces()

Return number of faces.

Returns:

size of the face list

numVertices

public final int numVertices()

Return number of vertices.

Returns:

size of the vertex list

removeEdge

public final void removeEdge(Edge<?,?,?> edge)
                      throws RuntimeException

Remove an edge from this halfedge data structure. Does nothing if edge is null. Otherwise, it is removed from the edge list and invalidated. This means getHalfEdgeDataStructure() will return null, isValid will return false, and many other methods will throw an exception. edge will not be linked with any edges, vertices, faces after execution of this method.

Parameters:

edge - the edge to remove.

Throws:

RuntimeException - if edge does not belong to this half-edge data structure

removeFace

public final void removeFace(Face<?,?,?> face)
                      throws RuntimeException

Remove a face from this halfedge data structure. Does nothing if face is null. Otherwise it is removed from the face list and invalidated. This means getHalfEdgeDataStructure() will return null, isValid() will return false, and many other methods will throw an exception. Edges which had face as left face will now return null.

Parameters:

face - the face to remove

Throws:

RuntimeException - if face does not belong to this half-edge data structure

removeVertex

public final void removeVertex(Vertex<?,?,?> vertex)

Remove a vertex from this half-edge data structure. Does nothing if vertex is null. Otherwise, it is removed from the vertex list and invalidated. This means getHalfEdgeDataStructure() will return null, isValid() will return false, and many other methods will throw an exception. Edges which had vertex as target vertex will now return null.

Parameters:

vertex - the vertex to remove.

Throws:

RuntimeException - if vertex does not belong to this half-edge data structure

toString

public String toString()

Overrides:

toString in class Object