PolygonalMesh (Artisynth API documentation)

java.lang.Object
- maspack.geometry.MeshBase
- - maspack.geometry.PolygonalMesh

All Implemented Interfaces:

java.lang.Cloneable, HasRenderProps, IsRenderable, IsSelectable, Renderable

Direct Known Subclasses:

NURBSMesh
```
public class PolygonalMesh
extends MeshBase
```
Implements a polygonal mesh consisting of vertices, faces, and half-edges.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALL_DEGENERACIES`
`boolean`	`canSelfIntersect`
`static int`	`computedFaceNormals`
`static int`	`ISOLATED_VERTICES`
`static int`	`NON_MANIFOLD_EDGES`
`static int`	`NON_MANIFOLD_VERTICES`
`static int`	`OPEN_EDGES`

Fields inherited from class maspack.geometry.MeshBase
XMeshToWorld

Fields inherited from interface maspack.render.IsRenderable
TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors
Constructor and Description
`PolygonalMesh()` Creates an empty polygonal mesh.
`PolygonalMesh(java.io.File file)` Creates a polygonal mesh and initializes it from a file, with the file format being inferred from the file name suffix.
`PolygonalMesh(PolygonalMesh old)`
`PolygonalMesh(java.lang.String fileName)` Creates a polygonal mesh and initializes it from a file, with the file format being inferred from the file name suffix.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Face`	`addFace(int[] indices)` Adds a face to this mesh.
`Face`	`addFace(int idx0, int idx1, int idx2)` Adds a triangular face to this mesh.
`Face`	`addFace(int idx0, int idx1, int idx2, int idx3)` Adds a quad face to this mesh.
`Face`	`addFace(Vertex3d[] vertices)` Adds a face to this mesh.
`Face`	`addFace(Vertex3d v0, Vertex3d v1, Vertex3d v2)` Adds a triangular face to this mesh.
`Face`	`addFace(Vertex3d v0, Vertex3d v1, Vertex3d v2, Vertex3d v3)` Adds a quad face to this mesh.
`void`	`addMesh(MeshBase mesh)`
`void`	`addMesh(PolygonalMesh mesh, boolean respectTransforms)` Adds copies of the vertices and faces of another mesh to this mesh.
`void`	`autoGenerateNormals()` Computes vertex normals using an angle-weighted average of the normals formed by the edges incident on each vertex.
`void`	`checkConsistency()` Make sure that this mesh is consistent, by checking that: (1) vertex and face indices are consistent (2) every face half edge is registered with it's head vertex (3) every half edge's opposite, if non-null, points back to itself (4) every half edge's head is the next half-edge's tail (5) every half edge's face is valid (6) every half edge's head and tail are different (7) every vertex indicent half edge refers to a valid face
`double`	`checkFaceNormals()`
`void`	`checkForDegenerateFaces()`
`void`	`clear()` Clears this mesh (makes it empty).
`void`	`clearBVTree()`
`void`	`clearFaces()`
`void`	`clearHardEdges()` Clears all the hard edges currently in this mesh.
`PolygonalMesh`	`clone()` Creates a clone of this mesh.
`double`	`computeArea()` Computes the surface area of this mesh.
`double`	`computeAverageEdgeLength()` Computes the average edge length for this mesh.
`double`	`computeCentreOfVolume(Vector3d c)` Computes the centre of volume of the mesh
`double`	`computeInertia(SpatialInertia M, double density)` Computes a spatial inertia for the volume defined by this mesh, assuming a uniform density density.
`RigidTransform3d`	`computePrincipalAxes()`
`static RigidTransform3d`	`computePrincipalAxes(PolygonalMesh mesh)`
`int[]`	`computeVertexNormals(java.util.ArrayList<Vector3d> normals, boolean multiNormals)` Computes a set of vertex normals for this mesh, using an angle-weighted average of the normals formed by the edges incident on each vertex.
`double`	`computeVolume()` Computes the volume of this mesh, on the assumption that it is manifold and closed.
`double`	`computeVolumeIntegrals(Vector3d mov1, Vector3d mov2, Vector3d pov)` Computes the volume integrals of this mesh, on the assumption that it is manifold and closed.
`PolygonalMesh`	`copy()` Creates a copy of this mesh.
`int`	`countBorders()`
`int`	`countConnected()`
`int`	`countEdges()`
`double`	`countGenus()`
`SpatialInertia`	`createInertia(double density)` Creates a spatial inertia for the volume defined by this mesh, assuming a constant density.
`SpatialInertia`	`createInertia(double mass, MassDistribution dist)` Computes a spatial inertia for this mesh, given a mass and a mass distribution.
`RenderProps`	`createRenderProps(HasProperties host)` Creates an appropriate RenderProps for this Mesh.
`int[]`	`createVertexIndices()` Creates and returns the vertex indices associated with each geometric feature in this mesh.
`double`	`distanceToPoint(Point3d pnt)` If this mesh is triangular, returns the nearest distance to a point.
`double`	`distanceToPoint(Point3d nearPnt, Point3d pnt)` If this mesh is triangular, returns the nearest distance to a point.
`int`	`doMergeCloseVertices(double dsqr)`
`boolean`	`epsilonEquals(MeshBase base, double eps)` Tests to see if a mesh equals this one.
`int`	`estimateMemoryUsage()` Returns the estimated memory useage for this mesh, in bytes.
`void`	`extendOpenEdges(double amount)` Extends the first open edge loop found.
`boolean`	`faceNormalsValid()` Returns true if face normals are currently valid.
`java.util.ArrayList<HalfEdge>`	`findBorderEdges()`
`java.util.ArrayList<Face>`	`findBorderFaces()`
`java.util.ArrayList<Vertex3d>`	`findNeighbouringVertices(Vertex3d vtx, double dist)` Find all vertices in the neighbourhood of `vtx` that are within a distance `dist` of `vtx`.
`java.util.ArrayList<Vertex3d>`	`findNonManifoldVertices()`
`void`	`flip()`
`BVTree`	`getBVTree()` Returns a bounding volume tree to be used for proximity queries involving this mesh.
`Face`	`getFace(int idx)` Returns the face with a specified index
`java.util.ArrayList<Face>`	`getFaces()` Returns this mesh's faces.
`HalfEdge`	`getHalfEdge(int idx)` Returns the half-edge with a specified index.
`boolean`	`getMultipleAutoNormals()` Returns `true` if multiple vertex normals are allowed when normals are computed automatically.
`int`	`getRenderHints()` Returns a bit code giving rendering hints about this renderable.
`DistanceGrid`	`getSignedDistanceGrid()`
`DistanceGrid`	`getSignedDistanceGrid(double margin, Vector3i cellDivisions)`
`PolygonalMesh`	`getSubdivisionMesh()` Generates and returns a subdivided version of this mesh interpolated using cubic patches.
`int`	`getSubdivisions()`
`boolean`	`getWriteNormals()` Returns `true` if this mesh's normals should be written to a file.
`boolean`	`hasAutoNormalCreation()` Returns `true` if this mesh automatically creates a default set of normals if `MeshBase.getNormals()` is called and no normals have been explicitly set using `MeshBase.setNormals(java.util.List<maspack.matrix.Vector3d>, int[])`.
`boolean`	`hasHardEdge(int vidx0, int vidx1)` Returns `true` if the edge between the vertices indexed by `vidx0` and `vidx1` exists and is hard, as described for `hasHardEdge(v0,v1)`.
`boolean`	`hasHardEdge(Vertex3d v0, Vertex3d v1)` Returns `true` if the edge between vertices `v0` and `v1` exists and is hard.
`boolean`	`hasIsolatedVertices()` Queries whether or not this mesh has isolated vertices.
`boolean`	`hasNonManifoldEdges()` Queries whether or not this mesh has non-manifold edges.
`boolean`	`hasNonManifoldVertices()` Queries whether or not this mesh has non-manifold vertices.
`boolean`	`hasOpenEdges()` Queries whether or not this mesh has open edges.
`void`	`interpolate(Point3d p, Face f, double u, double v)` Smoothly interpolate a face using barycentric coordinates.
`void`	`inverseTransform(AffineTransform3dBase X)` Applies an inverse affine transformation to the vertices of this mesh.
`void`	`inverseTransform(VectorTransformer3d T)` Applies an inverse vector transformation to the vertices of this mesh.
`boolean`	`isBorderVertex(Vertex3d vtx)`
`boolean`	`isClosed()` Queries if this mesh is closed.
`boolean`	`isManifold()` Queries if this mesh is manifold.
`boolean`	`isQuad()` Returns true if this is a quad mesh.
`boolean`	`isTriangular()` Returns true if this mesh is triangular.
`boolean`	`isWatertight()` Queries if this mesh is watertight.
`int`	`mergeCloseVertices(double dist)` Merge vertices that are within a prescribed distance of each other.
`boolean`	`mergeCoplanarFaces(double cosLimit)` Merges adjacent faces whose normals satisfy n1.dot(n2) `>` cosLimit
`Face`	`nearestFaceToPoint(Point3d nearPnt, Vector2d uv, Point3d pnt)` If this mesh is triangular, returns the nearest triangular face to a point.
`void`	`notifyVertexPositionsModified()` Notifies this mesh that vertex positions have been modified, and cached data dependent on these positions should be invalidated.
`int`	`numDegenerateFaces()`
`int`	`numDisconnectedVertices()`
`int`	`numFaces()` Returns the number of faces in this mesh.
`int`	`numFeatures()` Returns the number of features in this mesh.
`int`	`numHardEdges()` Returns the number of hard edges currently in this mesh.
`PolygonalMesh[]`	`partitionIntoConnectedMeshes()` Copies this mesh into a set of connected meshes and returns these as an array.
`int`	`pointIsInside(Point3d pnt)` If this mesh is triangular and closed, determines if a point is inside or outside the mesh.
`void`	`prerender(RenderProps props)`
`void`	`printDegeneracies()`
`void`	`printDegeneracies(int printCode)` Prints topological degeneracies associated with this mesh.
`void`	`printDegenerateFaces()`
`void`	`read(java.io.Reader reader)` Reads the contents of this mesh from a Reader.
`void`	`read(ReaderTokenizer rtok, boolean zeroIndexed)` Reads the contents of this mesh from a ReaderTokenizer.
`void`	`read(java.lang.String input)` Reads the contents of this mesh from a string.
`void`	`read(java.lang.String input, boolean zeroIndexed)` Reads the contents of this mesh from a string.
`int`	`removeDisconnectedFaces()`
`int`	`removeDisconnectedVertices()`
`boolean`	`removeFace(Face face)` Removes a face from this mesh.
`boolean`	`removeFaceFast(Face face)` Removes a face from this mesh, potentially changing order of faces
`java.util.ArrayList<java.lang.Integer>`	`removeFaces(java.util.Collection<Face> faces)` Removes a set of faces from this mesh, as indicated by a collection.
`java.util.ArrayList<java.lang.Integer>`	`removeFacesX(java.util.Collection<Face> faces)` Removes a set of faces from this mesh, as indicated by a collection.
`boolean`	`removeOppositeFaces(double cosLimit)` Remove adjacent faces whose normals satisfy n1.dot(n2) `<` cosLimit
`void`	`render(Renderer renderer, RenderProps props, int flags)`
`void`	`replaceVertices(java.util.List<? extends Vertex3d> vtxs)`
`void`	`set(double[][] pnts, int[][] faceIndices)` Sets the vertex points and faces associated with this mesh.
`void`	`set(Point3d[] pnts, int[][] faceIndices)` Sets the vertex points and faces associated with this mesh.
`boolean`	`setHardEdge(int vidx0, int vidx1, boolean hard)` Sets the edge between the vertices indexed by `vidx0` and `vidx1` to be hard, as described for `hasHardEdge(v0,v1)`.
`boolean`	`setHardEdge(Vertex3d v0, Vertex3d v1, boolean hard)` Sets the edge between the vertices `v0` and `v1` to be hard, as described for `hasHardEdge(v0,v1)`.
`void`	`setHardEdgesFromFaceNormals(double cosThreshold)` Sets edges to be "hard" based on angle between faces.
`boolean`	`setHardEdgesFromNormals()`
`void`	`setMeshToWorld(RigidTransform3d X)` Sets the spatial transform this mesh.
`void`	`setMultipleAutoNormals(boolean enable)` Enable or disable multiple vertex normals when normals are computed automatically, as described for `getMultipleAutoNormals()`.
`void`	`setSubdivisions(int subdivisions)` Setting this generates a new mesh therefore any previous meshes are invalidated and should be discarded.
`boolean`	`supportsMassDistribution(MassDistribution dist)` Queries whether or not a given mass distrubution is supported for this mesh type.
`void`	`transform(AffineTransform3dBase X)` Applies an affine transformation to the vertices of this mesh.
`void`	`transform(VectorTransformer3d T)` Applies a vector transformation to the vertices of this mesh.
`RigidTransform3d`	`translateToCenterOfVolume()` Translates the vertices of this mesh so that its origin coincides with the center of volume.
`void`	`triangulate()` Modifies this mesh to ensure that all faces are triangles.
`void`	`updateFaceNormals()` Updates face normals if necessary.
`void`	`updateRenderNormals()` Updates face rendering normals if necessary.
`void`	`updateSubdivisionMesh(PolygonalMesh mesh)` Updates a subdivision mesh.
`void`	`write(java.io.PrintWriter pw, NumberFormat fmt, boolean zeroIndexed)` Writes this mesh to a PrintWriter, using an Alias Wavefront "obj" file format.
`void`	`write(java.io.PrintWriter pw, NumberFormat fmt, boolean zeroIndexed, boolean facesClockwise)` Writes this mesh to a PrintWriter, using an Alias Wavefront "obj" file format.
`void`	`writePoly(java.io.PrintStream ps)`
`void`	`writePoly(java.lang.String nodeString)`
`void`	`writeWorld(java.io.PrintStream ps)`

