HalfEdgeUtils (de.jtem.halfedge package API documentation)

java.lang.Object
- de.jtem.halfedge.util.HalfEdgeUtils

public final class HalfEdgeUtils
extends Object

Author:: springb

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`addCube(HalfEdgeDataStructure<V,E,F> heds)`
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`addDodecahedron(HalfEdgeDataStructure<V,E,F> heds)`
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`addIcosahedron(HalfEdgeDataStructure<V,E,F> heds)`
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> F`	`addNGon(HalfEdgeDataStructure<V,E,F> heds, int n)` Add a new n-gon.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`addOctahedron(HalfEdgeDataStructure<V,E,F> heds)`
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`addTetrahedron(HalfEdgeDataStructure<V,E,F> heds)`
`static <E extends Edge<?,E,?>> List<List<E>>`	`boundaryComponents(HalfEdgeDataStructure<?,E,?> hds)` Returns a list containing lists for all boundary components of `hds` with left face equal to null.
`static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E>`	`boundaryEdges(E e0)` Return a list of edges which belong to the boundary component of e0
`static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E>`	`boundaryEdges(F face)` Return a list of the edges which have a given face as left face.
`static <E extends Edge<?,E,?>> List<E>`	`boundaryEdges(HalfEdgeDataStructure<?,E,?> heds)` Returns a collection containing all edges of `heds` with left face equal to null.
`static <E extends Edge<?,E,F>,F extends Face<?,E,F>> Collection<F>`	`boundaryFaces(HalfEdgeDataStructure<?,E,F> heds)` Returns a collection containing all faces of `heds` with at least one boundary edge.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> List<V>`	`boundaryVertices(F face)` Returns a list containing all vertices that are target vertices of the boundary of the given face
`static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> Collection<V>`	`boundaryVertices(HalfEdgeDataStructure<V,E,?> surf)` Returns a collection of all boundary vertices of `surf`.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E`	`constructFaceByVertices(HalfEdgeDataStructure<V,E,F> heds, Vertex<?,?,?>... v)` Construct a new face by giving its vertices in cyclic order.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>,HDSSRC extends HalfEdgeDataStructure<V,E,F>,VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>,HDSDST extends HalfEdgeDataStructure<VV,EE,FF>> int`	`copy(HDSSRC src, HDSDST dst)` Inserts the nodes of src into dst
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> List<F>`	`facesIncidentWithVertex(V vertex)` Return a list of faces that are incident with a given vertex.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> void`	`fillAllHoles(HalfEdgeDataStructure<V,E,F> heds)` Fill all holes by adding faces.
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> F`	`fillHole(E edge)` Insert a new face into an edge cycle with no left face.
`static <E extends Edge<?,E,F>,F extends Face<?,E,F>> E`	`findEdgeBetweenFaces(F leftFace, F rightFace)` Find an edge with given left and right faces.
`static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> E`	`findEdgeBetweenVertices(V startVertex, V targetVertex)` Find an edge with given start and target vertices.
`static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E>`	`findEdgesBetweenFaces(F leftFace, F rightFace)` Finds all edges with given left and right faces.
`static int`	`getGenus(HalfEdgeDataStructure<?,?,?> hds)` Calculates the genus of the 2-manifold represented by the given HalfedgeDataDtructure by evaluating X = hds.numVertices() - hds.numEdges() / 2 + hds.numFaces() r = number of boundary components g = (2 - X - r) / 2
`static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> E`	`incomingBoundaryEdge(V vertex)` For a boundary vertex, the incoming edge with getRightFace() == null is returned.
`static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<E>`	`incomingEdges(V vertex)` Return a list of the edges which have a given vertex as target vertex.
`static <E extends Edge<?,E,?>> boolean`	`isBoundaryEdge(E e)` Test if a given edge is on the boundary.
`static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> boolean`	`isBoundaryVertex(V vertex)` Test if a given vertex is on the boundary.
`static boolean`	`isInteriorEdge(Edge<?,?,?> e)` Test if a given edge is an interior edge (that is, not on the boundary).
`static <F extends Face<?,E,F>,E extends Edge<?,E,F>> boolean`	`isInteriorFace(F face)` Test if a given face is an inerior face (that is, not on the boundary).
`static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> boolean`	`isManifoldVertex(V v)` Returns true if the neighborhood of this vertex is homeomorphic either to R2 or to a half-space
`static boolean`	`isValidSurface(HalfEdgeDataStructure<?,?,?> heds)` Test whether the half-edge data structure represents a valid surface.
`static boolean`	`isValidSurface(HalfEdgeDataStructure<?,?,?> heds, boolean printReasonForFailureToSystemErr)` Test whether the half-edge data structure represents a valid surface and, optionally, give a reason if it fails the test.
`static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<V>`	`neighboringVertices(V vertex)` Return a list of those vertices that are connected to a given `vertex` by an edge.
`static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<E>`	`outgoingEdges(V vertex)` Return a list of the edges which have a given vertex as start vertex.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - addCube
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E addCube(HalfEdgeDataStructure<V,E,F> heds)
```
  - addDodecahedron
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E addDodecahedron(HalfEdgeDataStructure<V,E,F> heds)
```
  - addIcosahedron
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E addIcosahedron(HalfEdgeDataStructure<V,E,F> heds)
```
  - addNGon
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> F addNGon(HalfEdgeDataStructure<V,E,F> heds,
                                                                                              int n)
