jv.geom

## Class PgElementSet

- java.lang.Object
- - jv.object.PsObject
  - - jv.project.PgGeometry
    - - jv.geom.PgPointSet
      - - jv.geom.PgElementSet

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, PsUpdateIf, PgGeometryIf
  Direct Known Subclasses:
    MySurface, PgCatenoid, PgDomain, PgGenusSurface, PgGraph, PgHelicoid, PgLantern, PgMaxPrinciple, PgParmSurface, PgSurface, PgSurfaceGraph, PgSurfaceOfRotation, PgTube, PgWeierstrass

      public class PgElementSet
      extends PgPointSet

  Base class for most geometric surfaces with polygonal faces formed by vertices. The class contains an array with faces, i.e. elements, and each element may have different number of vertices. Each element is an instance of type PiVector containing indices of the vertices which are stored in the superclass `PgPointSet`. Additionally, there exist instance variables for element normals, element colors, element texture coordinates, and other element properties. Note, that such element properties are not stored with each element but each property is stored in an additional array of same length as the array of elements. If a property is not available then the corresponding array is `null`.

  The dimension of all points is determined as argument of the constructor and cannot be changed later. See `PgPointSet` for details about allocation and access.

  The number of vertices per element may be the same for all elements of the element set, and assigned using the method `setDimOfElements(int)`. Or, the size of elements may differ in which case `getDimOfElements()==-1`, which is the default case. The advantage of the first case is, that the class is able to do more memory allocations automatically.

  There exist several utility functions to allocate and modify the number of elements, for example,

              setNumElements(int num)

  allocates `num` elements. Internally, there exists a cache to reduce the number of actual memory allocations. The size of the cache is managed by protected methods.

  Whenever the number of elements is changed, the class automatically adjusts the size of those element properties which are currently in use, i.e. whose array is not `null`.

  Applications may modify the entries of an element and of element properties by direct method calls such as

              setElement(int, PiVector)

  which sets the element with index ind equal to the components of a vector v by copying. Alternatively, if an application modifies a larger number of elements then the application may prefer to obtain the element array from the element set and directly modify the array

              PiVector [] element = elementSet.getElements();
              for (int i=0; i<elementSet.getNumElements(); i++)
                      element[i].copy(v);

  The same choice is available for arrays containing element properties. Note, that classes like PgElementSet, may not reference all vertices, e.g. if the currently active elements consists of a subset of all vertices. Also note, that the actual size of the element array may differ from m_numElements efficiency reasons. Therefore, do not use element.length but use getNumElements().

  This class contains mainly basic methods for memory allocation and access to instance variables. Geometric methods operating on element sets such as computing a specific surface or computing the intersection of two surfaces are available in special workshop classes as extensions outside the base JavaView packages.

  A good starting to obtain further insight are methods like `computeTorus` (if source code access to JavaView is available), or the tutorial applets of JavaView.

  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class jv.object.PsObject

      `HAS_BOUNDARY_PANEL, HAS_CONFIG_PANEL, HAS_INFO_PANEL, HAS_LABEL_PANEL, HAS_MATERIAL_PANEL, HAS_TEXTURE_PANEL, HAS_VECTOR_PANEL, INSPECTOR_INFO, INSPECTOR_INFO_EXT, IS_DELETED, IS_FIXED, IS_FOCUSSED, IS_PICKED, IS_SELECTED, IS_USED, NUM_TAGS`

    - ### Fields inherited from interface jv.project.PgGeometryIf

      `AMBIENT_H2_HYPERBOLIC, AMBIENT_H3_HYPERBOLIC, AMBIENT_H4_HYPERBOLIC, AMBIENT_PROJECTIONS, AMBIENT_R1_EUCLIDEAN, AMBIENT_R2_EUCLIDEAN, AMBIENT_R3_EUCLIDEAN, AMBIENT_R4_EUCLIDEAN, AMBIENT_R5_EUCLIDEAN, AMBIENT_S1_SPHERE, AMBIENT_S2_SPHERE, AMBIENT_S3_SPHERE, AMBIENT_S4_SPHERE, AMBIENT_SPACES, BLEND_ALPHA, BLEND_MATERIAL, BLEND_REPLACE, FILTER_DIRECT, FILTER_LINEAR, FILTER_QUADRATIC, HAS_METHOD_MENU, INSPECTOR_CONTROL, INSPECTOR_CONTROL_EXT, INSPECTOR_MATERIAL, INSPECTOR_MATERIAL_EXT, INSPECTOR_TEXTURE, INSPECTOR_TEXTURE_EXT, LABEL_BASE, LABEL_CENTER, LABEL_HEAD, LABEL_MIDDLE, LABEL_TAIL, LABEL_TOP, m_numLabelTypes, METHOD_EXT, PERIODIC_BOTH, PERIODIC_HEIGHT, PERIODIC_NONE, PERIODIC_WIDTH, PROJ_KLEIN_BALL, PROJ_PARALLEL, PROJ_POINCARE_BALL, PROJ_STEREOGRAPHIC, PROJ_UPPER_HALFSPACE, SIDE_BACK, SIDE_BOTH, SIDE_FRONT, SIDE_NONE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PgElementSet()` Constructor of a polyhedral surface in three-dimensional space.
    `PgElementSet(int aVertexDim)` Constructor of a polyhedral surface in a space of given dimension.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `int` | `addElement(PiVector elem)` Add a new element to the end of the element list and increment the number of elements.
    `boolean` | `addElement(PiVector elem, int ind)` Deprecated. method is no longer supported, use addElement(PiVector).
    `void` | `allocateEdgeStars()` Enable edges and make edges stars if no edge stars available.
    `boolean` | `applyModelingMatrix()` Multiply the modeling matrix to all vertices and vectors.
    `void` | `assureBoundary(int num)` Allocate boundary polygons and register current element set.
    `boolean` | `assureDimOfElements()` Assure correctness of value m_dimOfElements specifying the number of vertices per Element.
    `void` | `assureEdgeColors()` Assures respectively allocates correct length of edge color array.
    `void` | `assureEdgeSizes()` Assures respectively allocates correct length of edge size array.
    `void` | `assureElementBackColors()` Assures respectively allocates correct length of element color array.
    `void` | `assureElementColors()` Assures respectively allocates correct length of element color array.
    `void` | `assureElementNormals()` Assures respectively allocates correct length of element normal array.
    `void` | `assureElementTextures()` Assures respectively allocates correct length of element texture array.
    `boolean` | `blend(double s, PgGeometry ag, double t, PgGeometry bg)` Blend between two element sets, used in interpolation and computing the associate surfaces `this = s*ag + t*bg`.
    `void` | `buildPolygon(PdVector[] polygon, int discr)` Generate the vertices for a macro polygon where all edges are subdivided into 'discr' points.
    `void` | `buildQuadr(PdVector[] quadr, int uDiscr, int vDiscr)` Create a rectangular elements by bilinear interpolation of four given vertices and discretization.
    `void` | `buildQuadrFromCurve(PgPolygon[] curve, PgBndConstraint[] bndConstr)` Generate the vertices for a macro quadrilateral given by four polygons with pairwise same discretization.
    `void` | `buildTriangle(PdVector[] triangle, int discr)` Generate the vertices for a macro triangle where all edges are subdivided into 'discr' points.
    `void` | `buildTriangleFromCurve(PgPolygon[] curve, PgBndConstraint[] bndConstr)` Generate the vertices for a macro triangle given by three polygons with same discretization.
    `boolean` | `checkNeighbour()` Deprecated. use checkNeighbour(boolean) instead.
    `boolean` | `checkNeighbour(boolean bMessage)` Check correct neighbour connectivity.
    `void` | `clearTagElement(int ind, int aTag)` Clear a single tag of a element.
    `java.lang.Object` | `clone()` Duplicate geometry by recursively cloning all instance variables except inspector panels and lists of registered listeners.
    `boolean` | `close()` Identify and remove all interior boundaries of a geometry, and compress vertex array.
    `void` | `computeCone(int numULines, int numVLines, double bottomRadius, double height)` Generate cone in z-direction centered at the origin with given bottom radius and height.
    `void` | `computeCylinder(int numULines, int numVLines, double radius, double length)` Generate cylinder in z-direction centered at the origin with given radius and length.
    `void` | `computeDisk(int numULines, int numVLines, double radius)` Generate disk in xy-plane with given radius.
    `void` | `computePlane(int numULines, int numVLines, double uMin, double vMin, double uMax, double vMax)` Generate rectangle in z=0 plane with given min/max values.
    `void` | `computeRotation(PgPolygon meridian, int numULines)` Generate rotational symmetric surface from given meridian around x-axis.
    `void` | `computeSnail(int numULines, int numVLines, double numWindings)` Generate a winding snail.
    `void` | `computeSphere(int numULines, int numVLines, double radius)` Generate sphere with given radius.
    `void` | `computeTorus(int numULines, int numVLines, double radius, double thick)` Generate torus in x-y plane with given radius of soal and thickness of tube.
    `void` | `copy(PsObject object)` Copy instance variables by duplication, not by copying a reference.
    `void` | `copyConnectivity(PgElementSet geom)` Copy connectivity of mesh, i.e. element and neighbour array.
    `void` | `copyConnectivitySelect(PgElementSet geom, PiVector vertexIndex, PiVector elemIndex)` Copy connectivity of mesh, i.e. element and neighbour array.
    `void` | `copyElementSet(PgElementSet geom)` Copy instance variables of this class but not of its superclass.
    `void` | `copyElementSetSelect(PgElementSet geom, PiVector vertexIndex, PiVector elemIndex)` Copy instance variables of this class but not of its superclass.
    `void` | `copySelect(PsObject object, PiVector elemIndex)` Copy only selected elements of argument geometry plus all related attributes and material data.
    `void` | `fixBoundaries()` Constrain all boundary vertices not to move during variations.
    `void` | `flipEdges()` Flip edge of pairs of adjacent triangles if sum of opposite angles is larger than sum of spatial angles at common edge.
    `void` | `flipOrientation()` Change orientation of all elements and invert normal vectors.
    `double` | `getArea()` Compute total area of polyhedral surface.
    `double` | `getAreaOfElement(int elemInd)` Compute area of polyhedral element with given index.
    `PgBndPolygon[]` | `getBoundaries()` Get array of boundary polygons, some of which may be marked inactive.
    `PdVector` | `getCenterOfElement(PdVector center, int e)` Compute the barycenter of a geometry element.
    `double` | `getCreaseAngle()` Get crease angle which is a threshold determining sharp crease edges.
    `int` | `getDimOfElement(int ind)` Get number of vertices of an element with given index.
    `int` | `getDimOfElements()` Get number of vertices per element if it is the same for all elements, otherwise return -1.
    `PiVector` | `getEdge(int ind)` Deprecated. since JavaView 3.96.031, use getEdgeStar(int).
    `PgEdgeStar` | `getEdge(int vInd1, int vInd2)` Create an edge structure with information about edge and adjacent elements.
    `java.awt.Color[]` | `getEdgeColors()` Get color array for read and write access, but do not modify the size of any color vector.
    `double` | `getEdgeLength(int elemInd, int locInd)` Compute length of element edge specified by element index and vertex index.
    `PdVector` | `getEdgeSizes()` Get array of relative edge sizes for read and write access.
    `PgEdgeStar` | `getEdgeStar(int ind)` Get edge object for read and write access, but do not modify the size of any edge.
    `PgEdgeStar[]` | `getEdgeStars()` Get edge array for read and write access, but do not modify the size of any edge.
    `PiVector` | `getElement(int ind)` Get a reference to an individual element.
    `java.awt.Color` | `getElementBackColor(int ind)` Get a reference to an individual backside element color.
    `java.awt.Color[]` | `getElementBackColors()` Get backside element color array for read and write access, but do not modify the size of any color vector.
    `java.awt.Color` | `getElementColor(int ind)` Get a reference to an individual element color.
    `java.awt.Color[]` | `getElementColors()` Get element color array for read and write access, but do not modify the size of any color vector.
    `int` | `getElementEdge(int elementInd, int locNeighbInd)` Get the index of an edge incident to the given element.
    `PiVector[]` | `getElementEdges()` Get an array which stores for each element the indices of its incident edges.
    `PdVector` | `getElementNormal(int ind)` Get a reference to an individual element normal.
    `PdVector[]` | `getElementNormals()` Get element normal array for read and write access, but do not modify the size of any normal vector.
    `PiVector[]` | `getElements()` Get element array for read and write access.
    `PdVector[]` | `getElementTexture(int ind)` Get element texture array of an individual element.
    `PdVector[][]` | `getElementTextures()` Get element texture array for read and write access, but do not modify the size of any texture vector.
    `PdVector[]` | `getElementVertices(int elemInd)` Get an array with pointers to all vertices of an element.
    `int` | `getElementWithVertex(int vertexInd)` Find first element referencing a given vertex.
    `int[]` | `getFVector()` Compute F-vector which shows the number of points, edges, faces, etc.
    `java.awt.Color` | `getGlobalBndColor()` Get global boundary color which is used if no local colors are available.
    `double` | `getGlobalBndSize()` Get thickness in pixels of boundary when drawn in display.
    `java.awt.Color` | `getGlobalBndTagColor()` Get global color of tagged boundaries.
    `java.awt.Color` | `getGlobalEdgeColor()` Get global edge color which is used if no local colors are available.
    `double` | `getGlobalEdgeSize()` Get thickness in pixels of edge when drawn in display.
    `java.awt.Color` | `getGlobalEdgeTagColor()` Get global color of tagged edges.
    `java.awt.Color` | `getGlobalElementBackColor()` Get global color of backface of elements.
    `java.awt.Color` | `getGlobalElementColor()` Get global element color which is used if no local colors are available.
    `java.awt.Color` | `getGlobalElementNormalColor()` Get global element normal color which is used if no local colors are available.
    `double` | `getGlobalElementNormalLength()` Get length factor of element normal vectors when drawn in display.
    `double` | `getGlobalElementNormalSize()` Get thickness in pixels of element normals when drawn in display.
    `java.awt.Color` | `getGlobalElementTagColor()` Get global color of tagged elements.
    `int` | `getIndexOfBndPolygon(PgBndPolygon bnd)` Get index of vector fields, assumes user data is stored in a vector.
    `PgJvxSrc` | `getJvx()` Fills a geometry object with data from this instance, for example, to print to file.
    `PdMatrix` | `getL2Matrix(PdMatrix mat)` Compute L2 matrix S such that L2-norm(u)^2 = u*S*u.
    `double` | `getL2Norm()` Compute L2 norm of identity map of element set.
    `int` | `getMaxDimOfElements()` Get maximal number of vertices appearing in an element.
    `int` | `getMaxNumElements()` Get total length of allocated element array.
    `PiVector` | `getNeighbour(int ind)` Get a reference to an individual neighbour vector.
    `int` | `getNeighbourLocInd(int elemInd, int vInd, int wInd)` For a given edge return the local index of the vertex containing the neighbourhood information.
    `PiVector[]` | `getNeighbours()` Get neighbour array for read and write access, but do not modify the size of any neighbour vector.
    `int` | `getNumBoundaries()` Return number of (living) boundary polygons.
    `int` | `getNumBoundaryEdges()` Calculate number of boundary edges of a manifold surface using m_neighbour information.
    `int` | `getNumBoundaryVertices()` Count number of boundary vertices assuming boundary vertices have been previously marked.
    `int` | `getNumEdges()` Calculate number of edges of a manifold surface using m_neighbour information.
    `int` | `getNumEdgeStars()` Get number of allocated edge stars.
    `int` | `getNumElementIndices()` Get total number of vertex entries in all elements.
    `int` | `getNumElements()` Get number of elements in element array.
    `int` | `getNumUnusedVertices()` Get the number of unused vertices which are not references by elements.
    `int` | `getOppVertexInd(int elemInd, int locInd)` In the adjacent element find the vertex containing the neighbourhood information for the original element.
    `int` | `getOppVertexLocInd(int elemInd, int locInd)` In the adjacent element find the vertex containing the neighbourhood information for the original element.
    `PiVector[]` | `getSavedElements()` Only used when working with non-conforming triangulations.
    `int` | `getSavedNumVertices()` Only used when working with non-conforming triangulations.
    `PgBndPolygon` | `getSelectedBndPolygon()` Get the currently selected boundary polygon, or null if there is none.
    `double` | `getVertexAngle(int elemInd, int locInd)` Compute the element angle specified by element index and local vertex index.
    `PdVector[]` | `getVertexTextures()` Get array of all texture coordinates both for vertex and element based textures.
    `static PiVector` | `getVertexValence(PgElementSet geom)` Compute valence of each vertex, that is, the number of incoming edges.
    `double` | `getVolume()` Compute total volume of polyhedral surface.
    `double` | `getVolumeOfElement(int elemInd)` Compute algebraic volume of the cone of a polyhedral element with the origin.
    `boolean` | `hasBoundary()` Check whether surface has boundary polygons, assume boundary has been calculated.
    `boolean` | `hasEdgeColors()` Check if edge colors have been allocated.
    `boolean` | `hasEdgeSizes()` Check if relative edge sizes have been allocated.
    `boolean` | `hasElementBackColors()` Check if element back colors have been allocated.
    `boolean` | `hasElementColors()` Check if element colors have been allocated.
    `boolean` | `hasElementNormals()` Check if element normals have been allocated.
    `boolean` | `hasElementTextures()` Check if element textures have been allocated.
    `boolean` | `hasTagElement(int ind, int aTag)` Check whether element has given tag.
    `void` | `init()` Initialize and reset instance variables after call to super.init().
    `PvPickEvent` | `intersectionWithLine(PdVector rayBaseWorld, PdVector rayDirWorld)` Find intersection of element set with a given ray.
    `boolean` | `isConforming()` Return `true` if elementSet is conforming, else `false`.
    `boolean` | `isEnabledEdges()` Check if storage and maintenance of edges is enabled.
    `boolean` | `isShowingBackface()` Determines whether drawing of backfacing elements whose normal points away from camera is enabled.
    `boolean` | `isShowingBoundaries()` Determines whether drawing of boundary curves is enabled.
    `boolean` | `isShowingEdgeColorFromElements()` Determines whether local edge color is induced from element or vertex colors.
    `boolean` | `isShowingEdgeColorFromVertices()` Determines whether smooth edge coloring uses vertex colors at vertices, requires vertex colors.
    `boolean` | `isShowingEdgeColors()` Determine whether showing of edge colors is enabled.
    `boolean` | `isShowingEdgeLabels()` Determines whether showing of edge labels is enabled.
    `boolean` | `isShowingEdges()` Determines whether drawing of element edges is enabled.
    `boolean` | `isShowingEdgeSizes()` Determine whether showing of edge sizes is enabled.
    `boolean` | `isShowingElementBackColor()` Determines whether global element backface color is used.
    `boolean` | `isShowingElementBackColors()` Determines whether drawing of individual backface element colors is enabled.
    `boolean` | `isShowingElementColors()` Determines whether global element color is used.
    `boolean` | `isShowingElementFromVertexColors()` Determines whether smooth element coloring uses vertex colors, requires vertex colors.
    `boolean` | `isShowingElementLabels()` Determines whether showing of element labels is enabled.
    `boolean` | `isShowingElementNormalArrow()` Determines whether drawing of arrow of element normals is enabled.
    `boolean` | `isShowingElementNormals()` Determines whether drawing of element normals is enabled.
    `boolean` | `isShowingElements()` Determines whether drawing of elements is enabled.
    `boolean` | `isShowingElementTexture()` Determines whether drawing of element texture is enabled.
    `boolean` | `isShowingElementTextures()` Deprecated. use isShowingElementTexture()
    `boolean` | `isShowingSilhouette()` Determines whether a polygon is shown along the silhouette if a shape.
    `boolean` | `isShowingSmoothEdgeColors()` Determines whether smooth coloring of edges is enabled, currently requires vertex colors.
    `boolean` | `isShowingSmoothElementColors()` Determines whether smooth coloring of elements is enabled, currently requires vertex colors.
    `boolean` | `isShowingSmoothLighting()` Determines whether smooth lighting is enabled, requires vertex normals.
    `boolean` | `isShowingTaggedBoundaries()` Determines whether drawing of tagged boundary curves is enabled.
    `boolean` | `isShowingTaggedEdges()` Determines whether drawing of tagged element edges is enabled.
    `boolean` | `isShowingTaggedElements()` Determines whether drawing of tagged elements is enabled.
    `void` | `makeAlternatingQuadrConn(int uDiscr, int vDiscr, boolean alternateUDir)` Make quadrilateral connectivity with quadrilaterals being alternately triangulated.
    `void` | `makeCylinderConn(int uDiscr, int vDiscr)` Generate element and neighbourhood information for a cylindrical surface.
    `PgEdgeStar[]` | `makeEdgeStars()` Generate list of edges from element information of a possibly non-manifold surface.
    `PgEdgeStar[]` | `makeEdgeStarsFromNeighbour()` Generate list of edges from the neighbourhood information of a possibly non-manifold surface.
    `boolean` | `makeElementColorsFromXYZ()` Create color from the element position within its bounding box which is interpreted as RGB cube.
    `boolean` | `makeElementColorsFromZ()` Create color from the vertical z-height within its bounding box ranging from low blue to high red.
    `boolean` | `makeElementColorsFromZHue()` Create color from the vertical z-height within its bounding box ranging through hue rainbow.
    `boolean` | `makeElementFromVertexColors()` Create element colors as average of all colors of its vertices.
    `boolean` | `makeElementFromVertexTexture()` Create element textures from vertex textures and remove vertex textures.
    `boolean` | `makeElementNormals()` Compute element normals from edge cross products.
    `boolean` | `makeNeighbour()` Generate neighbourhood information for a given manifold polyhedron.
    `void` | `makeQuadrBnd(int uDiscr, int vDiscr)` Generate boundary information for a quadrilateral surface.
    `void` | `makeQuadrConn(int uDiscr, int vDiscr)` Generate element and neighbourhood information for a quadrilateral surface.
    `void` | `makeQuadrElementTexture(int uDiscr, int vDiscr)` Generate default element texture in [0,1]*[0,1] for a quadrilateral surface.
    `void` | `makeTriangleBnd(int discr)` Generate the boundary of a macro triangle where all edges are subdivided into 'discr' points.
    `void` | `makeTriangleConn(int discr)` Generate the connectivity for a macro triangle where all edges are subdivided into 'discr' points.
    `boolean` | `makeVertexFromElementColors()` Create vertex colors as average of individual color of all adjacent elements.
    `boolean` | `makeVertexNormals()` Compute vertex normals from adjacent elements (without using element normals).
    `void` | `markBoundary()` Tag all boundary vertices as those.
    `boolean` | `merge(PgGeometryIf aGeom)` Merge element set with current object and store union of both objects in 'this'.
    `void` | `paint(PvGeometryIf dc)` Major rendering method fills an internal container class supplied by the display.
    `java.lang.String` | `printEdgeList()` Print list of edges to console if previously computed.
    `boolean` | `projectFromAmbientSpace()` Apply projection matrix and perform projection determined by projection flag of the surface in a Euclidean model R3, R2, or R1 with parallel projection.
    `boolean` | `refineGlobalIntoFour()` Deprecated. use refineGlobalIntoFour(boolean) instead.
    `boolean` | `refineGlobalIntoFour(boolean bInsertMidPoints)` Refine elementSet by dividing each triangle into four similar children.
    `PgGeometry` | `reflect(PdMatrix mat, boolean bOrient, boolean bVector)` Generate a cloned geometry and transform vertices by a matrix.
    `void` | `removeBoundaries()` Remove all boundary curves.
    `int` | `removeDeletedBoundaries()` Remove all boundary curves which are marked PsObject.IS_DELETED.
    `void` | `removeEdgeColors()` Remove local edge colors from a geometry and use global edge color instead.
    `void` | `removeEdgeSizes()` Remove edge sizes from a geometry.
    `int[]` | `removeElement(int ind)` Remove element with given index, and decrement index of all elements with higher index.
    `void` | `removeElementBackColors()` Remove local backface element colors from a geometry and use global backface element color instead.
    `void` | `removeElementColors()` Remove local element colors from a geometry and use global element color instead.
    `void` | `removeElementEdges()` Remove element-edge incidence information from element set.
    `void` | `removeElementNormals()` Remove element normals from a geometry.
    `int[]` | `removeMarkedElements()` Remove all elements which have been marked `PsObject.IS_DELETED`.
    `int[]` | `removeMarkedVertices()` Remove vertices marked with tag PsObject#IS_DELETED from elements.
    `void` | `removeTexture()` Remove all texture information from surface and switch off showing of texture.
    `boolean` | `removeUnusedVertices()` Remove all points not referenced by elements.
    `boolean` | `resetBoundaryNormals()` Remove boundary vertex normal.
    `int` | `selectBndPolygon(PgBndPolygon bnd)` Select a boundary polygon.
    `void` | `setBoundary(PgBndPolygon[] newBnd)` Set new boundary polygons by replacing the previous array with the argument array.
    `void` | `setConforming(boolean flag)` Set conformality state of geometry and boundary curves, and do not modify connectivity.
    `void` | `setCreaseAngle(double angle)` Set crease angle which is a threshold determining sharp crease edges.
    `void` | `setDimOfColors(int aSize)` Let all colors have same number of components `aSize<>0`.
    `void` | `setDimOfElement(int ind, int aSize)` Set size of a single element and associated data like neighbour list.
    `void` | `setDimOfElements(int aSize)` Let all elements have same number of vertices `aSize<>0`, or individual `aSize=-1`.
    `void` | `setDimOfVectors(int aSize)` Let all vectors have same number of vectors `aSize<>0`.
    `void` | `setDimOfVertices(int dim)` Set dimension of vertices.
    `void` | `setEdgeColors(java.awt.Color[] colorList)` Copy edge colors of list to existing array of edge colors.
    `void` | `setEdgeSizes(PdVector edgeSize)` Assign a set of relative edge sizes.
    `boolean` | `setEdgeStar(int ind, PgEdgeStar edgeStar)` Set index vector of edge with given index.
    `boolean` | `setElement(int elemInd, int[] anIndArray)` Copy new vertex indices to element at specified position in the element list.
    `void` | `setElement(int elemInd, int a, int b, int c)` Copy new vertex indices to element at specified position in the element list.
    `void` | `setElement(int elemInd, int a, int b, int c, int d)` Copy new vertex indices to element at specified position in the element list.
    `boolean` | `setElement(int ind, PiVector newElem)` Copy new vertex indices to element at specified position in the element list.
    `boolean` | `setElementBackColor(int ind, java.awt.Color aColor)` Copy new color to element color at specified position in the color list
    `void` | `setElementBackColors(java.awt.Color[] color)` Copy backface element colors of list to existing array of element colors.
    `boolean` | `setElementColor(int ind, java.awt.Color aColor)` Copy new color to element color at specified position in the color list
    `void` | `setElementColors(java.awt.Color[] color)` Copy element colors of list to existing array of element colors.
    `void` | `setElementEdges(PiVector[] elementEdge)` Set an array which stores for each element the indices of its incident edges.
    `boolean` | `setElementNormal(int ind, PdVector aNormal)` Copy new normal to element normal at specified position in the normal list
    `void` | `setElementNormals(PdVector[] normal)` Copy element normals of list to existing array of element normals.
    `void` | `setElements(PiVector[] element)` Copy the first `getNumElements()` elements of source array into an existing element array.
    `boolean` | `setElementTexture(int ind, PdVector[] aTexture)` Copy new texture coordinates to element texture at specified position in the element texture list
    `void` | `setElementTextures(PdVector[][] texCoords)` Use the given textures coordinates as element-based texture coordinates.
    `void` | `setElementTexturesFromList(PdVector[] texCoords)` Use the given textures coordinates as element-based texture coordinates.
    `boolean` | `setElementVertices(int elemInd, PdVector[] vArray)` Copy new element vertices at specified position in the vertex array of PgPointSet.
    `void` | `setEnabledEdges(boolean flag)` Enable storage and maintenance of edges.
    `void` | `setGlobalBndColor(java.awt.Color color)` Set global boundary color to be used if no local colors are available.
    `void` | `setGlobalBndSize(double size)` Set thickness in pixels of boundary when drawn in display.
    `void` | `setGlobalBndTagColor(java.awt.Color color)` Set global color of tagged boundaries.
    `void` | `setGlobalEdgeColor(java.awt.Color color)` Set global edge color to be used if no local colors are available.
    `void` | `setGlobalEdgeSize(double size)` Set thickness in pixels of edge when drawn in display.
    `void` | `setGlobalEdgeTagColor(java.awt.Color color)` Set global color of tagged edges.
    `void` | `setGlobalElementBackColor(java.awt.Color color)` Set global color of backface of elements.
    `void` | `setGlobalElementColor(java.awt.Color color)` Set global element color to be used if no local colors are available.
    `void` | `setGlobalElementNormalColor(java.awt.Color color)` Set global element normal color to be used if no local colors are available.
    `void` | `setGlobalElementNormalLength(double length)` Set length factor of element normal vectors when drawn in display.
    `void` | `setGlobalElementNormalSize(double size)` Set thickness in pixels of element normals when drawn in display.
    `void` | `setGlobalElementTagColor(java.awt.Color color)` Set global color of tagged elements.
    `void` | `setGlobalVertexNormalColor(java.awt.Color color)` Set global element normal color to be used if no local colors are available.
    `void` | `setGlobalVertexNormalLength(double length)` Set length factor of element normal vectors when drawn in display.
    `void` | `setGlobalVertexNormalSize(double size)` Set thickness in pixels of element normals when drawn in display.
    `void` | `setJvx(PgJvxSrc src)` Fill this instance with data from a geometry source, for example, previously read from file.
    `void` | `setMaxNumElements(int numElements)` Major memory allocation routine, all element allocation should be done here.
    `boolean` | `setNeighbour(int ind, PiVector newNeigh)` Set neighbour elements of given element.
    `void` | `setNeighbours(PiVector[] neighbour)` Copy neighbour array to existing array of neighbours.
    `void` | `setNumElements(int numElements)` Allocate given number of elements, and allocate normals, colors etc.
    `void` | `setSavedElements(PiVector[] element)` Only used when working with non-conforming triangulations.
    `void` | `setSavedNumVertices(int num)` Only used when working with non-conforming triangulations.
    `void` | `setTagElement(int ind, int aTag)` Set a tag of a element.
    `void` | `showBackface(boolean flag)` Set flag to enable drawing of backfacing elements whose normal points away from camera.
    `void` | `showBoundaries(boolean flag)` Set flag to enable drawing of boundary curves.
    `void` | `showEdgeColorFromElements(boolean flag)` Set flag if edge colors are induced from local element or vertex colors.
    `void` | `showEdgeColorFromVertices(boolean flag)` Set flag to enable smooth edge coloring using vertex colors at vertices, requires vertex colors.
    `void` | `showEdgeColors(boolean flag)` Set flag to enable drawing of individual edge colors.
    `void` | `showEdgeLabels(boolean flag)` Set flag to enable drawing of edge labels in display.
    `void` | `showEdges(boolean flag)` Set flag to enable drawing of element edges.
    `void` | `showEdgeSizes(boolean flag)` Set flag to enable drawing of edge sizes.
    `void` | `showElementBackColor(boolean flag)` Set flag to enable drawing of backface color of elements.
    `void` | `showElementBackColors(boolean flag)` Set flag to enable drawing of individual backface element colors.
    `void` | `showElementColors(boolean flag)` Set flag of using global element color instead of coloring each element individually.
    `void` | `showElementFromVertexColors(boolean flag)` Set flag to enable smooth element coloring using vertex colors at vertices, requires vertex colors.
    `void` | `showElementLabels(boolean flag)` Set flag to enable drawing of element labels in display.
    `void` | `showElementNormalArrow(boolean flag)` Set flag to enable drawing of arrow of element normal.
    `void` | `showElementNormals(boolean flag)` Set flag to enable drawing of element normals.
    `void` | `showElements(boolean flag)` Set flag to enable drawing of elements.
    `void` | `showElementTexture(boolean flag)` Set flag to enable drawing of element texture.
    `void` | `showSilhouette(boolean flag)` Set flag to enable if a polygon is shown along the silhouette if a shape.
    `void` | `showSmoothEdgeColors(boolean flag)` Set flag to enable smooth coloring of edges, currently requires vertex colors.
    `void` | `showSmoothElementColors(boolean flag)` Set flag to enable smooth coloring of elements, currently requires vertex colors.
    `void` | `showSmoothLighting(boolean flag)` Set flag to enable smooth lighting, requires vertex normals.
    `void` | `showTaggedBoundaries(boolean flag)` Set flag to enable drawing of boundary curves.
    `void` | `showTaggedEdges(boolean flag)` Set flag to enable drawing of element edges.
    `void` | `showTaggedElements(boolean flag)` Set flag to enable drawing of tagged elements.
    `void` | `showVertexTexture(boolean flag)` Set flag to enable drawing of vertex texture.
    `java.lang.String` | `toString()` Create a multi-line string representation with detailed information about all instance variables.
    `static boolean` | `triangulate(PgElementSet geom)` Triangulate the given element set in place.
    `boolean` | `update(java.lang.Object event)` Update the class whenever a child has changed.

    - ### Methods inherited from class jv.geom.PgPointSet

      `addGeometryItem, addVectorField, addVertex, applyAmbientMatrix, assureVertexColors, assureVertexNormals, assureVertexSizes, assureVertexTextures, clearTagVertex, getAmbientBounds, getBounds, getCenterOfBndBox, getCenterOfGravity, getDimOfColors, getDimOfTextures, getDimOfVectors, getEulerCharacteristic, getGlobalVectorColor, getGlobalVectorLength, getGlobalVectorSize, getGlobalVertexColor, getGlobalVertexNormalColor, getGlobalVertexNormalLength, getGlobalVertexNormalSize, getGlobalVertexSize, getGlobalVertexTagColor, getIndexOfVectorField, getMarkedVertices, getMaxNumVertices, getNumVectorFields, getNumVertices, getSelectedVectorField, getShininess, getSpecularColor, getTexture, getTextureImage, getTextureImageName, getTransparency, getVectorField, getVectorField, getVertex, getVertexColor, getVertexColors, getVertexNormal, getVertexNormals, getVertexSize, getVertexSizes, getVertexTexture, getVertices, hasTagVertex, hasVertex, hasVertex, hasVertexColors, hasVertexNormals, hasVertexSizes, hasVertexTextures, isDefaultLabelEnabled, isEnabledIndexLabels, isShowingIndices, isShowingSingleVectorField, isShowingTaggedVertices, isShowingTransparency, isShowingVectorArrow, isShowingVectorArrows, isShowingVectorColors, isShowingVectorField, isShowingVectorFields, isShowingVertexColors, isShowingVertexLabels, isShowingVertexNormalArrow, isShowingVertexNormals, isShowingVertexOutline, isShowingVertexSizes, isShowingVertexTexture, isShowingVertices, makeColorFromVectorLength, makeQuadrVertexTexture, makeVertexColorsFromXYZ, makeVertexColorsFromZ, makeVertexColorsFromZHue, makeVertexTextureFromBndBox, makeVertexTextureFromCylinder, makeVertexTextureFromSphere, makeVertexTextureFromUV, projectToSphere, removeAllVectorFields, removeHiddenVectorFields, removeVectorField, removeVertex, removeVertexColors, removeVertexNormals, removeVertexSizes, scale, scale, selectVectorField, setCenterOfBndBox, setDefaultLabelEnabled, setDimOfTextures, setEnabledIndexLabels, setGlobalVectorColor, setGlobalVectorLength, setGlobalVectorSize, setGlobalVertexColor, setGlobalVertexSize, setGlobalVertexSize, setGlobalVertexTagColor, setMaxNumVertices, setNumVertices, setShininess, setSpecularColor, setState, setTagVertex, setTexture, setTextureImage, setTextureImageName, setTransparency, setVertex, setVertex, setVertex, setVertex, setVertexColor, setVertexColors, setVertexNormal, setVertexNormals, setVertexSize, setVertexSizes, setVertexTexture, setVertexTextures, setVertices, showIndices, showSingleVectorField, showTaggedVertices, showTransparency, showVectorArrow, showVectorArrows, showVectorColors, showVectorField, showVectorFields, showVertexColors, showVertexLabels, showVertexNormalArrow, showVertexNormals, showVertexOutline, showVertexSizes, showVertices, translate`

    - ### Methods inherited from class jv.project.PgGeometry

      `addDisplay, addPolygon, clearTagPolygon, convertWorldToModel, fillMethodMenu, fillMethodMenu, getAmbientInvMatrix, getAmbientMatrix, getAmbientProjection, getAmbientSpace, getAuthorInfo, getAuthors, getCenter, getCenterOfElement, getControlPanel, getDiameter, getDimOfSimplex, getDimOfVertices, getDisplayList, getDisplays, getGeometryInfo, getLabelAttribute, getLabelColor, getLabelFont, getLabelSize, getLabelStyle, getMaterialPanel, getModelMatrix, getPolygon, getState, getTitle, getType, getVersion, getVersionType, hasAmbientMatrix, hasDisplay, hasModelMatrix, hasTagPolygon, isConfigurable, isEnabledInstanceSharing, isShowingBndBox, isShowingCenter, isShowingName, isShowingTitle, isVisible, removeDisplay, removeMethodMenus, removePolygon, setAmbientMatrix, setAmbientProjection, setAmbientSpace, setAuthorInfo, setAuthors, setCenter, setDimOfSimplex, setEnabledInstanceSharing, setGeometryInfo, setLabelAttribute, setLabelAttribute, setLabelColor, setLabelFont, setLabelSize, setLabelStyle, setModelMatrix, setPolygon, setTagPolygon, setTitle, setType, setVersion, setVersionType, setVisible, showBndBox, showCenter, showName, showTitle`

    - ### Methods inherited from class jv.object.PsObject

      `addInspector, addUpdateListener, assureInspector, clearTag, clone, clone, getFather, getInfoPanel, getInspector, getName, getNumObjects, getSymbol, hasInspector, hasTag, hasUpdateListener, instanceOf, instanceOf, newInspector, newInspector, removeInspector, removeInspector, removeUpdateListener, setName, setParent, setSymbol, setTag, updatePanels`

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface jv.project.PgGeometryIf

      `assureInspector, getInfoPanel, getName, hasTag, setName`

    - ### Methods inherited from interface jv.object.PsUpdateIf

      `getFather, setParent`