Methods inherited from class maspack.geometry.MeshBase
addVertex, addVertex, addVertex, addVertex, checksum, clearColors, clearNormals, clearTextureCoords, computeAverageRadius, computeCentroid, computeLocalBounds, computeOBB, computeOBB, computeRadius, computeWorldBounds, containsVertex, createFeatureIndices, createRenderProps, getColor, getColorIndices, getColorInterpolation, getColors, getFeatureColor, getFeatureColoringEnabled, getFeatureIndexOffsets, getFeatureNormal, getFeatureTextureCoords, getLocalBounds, getMeshToWorld, getMeshToWorld, getName, getNormal, getNormalIndices, getNormals, getRadius, getRenderNormal, getRenderProps, getSelection, getTextureCoords, getTextureCoords, getTextureIndices, getVersion, getVertex, getVertexColoringEnabled, getVertexColorMixing, getVertices, getWorldBounds, getXMeshToWorldRender, hasColors, hasExplicitColors, hasExplicitNormals, hasNormals, hasTextureCoords, isColorsFixed, isEmpty, isFeatureColored, isFixed, isRenderBuffered, isSelectable, isTextureCoordsFixed, isVertexColored, meshToWorldIsIdentity, numColors, numNormals, numSelectionQueriesNeeded, numTextureCoords, numVertices, perturb, prerender, read, read, read, removeVertex, removeVertexFast, removeVertices, render, saveRenderInfo, scale, scale, setColor, setColor, setColor, setColor, setColorInterpolation, setColors, setColorsFixed, setFeatureColoringEnabled, setFixed, setName, setNormal, setNormals, setRenderBuffered, setRenderProps, setTextureCoords, setTextureCoords, setTextureCoordsFixed, setVertexColoringEnabled, setVertexColorMixing, size, transformToLocal, transformToLocal, transformToOBB, transformToOBB, transformToWorld, transformToWorld, translate, translateToCentroid, updateBounds, write, write, write, write

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