```
    Add a new n-gon.
    Increases the number of faces by 1, the number of edges by 2*n, and the number of vertices by n.
    
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    heds - the half-edge data structure
    
    n - the number of vertices
    
    Returns:
    
    the new face
  - addOctahedron
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E addOctahedron(HalfEdgeDataStructure<V,E,F> heds)
```
  - addTetrahedron
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E addTetrahedron(HalfEdgeDataStructure<V,E,F> heds)
```
  - boundaryComponents
```
public static <E extends Edge<?,E,?>> List<List<E>> boundaryComponents(HalfEdgeDataStructure<?,E,?> hds)
```
    Returns a list containing lists for all boundary components of hds with left face equal to null.
    
    Type Parameters:
    
    E - the edge type
    
    Parameters:
    
    hds - the surface
    
    Returns:
    
    the collection of boundary components
    
    See Also:
    
    boundaryEdges
  - boundaryEdges
```
public static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E> boundaryEdges(E e0)
```
    Return a list of edges which belong to the boundary component of e0
    
    Type Parameters:
    
    E -
    
    F -
    
    Parameters:
    
    e0 -
    
    Returns:
    
    the list of boundary edges in the correct cyclic order starting with the given e
  - boundaryEdges
```
public static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E> boundaryEdges(F face)
```
    Return a list of the edges which have a given face as left face.
    This method expects that if there is at least one such edge e, then all such edges, and only those, can be reached by repeatedly executing e = e.getNextEdge(), and that in the process e never becomes null.
    The returned list contains the boundary edges in the correct cyclic order.
    
    Type Parameters:
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    face - the face
    
    Returns:
    
    the list of boundary edges in the correct cyclic order
  - boundaryEdges
```
public static <E extends Edge<?,E,?>> List<E> boundaryEdges(HalfEdgeDataStructure<?,E,?> heds)
```
    Returns a collection containing all edges of heds with left face equal to null.
    
    Type Parameters:
    
    E - the edge type
    
    Parameters:
    
    heds - the surface
    
    Returns:
    
    the collection of boundary edges
  - boundaryFaces
```
public static <E extends Edge<?,E,F>,F extends Face<?,E,F>> Collection<F> boundaryFaces(HalfEdgeDataStructure<?,E,F> heds)
```
    Returns a collection containing all faces of heds with at least one boundary edge.
    
    Type Parameters:
    
    E - the edge type
    
    Parameters:
    
    heds - the surface
    
    Returns:
    
    the collection of boundary edges
  - boundaryVertices
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> List<V> boundaryVertices(F face)
```
    Returns a list containing all vertices that are target vertices of the boundary of the given face
    
    Type Parameters:
    
    V -
    
    E -
    
    F -
    
    Parameters:
    
    face - the face
    
    Returns:
    
    See Also:
    
    HalfEdgeUtils#boundaryEdges(Face)}
  - boundaryVertices