- - ### Constructor Detail

    - #### PgElementSet

          public PgElementSet()

      Constructor of a polyhedral surface in three-dimensional space.

      This constructor allows to create a geometry by specifying the class name as string. By default, showing of vertices is enabled.

    - #### PgElementSet

          public PgElementSet(int aVertexDim)

      Constructor of a polyhedral surface in a space of given dimension. This constructor should be preferred by all applications. By default, showing of vertices is disabled.

  - ### Method Detail

    - #### init

          public void init()

      Initialize and reset instance variables after call to super.init().
      Overrides:
        `init` in class `PgPointSet`

    - #### getJvx

          public PgJvxSrc getJvx()

      Fills a geometry object with data from this instance, for example, to print to file.
      Specified by:
        `getJvx` in interface `PgGeometryIf`
      Overrides:
        `getJvx` in class `PgPointSet`
      Returns:
        src a geometry source to be filled with data from this instance.

    - #### setJvx

          public void setJvx(PgJvxSrc src)

      Fill this instance with data from a geometry source, for example, previously read from file.

      If src geometry has missing neighbour information then method calculates neighbour information using makeNeighbour(), unless PsJavaView.m_bAutoNeighbour==false.

      If src geometry has missing element or vertex normals then method re-calculates normals using makeElementNormals() or makeVertexNormals(), unless PsJavaView.m_bAutoNormals==false.

      Specified by:
        `setJvx` in interface `PgGeometryIf`
      Overrides:
        `setJvx` in class `PgPointSet`
      Parameters:
        `src` - a geometry source used to fill this instance with data.

    - #### applyModelingMatrix

          public boolean applyModelingMatrix()

      Multiply the modeling matrix to all vertices and vectors. The modeling matrix of this geometry is set to the identity matrix.
      Overrides:
        `applyModelingMatrix` in class `PgPointSet`
      Returns:
        `true` if operation was applied successfully.
      Since:
        JavaView 2.36

    - #### projectFromAmbientSpace

          public boolean projectFromAmbientSpace()

      Apply projection matrix and perform projection determined by projection flag of the surface in a Euclidean model R3, R2, or R1 with parallel projection. Dimension of vertices may be decremented by one after this operation.
      Overrides:
        `projectFromAmbientSpace` in class `PgPointSet`
      Returns:
        `true` if operation was applied successfully.
      Since:
        JavaView 3.99.007

    - #### clone

          public java.lang.Object clone()

      Duplicate geometry by recursively cloning all instance variables except inspector panels and lists of registered listeners. The parent relationship is maintained only within this class but not to external classes. In general, all links of the clone to external objects are set to `null`.
      Specified by:
        `clone` in interface `PgGeometryIf`
      Overrides:
        `clone` in class `PgPointSet`
      See Also:
        `copy(PsObject)`

    - #### copy

          public void copy(PsObject object)

      Copy instance variables by duplication, not by copying a reference.

      The argument was changed from PgGeometry to PsObject since there were problems in J/Link which preferred to use jv.object.PsObject#copy(PsObject) instead of jv.project.PgGeometry#copy(PsObject).

      Overrides:
        `copy` in class `PgPointSet`
      See Also:
        `clone()`

    - #### copyElementSet

          public void copyElementSet(PgElementSet geom)

      Copy instance variables of this class but not of its superclass.

    - #### copyConnectivity

          public void copyConnectivity(PgElementSet geom)

      Copy connectivity of mesh, i.e. element and neighbour array.

    - #### copySelect

          public void copySelect(PsObject object,
                        PiVector elemIndex)

      Copy only selected elements of argument geometry plus all related attributes and material data.

      Overrides:
        `copySelect` in class `PgPointSet`
      See Also:
        `copy(PsObject)`

    - #### copyConnectivitySelect

          public void copyConnectivitySelect(PgElementSet geom,
                                    PiVector vertexIndex,
                                    PiVector elemIndex)

      Copy connectivity of mesh, i.e. element and neighbour array.

      See Also:
        `copyConnectivity(PgElementSet)`

    - #### copyElementSetSelect

          public void copyElementSetSelect(PgElementSet geom,
                                  PiVector vertexIndex,
                                  PiVector elemIndex)

      Copy instance variables of this class but not of its superclass.

      See Also:
        `copyElementSet(PgElementSet)`

    - #### toString

          public java.lang.String toString()

      Create a multi-line string representation with detailed information about all instance variables.
      Specified by:
        `toString` in interface `PgGeometryIf`
      Overrides:
        `toString` in class `PgPointSet`

    - #### update

          public boolean update(java.lang.Object event)

      Update the class whenever a child has changed. Method is usually invoked from the children.
      Specified by:
        `update` in interface `PsUpdateIf`
      Overrides:
        `update` in class `PgPointSet`
      Parameters:
        `event` - carries a lot of information
      Returns:
        true if event has been handled, otherwise false
      See Also:
        `PsObject.setParent(PsUpdateIf)`, `PsObject.getFather()`, `PsObject.addUpdateListener(PsUpdateIf)`

    - #### addElement

          public int addElement(PiVector elem)

      Add a new element to the end of the element list and increment the number of elements. The neighbour array is automatically updated.

      If element normals exist then the normal is calculated for the new element too. Note, if vertex normals exist then the normals of the element vertices are currently not recalculated (this behavior might change in the future).

      If element colors exist then the color of the new element is the global element color.

      Specified by:
        `addElement` in interface `PgGeometryIf`
      Overrides:
        `addElement` in class `PgGeometry`
      Parameters:
        `elem` - element to be added to element list
      Returns:
        int index of new element in element list

    - #### addElement

          public boolean addElement(PiVector elem,
                           int ind)

      Deprecated. method is no longer supported, use addElement(PiVector).
      Add a new element at the specified position in the element list. All elements with larger index are moved by one to the end of the list. After adding an element or a set of elements, the neighbour relation is out of date and must be updated by calling makeNeighbour().

      Length of element must be at least three, and all entries of the index vector must be different.

      When the first element is added to an element set then the internal variable m_dimOfElements is set to the length of the first element. The variable dimOfElements is adjusted if it is different from size of the argument element.

      Parameters:
        `elem` - element to be added to element list
        `ind` - index of element position
      Returns:
        false, if index out of range

    - #### getGlobalElementColor

          public java.awt.Color getGlobalElementColor()

      Get global element color which is used if no local colors are available.

    - #### getGlobalElementBackColor

          public java.awt.Color getGlobalElementBackColor()

      Get global color of backface of elements.

    - #### getGlobalElementTagColor

          public java.awt.Color getGlobalElementTagColor()

      Get global color of tagged elements.

    - #### setGlobalElementColor

          public void setGlobalElementColor(java.awt.Color color)

      Set global element color to be used if no local colors are available.

    - #### setGlobalElementBackColor

          public void setGlobalElementBackColor(java.awt.Color color)

      Set global color of backface of elements.

    - #### setGlobalElementTagColor

          public void setGlobalElementTagColor(java.awt.Color color)

      Set global color of tagged elements.

    - #### getGlobalElementNormalColor

          public java.awt.Color getGlobalElementNormalColor()

      Get global element normal color which is used if no local colors are available.

    - #### getGlobalElementNormalLength

          public double getGlobalElementNormalLength()

      Get length factor of element normal vectors when drawn in display.

    - #### getGlobalElementNormalSize

          public double getGlobalElementNormalSize()

      Get thickness in pixels of element normals when drawn in display.

    - #### setGlobalElementNormalColor

          public void setGlobalElementNormalColor(java.awt.Color color)

      Set global element normal color to be used if no local colors are available.

      Note, currently element normal attributes like color, length and size are identical with the settings for vertex normals. The reason is that the material panel would become too messed up if there are sliders for both types of normal vectors. In the future the synchronization of the two normal vectors may be skipped, so it is a good programming practice to make use of the individual methods of each type.

    - #### setGlobalElementNormalLength

          public void setGlobalElementNormalLength(double length)

      Set length factor of element normal vectors when drawn in display.

      Note, currently element normal attributes like color, length and size are identical with the settings for vertex normals. The reason is that the material panel would become too messed up if there are sliders for both types of normal vectors. In the future the synchronization of the two normal vectors may be skipped, so it is a good programming practice to make use of the individual methods of each type.

    - #### setGlobalElementNormalSize

          public void setGlobalElementNormalSize(double size)

      Set thickness in pixels of element normals when drawn in display.

      Note, currently element normal attributes like color, length and size are identical with the settings for vertex normals. The reason is that the material panel would become too messed up if there are sliders for both types of normal vectors. In the future the synchronization of the two normal vectors may be skipped, so it is a good programming practice to make use of the individual methods of each type.

    - #### setGlobalVertexNormalColor

          public void setGlobalVertexNormalColor(java.awt.Color color)

      Set global element normal color to be used if no local colors are available.
      Overrides:
        `setGlobalVertexNormalColor` in class `PgPointSet`

    - #### setGlobalVertexNormalLength

          public void setGlobalVertexNormalLength(double length)

      Set length factor of element normal vectors when drawn in display.
      Overrides:
        `setGlobalVertexNormalLength` in class `PgPointSet`

    - #### setGlobalVertexNormalSize

          public void setGlobalVertexNormalSize(double size)

      Set thickness in pixels of element normals when drawn in display.
      Overrides:
        `setGlobalVertexNormalSize` in class `PgPointSet`

    - #### getCreaseAngle

          public double getCreaseAngle()

      Get crease angle which is a threshold determining sharp crease edges.
      Since:
        JavaView 3.03.007
      See Also:
        `setCreaseAngle(double)`

    - #### setCreaseAngle

          public void setCreaseAngle(double angle)

      Set crease angle which is a threshold determining sharp crease edges. In smooth lighting and shading there is no interpolation across crease edges. An edge is a crease edge if the dihedral angle (positive angle between normals) between the two adjacent faces is equal or larger than the crease angle threshold. The crease angle is measure in radians in [0,Pi]. A crease angle 0 induces flat shading and prevents all smoothing, and a crease angle Pi+eps shows all edges with smooth shading.
      Since:
        JavaView 3.03.007
      See Also:
        `getCreaseAngle()`

    - #### getGlobalEdgeColor

          public java.awt.Color getGlobalEdgeColor()

      Get global edge color which is used if no local colors are available.

    - #### getGlobalEdgeTagColor

          public java.awt.Color getGlobalEdgeTagColor()

      Get global color of tagged edges.

    - #### getGlobalEdgeSize

          public double getGlobalEdgeSize()

      Get thickness in pixels of edge when drawn in display.

    - #### setGlobalEdgeColor

          public void setGlobalEdgeColor(java.awt.Color color)

      Set global edge color to be used if no local colors are available.

    - #### setGlobalEdgeTagColor

          public void setGlobalEdgeTagColor(java.awt.Color color)

      Set global color of tagged edges.

    - #### setGlobalEdgeSize

          public void setGlobalEdgeSize(double size)

      Set thickness in pixels of edge when drawn in display.

    - #### isShowingEdgeColors

          public boolean isShowingEdgeColors()

      Determine whether showing of edge colors is enabled.

    - #### showEdgeColors

          public void showEdgeColors(boolean flag)

      Set flag to enable drawing of individual edge colors.

    - #### isShowingEdgeSizes

          public boolean isShowingEdgeSizes()

      Determine whether showing of edge sizes is enabled.

    - #### showEdgeSizes

          public void showEdgeSizes(boolean flag)

      Set flag to enable drawing of edge sizes.

    - #### getGlobalBndColor

          public java.awt.Color getGlobalBndColor()

      Get global boundary color which is used if no local colors are available.

    - #### getGlobalBndTagColor

          public java.awt.Color getGlobalBndTagColor()

      Get global color of tagged boundaries.

    - #### getGlobalBndSize

          public double getGlobalBndSize()

      Get thickness in pixels of boundary when drawn in display.

    - #### setGlobalBndColor

          public void setGlobalBndColor(java.awt.Color color)

      Set global boundary color to be used if no local colors are available.

    - #### setGlobalBndTagColor

          public void setGlobalBndTagColor(java.awt.Color color)

      Set global color of tagged boundaries.

    - #### setGlobalBndSize

          public void setGlobalBndSize(double size)

      Set thickness in pixels of boundary when drawn in display.

    - #### isEnabledEdges

          public boolean isEnabledEdges()

      Check if storage and maintenance of edges is enabled.
      Since:
        JavaView 3.96.026

    - #### setEnabledEdges

          public void setEnabledEdges(boolean flag)

      Enable storage and maintenance of edges. By default, element edges are not permanently stored to reduce memory consumption.

      When enabled, then just a flag is set. Call makeEdgeStars() or makeNeighbour() to rebuilt the edge array.

      When disabled, then internal edge variables are deleted.

      Since:
        JavaView 3.96.026
      See Also:
        `makeEdgeStars()`, `makeNeighbour()`

    - #### getNumEdgeStars

          public int getNumEdgeStars()

      Get number of allocated edge stars. Edge stars are allocated only if isEnabledEdges()==true.

      See also getNumEdges() which returns the number of edges of the underlying simplicial complex. Note, getNumEdgeStars() will return 0 if no edgeStars are allocated while getNumEdges() always returns a number related to the simplicial complex. Use getNumEdgesStars() when working with edgeStar array, and use getNumEdges() in combinatorial calculations.

      See Also:
        `getNumEdges()`

    - #### getEdgeStars

          public PgEdgeStar[] getEdgeStars()

      Get edge array for read and write access, but do not modify the size of any edge. Use makeEdgeStars() or makeNeighbour() to generate edge array. Also note, that the actual size of the array may be larger than number of edges for efficiency reasons. Therefore, do not use length of array.
      Since:
        JavaView 3.96.026

    - #### getEdgeStar

          public PgEdgeStar getEdgeStar(int ind)

      Get edge object for read and write access, but do not modify the size of any edge. Use makeEdgeStars() or makeNeighbour() to generate edge array.
      Since:
        JavaView 3.96.026

    - #### getEdge

          public PiVector getEdge(int ind)

      Deprecated. since JavaView 3.96.031, use getEdgeStar(int).
      Get a reference to index vector of edge with given index.

    - #### setEdgeStar

          public boolean setEdgeStar(int ind,
                            PgEdgeStar edgeStar)

      Set index vector of edge with given index. Copy new edge to edge at specified position in the edge list. Number of edges is increased if required.
      Parameters:
        `ind` - index of edge
        `edgeStar` - array with indices of new edge
      Returns:
        boolean false, if index out of range, or argument missing
      Since:
        JavaView 3.96.026

    - #### getElementEdges

          public PiVector[] getElementEdges()

      Get an array which stores for each element the indices of its incident edges. For each element, the indices of the incident edges are ordered in the same way as the neighbour array.
      Returns:
        array of length=numElements with indices of edges
      Since:
        JavaView 3.96.026

    - #### getElementEdge

          public int getElementEdge(int elementInd,
                           int locNeighbInd)

      Get the index of an edge incident to the given element. The local index of edge is in the same order as the neighbour array.
      Parameters:
        `elementInd` - Index of an element.
        `locNeighbInd` - Local neighbour index of the edge.
      Returns:
        index of edge
      Since:
        JavaView 3.96.026

    - #### setElementEdges

          public void setElementEdges(PiVector[] elementEdge)

      Set an array which stores for each element the indices of its incident edges. For each element, the indices of the incident edges are ordered in the same way as the neighbour array.
      Since:
        JavaView 3.96.026

    - #### removeElementEdges

          public void removeElementEdges()

      Remove element-edge incidence information from element set.
      Since:
        JavaView 3.96.026

    - #### getEdgeColors

          public java.awt.Color[] getEdgeColors()

      Get color array for read and write access, but do not modify the size of any color vector. Also note, that the actual size of the array may be larger than the number of used edges for efficiency reasons. Therefore, do not use length of array.
      Since:
        JavaView 3.96.026

    - #### hasEdgeColors

          public boolean hasEdgeColors()

      Check if edge colors have been allocated.
      Since:
        JavaView 3.96.026
      See Also:
        `assureEdgeColors()`

    - #### assureEdgeColors

          public void assureEdgeColors()

      Assures respectively allocates correct length of edge color array. Length of array is equal to length of edge array.
      Since:
        JavaView 3.96.026

    - #### removeEdgeColors

          public void removeEdgeColors()

      Remove local edge colors from a geometry and use global edge color instead.

      Showing of edge colors must be switched off explicitly using `showEdgeColors(boolean)`.

      Since:
        JavaView 3.96.026

    - #### setEdgeColors

          public void setEdgeColors(java.awt.Color[] colorList)

      Copy edge colors of list to existing array of edge colors. Length of argument list must be equal or larger than getNumEdgeStars(). All edge colors are copied. The dimension of all argument colors must be equal to getDimOfColors() of the geometry.

      Showing of edge colors must be switched on in order to be visible.

      Parameters:
        `colorList` - array with new edge colors
      Since:
        JavaView 3.96.026

    - #### getEdgeSizes

          public PdVector getEdgeSizes()

      Get array of relative edge sizes for read and write access. Also note, that the actual size of the array may be larger than the number of used edges for efficiency reasons. Therefore, do not use length of array.
      Since:
        JavaView 3.96.026

    - #### hasEdgeSizes

          public boolean hasEdgeSizes()

      Check if relative edge sizes have been allocated.
      Since:
        JavaView 3.96.026
      See Also:
        `assureEdgeSizes()`

    - #### assureEdgeSizes

          public void assureEdgeSizes()

      Assures respectively allocates correct length of edge size array. Length of array is equal to length of edge array. Dimension of size vector is equal to maximal number of vertices.
      Since:
        JavaView 3.96.026

    - #### removeEdgeSizes

          public void removeEdgeSizes()

      Remove edge sizes from a geometry.

      Showing of edge sizes must be switched off explicitly using `showEdgeSizes(boolean)`.

      Since:
        JavaView 3.96.026

    - #### setEdgeSizes

          public void setEdgeSizes(PdVector edgeSize)

      Assign a set of relative edge sizes. Length of argument list must be equal or larger than getNumEdgeStars(). All edge sizes are copied.

      Showing of edge sizes must be switched on in order to be visible.

      Parameters:
        `edgeSize` - array with new edge size for all edges
      Since:
        JavaView 3.96.026

    - #### getElements

          public PiVector[] getElements()

      Get element array for read and write access.

      Do not modify the size of any element vector.

      Note, that the actual size of the array may be larger than m_numElements for efficiency reasons. Therefore, do not use the length of array.

    - #### getElementColors

          public java.awt.Color[] getElementColors()

      Get element color array for read and write access, but do not modify the size of any color vector. Note, that subclasses may not reference all element colors. Also note, that the actual size of the color array may be larger than m_numElements for efficiency reasons. Therefore, do not use length of array.

    - #### getElementBackColors

          public java.awt.Color[] getElementBackColors()

      Get backside element color array for read and write access, but do not modify the size of any color vector. Note, that subclasses may not reference all element colors. Also note, that the actual size of the color array may be larger than m_numElements for efficiency reasons. Therefore, do not use length of array.

    - #### getElementNormals

          public PdVector[] getElementNormals()

      Get element normal array for read and write access, but do not modify the size of any normal vector. Note, that subclasses may not reference all element normals. Also note, that the actual size of the color may be larger than m_numElements for efficiency reasons. Therefore, do not use length of array.

    - #### getElementTexture

          public PdVector[] getElementTexture(int ind)

      Get element texture array of an individual element. Returns null if no element texture available, or index out of range.
      Since:
        JavaView 2.80.000

    - #### getElementTextures

          public PdVector[][] getElementTextures()

      Get element texture array for read and write access, but do not modify the size of any texture vector. Note, that subclasses may not reference all element textures. Also note, that the actual size of the texture array may be larger than m_numElements for efficiency reasons. Therefore, do not use length of array. Each element has associated an array of 2-dimensional vectors with normalized texture coordinates.

    - #### getVertexTextures

          public PdVector[] getVertexTextures()

      Get array of all texture coordinates both for vertex and element based textures. This method overwrites PgPointSet#getVertexTextures if texture is element based.
      Overrides:
        `getVertexTextures` in class `PgPointSet`
      Returns:
        plain array of texture coordinates

    - #### getNeighbours

          public PiVector[] getNeighbours()

      Get neighbour array for read and write access, but do not modify the size of any neighbour vector. Also note, that the actual size of the array may be larger than m_numElements for efficiency reasons. Therefore, do not use length of array.

    - #### getNumBoundaries

          public int getNumBoundaries()

      Return number of (living) boundary polygons. This number may be different from number of boundary components and number of boundary edges.
      Returns:
        number of boundary segments used
      See Also:
        `getNumBoundaryEdges()`

    - #### hasBoundary

          public boolean hasBoundary()

      Check whether surface has boundary polygons, assume boundary has been calculated. TODO: Check for boundary even if boundary polygons have not been calculated yet.

    - #### getBoundaries

          public PgBndPolygon[] getBoundaries()

      Get array of boundary polygons, some of which may be marked inactive. If there does not exist a boundary then method returns array of zero length.
      Returns:
        a possibly empty array of boundary polygons. Array is never null.

    - #### getSelectedBndPolygon

          public PgBndPolygon getSelectedBndPolygon()

      Get the currently selected boundary polygon, or null if there is none.

    - #### selectBndPolygon

          public int selectBndPolygon(PgBndPolygon bnd)

      Select a boundary polygon.

    - #### getIndexOfBndPolygon

          public int getIndexOfBndPolygon(PgBndPolygon bnd)

      Get index of vector fields, assumes user data is stored in a vector.
      Returns:
        index of vector field, or -1 if it does not exist

    - #### removeBoundaries

          public void removeBoundaries()

      Remove all boundary curves.

    - #### removeDeletedBoundaries

          public int removeDeletedBoundaries()

      Remove all boundary curves which are marked PsObject.IS_DELETED.
      Returns:
        number of deleted boundaries.

    - #### setBoundary

          public void setBoundary(PgBndPolygon[] newBnd)

      Set new boundary polygons by replacing the previous array with the argument array.
      Parameters:
        `newBnd` - array with new boundary polygons of element set.

    - #### assureBoundary

          public void assureBoundary(int num)

      Allocate boundary polygons and register current element set. If new number of polygons is smaller than old number then try to reuse old polygons.

    - #### isShowingEdges

          public boolean isShowingEdges()

      Determines whether drawing of element edges is enabled.

    - #### showEdges

          public void showEdges(boolean flag)

      Set flag to enable drawing of element edges.

    - #### isShowingEdgeColorFromElements

          public boolean isShowingEdgeColorFromElements()

      Determines whether local edge color is induced from element or vertex colors.

    - #### showEdgeColorFromElements

          public void showEdgeColorFromElements(boolean flag)

      Set flag if edge colors are induced from local element or vertex colors.

    - #### isShowingSmoothEdgeColors

          public boolean isShowingSmoothEdgeColors()

      Determines whether smooth coloring of edges is enabled, currently requires vertex colors.

    - #### showSmoothEdgeColors

          public void showSmoothEdgeColors(boolean flag)

      Set flag to enable smooth coloring of edges, currently requires vertex colors.

    - #### isShowingEdgeColorFromVertices

          public boolean isShowingEdgeColorFromVertices()

      Determines whether smooth edge coloring uses vertex colors at vertices, requires vertex colors.

    - #### showEdgeColorFromVertices

          public void showEdgeColorFromVertices(boolean flag)

      Set flag to enable smooth edge coloring using vertex colors at vertices, requires vertex colors.

    - #### isShowingEdgeLabels

          public boolean isShowingEdgeLabels()

      Determines whether showing of edge labels is enabled.

    - #### showEdgeLabels

          public void showEdgeLabels(boolean flag)

      Set flag to enable drawing of edge labels in display.

    - #### isShowingTaggedEdges

          public boolean isShowingTaggedEdges()

      Determines whether drawing of tagged element edges is enabled.

    - #### showTaggedEdges

          public void showTaggedEdges(boolean flag)

      Set flag to enable drawing of element edges.

    - #### isShowingElementLabels

          public boolean isShowingElementLabels()

      Determines whether showing of element labels is enabled.

    - #### isShowingElements

          public boolean isShowingElements()

      Determines whether drawing of elements is enabled.

    - #### isShowingTaggedElements

          public boolean isShowingTaggedElements()

      Determines whether drawing of tagged elements is enabled.

    - #### isShowingBackface

          public boolean isShowingBackface()

      Determines whether drawing of backfacing elements whose normal points away from camera is enabled.

    - #### isShowingElementNormals

          public boolean isShowingElementNormals()

      Determines whether drawing of element normals is enabled.

    - #### isShowingElementNormalArrow

          public boolean isShowingElementNormalArrow()

      Determines whether drawing of arrow of element normals is enabled.

    - #### isShowingElementTextures

          public boolean isShowingElementTextures()

      Deprecated. use isShowingElementTexture()
      Determines whether drawing of element texture is enabled.

    - #### isShowingElementTexture

          public boolean isShowingElementTexture()

      Determines whether drawing of element texture is enabled.

    - #### isShowingSilhouette

          public boolean isShowingSilhouette()

      Determines whether a polygon is shown along the silhouette if a shape.

    - #### showSilhouette

          public void showSilhouette(boolean flag)

      Set flag to enable if a polygon is shown along the silhouette if a shape.

    - #### isShowingBoundaries

          public boolean isShowingBoundaries()

      Determines whether drawing of boundary curves is enabled.

    - #### isShowingTaggedBoundaries

          public boolean isShowingTaggedBoundaries()

      Determines whether drawing of tagged boundary curves is enabled.

    - #### isShowingElementColors

          public boolean isShowingElementColors()

      Determines whether global element color is used.

    - #### isShowingElementBackColors

          public boolean isShowingElementBackColors()

      Determines whether drawing of individual backface element colors is enabled.

    - #### isShowingElementBackColor

          public boolean isShowingElementBackColor()

      Determines whether global element backface color is used.

    - #### isShowingSmoothLighting

          public boolean isShowingSmoothLighting()

      Determines whether smooth lighting is enabled, requires vertex normals.

    - #### showSmoothLighting

          public void showSmoothLighting(boolean flag)

      Set flag to enable smooth lighting, requires vertex normals.

    - #### isShowingSmoothElementColors

          public boolean isShowingSmoothElementColors()

      Determines whether smooth coloring of elements is enabled, currently requires vertex colors.

    - #### showSmoothElementColors

          public void showSmoothElementColors(boolean flag)

      Set flag to enable smooth coloring of elements, currently requires vertex colors.

    - #### isShowingElementFromVertexColors

          public boolean isShowingElementFromVertexColors()

      Determines whether smooth element coloring uses vertex colors, requires vertex colors.

    - #### showElementFromVertexColors

          public void showElementFromVertexColors(boolean flag)

      Set flag to enable smooth element coloring using vertex colors at vertices, requires vertex colors.

    - #### showElementLabels

          public void showElementLabels(boolean flag)

      Set flag to enable drawing of element labels in display.

    - #### showElements

          public void showElements(boolean flag)

      Set flag to enable drawing of elements.

    - #### showTaggedElements

          public void showTaggedElements(boolean flag)

      Set flag to enable drawing of tagged elements.

    - #### showElementBackColor

          public void showElementBackColor(boolean flag)

      Set flag to enable drawing of backface color of elements.

    - #### showElementBackColors

          public void showElementBackColors(boolean flag)

      Set flag to enable drawing of individual backface element colors.

    - #### showBackface

          public void showBackface(boolean flag)

      Set flag to enable drawing of backfacing elements whose normal points away from camera. If backface is disabled and element set has no element normals then method creates element normals.

    - #### showElementNormals

          public void showElementNormals(boolean flag)

      Set flag to enable drawing of element normals.

    - #### showElementNormalArrow

          public void showElementNormalArrow(boolean flag)

      Set flag to enable drawing of arrow of element normal.

    - #### showElementTexture

          public void showElementTexture(boolean flag)

      Set flag to enable drawing of element texture.

    - #### showVertexTexture

          public void showVertexTexture(boolean flag)

      Set flag to enable drawing of vertex texture. This method disables element texture whenever vertex texture is enabled, and vice versa.
      Overrides:
        `showVertexTexture` in class `PgPointSet`

    - #### showBoundaries

          public void showBoundaries(boolean flag)

      Set flag to enable drawing of boundary curves.

    - #### showTaggedBoundaries

          public void showTaggedBoundaries(boolean flag)

      Set flag to enable drawing of boundary curves.

    - #### showElementColors

          public void showElementColors(boolean flag)

      Set flag of using global element color instead of coloring each element individually.

    - #### getMaxNumElements

          public int getMaxNumElements()

      Get total length of allocated element array. Usually, only a subset is filled with data. Method is for internal use, see getNumElements() for daily work.

    - #### setMaxNumElements

          public void setMaxNumElements(int numElements)

      Major memory allocation routine, all element allocation should be done here. Element and neighbour array are adjusted to new size. All element property arrays, such as element normals, are adjusted if they where allocated before. All element allocation is done in this method. Method should not be called directly unless a specific allocation is required. Usually, a user would specify the number of elements via setNumElements().

    - #### getNumElements

          public int getNumElements()

      Get number of elements in element array. Note, that the actual size of the element array may be larger for efficiency reasons. Therefore, do not use m_element.length.

    - #### getNumElementIndices

          public int getNumElementIndices()

      Get total number of vertex entries in all elements. If instance variable m_dimOfElements is unequal to -1 then total number is equal to m_numElements*m_dimOfElements.
      Returns:
        int total number of all vertex indices of all elements

    - #### setNumElements

          public void setNumElements(int numElements)

      Allocate given number of elements, and allocate normals, colors etc. if they already exist. Internally, there may exist more elements than requested serving as buffer and to reduce allocation times.

      Note, the neighbour array might be initialized to -1 when its size changes.

    - #### getMaxDimOfElements

          public int getMaxDimOfElements()

      Get maximal number of vertices appearing in an element. Method returns the same value as getDimOfElements() if all elements have the same size.
      Since:
        JavaView 2.84.000
      See Also:
        `getDimOfElements()`

    - #### getDimOfElements

          public int getDimOfElements()

      Get number of vertices per element if it is the same for all elements, otherwise return -1. If elements have different size, then use getMaxDimOfElements() to obtain the maximal size of an element.
      See Also:
        `getMaxDimOfElements()`, `getDimOfElement(int)`, `setDimOfElements(int)`

    - #### setDimOfElements

          public void setDimOfElements(int aSize)

      Let all elements have same number of vertices `aSize<>0`, or individual `aSize=-1`. It is more efficient to call method before `setNumElements()`.

      Argument must be -1 or >=3. Other values lead to a warning message.

      Note, if aSize!=-1 then this method initializes the neighbour array of all elements to -1.

      Parameters:
        `aSize` - Number of vertices for all elements.
      See Also:
        `setNumElements(int)`

    - #### getDimOfElement

          public int getDimOfElement(int ind)

      Get number of vertices of an element with given index.
      Since:
        JavaView 2.80.000
      See Also:
        `getDimOfElements()`, `setDimOfElement(int, int)`

    - #### setDimOfElement

          public void setDimOfElement(int ind,
                             int aSize)

      Set size of a single element and associated data like neighbour list. Element must exist already, and index of element must be in range [0,m_numElements-1]. Method may modify instance variable m_dimOfElements. It is more efficient to call method before `setElement(int, PiVector)`.

      New size must be larger than 3, other values lead to a warning message.

      Note, this method initializes the neighbour array of this element to -1.

      Parameters:
        `ind` - Index of element to change size.
        `aSize` - New number of vertices of element, must be larger than 3.
      See Also:
        `getDimOfElement(int)`, `setDimOfElements(int)`, `setElement(int, PiVector)`

    - #### setDimOfColors

          public void setDimOfColors(int aSize)

      Let all colors have same number of components `aSize<>0`.
      Overrides:
        `setDimOfColors` in class `PgPointSet`
      Parameters:
        `aSize` - Number of components of each color vector.

    - #### setDimOfVertices

          public void setDimOfVertices(int dim)

      Set dimension of vertices. Make rare use, and try to assign dimension of vertices already in the constructor.
      Overrides:
        `setDimOfVertices` in class `PgPointSet`

    - #### setDimOfVectors

          public void setDimOfVectors(int aSize)

      Let all vectors have same number of vectors `aSize<>0`. It is more efficient to call method before `setNumVertices()`.
      Overrides:
        `setDimOfVectors` in class `PgPointSet`
      Parameters:
        `aSize` - Number of coordinates of each element.
      See Also:
        `PgPointSet.setDimOfVectors(int)`

    - #### assureDimOfElements

          public boolean assureDimOfElements()

      Assure correctness of value m_dimOfElements specifying the number of vertices per Element. If value is incorrect then `setDimOfElements(int)` is called to set the correct value. Note: this check does not include the size of elements with index in {m_numElements, m_maxNumElements-1}.
      Returns:
        true if m_dimOfElements had the correct value.
      See Also:
        `setDimOfElements(int)`

    - #### hasElementColors

          public boolean hasElementColors()

      Check if element colors have been allocated.
      See Also:
        `assureElementColors()`

    - #### hasElementBackColors

          public boolean hasElementBackColors()

      Check if element back colors have been allocated.
      See Also:
        `assureElementBackColors()`

    - #### hasElementNormals

          public boolean hasElementNormals()

      Check if element normals have been allocated.
      See Also:
        `assureElementNormals()`

    - #### hasElementTextures

          public boolean hasElementTextures()

      Check if element textures have been allocated.
      See Also:
        `assureElementTextures()`

    - #### assureElementColors

          public void assureElementColors()

      Assures respectively allocates correct length of element color array. Length of array is equal to length of element array.

    - #### assureElementBackColors

          public void assureElementBackColors()

      Assures respectively allocates correct length of element color array. Length of array is equal to length of element array.

    - #### assureElementNormals

          public void assureElementNormals()

      Assures respectively allocates correct length of element normal array. Length of array is equal to length of element array. Dimension of normal vectors is equal to dimension of vertices.

    - #### assureElementTextures

          public void assureElementTextures()

      Assures respectively allocates correct length of element texture array. Length of array is equal to length of element array. Dimension of normal vectors is equal to `getDimOfTextures()`.

    - #### paint

          public void paint(PvGeometryIf dc)

      Major rendering method fills an internal container class supplied by the display. See `jv.project.PgGeometryIf` for detailed information.
      Specified by:
        `paint` in interface `PgGeometryIf`
      Overrides:
        `paint` in class `PgPointSet`
      See Also:
        `PgGeometryIf`

    - #### makeQuadrElementTexture

          public void makeQuadrElementTexture(int uDiscr,
                                     int vDiscr)

      Generate default element texture in [0,1]*[0,1] for a quadrilateral surface.
      Parameters:
        `uDiscr` - Number of lines in `u` direction.
        `vDiscr` - Number of lines in `v` direction.

    - #### makeQuadrConn

          public void makeQuadrConn(int uDiscr,
                           int vDiscr)

      Generate element and neighbourhood information for a quadrilateral surface. Method generates only topological information, no coordinates are required.
      Parameters:
        `uDiscr` - Number of lines in `u` direction.
        `vDiscr` - Number of lines in `v` direction.
      See Also:
        `makeCylinderConn(int, int)`

    - #### makeAlternatingQuadrConn

          public void makeAlternatingQuadrConn(int uDiscr,
                                      int vDiscr,
                                      boolean alternateUDir)

      Make quadrilateral connectivity with quadrilaterals being alternately triangulated. Quadrilaterals are triangulated along a diagonal. If alternateUDir==true then along uDir the diagonal is changed from one quadrilateral to the next, and kept the same along the vDir. Otherwise the flipping happens along the vDir.
      Parameters:
        `uDiscr` - Number of lines in `u` direction.
        `vDiscr` - Number of lines in `v` direction.
        `alternateUDir` - Determines if diagonals are flipped along uDir or vDir.
      See Also:
        `makeCylinderConn(int, int)`

    - #### makeCylinderConn

          public void makeCylinderConn(int uDiscr,
                              int vDiscr)

      Generate element and neighbourhood information for a cylindrical surface. Method generates only topological information, no coordinates are required. Remark: In contrast to makeQuadrConn this method produces a cylinder with exactly vDiscr vertices and vDiscr elements around the tube. Therefore, the number of elements differ between makeQuadrConn and makeCylinderConn.
      Parameters:
        `uDiscr` - Number of lines in `u` direction.
        `vDiscr` - Number of lines in `v` direction.
      See Also:
        `makeQuadrConn(int, int)`

    - #### makeQuadrBnd

          public void makeQuadrBnd(int uDiscr,
                          int vDiscr)

      Generate boundary information for a quadrilateral surface. Method generates only topological information, no coordinates are required. Boundary runs counter-clockwise around (i,j) domain, where i increments by vDiscr along x-axis and j increments by 1 along y-axis.
      Parameters:
        `uDiscr` - Number of lines in `u` direction.
        `vDiscr` - Number of lines in `v` direction.
      See Also:
        `makeQuadrConn(int, int)`, `getBoundaries()`

    - #### makeTriangleConn

          public void makeTriangleConn(int discr)

      Generate the connectivity for a macro triangle where all edges are subdivided into 'discr' points. Method generates only topological information, no coordinates are required.
      Parameters:
        `discr` - number of points on each edge
      See Also:
        `makeTriangleBnd(int)`

    - #### makeTriangleBnd

          public void makeTriangleBnd(int discr)

      Generate the boundary of a macro triangle where all edges are subdivided into 'discr' points. Method generates only topological information, no coordinates are required.
      Parameters:
        `discr` - number of points on each edge
      See Also:
        `makeTriangleConn(int)`

    - #### flipOrientation

          public void flipOrientation()

      Change orientation of all elements and invert normal vectors.
      Overrides:
        `flipOrientation` in class `PgPointSet`
      See Also:
        `PgPointSet.flipOrientation()`

    - #### getVertexValence

          public static PiVector getVertexValence(PgElementSet geom)

      Compute valence of each vertex, that is, the number of incoming edges. This method requires correct neighbour information.
      Returns:
        vector with the valence of each vertex, its length equals the number of vertices.

    - #### flipEdges

          public void flipEdges()

      Flip edge of pairs of adjacent triangles if sum of opposite angles is larger than sum of spatial angles at common edge. Valid for triangulations only. This algorithm tries to avoid degenerate triangulations, say, having valence 3 vertices.

    - #### allocateEdgeStars

          public void allocateEdgeStars()

      Enable edges and make edges stars if no edge stars available.

    - #### makeEdgeStars

          public PgEdgeStar[] makeEdgeStars()

      Generate list of edges from element information of a possibly non-manifold surface. Method does not use neighbour information but computes the edge list solely based on information of the m_element array.

      The routine computes an array of edges temporarily in a single pass through all elements. Additionally, it stores the (1, 2, ..) elements sharing an edge.

      The method allows an edge to be shared by more than two elements, i.e. non-manifold polyhedra. Method consists of code from previous version of `makeNeighbour()`, which now calls makeEdgeStars(). Therefore, the method does not use any neighbour information.

      During edge collection, each edge is stored in the array edgesAtVertex at an index equal to the lowest of its two vertex indices. After the collection, each entry of edgesAtVertex is a vector containing those edges emanating from this vertex to vertices with higher vertex index. The entry at index i in edgesAtVertex is an array which contains all edges emanating from vertex with index i to vertices with higher index.

      This algorithm requires the array edgesAtVertex to have size equal to largest vertex index referenced from an element, but has a linear runtime when finding entries with identical edges. When collection is finished, usually some array entries will be `null`. The return parameter is an array of edges constructed from edgesAtVertex.

      Note, think about using `getEdge(int,int)` to obtain just a few edges.

      If element set is non-manifold then the number of edges returned by this method may differ from the number which getNumEdgeStars() returns and getNumEdges() since the later relies on a correct neighbour information which is not used here.

      Returns:
        array with all edge, size equals number of edges.
      See Also:
        `getNumEdgeStars()`, `getEdgeStars()`, `getEdge(int, int)`

    - #### makeEdgeStarsFromNeighbour

          public PgEdgeStar[] makeEdgeStarsFromNeighbour()

      Generate list of edges from the neighbourhood information of a possibly non-manifold surface. Method computes the edge list based on information of the m_neighbour and m_element arrays.

      The routine computes an array of edges temporarily in a single pass through all elements. Additionally, it stores the 1 or 2 elements sharing an edge.

      This method does not allow an edge to be shared by more than two elements; for non-manifold edges the neighbourhood information must be set correctly in m_neighbour. By this method the edge list can be reconstructed for models saved to a jvx file.

      During edge collection, each edge is stored in the array edgesAtVertex at an index equal to the lowest of its two vertex indices. After the collection, each entry of edgesAtVertex is a vector containing those edges emanating from this vertex to vertices with higher vertex index.

      This algorithm requires the array edgesAtVertex to have size equal to largest vertex index referenced from an element, but has a linear runtime when finding entries with identical edges. When collection is finished, usually some array entries will be `null`. The return parameter is an array of edges constructed from edgesAtVertex.

      Returns:
        array with all edges, size equals number of edges.
      See Also:
        `getNumEdgeStars()`, `getEdgeStars()`, `getEdge(int, int)`, `makeEdgeStars()`

    - #### printEdgeList

          public java.lang.String printEdgeList()

      Print list of edges to console if previously computed.

    - #### makeNeighbour

          public boolean makeNeighbour()

      Generate neighbourhood information for a given manifold polyhedron. The routine computes an array of edges temporarily in a single pass through all elements, and uses this information to fill out the neighbour instance variable. The diagram details this.

      Since version 2.60 the construction of the edge list is outsourced in `getEdgeStars()`.

      Edges belonging to more than two elements become a boundary edge in each element.

      Returns:
        boolean false, if polyhedron is not a manifold, i.e. an edge is shared by more than two elements.

    - #### makeElementNormals

          public boolean makeElementNormals()

      Compute element normals from edge cross products. For each element, a normal is computed at each of its vertices as the cross product of the adjacent edges. These vertex normals are then added, and the normalized sum used as element normal. This strategy reduces the effect of non-planar elements.

      Method works reliably only for convex planar elements.

      Dimension of vertices must be equal to 3.

      See Also:
        `makeVertexNormals()`

    - #### makeVertexNormals

          public boolean makeVertexNormals()

      Compute vertex normals from adjacent elements (without using element normals). For each vertex compute for each element a normal vector from two edges. The contribution of these element normals is proportional to the element area.

      Dimension of vertices must be equal to 3.

      Overrides:
        `makeVertexNormals` in class `PgPointSet`
      See Also:
        `makeElementNormals()`

    - #### buildQuadr

          public void buildQuadr(PdVector[] quadr,
                        int uDiscr,
                        int vDiscr)

      Create a rectangular elements by bilinear interpolation of four given vertices and discretization. This method creates the vertices, the connectivity is generated in makeQuadrConn.
      Parameters:
        `quadr` - array with four vertices of macro patch
        `uDiscr` - number of vertices along u-direction
        `vDiscr` - number of vertices along v-direction
      See Also:
        `makeQuadrConn(int, int)`

    - #### buildTriangle

          public void buildTriangle(PdVector[] triangle,
                           int discr)

      Generate the vertices for a macro triangle where all edges are subdivided into 'discr' points. This method creates the vertices, the connectivity is generated in makeTriangleConn. TODO: Method should be split, and coordinate stuff move to PgPointSet.
      Parameters:
        `triangle` - array with three vertices of macro patch
        `discr` - number of points on each edge
      See Also:
        `makeTriangleBnd(int)`

    - #### buildPolygon

          public void buildPolygon(PdVector[] polygon,
                          int discr)

      Generate the vertices for a macro polygon where all edges are subdivided into 'discr' points. This method creates the vertices, the connectivity is generated in makePolygonConn.

      TODO: Method should be split, and coordinate stuff move to PgPointSet.

      Parameters:
        `polygon` - triangle array with three vertices of macro patch
        `discr` - number of points on each edge
      See Also:
        `makeTriangleBnd(int)`

    - #### buildTriangleFromCurve

          public void buildTriangleFromCurve(PgPolygon[] curve,
                                    PgBndConstraint[] bndConstr)

      Generate the vertices for a macro triangle given by three polygons with same discretization. This method creates the vertices, the connectivity is generated in makeTriangleConn. Boundary constraints are assigned to boundary curves of resulting element set. TODO: Method should be split, and coordinate stuff move to PgPointSet.
      Parameters:
        `curve` - array with three polygons with same number of vertices
        `bndConstr` - boundary constraints assigned to boundary polygons
      See Also:
        `makeTriangleConn(int)`

    - #### buildQuadrFromCurve

          public void buildQuadrFromCurve(PgPolygon[] curve,
                                 PgBndConstraint[] bndConstr)

      Generate the vertices for a macro quadrilateral given by four polygons with pairwise same discretization. curve[0] and curve[2] respectively curve[1] and curve[3] must have same discretization. This method creates the vertices, the connectivity is generated in makeTriangleConn. Boundary constraints are assigned to boundary curves of resulting element set. TODO: Method should be split, and coordinate stuff move to PgPointSet.
      Parameters:
        `curve` - array with four polygons with pairwise same number of vertices
        `bndConstr` - boundary constraints assigned to boundary polygons
      See Also:
        `makeTriangleConn(int)`

    - #### close

          public boolean close()

      Identify and remove all interior boundaries of a geometry, and compress vertex array. Currently, the method requires a list of precomputed boundary curves. The method should be extend to use edge and neighbour information to determine boundaries.
      Returns:
        `true` if successful
      See Also:
        `removeUnusedVertices()`

    - #### getNumUnusedVertices

          public int getNumUnusedVertices()

      Get the number of unused vertices which are not references by elements. This method is very cheap and should be
      Returns:
        number of unused vertices

    - #### removeUnusedVertices

          public boolean removeUnusedVertices()

      Remove all points not referenced by elements. E.g. after application of method `close()` vertices are no longer in used since elements are identified long interior boundary curves. First, the method computes where each point is moved to, then all point data is moved and the vertex indices are changed. This routine is O(n).
      Returns:
        `true` if method was successful

    - #### removeMarkedVertices

          public int[] removeMarkedVertices()

      Remove vertices marked with tag PsObject#IS_DELETED from elements. Remove all elements containing a marked vertex, and remove all marked vertices. It is necessary to keep a valid element set after removal of vertices in the superclass.
      Overrides:
        `removeMarkedVertices` in class `PgPointSet`
      Returns:
        array with indices of new positions of all previously existing vertices

    - #### removeElement

          public int[] removeElement(int ind)

      Remove element with given index, and decrement index of all elements with higher index. Method just marks element with tag `PsObject.IS_DELETED` and invokes `removeMarkedElements()`.
      Specified by:
        `removeElement` in interface `PgGeometryIf`
      Overrides:
        `removeElement` in class `PgGeometry`
      Parameters:
        `ind` - index of element which is to be deleted
      Returns:
        Array with indices of new positions of all previously existing elements

    - #### removeMarkedElements

          public int[] removeMarkedElements()

      Remove all elements which have been marked `PsObject.IS_DELETED`. E.g. after application of method `close()` elements are no longer in use since elements are shrunk at zero-length boundary curves. First, the method computes where each element is moved to, then all element data is moved and the references to the element in bnd curves is changed. This routine is O(n).

      Method assumes that there exist no references to marked elements. Otherwise application of this method would lead to unpredictable results.

      Returns:
        Array with indices of new positions of all previously existing elements

    - #### merge

          public boolean merge(PgGeometryIf aGeom)

      Merge element set with current object and store union of both objects in 'this'. Number of points and elements is the sum of both objects. List of boundary curves is the union of both objects, i.e. both objects are not identified along common boundary curves. This identification can be made by a later call to `close()`.

      The merged geometry will local colors allocated and assigned if

                          1. both the global color of both geometries are different, or
                          2. either geometry has local colors.

      If local colors are allocated but one of the geometries does not have local colors then its local colors are be assumed to be its global color. The merged geometry will show globalVertexColors if

                          1. the global color of both geometries is the same, and
                          2. both geometries are showing the global color.

      In all other cases the merged geometry will show local colors. The global color of the merged geometry is never changed.
      Specified by:
        `merge` in interface `PgGeometryIf`
      Overrides:
        `merge` in class `PgPointSet`
      Parameters:
        `aGeom` - elementSet to be merged into 'this'
      Returns:
        `true` if method was successful
      See Also:
        `close()`

    - #### refineGlobalIntoFour

          public boolean refineGlobalIntoFour()

      Deprecated. use refineGlobalIntoFour(boolean) instead.
      Refine elementSet by dividing each triangle into four similar children.

    - #### refineGlobalIntoFour

          public boolean refineGlobalIntoFour(boolean bInsertMidPoints)

      Refine elementSet by dividing each triangle into four similar children. Initially we triangulate the elementSet; this method requires correct neighbour information. On return the neighbour information is correct. The refinement scheme is sketched in the following image .
      Parameters:
        `bInsertMidPoints` - flag, if new vertices shall be computed to edge mid points.
      Returns:
        `true` if method was successful
      See Also:
        `PwRivaraBisection.rivaraRefinement(jv.geom.PgElementSet, int[])`

    - #### getElementWithVertex

          public int getElementWithVertex(int vertexInd)

      Find first element referencing a given vertex.

    - #### getEdge

          public PgEdgeStar getEdge(int vInd1,
                           int vInd2)

      Create an edge structure with information about edge and adjacent elements. Two vertex indices of an edge are given as parameters. Method does not use neighbour information of element set.

      Note, method runs through all elements to find an edge. So, do not use this method in inner loops but create an edge array instead using `getEdgeStars()`.

      Parameters:
        `vInd1` - Index of edge vertices in global vertex array of elementSet.
        `vInd2` - Index of edge vertices in global vertex array of elementSet.
      Returns:
        Edge structure with information about adjacent elements
      See Also:
        `getEdgeStars()`

    - #### clearTagElement

          public void clearTagElement(int ind,
                             int aTag)

      Clear a single tag of a element. For possible tags see `PvGeometryIf`.
      Specified by:
        `clearTagElement` in interface `PgGeometryIf`
      Overrides:
        `clearTagElement` in class `PgGeometry`

    - #### hasTagElement

          public boolean hasTagElement(int ind,
                              int aTag)

      Check whether element has given tag. For possible tags see `PvGeometryIf`.
      Specified by:
        `hasTagElement` in interface `PgGeometryIf`
      Overrides:
        `hasTagElement` in class `PgGeometry`

    - #### setTagElement

          public void setTagElement(int ind,
                           int aTag)

      Set a tag of a element. For possible tags see `PvGeometryIf`.
      Specified by:
        `setTagElement` in interface `PgGeometryIf`
      Overrides:
        `setTagElement` in class `PgGeometry`

    - #### getElementVertices

          public PdVector[] getElementVertices(int elemInd)

      Get an array with pointers to all vertices of an element. Vertices appear in the array in the same order as in the element.

    - #### getElement

          public PiVector getElement(int ind)

      Get a reference to an individual element.
      Specified by:
        `getElement` in interface `PgGeometryIf`
      Overrides:
        `getElement` in class `PgGeometry`
      Parameters:
        `ind` - index of element
      Returns:
        reference to element vector with given index

    - #### getNeighbour

          public PiVector getNeighbour(int ind)

      Get a reference to an individual neighbour vector.
      Parameters:
        `ind` - index of element

    - #### getElementColor

          public java.awt.Color getElementColor(int ind)

      Get a reference to an individual element color.
      Parameters:
        `ind` - index of element

    - #### getElementBackColor

          public java.awt.Color getElementBackColor(int ind)

      Get a reference to an individual backside element color.
      Parameters:
        `ind` - index of element

    - #### getElementNormal

          public PdVector getElementNormal(int ind)

      Get a reference to an individual element normal.
      Parameters:
        `ind` - index of element

    - #### setElementVertices

          public boolean setElementVertices(int elemInd,
                                   PdVector[] vArray)

      Copy new element vertices at specified position in the vertex array of PgPointSet. Destination element including data array must already exists.
      Parameters:
        `elemInd` - index of element
        `vArray` - array with new coordinates of element vertices
      Returns:
        boolean false, if index out of range, or argument missing

    - #### setElement

          public void setElement(int elemInd,
                        int a,
                        int b,
                        int c)

      Copy new vertex indices to element at specified position in the element list. Number of elements is increased if required. Dimension of elements is adjusted if necessary.
      Parameters:
        `elemInd` - index of element
        `a` - new vertex index of element
        `b` - new vertex index of element
        `c` - new vertex index of element

    - #### setElement

          public void setElement(int elemInd,
                        int a,
                        int b,
                        int c,
                        int d)

      Copy new vertex indices to element at specified position in the element list. Number of elements is increased if required. Dimension of elements is adjusted if necessary.
      Parameters:
        `elemInd` - index of element
        `a` - new vertex index of element
        `b` - new vertex index of element
        `c` - new vertex index of element
        `d` - new vertex index of element

    - #### setElement

          public boolean setElement(int elemInd,
                           int[] anIndArray)

      Copy new vertex indices to element at specified position in the element list. Number of elements is increased if required. Dimension of elements is adjusted if necessary.
      Parameters:
        `elemInd` - index of element
        `anIndArray` - array with new vertex indices of element
      Returns:
        boolean false, if element and array have different

    - #### setElement

          public boolean setElement(int ind,
                           PiVector newElem)

      Copy new vertex indices to element at specified position in the element list. Number of elements is increased if required.
      Specified by:
        `setElement` in interface `PgGeometryIf`
      Overrides:
        `setElement` in class `PgGeometry`
      Parameters:
        `ind` - index of element
        `newElem` - vector with new indices of element
      Returns:
        boolean false, if element and array have different

    - #### setNeighbour

          public boolean setNeighbour(int ind,
                             PiVector newNeigh)

      Set neighbour elements of given element. Index must be a valid element index, and length of neighbour entries must be equal to size of specified element.

      Usually, an applications calls makeNeighbour() instead of calling this low level method. This method is provided for efficiency.

      Parameters:
        `ind` - index of element
        `newNeigh` - vector with indices of neighbour elements
      Returns:
        boolean false, if element and array have different
      Since:
        JavaView 3.24.001

    - #### setElementColor

          public boolean setElementColor(int ind,
                                java.awt.Color aColor)

      Copy new color to element color at specified position in the color list
      Parameters:
        `ind` - index of element
        `aColor` - color to be copied to color list
      Returns:
        boolean false, if index out of range, or argument missing

    - #### setElementBackColor

          public boolean setElementBackColor(int ind,
                                    java.awt.Color aColor)

      Copy new color to element color at specified position in the color list
      Parameters:
        `ind` - index of element
        `aColor` - color to be copied to color list
      Returns:
        boolean false, if index out of range, or argument missing

    - #### setElementNormal

          public boolean setElementNormal(int ind,
                                 PdVector aNormal)

      Copy new normal to element normal at specified position in the normal list
      Parameters:
        `ind` - index of element
        `aNormal` - normal to be copied to normal list
      Returns:
        boolean false, if index out of range, or argument missing

    - #### setElementTexture

          public boolean setElementTexture(int ind,
                                  PdVector[] aTexture)

      Copy new texture coordinates to element texture at specified position in the element texture list
      Parameters:
        `ind` - index of element
        `aTexture` - array with texture coordinates to be copied
      Returns:
        boolean false, if index out of range, or argument missing

    - #### setElements

          public void setElements(PiVector[] element)

      Copy the first `getNumElements()` elements of source array into an existing element array. If source array is too small then abort operation. Assure size of neighbour array, but recomputation of neighbour information must be invoked explicitly using `makeNeighbour()`.

      Appearance of elements with 2 or less vertices should be avoid. They lead to a setting of m_dimOfElements=2.

      Parameters:
        `element` - array of element vectors to be copied

    - #### removeElementColors

          public void removeElementColors()

      Remove local element colors from a geometry and use global element color instead.

      Showing of element colors must be switched off explicitly using `showElementColors(boolean)`.

    - #### setElementColors

          public void setElementColors(java.awt.Color[] color)

      Copy element colors of list to existing array of element colors. Length of argument list must be equal or larger than getNumElements().

      Showing of element colors must be switched on in order to be visible.

      Parameters:
        `color` - array with new element colors

    - #### removeElementBackColors

          public void removeElementBackColors()

      Remove local backface element colors from a geometry and use global backface element color instead.

      Showing of backface element colors must be switched off explicitly using `showElementBackColor(boolean)`.

    - #### setElementBackColors

          public void setElementBackColors(java.awt.Color[] color)

      Copy backface element colors of list to existing array of element colors. Length of argument list must be equal or larger than getNumElements().

      Showing of back element colors must be switched on in order to be visible.

      Parameters:
        `color` - array with new element colors

    - #### removeElementNormals

          public void removeElementNormals()

      Remove element normals from a geometry.

      Showing of element normals must be switched off explicitly using `showElementColors(boolean)`.

    - #### setElementNormals

          public void setElementNormals(PdVector[] normal)

      Copy element normals of list to existing array of element normals. Length of argument list must be equal or larger than getNumElements(). All element normals are copied. The dimension of all argument normals must be equal same as dimension of vectors.

      Showing of element normals must be switched on in order to be visible.

      Parameters:
        `normal` - array with new element normals

    - #### setElementTextures

          public void setElementTextures(PdVector[][] texCoords)

      Use the given textures coordinates as element-based texture coordinates. Length of argument list must be equal or larger than getNumElements(). All element textures are copied. The dimension of all argument textures must be equal to `getDimOfTextures()` of the geometry.

      Showing of textures must be switched on in order to be visible.

      Parameters:
        `texCoords` - array with new element textures
      See Also:
        `setElementTexturesFromList(PdVector [])`

    - #### setElementTexturesFromList

          public void setElementTexturesFromList(PdVector[] texCoords)

      Use the given textures coordinates as element-based texture coordinates. Length of argument list must be equal or larger than `getNumElementIndices()`. All textures coordinates are copied. The dimension of all argument texture vectors must be equal to getDimOfTextures() of the geometry.

      In contrast to the method `setElementTextures(PdVector [][])` the texture coordinates of the double vector are simply linearized, that means, if the first element has n-vertices, then the first n-textures coordinates are used as texture coordinates of this element.

      Showing of textures must be switched on in order to be visible.

      Parameters:
        `texCoords` - array with new element textures
      Since:
        JavaView 2.45
      See Also:
        `setElementTextures(PdVector [][])`

    - #### removeTexture

          public void removeTexture()

      Remove all texture information from surface and switch off showing of texture. Removes texture image and texture coordinates from elements and vertices both.
      Overrides:
        `removeTexture` in class `PgPointSet`

    - #### setNeighbours

          public void setNeighbours(PiVector[] neighbour)

      Copy neighbour array to existing array of neighbours. Length of argument list must be equal or larger than getNumElements(). All neighbour information is copied.
      Parameters:
        `neighbour` - array with neighbour information
      See Also:
        `makeNeighbour()`

    - #### getNeighbourLocInd

          public int getNeighbourLocInd(int elemInd,
                               int vInd,
                               int wInd)

      For a given edge return the local index of the vertex containing the neighbourhood information. For triangles, return the local index of the third vertex in the element[anElem], i.e. the vertex not on the edge (vInd, wInd).

      Modified to handle elements with more than three edges too. The 'neighbour vertex' is now defined as the place which stores the neighbourhood information for edge (vInd, wInd) in m_neighbour. If i is the lowest local index of both edge vertices, then i+elemLen-1 is the searched position. In case of a triangle, i+elemLen-1 == i+2, so nothing is changed for triangles.

      Parameters:
        `vInd` - index of first vertex of an element edge, not local indices
        `wInd` - index of second vertex of an element edge, not local indices
        `elemInd` - an element index
      Returns:
        local index of the vertex containing the neighbourhood information for given edge
      See Also:
        `getOppVertexLocInd(int, int)`

    - #### getOppVertexInd

          public int getOppVertexInd(int elemInd,
                            int locInd)

      In the adjacent element find the vertex containing the neighbourhood information for the original element. Return the index of the vertex in the adjacent element whose neighbour entry references to the original element.
      Parameters:
        `elemInd` - an element index
        `locInd` - local index such that `m_neighbour[elemInd].m_data[locInd]==neighElemInd` is the adjacent element.
      Returns:
        index of the vertex in adjacent triangle containing the neighbourhood information for common edge, or -1.
      See Also:
        `getOppVertexLocInd(int, int)`

    - #### getOppVertexLocInd

          public int getOppVertexLocInd(int elemInd,
                               int locInd)

      In the adjacent element find the vertex containing the neighbourhood information for the original element. Return the local index of the vertex in the adjacent element whose neighbour entry references to the original element. Modified to handle elements with more than three edges too. The 'otherVertex' is now defined as the place which stores the neighbourhood information for edge (vInd, wInd) in m_neighbour. If i is the lowest local index of both edge vertices, then `(i-1+nov)%nov` is the searched position. In case of a triangle, `(i-1+nov)%nov == (i+2)%nov`, so nothing has changed for triangles.

      Returns -2 in case of bug in neighbourhood. Use makeNeighbour() to create a new neighbourhood.

      Parameters:
        `elemInd` - an element index
        `locInd` - local index such that `m_neighbour[elemInd].m_data[locInd]==neighElemInd` is the adjacent element.
      Returns:
        local index of the vertex in adjacent triangle containing the neighbourhood information for common edge.
      See Also:
        `getNeighbourLocInd(int, int, int)`

    - #### getAreaOfElement

          public double getAreaOfElement(int elemInd)

      Compute area of polyhedral element with given index.

    - #### getArea

          public double getArea()

      Compute total area of polyhedral surface.

    - #### getVolumeOfElement

          public double getVolumeOfElement(int elemInd)

      Compute algebraic volume of the cone of a polyhedral element with the origin.

      A sphere with positively oriented triangles such that normals point outward will have a positive volume.

    - #### getVolume

          public double getVolume()

      Compute total volume of polyhedral surface. If surface is not closed, then the volume of the cone of the surface with the origin is computed.

    - #### getL2Norm

          public double getL2Norm()

      Compute L2 norm of identity map of element set. Elements are temporarily triangulated if they have more than three vertices.

    - #### getL2Matrix

          public PdMatrix getL2Matrix(PdMatrix mat)

      Compute L2 matrix S such that L2-norm(u)^2 = u*S*u. Elements must be triangulated.

    - #### getEdgeLength

          public double getEdgeLength(int elemInd,
                             int locInd)

      Compute length of element edge specified by element index and vertex index.
      Parameters:
        `elemInd` - index of element
        `locInd` - local index of vertex whose neighbour refers to this edge
      Returns:
        length of edge

    - #### getVertexAngle

          public double getVertexAngle(int elemInd,
                              int locInd)

      Compute the element angle specified by element index and local vertex index.
      Parameters:
        `elemInd` - index of element
        `locInd` - local index of vertex
      Returns:
        angle between edges at vertex

    - #### computeRotation

          public void computeRotation(PgPolygon meridian,
                             int numULines)

      Generate rotational symmetric surface from given meridian around x-axis. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals.
      Overrides:
        `computeRotation` in class `PgPointSet`
      Parameters:
        `meridian` - meridian given as polygon
        `numULines` - discretization in angular direction

    - #### computeCone

          public void computeCone(int numULines,
                         int numVLines,
                         double bottomRadius,
                         double height)

      Generate cone in z-direction centered at the origin with given bottom radius and height. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeCone` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in angular direction
        `numVLines` - discretization in z-axis direction
        `bottomRadius` - radius of bottom disk of cone
        `height` - height of cone from bottom disk to tip

    - #### computeCylinder

          public void computeCylinder(int numULines,
                             int numVLines,
                             double radius,
                             double length)

      Generate cylinder in z-direction centered at the origin with given radius and length. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeCylinder` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in angular direction
        `numVLines` - discretization in z-axis direction
        `radius` - radius of cylinder
        `length` - height of cylinder

    - #### computeDisk

          public void computeDisk(int numULines,
                         int numVLines,
                         double radius)

      Generate disk in xy-plane with given radius. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeDisk` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in radial direction
        `numVLines` - discretization in angular direction
        `radius` - radius of disk

    - #### computePlane

          public void computePlane(int numULines,
                          int numVLines,
                          double uMin,
                          double vMin,
                          double uMax,
                          double vMax)

      Generate rectangle in z=0 plane with given min/max values. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computePlane` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in x direction
        `numVLines` - discretization in y direction
        `uMin` - u coordinate of lower left corner of rectangle
        `vMin` - v coordinate of lower left corner of rectangle
        `uMax` - u coordinate of upper right corner of rectangle
        `vMax` - v coordinate of upper right corner of rectangle

    - #### computeSphere

          public void computeSphere(int numULines,
                           int numVLines,
                           double radius)

      Generate sphere with given radius. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeSphere` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in angular direction
        `numVLines` - discretization in meridian direction
        `radius` - radius of sphere

    - #### computeTorus

          public void computeTorus(int numULines,
                          int numVLines,
                          double radius,
                          double thick)

      Generate torus in x-y plane with given radius of soal and thickness of tube. Surface has connectivity of a rectangle. Use `close()` to remove interior boundaries. Compute vertex normals. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeTorus` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in angular direction
        `numVLines` - discretization in meridian direction
        `radius` - radius of soal
        `thick` - radius of torus tube

    - #### computeSnail

          public void computeSnail(int numULines,
                          int numVLines,
                          double numWindings)

      Generate a winding snail. Sample method to have simple geometry available for test purposes.
      Overrides:
        `computeSnail` in class `PgPointSet`
      Parameters:
        `numULines` - discretization in angular direction
        `numVLines` - discretization in meridian direction
        `numWindings` - number of half-turns of snail house

    - #### getNumBoundaryEdges

          public int getNumBoundaryEdges()

      Calculate number of boundary edges of a manifold surface using m_neighbour information. This number may be different from number of boundary components and number of boundary segments.

      If surface is non-manifold and neighbour information is not correct then this method may determine a wrong number of boundary edges.

      Returns:
        number of boundary edges
      See Also:
        `getNumBoundaries()`, `getNumEdges()`

    - #### getNumEdges

          public int getNumEdges()

      Calculate number of edges of a manifold surface using m_neighbour information.

      If neighbour information is missing, then each element edge is counted. Algorithm runs once over all elements and counts an edge if the index of the adjacent element is smaller than the index of the current element.

      If surface is non-manifold and neighbour information is not correct then this method may determine a wrong number of edges.

      See also getNumEdges() which returns the number of edges of the underlying simplicial complex. Note, getNumEdgeStars() will return 0 if no edgeStars are allocated while getNumEdges() always returns a number related to the simplicial complex. Use getNumEdgesStars() when working with edgeStar array, and use getNumEdges() in combinatorial calculations.

      Returns:
        number of edges
      See Also:
        `getNumEdgeStars()`, `getNumBoundaryEdges()`

    - #### fixBoundaries

          public void fixBoundaries()

      Constrain all boundary vertices not to move during variations. This is method imposes the simplest kind of constraints to boundary polygons used in variational problems.

    - #### markBoundary

          public void markBoundary()

      Tag all boundary vertices as those. Assume a correct neighbour connectivity. Method is used in conjunction with getNumBoundaryVertices(). Method handles non-conforming element sets too.

    - #### getNumBoundaryVertices

          public int getNumBoundaryVertices()

      Count number of boundary vertices assuming boundary vertices have been previously marked.
      See Also:
        `markBoundary()`

    - #### blend

          public boolean blend(double s,
                      PgGeometry ag,
                      double t,
                      PgGeometry bg)

      Blend between two element sets, used in interpolation and computing the associate surfaces `this = s*ag + t*bg`.
      Specified by:
        `blend` in interface `PgGeometryIf`
      Overrides:
        `blend` in class `PgPointSet`
      Parameters:
        `s` - weight of vertices of first geometry
        `ag` - first geometry used for blending
        `t` - weight of vertices of second geometry
        `bg` - second geometry used for blending
      Returns:
        true on success

    - #### isConforming

          public boolean isConforming()

      Return `true` if elementSet is conforming, else `false`.

    - #### setConforming

          public void setConforming(boolean flag)

      Set conformality state of geometry and boundary curves, and do not modify connectivity. Mainly used to temporarily switch conformality state, use a conforming method, and the restore the previous state by calling makeNonConformal().

    - #### triangulate

          public static boolean triangulate(PgElementSet geom)

      Triangulate the given element set in place. Each element is split into triangles using the method `PgUtil.triangulate(PdVector [], int)`.
      Parameters:
        `geom` - Surface with polygonal faces. Modified after this calling method.
      Returns:
        true on success
      See Also:
        `PgUtil.triangulate(PdVector [], int)`

    - #### checkNeighbour

          public boolean checkNeighbour()

      Deprecated. use checkNeighbour(boolean) instead.
      Check correct neighbour connectivity.

    - #### checkNeighbour

          public boolean checkNeighbour(boolean bMessage)

      Check correct neighbour connectivity. For each triangle ensure that:

                          - length of each neighbour array has same size as element array
                          - it does not reference itself
                          - it is neighbour of each adjacent element
                          - it and its neighbour join an edge with common vertices.

      Parameters:
        `bMessage` - Flag to send a message to the console.
      Returns:
        true if neighbour connectivity is correct

    - #### intersectionWithLine

          public PvPickEvent intersectionWithLine(PdVector rayBaseWorld,
                                         PdVector rayDirWorld)

      Find intersection of element set with a given ray. Method is used for interactive picking. Base and direction of ray must be given in 3D world coordinates.
      Specified by:
        `intersectionWithLine` in interface `PgGeometryIf`
      Overrides:
        `intersectionWithLine` in class `PgPointSet`
      Parameters:
        `rayBaseWorld` - 3D base point of ray eventually hitting the surface.
        `rayDirWorld` - 3D direction vector of ray eventually hitting the surface.
      Returns:
        full information about hit element, barycentric coordinates etc.

    - #### getSavedNumVertices

          public int getSavedNumVertices()

      Only used when working with non-conforming triangulations.

    - #### setSavedNumVertices

          public void setSavedNumVertices(int num)

      Only used when working with non-conforming triangulations.

    - #### getSavedElements

          public PiVector[] getSavedElements()

      Only used when working with non-conforming triangulations.

    - #### setSavedElements

          public void setSavedElements(PiVector[] element)

      Only used when working with non-conforming triangulations.

    - #### makeElementColorsFromXYZ

          public boolean makeElementColorsFromXYZ()

      Create color from the element position within its bounding box which is interpreted as RGB cube. If dimension of vertices is smaller than three then only the first vertex components are used in the color computation.

    - #### makeElementColorsFromZ

          public boolean makeElementColorsFromZ()

      Create color from the vertical z-height within its bounding box ranging from low blue to high red. If dimension of vertices is smaller than three then the highest vertex component are used instead of the z-component in the color computation.

    - #### makeElementColorsFromZHue

          public boolean makeElementColorsFromZHue()

      Create color from the vertical z-height within its bounding box ranging through hue rainbow. If dimension of vertices is smaller than three then the highest vertex component are used instead of the z-component in the color computation.

    - #### makeElementFromVertexColors

          public boolean makeElementFromVertexColors()

      Create element colors as average of all colors of its vertices. Vertex colors must be available.

    - #### makeVertexFromElementColors

          public boolean makeVertexFromElementColors()

      Create vertex colors as average of individual color of all adjacent elements. Local element colors must be available.

    - #### makeElementFromVertexTexture

          public boolean makeElementFromVertexTexture()

      Create element textures from vertex textures and remove vertex textures. Vertex textures must be available.

    - #### reflect

          public PgGeometry reflect(PdMatrix mat,
                           boolean bOrient,
                           boolean bVector)

      Generate a cloned geometry and transform vertices by a matrix. For example, this method is called to calculate mirror images of a geometry. Orientation of geometry affects surface vectors.
      Specified by:
        `reflect` in interface `PgGeometryIf`
      Overrides:
        `reflect` in class `PgPointSet`
      Parameters:
        `mat` - 3*3 or 4*4 transformation matrix
        `bOrient` - flag whether to keep the orientation of the geometry
        `bVector` - flag whether to keep the orientation of vectors
      Returns:
        new reflected copy of the geometry

    - #### resetBoundaryNormals

          public boolean resetBoundaryNormals()

      Remove boundary vertex normal. Often boundary vertex normals can not be determined correctly. This method allows to reset these normal to zero. The boundary is determined from the neighbour information.
      Returns:
        false if vertex normals are missing

    - #### getFVector

          public int[] getFVector()

      Compute F-vector which shows the number of points, edges, faces, etc.

      Note, the number of vertices may include some vertices which are not referenced by elements. The number of unused vertices must be subtracted from the number of vertices found in the F-vector when computing the Euler characteristic.

      Overrides:
        `getFVector` in class `PgPointSet`

    - #### getCenterOfElement

          public PdVector getCenterOfElement(PdVector center,
                                    int e)

      Compute the barycenter of a geometry element.
      Parameters:
        `center` - Buffer for the center. May be null.
        `e` - Index of the element.
      Returns:
        Argument center is filled with the position of the barycenter.

"

The software JavaView? is copyright protected. All Rights Reserved.
"