- Field Detail
  - NON_MANIFOLD_EDGES
```
public static final int NON_MANIFOLD_EDGES
```
    See Also:
    
    Constant Field Values
  - NON_MANIFOLD_VERTICES
```
public static final int NON_MANIFOLD_VERTICES
```
    See Also:
    
    Constant Field Values
  - OPEN_EDGES
```
public static final int OPEN_EDGES
```
    See Also:
    
    Constant Field Values
  - ISOLATED_VERTICES
```
public static final int ISOLATED_VERTICES
```
    See Also:
    
    Constant Field Values
  - ALL_DEGENERACIES
```
public static final int ALL_DEGENERACIES
```
    See Also:
    
    Constant Field Values
  - canSelfIntersect
```
public boolean canSelfIntersect
```
  - computedFaceNormals
```
public static int computedFaceNormals
```
- Constructor Detail
  - PolygonalMesh
```
public PolygonalMesh()
```
    Creates an empty polygonal mesh.
  - PolygonalMesh
```
public PolygonalMesh(java.lang.String fileName)
              throws java.io.IOException
```
    Creates a polygonal mesh and initializes it from a file, with the file format being inferred from the file name suffix.
    
    Parameters:
    
    fileName - name of the file containing the mesh description
    
    Throws:
    
    java.io.IOException - if an I/O error occurred or if the file type is not compatible with polygonal meshes
  - PolygonalMesh
```
public PolygonalMesh(java.io.File file)
              throws java.io.IOException
```
    Creates a polygonal mesh and initializes it from a file, with the file format being inferred from the file name suffix.
    
    Parameters:
    
    file - file containing the mesh description
    
    Throws:
    
    java.io.IOException - if an I/O error occurred or if the file type is not compatible with polygonal meshes
  - PolygonalMesh
```
public PolygonalMesh(PolygonalMesh old)
```
- Method Detail
  - notifyVertexPositionsModified
```
public void notifyVertexPositionsModified()
```
    Notifies this mesh that vertex positions have been modified, and cached data dependent on these positions should be invalidated.
    
    Overrides:
    
    notifyVertexPositionsModified in class MeshBase
  - updateFaceNormals
```
public void updateFaceNormals()
```
    Updates face normals if necessary.
  - updateRenderNormals
```
public void updateRenderNormals()
```
    Updates face rendering normals if necessary.
  - faceNormalsValid
```
public boolean faceNormalsValid()
```
    Returns true if face normals are currently valid.
  - createRenderProps
```
public RenderProps createRenderProps(HasProperties host)
```
    Creates an appropriate RenderProps for this Mesh. If the supplied host is non-null, then it is used to initialize any inherited properties. The property name associated with the host is assumed to be "renderProps".
    
    Specified by:
    
    createRenderProps in class MeshBase
    
    Parameters:
    
    host - if non-null, is used to initialize inherited values
    
    Returns:
    
    render properties appropriate for this mesh
  - isTriangular
```
public boolean isTriangular()
```
    Returns true if this mesh is triangular. A mesh is triangular if all its faces are triangles.
    
    Returns:
    
    true if this mesh is triangular
  - isQuad
```
public boolean isQuad()
```
    Returns true if this is a quad mesh. A mesh is quad if all its faces have four sides.
    
    Returns:
    
    true if this is a quad mesh
  - hasIsolatedVertices
```
public boolean hasIsolatedVertices()
```
    Queries whether or not this mesh has isolated vertices. These are vertices which are not connected to any edge.
    
    Returns:
    
    true if this mesh has isolated vertices.
  - hasOpenEdges
```
public boolean hasOpenEdges()
```
    Queries whether or not this mesh has open edges. An open edge is an edge which is connected to only a single face.
    
    Returns:
    
    true if this mesh has open edges.
  - hasNonManifoldEdges
```
public boolean hasNonManifoldEdges()
```
    Queries whether or not this mesh has non-manifold edges. A non-manifold edge is an edge that is connected to three or more faces. Note: in some literature, a manifold edge is defined more strictly to require that it is connected to exactly two faces. We relax this definition so that an edge may have one or two faces. If any edges are associated with one face, then hasOpenEdges() will return true.
    
    Returns:
    
    true if this mesh has non-manifold edges.
    
    See Also:
    
    hasOpenEdges()
  - hasNonManifoldVertices
```
public boolean hasNonManifoldVertices()
```
    Queries whether or not this mesh has non-manifold vertices. A non-vertex is a vertex whose incident faces do not form a fan. This fan may be either open or closed. In some literature, a manifold vertex is defined more strictly to require that the fan be closed. If any fans are not closed, then hasOpenEdges() will return true.
    If hasNonManifoldEdges() returns true, then this predicate will return true also.
    
    Returns:
    
    true if this mesh has non-manifold vertices.
    
    See Also:
    
    hasOpenEdges(), hasNonManifoldEdges()
  - isClosed