```
public static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> Collection<V> boundaryVertices(HalfEdgeDataStructure<V,E,?> surf)
```
    Returns a collection of all boundary vertices of surf. Assumes that surf represents a valid surface.
    
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    Parameters:
    
    surf -
    
    Returns:
    
    collection of boundary vertices
  - constructFaceByVertices
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> E constructFaceByVertices(HalfEdgeDataStructure<V,E,F> heds,
                                                                                                              Vertex<?,?,?>... v)
                                                                                                       throws RuntimeException
```
    Construct a new face by giving its vertices in cyclic order.
    This method assumes:
    - At least three non-null vertices are passed as parameters.
    - They belong to the HalfEdgeDataStructure heds.
    - Except for isolated vertices and missing faces, heds is a valid surface or empty. More precisely: If all vertices v with v.getIncomingEdge()== null were removed from heds, and after executing fillAllHoles(heds), heds would be empty or a valid surface.
    - There are no loops or double edges in heds. More precisely: If v0 and v1 are vertices of heds (where v0 == v1 is allowed) then there is at most one Edge with start vertex v0 and target vertex v1.
    - Adding a face with the given vertices will result in a HalfEdgeDataStructure without loops or double edges, which is again valid surface except for isolated vertices and missing faces.
    Failure of this method is not atomic: If it throws an exception, the half-edge data structure may be left in some intermediate state.
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    heds - the half-edge data structure
    
    v - the vertices
    
    Returns:
    
    an edge with the new face as left face
    
    Throws:
    
    RuntimeException - in some cases when something goes wrong. Of course, this should not happen if the above preconditions are fulfilled.
  - copy
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>,HDSSRC extends HalfEdgeDataStructure<V,E,F>,VV extends Vertex<VV,EE,FF>,EE extends Edge<VV,EE,FF>,FF extends Face<VV,EE,FF>,HDSDST extends HalfEdgeDataStructure<VV,EE,FF>> int copy(HDSSRC src,
                                                                                                                                                                                                                                                                        HDSDST dst)
```
    Inserts the nodes of src into dst
    
    Parameters:
    
    src -
    
    dst -
    
    Returns:
    
    The vertex offset of the new vertices in dst
  - facesIncidentWithVertex
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> List<F> facesIncidentWithVertex(V vertex)
```
    Return a list of faces that are incident with a given vertex.
    Uses incomingEdges(Vertex), so the preconditions explained there apply.
    The returned list contains the incident faces in clockwise order. It does not contain null, even if the vertex is on the boundary.
    
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    vertex - the vertex
    
    Returns:
    
    the incident faces in clockwise order
  - fillAllHoles
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> void fillAllHoles(HalfEdgeDataStructure<V,E,F> heds)
```
    Fill all holes by adding faces.
    Simply calls fillHole(Edge) on edges with no left face until all edges have a left face. Hence, the preconditions described there apply.
    
    Parameters:
    
    heds -
  - fillHole
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> F fillHole(E edge)
                                                                                        throws RuntimeException
```
    Insert a new face into an edge cycle with no left face.
    An edge cycle is a cycle of edges obtained by repeatedly applying Edge.getNextEdge(). This method expects that one does not encounter null when doing so, and that all edges in the cycle have null as left face.
    
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    edge - an edge of the edge cycle
    
    Returns:
    
    the new face
    
    Throws:
    
    RuntimeException - if it is called with null as parameter, of if Edge.getNextEdge() returns null for some edge in the edge cycle, or if Edge.getLeftFace() is not null for some edge in the cycle.
  - findEdgeBetweenFaces
```
public static <E extends Edge<?,E,F>,F extends Face<?,E,F>> E findEdgeBetweenFaces(F leftFace,
                                                                                   F rightFace)
```
    Find an edge with given left and right faces.
    Uses boundaryEdges(Face), so the preconditions explained there apply.
    
    Type Parameters:
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    leftFace - the left face (must not be null)
    
    rightFace - the right face (can be null)
    
    Returns:
    
    an edge with those faces as left and right face, or null if no such edge exists.
  - findEdgeBetweenVertices
```
public static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> E findEdgeBetweenVertices(V startVertex,
                                                                                        V targetVertex)