```
public boolean isClosed()
```
    Queries if this mesh is closed. This is the strictest topology predicate, requiring that the mesh is both manifold (so that isManifold() returns true), and also has no open edges, so that hasOpenEdges() returns false.
    
    Returns:
    
    true if the mesh is closed
  - isManifold
```
public boolean isManifold()
```
    Queries if this mesh is manifold. This is equivalent to hasNonManifoldEdges(), hasNonManifoldVertices(), and hasIsolatedVertices() all returning false.
    Note: some definitions of "manifold" also require that the mesh does not self-intersect. This primitive does not check for this.
    
    Returns:
    
    true if the mesh is manifold.
  - isWatertight
```
public boolean isWatertight()
```
    Queries if this mesh is watertight. This is a more relaxed version of closed, in which the mesh may not have any open edges but in which it may have non-manifold vertices. It is therefore equivalent to hasOpenEdges(), hasNonManifoldEdges(), and hasIsolatedVertices() all returning false.
    
    Returns:
    
    true if the mesh is watertight.
  - findNonManifoldVertices
```
public java.util.ArrayList<Vertex3d> findNonManifoldVertices()
```
  - getFaces
```
public java.util.ArrayList<Face> getFaces()
```
    Returns this mesh's faces. The faces are contained within an ArrayList, each element of which is of type Face. Modifying these elements will modify the mesh.
    
    Returns:
    
    list of this mesh's faces.
  - numFaces
```
public int numFaces()
```
    Returns the number of faces in this mesh.
    
    Returns:
    
    number of faces in this mesh
  - getFace
```
public Face getFace(int idx)
```
    Returns the face with a specified index
    
    Parameters:
    
    idx - index of the face
    
    Returns:
    
    indexed face
  - getHalfEdge
```
public HalfEdge getHalfEdge(int idx)
```
    Returns the half-edge with a specified index. The index is assumed to be
```
 3 * faceIdx + edgeNum
 
```
    where faceIdx is the index for the edge's face, and edgeNum is the edge's number with respect to the face (with face.firstHalfEdge() corresponding to 0).
    Parameters:
    
    idx - index of the half-edge
    
    Returns:
    
    indexed half-edge
  - countEdges
```
public int countEdges()
```
  - getSignedDistanceGrid
```
public DistanceGrid getSignedDistanceGrid()
```
  - getSignedDistanceGrid
```
public DistanceGrid getSignedDistanceGrid(double margin,
                                          Vector3i cellDivisions)
```
  - setMeshToWorld
```
public void setMeshToWorld(RigidTransform3d X)
```
    Description copied from class: MeshBase
    
    Sets the spatial transform this mesh. At present, the spatial transform is used only for rendering. If the transform is the identity, then meshToWorldIsIdentity will subsequently return true.
    
    Overrides:
    
    setMeshToWorld in class MeshBase
    
    Parameters:
    
    X - transform from mesh to world coordinates
  - read
```
public void read(java.io.Reader reader)
          throws java.io.IOException
```
    Reads the contents of this mesh from a Reader. The input is assumed to be supplied in Alias Wavefront obj format, as described for the method write(PrintWriter,NumberFormat,boolean).
    
    Overrides:
    
    read in class MeshBase
    
    Parameters:
    
    reader - supplied the input description of the mesh
    
    Throws:
    
    java.io.IOException
  - read
```
public void read(java.lang.String input)
```
    Reads the contents of this mesh from a string. The string input is assumed to be supplied in Alias Wavefront obj format, as described for the method write(PrintWriter,NumberFormat,boolean).
    
    Parameters:
    
    input - supplied input description of the mesh
  - read
```
public void read(java.lang.String input,
                 boolean zeroIndexed)
```
    Reads the contents of this mesh from a string. The string input is assumed to be supplied in Alias Wavefront obj format, as described for the method write(PrintWriter,NumberFormat,boolean).
    
    Parameters:
    
    input - supplied input description of the mesh
  - read
```
public void read(ReaderTokenizer rtok,
                 boolean zeroIndexed)
          throws java.io.IOException
```
    Reads the contents of this mesh from a ReaderTokenizer. The input is assumed to be supplied in Alias Wavefront obj format, as described for the method write(PrintWriter,NumberFormat,boolean).
    
    Specified by:
    
    read in class MeshBase
    
    Parameters:
    
    rtok - tokenizer supplying the input description of the mesh
    
    zeroIndexed - if true, the index numbering for mesh vertices starts at 0. Otherwise, numbering starts at 1.
    
    Throws:
    
    java.io.IOException
  - set
```
public void set(Point3d[] pnts,
                int[][] faceIndices)
```
    Sets the vertex points and faces associated with this mesh.
    
    Parameters:
    
    pnts - points from which the vertices are formed
    
    faceIndices - integer arrays giving the indices of each face. Each index should correspond to a particular point in pnts.
    
    Throws:
    
    java.lang.IllegalArgumentException - if a vertex index is out of bounds
  - addFace
```
public Face addFace(int[] indices)
```
    Adds a face to this mesh. A face is described by indices which specify, in counter-clockwise order, the vertices which describe this face.
    
    Parameters:
    
    indices - integer array giving the vertex indices of the face. Each index should correspond to a vertex presently associated with this mesh.
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if a vertex index is out of bounds
  - addFace
```
public Face addFace(Vertex3d[] vertices)
```
    Adds a face to this mesh. A face is described by an array of vertices arranged in counter-clockwise order with respect to the face's normal.
    
    Parameters:
    
    vertices - vertices comprising this faces. Each vertex should be presently contained in this mesh.
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if any vertices are not contained within this mesh
  - addFace
```
public Face addFace(Vertex3d v0,
                    Vertex3d v1,
                    Vertex3d v2)
```
    Adds a triangular face to this mesh. The face is described by three vertices arranged in counter-clockwise order with respect to the face's normal.
    
    Parameters:
    
    v0 - first vertex
    
    v1 - second vertex
    
    v2 - third vertex
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if any vertices are not contained within this mesh
  - addFace
```
public Face addFace(int idx0,
                    int idx1,
                    int idx2)
```
    Adds a triangular face to this mesh. The face is described by three vertex indices arranged in counter-clockwise order with respect to the face's normal.
    
    Parameters:
    
    idx0 - first vertex index
    
    idx1 - second vertex index
    
    idx2 - third vertex index
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if any vertices are not contained within this mesh
  - addFace
```
public Face addFace(Vertex3d v0,
                    Vertex3d v1,
                    Vertex3d v2,
                    Vertex3d v3)
```
    Adds a quad face to this mesh. The face is described by four vertices arranged in counter-clockwise order with respect to the face's normal.
    
    Parameters:
    
    v0 - first vertex
    
    v1 - second vertex
    
    v2 - third vertex
    
    v3 - fourth vertex
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if any vertices are not contained within this mesh
  - addFace
```
public Face addFace(int idx0,
                    int idx1,
                    int idx2,
                    int idx3)
```
    Adds a quad face to this mesh. The face is described by four vertex indices arranged in counter-clockwise order with respect to the face's normal.
    
    Parameters:
    
    idx0 - first vertex index
    
    idx1 - second vertex index
    
    idx2 - third vertex index
    
    idx3 - fourth vertex index
    
    Returns:
    
    the created Face object
    
    Throws:
    
    java.lang.IllegalArgumentException - if any vertices are not contained within this mesh
  - removeFace
```
public boolean removeFace(Face face)
```
    Removes a face from this mesh.
    
    Parameters:
    
    face - face to remove
    
    Returns:
    
    false if the face does not belong to this mesh.
  - removeFaceFast
```
public boolean removeFaceFast(Face face)
```
    Removes a face from this mesh, potentially changing order of faces
  - removeFaces
```
public java.util.ArrayList<java.lang.Integer> removeFaces(java.util.Collection<Face> faces)
```
    Removes a set of faces from this mesh, as indicated by a collection.
    
    Parameters:
    
    faces - Collection of faces to remove
  - removeFacesX
```
public java.util.ArrayList<java.lang.Integer> removeFacesX(java.util.Collection<Face> faces)
```
    Removes a set of faces from this mesh, as indicated by a collection.
    
    Parameters:
    
    faces - Collection of faces to remove
  - clearFaces
```
public void clearFaces()
```
  - doMergeCloseVertices
```
public int doMergeCloseVertices(double dsqr)
```
  - mergeCloseVertices
```
public int mergeCloseVertices(double dist)
```
    Merge vertices that are within a prescribed distance of each other. Setting this distance to zero will cause only duplicate vertices to be merge. The algorithm used by this method determines vertex distances by examining edge lengths, and then collapsing edges whose distances are less than or equal to dist. Thus vertices which are isolated, or not otherwise connected by edges, will be unaffected.
    The implementation of this algorithm is not perfect. If the mesh is not closed, and merging results in the alignment of one or more boundary edges, these edges will not be connected. Moreover, the mesh topology may sometimes may it impossible to merge an adjacent vertex without corrupting the mesh topology; in these cases, merges will not be done and a warning will be printed.
    
    Parameters:
    
    dist - distance within which vertices should be merged.
  - mergeCoplanarFaces
```
public boolean mergeCoplanarFaces(double cosLimit)
```
    Merges adjacent faces whose normals satisfy n1.dot(n2) > cosLimit
    
    Parameters:
    
    cosLimit - limit above which faces should be merged
    
    Returns:
    
    true if modified, false otherwise
  - removeOppositeFaces
```
public boolean removeOppositeFaces(double cosLimit)
```
    Remove adjacent faces whose normals satisfy n1.dot(n2) < cosLimit
    
    Parameters:
    
    cosLimit - limit above which faces should be removed
    
    Returns:
    
    true if modified, false otherwise
  - numDisconnectedVertices
```
public int numDisconnectedVertices()
```
  - removeDisconnectedVertices
```
public int removeDisconnectedVertices()
```
  - removeDisconnectedFaces
```
public int removeDisconnectedFaces()
```
  - partitionIntoConnectedMeshes
```
public PolygonalMesh[] partitionIntoConnectedMeshes()
```
    Copies this mesh into a set of connected meshes and returns these as an array. If this mesh is already fully connected, no meshes are produced and null is returned. At present, the copied meshes do not preserve face normal or texture information.
    The returned meshes are sorted, high to low, by the number of vertices.
  - checkConsistency
```
public void checkConsistency()
```
    Make sure that this mesh is consistent, by checking that: (1) vertex and face indices are consistent (2) every face half edge is registered with it's head vertex (3) every half edge's opposite, if non-null, points back to itself (4) every half edge's head is the next half-edge's tail (5) every half edge's face is valid (6) every half edge's head and tail are different (7) every vertex indicent half edge refers to a valid face
  - set
```
public void set(double[][] pnts,
                int[][] faceIndices)
```
    Sets the vertex points and faces associated with this mesh.
    
    Parameters:
    
    pnts - set of values (x,y,z) from which the vertices are formed
    
    faceIndices - integer arrays giving the indices of each face. Each index should correspond to a particular point in pnts.
    
    Throws:
    
    java.lang.IllegalArgumentException - if a vertex index is out of bounds
  - write
```
public void write(java.io.PrintWriter pw,
                  NumberFormat fmt,
                  boolean zeroIndexed)
           throws java.io.IOException
```
    Writes this mesh to a PrintWriter, using an Alias Wavefront "obj" file format. Behaves the same as write(java.io.PrintWriter,maspack.util.NumberFormat,boolean,boolean) with facesClockwise set to false.
    
    Specified by:
    
    write in class MeshBase
    
    Parameters:
    
    pw - PrintWriter to write this mesh to
    
    fmt - format for writing the vertex coordinates. If null, a format of "%.8g" is assumed.
    
    zeroIndexed - if true, index numbering for mesh vertices starts at 0. Otherwise, numbering starts at 1.
    
    Throws:
    
    java.io.IOException
  - write
```
public void write(java.io.PrintWriter pw,
                  NumberFormat fmt,
                  boolean zeroIndexed,
                  boolean facesClockwise)
           throws java.io.IOException
```
    Writes this mesh to a PrintWriter, using an Alias Wavefront "obj" file format. Vertices are printed first, each starting with the letter "v" and followed by x, y, and z coordinates. Faces are printed next, starting with the letter "f" and followed by a list of integers which gives the indices of that face's vertices in counter-clockwise order. For example, a mesh consisting of a simple tetrahedron might be written like this:
```
    v 0.0 0.0 0.0
    v 1.0 0.0 0.0
    v 0.0 1.0 0.0
    v 0.0 0.0 1.0
    f 1 2 3
    f 0 2 1
    f 0 3 2
    f 0 1 3
 
```
    The format used to print vertex coordinates is specified by a NumberFormat.
    Parameters:
    
    pw - PrintWriter to write this mesh to
    
    fmt - format for writing the vertex coordinates. If null, a format of "%.8g" is assumed.
    
    zeroIndexed - if true, index numbering for mesh vertices starts at 0. Otherwise, numbering starts at 1.
    
    facesClockwise - if true, face indices are written clockwise instead of the usual counter-clockwise convention.
    
    Throws:
    
    java.io.IOException
  - writePoly
```
public void writePoly(java.lang.String nodeString)
               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - writePoly
```
public void writePoly(java.io.PrintStream ps)
               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - translateToCenterOfVolume
```
public RigidTransform3d translateToCenterOfVolume()
```
    Translates the vertices of this mesh so that its origin coincides with the center of volume. The topology of the mesh remains unchanged.
    
    Returns:
    
    the resulting rigid transform that was applied to the mesh
  - transform
```
public void transform(AffineTransform3dBase X)
```
    Applies an affine transformation to the vertices of this mesh. The topology of the mesh remains unchanged.
    
    Overrides:
    
    transform in class MeshBase
    
    Parameters:
    
    X - affine transformation
  - inverseTransform