```
    Find an edge with given start and target vertices.
    Uses incomingEdges(Vertex), so the preconditions explained there apply.
    
    Type Parameters:
    
    V - the vertex type
    
    E - the edge type
    
    Parameters:
    
    startVertex - the start vertex
    
    targetVertex - the target vertex
    
    Returns:
    
    an edge with those vertices as start and target vertices, or null if no such edge exists.
  - findEdgesBetweenFaces
```
public static <E extends Edge<?,E,F>,F extends Face<?,E,F>> List<E> findEdgesBetweenFaces(F leftFace,
                                                                                          F rightFace)
```
    Finds all edges with given left and right faces.
    Uses boundaryEdges(Face), so the preconditions explained there apply.
    
    Type Parameters:
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    leftFace - the left face (must not be null)
    
    rightFace - the right face (can be null)
    
    Returns:
    
    a list of edges with those faces as left and right face, or an empty list if no such edge exists.
  - getGenus
```
public static int getGenus(HalfEdgeDataStructure<?,?,?> hds)
```
    Calculates the genus of the 2-manifold represented by the given HalfedgeDataDtructure by evaluating X = hds.numVertices() - hds.numEdges() / 2 + hds.numFaces() r = number of boundary components g = (2 - X - r) / 2
    
    Parameters:
    
    hds - a 2-manifold
    
    Returns:
    
    g
  - incomingBoundaryEdge
```
public static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> E incomingBoundaryEdge(V vertex)
```
    For a boundary vertex, the incoming edge with getRightFace() == null is returned.
    Uses incomingEdges(Vertex), so the preconditions explained there apply.
    
    Parameters:
    
    vertex -
    
    Returns:
    
    The first boundary edge that is found with the given vertex as target, null if the vertex is no boundary vertex.
  - incomingEdges
```
public static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<E> incomingEdges(V vertex)
```
    Return a list of the edges which have a given vertex as target vertex.
    This method expects that if there is one such edge e, then all such edges, and only those, can be reached by repeatedly executing e = e.getNextEdge().getOppositeEdge(), and that in the process e never becomes null.
    The returned list contains the incoming edges in clockwise order.
    
    Type Parameters:
    
    E - the edge type
    
    V - the vertex type
    
    Parameters:
    
    vertex - the vertex
    
    Returns:
    
    the list of incoming edges, in clockwise order
  - isBoundaryEdge
```
public static <E extends Edge<?,E,?>> boolean isBoundaryEdge(E e)
```
    Test if a given edge is on the boundary.
    
    Parameters:
    
    e -
    
    Returns:
    
    true if either e.getLeftFace() == null or e.getRightFace() == null.
  - isBoundaryVertex
```
public static <V extends Vertex<V,E,?>,E extends Edge<V,E,?>> boolean isBoundaryVertex(V vertex)
```
    Test if a given vertex is on the boundary.
    Uses incomingEdges(Vertex), so the preconditions explained there apply.
    
    Parameters:
    
    vertex -
    
    Returns:
    
    true if there is an incoming edge with null as left face, otherwise false.
  - isInteriorEdge
```
public static boolean isInteriorEdge(Edge<?,?,?> e)
```
    Test if a given edge is an interior edge (that is, not on the boundary).
    
    Parameters:
    
    e - the edge
    
    Returns:
    
    e.getLeftFace() != null && e.getRightFace() != null
  - isInteriorFace
```
public static <F extends Face<?,E,F>,E extends Edge<?,E,F>> boolean isInteriorFace(F face)
```
    Test if a given face is an inerior face (that is, not on the boundary).
    Uses boundaryEdges(Face), so the preconditions explained there apply.
    
    Type Parameters:
    
    E - the edge type
    
    F - the face type
    
    Parameters:
    
    face - the face
    
    Returns:
    
    false if there is a boundary edge with null as right face, otherwise true
  - isManifoldVertex
```
public static <V extends Vertex<V,E,F>,E extends Edge<V,E,F>,F extends Face<V,E,F>> boolean isManifoldVertex(V v)
```
    Returns true if the neighborhood of this vertex is homeomorphic either to R2 or to a half-space
    
    Parameters:
    
    v - the vertex
    
    Returns:
  - isValidSurface
```
public static boolean isValidSurface(HalfEdgeDataStructure<?,?,?> heds)
```
    Test whether the half-edge data structure represents a valid surface. Checks whether the following conditions are satisfied.
    
    1. The edge list is not empty.
    
    For all edges e in the edge list:
    
    2. Neither e.getNextEdge(), nor e.getPreviousEdge(), nor e.getOppositeEdge() returns null.
    3. e.getTargetVertex() does not return null.
    4. e.getLeftFace() and e.getRightFace() do not both return null.
    5. getLeftFace() returns the same face for e and e.getNextEdge().
    6. getTargetVertex() returns the same vertex for e and e.getNextEdge().getOppositeEdge().
    
    For all faces f in the face list:
    
    7. There is at least one edge e in the edge list that has f as left face. That is, there are no isolated faces.
    8. If you repeatedly perform e = e.getNextEdge(), you can reach all edges with f as left face.
    
    For all vertices v in the vertex list:
    
    9. There is at least one edge e in the edge list that has v as target vertex. That is, there are no isolated vertices.
    10. If you repeatedly perform e = e.getNextEdge().getOppositeEdge(), you can reach all edges with v as target vertex.
    11. Among all edges e with v as target vertex, there is at most one for which e.getLeftFace() returns null.
    
    Together with the invariants that are maintained by the classes in this package, this guarantees that the half-edge data structure encodes a cell decomposition of a surface.
    
    Returns:
    
    true if the half-edge data structure represents a valid surface, false otherwise
  - isValidSurface
```
public static boolean isValidSurface(HalfEdgeDataStructure<?,?,?> heds,
                                     boolean printReasonForFailureToSystemErr)