```
public void inverseTransform(AffineTransform3dBase X)
```
    Applies an inverse affine transformation to the vertices of this mesh. The topology of the mesh remains unchanged.
    
    Overrides:
    
    inverseTransform in class MeshBase
    
    Parameters:
    
    X - affine transformation
  - transform
```
public void transform(VectorTransformer3d T)
```
    Applies a vector transformation to the vertices of this mesh. The topology of the mesh remains unchanged.
    
    Overrides:
    
    transform in class MeshBase
    
    Parameters:
    
    T - vector transformation
  - inverseTransform
```
public void inverseTransform(VectorTransformer3d T)
```
    Applies an inverse vector transformation to the vertices of this mesh. The topology of the mesh remains unchanged.
    
    Overrides:
    
    inverseTransform in class MeshBase
    
    Parameters:
    
    T - vector transformation
  - getRenderHints
```
public int getRenderHints()
```
    Returns a bit code giving rendering hints about this renderable. Current bit codes include TRANSPARENT and TWO_DIMENSIONAL.
    
    Specified by:
    
    getRenderHints in interface IsRenderable
    
    Overrides:
    
    getRenderHints in class MeshBase
    
    Returns:
    
    bit code of rendering hints.
  - clear
```
public void clear()
```
    Clears this mesh (makes it empty).
    
    Overrides:
    
    clear in class MeshBase
  - prerender
```
public void prerender(RenderProps props)
```
    Overrides:
    
    prerender in class MeshBase
  - render
```
public void render(Renderer renderer,
                   RenderProps props,
                   int flags)
```
    Specified by:
    
    render in class MeshBase
  - getSubdivisionMesh
```
public PolygonalMesh getSubdivisionMesh()
```
    Generates and returns a subdivided version of this mesh interpolated using cubic patches.
    
    Returns:
    
    The subdivision mesh. Null is returned
  - updateSubdivisionMesh
```
public void updateSubdivisionMesh(PolygonalMesh mesh)
```
    Updates a subdivision mesh.
    
    Parameters:
    
    mesh - Must be a mesh generated by calling getSubdivisionMesh on this mesh.
  - interpolate
```
public void interpolate(Point3d p,
                        Face f,
                        double u,
                        double v)
```
    Smoothly interpolate a face using barycentric coordinates.
    
    Parameters:
    
    f - The face to interpolate.
    
    u - The weighting of the first vertice.
    
    v - The weighting of the second vertice.
  - getSubdivisions
```
public int getSubdivisions()
```
  - setSubdivisions
```
public void setSubdivisions(int subdivisions)
```
    Setting this generates a new mesh therefore any previous meshes are invalidated and should be discarded.
    
    Parameters:
    
    subdivisions - The number of times to subdivide each triangle.
  - extendOpenEdges
```
public void extendOpenEdges(double amount)
```
    Extends the first open edge loop found.
    
    Parameters:
    
    amount - The amount to extend it by.
  - triangulate
```
public void triangulate()
```
    Modifies this mesh to ensure that all faces are triangles.
  - numHardEdges
```
public int numHardEdges()
```
    Returns the number of hard edges currently in this mesh.
    
    Returns:
    
    number of hard edges
  - clearHardEdges
```
public void clearHardEdges()
```
    Clears all the hard edges currently in this mesh.
  - setHardEdge
```
public boolean setHardEdge(int vidx0,
                           int vidx1,
                           boolean hard)
```
    Sets the edge between the vertices indexed by vidx0 and vidx1 to be hard, as described for hasHardEdge(v0,v1). If so such edge exists, the method returns false.
    
    Parameters:
    
    vidx0 - first vertex index
    
    vidx1 - second vertex index
    
    Returns:
    
    true if the edge exists
  - setHardEdge
```
public boolean setHardEdge(Vertex3d v0,
                           Vertex3d v1,
                           boolean hard)
```
    Sets the edge between the vertices v0 and v1 to be hard, as described for hasHardEdge(v0,v1). If no such edge exists, or if the edge corresponds only to a single half-edge, the method returns false.
    
    Parameters:
    
    v0 - first vertex
    
    v1 - second vertex
    
    Returns:
    
    true if the edge exists
  - hasHardEdge
```
public boolean hasHardEdge(int vidx0,
                           int vidx1)
```
    Returns true if the edge between the vertices indexed by vidx0 and vidx1 exists and is hard, as described for hasHardEdge(v0,v1).
    
    Parameters:
    
    vidx0 - first vertex index
    
    vidx1 - second vertex index
    
    Returns:
    
    true if the edge exists and is hard.
  - hasHardEdge
```
public boolean hasHardEdge(Vertex3d v0,
                           Vertex3d v1)
```
    Returns true if the edge between vertices v0 and v1 exists and is hard. A hard setting is used as a hint that the edge is associated with an actual discontinuity in the surface derivative, and that it may be desirable to render it crisply even when using smooth shading.
    
    Parameters:
    
    v0 - first vertex
    
    v1 - second vertex
    
    Returns:
    
    true if the edge exists and is hard.
  - checkFaceNormals
```
public double checkFaceNormals()
```
  - numDegenerateFaces
```
public int numDegenerateFaces()
```
  - checkForDegenerateFaces
```
public void checkForDegenerateFaces()
```
  - copy
```
public PolygonalMesh copy()
```
    Creates a copy of this mesh.
    
    Overrides:
    
    copy in class MeshBase
  - clone
```
public PolygonalMesh clone()
```
    Description copied from class: MeshBase
    
    Creates a clone of this mesh.
    
    Overrides:
    
    clone in class MeshBase
  - replaceVertices
```
public void replaceVertices(java.util.List<? extends Vertex3d> vtxs)
```
    Overrides:
    
    replaceVertices in class MeshBase
  - addMesh
```
public void addMesh(MeshBase mesh)
```
  - addMesh
```
public void addMesh(PolygonalMesh mesh,
                    boolean respectTransforms)
```
    Adds copies of the vertices and faces of another mesh to this mesh. If the other mesh contains normal information, this will be added as well providing this mesh already contains normal information or is empty. Otherwise, normal information for this mesh will be cleared. The same behavior is observed for texture and color information.
    
    Parameters:
    
    mesh - Mesh to be added to this mesh
  - computeVolume
```
public double computeVolume()
```
    Computes the volume of this mesh, on the assumption that it is manifold and closed. The code for this was taken from vclip, by Brian Mirtich. See "Fast and Accurate Computation of Polyhedral Mass Properties," Brian Mirtich, journal of graphics tools, volume 1, number 2, 1996.
    
    Returns:
    
    closed volume of the mesh
  - computeArea
```
public double computeArea()
```
    Computes the surface area of this mesh.
    
    Returns:
    
    surface area of the mesh
  - computeAverageEdgeLength
```
public double computeAverageEdgeLength()
```
    Computes the average edge length for this mesh.
    
    Returns:
    
    average edge length of the mesh
  - findBorderFaces
```
public java.util.ArrayList<Face> findBorderFaces()
```
  - findBorderEdges
```
public java.util.ArrayList<HalfEdge> findBorderEdges()
```
  - findNeighbouringVertices
```
public java.util.ArrayList<Vertex3d> findNeighbouringVertices(Vertex3d vtx,
                                                              double dist)
```
    Find all vertices in the neighbourhood of vtx that are within a distance dist of vtx. The returned list includes vtx as its first component.
    The method will not necessarily return all vertices that are within dist of vtx. For example, if the mesh folds back on itself, then vertices in the ``fold back'' region may be missed.
    
    Parameters:
    
    vtx - vertex for which nearest vertices are desired
    
    dist - search distance from vtx
  - computeVolumeIntegrals
```
public double computeVolumeIntegrals(Vector3d mov1,
                                     Vector3d mov2,
                                     Vector3d pov)
```
    Computes the volume integrals of this mesh, on the assumption that it is manifold and closed. The code for this was taken from vclip, by Brian Mirtich. See "Fast and Accurate Computation of Polyhedral Mass Properties," Brian Mirtich, journal of graphics tools, volume 1, number 2, 1996.
    
    Parameters:
    
    mov1 - if non-null, returns the first moment of volume
    
    mov2 - if non-null, returns the second moment of volume
    
    pov - if non-null, returns the product of volume
    
    Returns:
    
    closed volume of the mesh
  - computePrincipalAxes
```
public RigidTransform3d computePrincipalAxes()
```
  - computePrincipalAxes
```
public static RigidTransform3d computePrincipalAxes(PolygonalMesh mesh)
```
  - getBVTree
```
public BVTree getBVTree()
```
    Description copied from class: MeshBase
    
    Returns a bounding volume tree to be used for proximity queries involving this mesh.
    
    Specified by:
    
    getBVTree in class MeshBase
    
    Returns:
    
    bounding volume tree
  - clearBVTree
```
public void clearBVTree()
```
  - distanceToPoint
```
public double distanceToPoint(Point3d pnt)
```
    If this mesh is triangular, returns the nearest distance to a point. This method uses the default bounding volume hierarchy returned by getBVTree().
    
    Parameters:
    
    pnt - point for which distance should be computed (world coords)
    
    Returns:
    
    distance to the mesh, or -1 if the no nearest mesh face is found.
    
    Throws:
    
    java.lang.IllegalArgumentException - if this mesh is not triangular
  - distanceToPoint
```
public double distanceToPoint(Point3d nearPnt,
                              Point3d pnt)
```
    If this mesh is triangular, returns the nearest distance to a point. This method uses the default bounding volume hierarchy returned by getBVTree().
    
    Parameters:
    
    nearPnt - if not null, returns the nearest point on the mesh in world coordinates.
    
    pnt - point for which distance should be computed (world coords)
    
    Returns:
    
    distance to the mesh, or -1 if the no nearest mesh face is found.
    
    Throws:
    
    java.lang.IllegalArgumentException - if this mesh is not triangular
  - nearestFaceToPoint
```
public Face nearestFaceToPoint(Point3d nearPnt,
                               Vector2d uv,
                               Point3d pnt)
```
    If this mesh is triangular, returns the nearest triangular face to a point. This method uses the default bounding volume hierarchy returned by getBVTree().
    
    Parameters:
    
    nearPnt - if not null, returns the nearest point on the face in world coordinates.
    
    uv - if not null, returns the UV coordinates of the nearest point on the face. These are the barycentric coordinates with respect to the second and third vertices.
    
    pnt - point for which the nearest face should be found.
    
    Returns:
    
    the nearest face to the point, or null if the mesh contains no faces.
    
    Throws:
    
    java.lang.IllegalArgumentException - if this mesh is not triangular
  - pointIsInside
```
public int pointIsInside(Point3d pnt)
```
    If this mesh is triangular and closed, determines if a point is inside or outside the mesh. Being exactly ``on'' the mesh counts as outside. The mesh normals are assumed to be pointing outwards. This method uses the default bounding volume hierarchy returned by getBVTree(). The method works by counting the number of times a random ray cast from the point intersects the mesh. Degeneracies are detected and result in another ray being cast. Whether or not the point is on the mesh is determined using a numerical tolerance computed from the mesh's overall dimensions. In rare cases, the method may be unable to determine whether the point is inside or outside, in which case the method returns -1. In such cases, or if one wishes to distinquish whether the point is outside vs. ``on'' the mesh, it may be useful to call the underlying BVFeatureQuery method isInsideMesh() directly, which offers more control.
    
    Parameters:
    
    pnt - point to check.
    
    Returns:
    
    1 if pnt is inside, 0 if outside, or -1 if the method is can't find an answer.
    
    Throws:
    
    java.lang.IllegalArgumentException - if this mesh is not triangular
  - writeWorld
```
public void writeWorld(java.io.PrintStream ps)
                throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - epsilonEquals
```
public boolean epsilonEquals(MeshBase base,
                             double eps)
```
    Tests to see if a mesh equals this one. The meshes are equal if they are both PolygonalMeshes, and their transforms, vertices, faces, normals and texture coordinates are equal (within eps).
    
    Overrides:
    
    epsilonEquals in class MeshBase
  - computeInertia
```
public double computeInertia(SpatialInertia M,
                             double density)
```
    Computes a spatial inertia for the volume defined by this mesh, assuming a uniform density density. It is assumed that the mesh is closed, although small holes in the mesh should not affect the calculation that much. It is also assumed that the faces are oriented counter-clockwise about their outward-facing normal.
    
    Parameters:
    
    M - returns the computed spatial inertia
    
    density - density of the volume
    
    Returns:
    
    the volume of the mesh
  - computeCentreOfVolume
```
public double computeCentreOfVolume(Vector3d c)
```
    Computes the centre of volume of the mesh
  - createInertia
```
public SpatialInertia createInertia(double density)
```
    Creates a spatial inertia for the volume defined by this mesh, assuming a constant density. It is assumed that the mesh is closed, although small holes in the mesh should not affect the calculation that much. Is is also assumed that the faces are oriented counter-clockwise about their outward-facing normal.
    
    Parameters:
    
    density - density of the volume
  - createInertia
```
public SpatialInertia createInertia(double mass,
                                    MassDistribution dist)
```
    Computes a spatial inertia for this mesh, given a mass and a mass distribution. All distributions are supported.
    
    Overrides:
    
    createInertia in class MeshBase
    
    Parameters:
    
    mass - overall mass
    
    dist - how the mass is distributed across the features
  - supportsMassDistribution
```
public boolean supportsMassDistribution(MassDistribution dist)
```
    Queries whether or not a given mass distrubution is supported for this mesh type.
    
    Overrides:
    
    supportsMassDistribution in class MeshBase
    
    Returns:
    
    true if the indicated mass distrubution is supported
  - isBorderVertex
```
public boolean isBorderVertex(Vertex3d vtx)
```
  - countConnected
```
public int countConnected()
```
  - countBorders
```
public int countBorders()
```
  - countGenus
```
public double countGenus()
```
  - flip
```
public void flip()
```
  - createVertexIndices
```
public int[] createVertexIndices()
```
    Description copied from class: MeshBase
    Creates and returns the vertex indices associated with each geometric feature in this mesh.
    The indices are zero-based and specify the vertex indices for each mesh feature. The number of indices and their structure hence depends on the mesh subclass: for PolygonalMesh meshes, this gives the vertices for each face; for PolylineMesh, the vertices for each polyline, and for PointMesh, the vertices for each point. For example, assume that we have a PolygonalMesh with four vertices and four triangles arranged to form a tetrahedron, so that the vertex indices for each triangular face are given by (0, 2, 1), (0, 3, 2), (0, 1, 3), and (1, 2, 3). Then the returned vertex indices will be
```
   0 2 1  0 3 2  0 1 3  1 2 3
 