```
    Test whether the half-edge data structure represents a valid surface and, optionally, give a reason if it fails the test. If the parameter is false, this method behaves exatly as isValidSurface(HalfEdgeDataStructure). If the parameter is true, and the half-edge data structure fails to represent a valid surface, the method outputs a brief explanation to System.err. This feature is intended for debugging.
    
    Parameters:
    
    printReasonForFailureToSystemErr - true if you want output to System.err.
    
    Returns:
    
    true if the half-edge data structure represents a valid surface, false otherwise
  - neighboringVertices
```
public static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<V> neighboringVertices(V vertex)
```
    Return a list of those vertices that are connected to a given vertex by an edge.
    The ith element of in this list is simply
    vertex.getIncomingEdges(vertex).get(i).getStartVertex() .
    Thus, the preconditions of incomingEdges(Vertex) apply.
    The list contains the neighboring vertices in clockwise order, and it may contain the same vertex multiple times. (It may also contain nulls.)
    
    Type Parameters:
    
    E - the edge type
    
    V - the vertex type
    
    Parameters:
    
    vertex - the list of neighboring vertices.
    
    Returns:
    
    the list of neighbor vertices, in clockwise order
  - outgoingEdges
```
public static <E extends Edge<V,E,?>,V extends Vertex<V,E,?>> List<E> outgoingEdges(V vertex)
```
    Return a list of the edges which have a given vertex as start vertex.
    
    Parameters:
    
    vertex - the vertex
    
    Returns:
    
    the list of outgoing edges, in clockwise order
    
    See Also:
    
    incomingEdges

Class HalfEdgeUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

addCube

addDodecahedron

addIcosahedron

addNGon

addOctahedron

addTetrahedron

boundaryComponents

boundaryEdges

boundaryEdges

boundaryEdges

boundaryFaces

boundaryVertices

boundaryVertices

constructFaceByVertices

copy

facesIncidentWithVertex

fillAllHoles

fillHole

findEdgeBetweenFaces

findEdgeBetweenVertices

findEdgesBetweenFaces

getGenus

incomingBoundaryEdge

incomingEdges

isBoundaryEdge

isBoundaryVertex

isInteriorEdge

isInteriorFace

isManifoldVertex

isValidSurface

isValidSurface

neighboringVertices

outgoingEdges