```
    Specified by:
    
    createVertexIndices in class MeshBase
    
    Returns:
    
    vertex indices for this mesh. Should not be modified.
  - numFeatures
```
public int numFeatures()
```
    Description copied from class: MeshBase
    
    Returns the number of features in this mesh. What a feature is depends on the mesh type: faces for PolygonalMesh, lines for PolylineMesh, points (which map to vertices) for PointMesh.
    
    Specified by:
    
    numFeatures in class MeshBase
    
    Returns:
    
    number of features in this mesh
  - hasAutoNormalCreation
```
public boolean hasAutoNormalCreation()
```
    Returns true if this mesh automatically creates a default set of normals if MeshBase.getNormals() is called and no normals have been explicitly set using MeshBase.setNormals(java.util.List<maspack.matrix.Vector3d>, int[]).
    
    Specified by:
    
    hasAutoNormalCreation in class MeshBase
    
    Returns:
    
    true if this mesh automatically creates normals.
  - getWriteNormals
```
public boolean getWriteNormals()
```
    Returns true if this mesh's normals should be written to a file. This will be the case if the normals were explicitly set, or if they were automatically created using information (such as hard edges) that cannot be easily reconstructed from the information written to standard file formats.
    
    Specified by:
    
    getWriteNormals in class MeshBase
    
    Returns:
    
    true if the normals should be written to a file
  - setMultipleAutoNormals
```
public void setMultipleAutoNormals(boolean enable)
```
    Enable or disable multiple vertex normals when normals are computed automatically, as described for getMultipleAutoNormals().
    
    Parameters:
    
    enable - enables or disables automatic computation of multiple vertex normals.
  - getMultipleAutoNormals
```
public boolean getMultipleAutoNormals()
```
    Returns true if multiple vertex normals are allowed when normals are computed automatically. If allowed, then a different normal will be computed for each contiguous region of faces about the vertex that is delimited by an open or hard edge (see hasHardEdge(Vertex3d,Vertex3d)). Note that vertices will be associated with multiple normals only when the surrounding faces contain open or hard edges.
    
    Returns:
    
    true if multiple vertex normals are allowed
  - autoGenerateNormals
```
public void autoGenerateNormals()
```
    Computes vertex normals using an angle-weighted average of the normals formed by the edges incident on each vertex. The normals and normal indices for this mesh will be reset. One normal will be computed per vertex, except in situations where the vertex has incident half edges that are open or hard, in which case extra normals will be computed.
  - setHardEdgesFromFaceNormals
```
public void setHardEdgesFromFaceNormals(double cosThreshold)
```
    Sets edges to be "hard" based on angle between faces.
    
    Parameters:
    
    cosThreshold - dot product between face normals is below this threshold, marks edge as hard
  - computeVertexNormals
```
public int[] computeVertexNormals(java.util.ArrayList<Vector3d> normals,
                                  boolean multiNormals)
```
    Computes a set of vertex normals for this mesh, using an angle-weighted average of the normals formed by the edges incident on each vertex. If the angle-weighted average would result in a zero normal (e.g. vertices on a straight line), then the adjacent face normals are used. If multiNormals is true, then multiple normals may be computed for each vertex, with different normals being computed for edge regions that are separated by open or hard edges. Otherwise, only one normal is computed per vertex.
    If normals is passed in with zero size, then the normals are computed and returned in new Vector3d objects that are and added to it. Also, the method returns a set of computed normal indices. This option is used for the initial creation of normals.
    If normals is passed in with non-zero size, then it is assumed to contain enough Vector3d objects to store all the computed normals, and the method returns null. This option is used for updating normals.
    
    Parameters:
    
    normals - returns the computed normals
    
    multiNormals - if true, then multiple normals may be computed for each vertex
    
    Returns:
    
    normals indices, if normals has zero size, otherwise null.
  - setHardEdgesFromNormals
```
public boolean setHardEdgesFromNormals()
```
  - printDegenerateFaces
```
public void printDegenerateFaces()
```
  - printDegeneracies
```
public void printDegeneracies(int printCode)
```
    Prints topological degeneracies associated with this mesh. Which degeneracies to print are determined by the flags in printCode:
    
    NON_MANIFOLD_EDGES
    NON_MANIFOLD_VERTICES
    OPEN_EDGES
    ISOLATED_VERTICES
  - printDegeneracies
```
public void printDegeneracies()
```
  - estimateMemoryUsage
```
public int estimateMemoryUsage()
```
    Returns the estimated memory useage for this mesh, in bytes. The following formula is used:
```
 numBytes = 84*F + 92*V + 64*H
 
```
    where F, V and H are the numbers of faces, vertices, and half edges, respectively. This number is only a rough estimate and assumes that references require 4 bytes and not 8.

Class PolygonalMesh

Field Summary

Fields inherited from class maspack.geometry.MeshBase

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class maspack.geometry.MeshBase

Methods inherited from class java.lang.Object

Field Detail

NON_MANIFOLD_EDGES

NON_MANIFOLD_VERTICES

OPEN_EDGES

ISOLATED_VERTICES

ALL_DEGENERACIES

canSelfIntersect

computedFaceNormals

Constructor Detail

PolygonalMesh

PolygonalMesh

PolygonalMesh

PolygonalMesh

Method Detail

notifyVertexPositionsModified

updateFaceNormals

updateRenderNormals

faceNormalsValid

createRenderProps

isTriangular

isQuad

hasIsolatedVertices

hasOpenEdges

hasNonManifoldEdges

hasNonManifoldVertices

isClosed

isManifold

isWatertight

findNonManifoldVertices

getFaces

numFaces

getFace

getHalfEdge

countEdges

getSignedDistanceGrid

getSignedDistanceGrid

setMeshToWorld

read

read

read

read

set

addFace

addFace

addFace

addFace

addFace

addFace

removeFace

removeFaceFast

removeFaces

removeFacesX

clearFaces

doMergeCloseVertices

mergeCloseVertices

mergeCoplanarFaces

removeOppositeFaces

numDisconnectedVertices

removeDisconnectedVertices

removeDisconnectedFaces

partitionIntoConnectedMeshes

checkConsistency

set

write

write

writePoly

writePoly

translateToCenterOfVolume

transform

inverseTransform

transform

inverseTransform