igeo

## Class IMesh

- java.lang.Object
- - igeo.IObject
  - - igeo.IGeometry
    - - igeo.IMesh

- All Implemented Interfaces:
    IMeshI, ITransformable
  Direct Known Subclasses:
    ICollidableMesh

      public class IMesh
      extends IGeometry
      implements IMeshI

  Class of polygon mesh object.
  Author:
    Satoru Sugihara

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `boolean` | `enableFaceColor`
    `boolean` | `enableVertexColor`
    `IMeshGeo` | `mesh`

    - ### Fields inherited from class igeo.IObject

      `attribute, dynamics, graphics, parameter, server, userData`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `IMesh()`
    `IMesh(java.util.ArrayList<IVertex> v, java.util.ArrayList<IEdge> e, java.util.ArrayList<IFace> f)`
    `IMesh(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `IMesh(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `IMesh(ICurveI[] lines)`
    `IMesh(IFace[] fcs)`
    `IMesh(IMesh m)`
    `IMesh(IMeshGeo m)`
    `IMesh(IServerI s)`
    `IMesh(IServerI s, java.util.ArrayList<IVertex> v, java.util.ArrayList<IEdge> e, java.util.ArrayList<IFace> f)`
    `IMesh(IServerI s, double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `IMesh(IServerI s, double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `IMesh(IServerI s, ICurveI[] lines)`
    `IMesh(IServerI s, IFace[] fcs)`
    `IMesh(IServerI s, IMesh m)`
    `IMesh(IServerI s, IMeshGeo m)`
    `IMesh(IServerI s, ISurfaceI[] faces)` each input surface builds one 3 or 4 point face.
    `IMesh(IServerI s, IVec[] vert)`
    `IMesh(IServerI s, IVec[][] matrix)`
    `IMesh(IServerI s, IVec[][] matrix, boolean triangulateDir)`
    `IMesh(IServerI s, IVec[][] matrix, boolean triangulateDir, IMeshType creator)`
    `IMesh(IServerI s, IVec[][] matrix, int unum, int vnum, boolean triangulateDir)`
    `IMesh(IServerI s, IVec[][] matrix, int unum, int vnum, boolean triangulateDir, IMeshType creator)`
    `IMesh(IServerI s, IVecI v1, IVecI v2, IVecI v3)`
    `IMesh(IServerI s, IVecI v1, IVecI v2, IVecI v3, IVecI v4)`
    `IMesh(IServerI s, IVertex[] vert)`
    `IMesh(IServerI s, IVertex[] vtx, IEdge[] edg, IFace[] fcs)`
    `IMesh(IServerI s, IVertex v1, IVertex v2, IVertex v3)`
    `IMesh(IServerI s, IVertex v1, IVertex v2, IVertex v3, IVertex v4)`
    `IMesh(ISurfaceI[] faces)` each input surface builds one 3 or 4 point face.
    `IMesh(IVec[] vert)`
    `IMesh(IVec[][] matrix)`
    `IMesh(IVec[][] matrix, boolean triangulateDir)`
    `IMesh(IVec[][] matrix, boolean triangulateDir, IMeshType creator)`
    `IMesh(IVec[][] matrix, int unum, int vnum, boolean triangulateDir)`
    `IMesh(IVec[][] matrix, int unum, int vnum, boolean triangulateDir, IMeshType creator)`
    `IMesh(IVecI v1, IVecI v2, IVecI v3)`
    `IMesh(IVecI v1, IVecI v2, IVecI v3, IVecI v4)`
    `IMesh(IVertex[] vert)`
    `IMesh(IVertex[] vtx, IEdge[] edg, IFace[] fcs)`
    `IMesh(IVertex v1, IVertex v2, IVertex v3)`
    `IMesh(IVertex v1, IVertex v2, IVertex v3, IVertex v4)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `IMesh` | `add(double x, double y, double z)` ITransformable methods
    `IMesh` | `add(double f, IVecI v)` scale add alias
    `IMesh` | `add(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IMesh` | `add(IDoubleI f, IVecI v)` scale add alias
    `IMesh` | `add(IVecI v)`
    `IMesh` | `add(IVecI v, double f)` scale add
    `IMesh` | `add(IVecI v, IDoubleI f)` scale add
    `IMesh` | `addFace(IFace f)`
    `IMesh` | `addFace(IFace f, boolean checkExistingVertex, boolean checkExistingEdge, boolean checkExistingFace)`
    `IMesh` | `addPolygon(IVec[] v)`
    `IMesh` | `addPolygon(IVertex[] v)`
    `IMesh` | `addQuads(IVec[] v)`
    `IMesh` | `addQuads(IVertex[] v)`
    `IMesh` | `addQuadStrip(IVec[] v)`
    `IMesh` | `addQuadStrip(IVertex[] v)`
    `IMesh` | `addTriangleFan(IVec[] v)`
    `IMesh` | `addTriangleFan(IVertex[] v)`
    `IMesh` | `addTriangles(IVec[] v)`
    `IMesh` | `addTriangles(IVertex[] v)`
    `IMesh` | `addTriangleStrip(IVec[] v)`
    `IMesh` | `addTriangleStrip(IVertex[] v)`
    `IMesh` | `attr(IAttribute at)` set attributes
    `IVec` | `center()` center of mesh, calculated by average of all vertices
    `IMesh` | `close()` only setting value to closed.
    `IMesh` | `clr(java.awt.Color c)`
    `IMesh` | `clr(java.awt.Color c, double alpha)`
    `IMesh` | `clr(java.awt.Color c, float alpha)`
    `IMesh` | `clr(java.awt.Color c, int alpha)`
    `IMesh` | `clr(double dgray)`
    `IMesh` | `clr(double dgray, double dalpha)`
    `IMesh` | `clr(double dr, double dg, double db)`
    `IMesh` | `clr(double dr, double dg, double db, double da)`
    `IMesh` | `clr(float fgray)`
    `IMesh` | `clr(float fgray, float falpha)`
    `IMesh` | `clr(float fr, float fg, float fb)`
    `IMesh` | `clr(float fr, float fg, float fb, float fa)`
    `IMesh` | `clr(IColor c)` to set an object color
    `IMesh` | `clr(IColor c, double alpha)` to set color, with alpha value overwritten
    `IMesh` | `clr(IColor c, float alpha)` to set color, with alpha value overwritten
    `IMesh` | `clr(IColor c, int alpha)` to set color, with alpha value overwritten
    `IMesh` | `clr(int gray)`
    `IMesh` | `clr(int gray, int alpha)`
    `IMesh` | `clr(int r, int g, int b)`
    `IMesh` | `clr(int r, int g, int b, int a)`
    `IMesh` | `clr(IObject o)` to set the same color with the object
    `static IMesh` | `connectVertex(IMesh mesh1, IMesh mesh2)` connect closest vertex
    `static IMesh` | `connectVertex(IMesh mesh1, IVertex v1, IMesh mesh2, IVertex v2)` connect faces over a vertex
    `IMesh` | `cp()` cp() is alias of dup()
    `IMesh` | `cp(double x, double y, double z)` cp() is alias of dup().add()
    `IMesh` | `cp(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IMesh` | `cp(IVecI v)`
    `IGraphicObject` | `createGraphic(IGraphicMode m)`
    `static IMesh` | `createPolyhedron(IVecI[] pts)` create polyhedron mesh by delaunay triangulation around a center
    `static IMesh` | `createPolyhedron(IVecI[] pts, double threshold)` create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length
    `static IMesh` | `createPolyhedron(IVertex[] vtx)` create polyhedron mesh by delaunay triangulation around a center
    `static IMesh` | `createPolyhedron(IVertex[] vtx, double threshold)` create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length
    `IMesh` | `deleteEdge(IEdge e)`
    `IMesh` | `deleteEdge(IIntegerI i)`
    `IMesh` | `deleteEdge(int i)`
    `IMesh` | `deleteFace(IFace f)`
    `IMesh` | `deleteFace(IIntegerI i)`
    `IMesh` | `deleteFace(int i)`
    `IMesh` | `deleteVertex(IIntegerI i)`
    `IMesh` | `deleteVertex(int i)`
    `IMesh` | `deleteVertex(IVertex v)`
    `IMesh` | `disableFaceColor()`
    `IMesh` | `disableVertexColor()`
    `IMesh` | `div(double v)`
    `IMesh` | `div(IDoubleI v)`
    `IMesh` | `dup()` duplicate object
    `IEdge` | `edge(IIntegerI i)`
    `IEdge` | `edge(int i)`
    `int` | `edgeNum()`
    `int` | `edgeNum(ISwitchE e)`
    `IIntegerI` | `edgeNum(ISwitchR r)`
    `java.util.ArrayList<IEdge>` | `edges()` return all edges
    `IMesh` | `enableFaceColor()`
    `IMesh` | `enableVertexColor()`
    `IFace` | `face(IIntegerI i)`
    `IFace` | `face(int i)`
    `IColor` | `faceColor(int i)` set face color
    `IMesh` | `faceColor(int i, java.awt.Color c)`
    `IMesh` | `faceColor(int i, java.awt.Color c, double alpha)`
    `IMesh` | `faceColor(int i, java.awt.Color c, float alpha)`
    `IMesh` | `faceColor(int i, java.awt.Color c, int alpha)`
    `IMesh` | `faceColor(int i, double dgray)`
    `IMesh` | `faceColor(int i, double dgray, double dalpha)`
    `IMesh` | `faceColor(int i, double dr, double dg, double db)`
    `IMesh` | `faceColor(int i, double dr, double dg, double db, double da)`
    `IMesh` | `faceColor(int i, float fgray)`
    `IMesh` | `faceColor(int i, float fgray, float falpha)`
    `IMesh` | `faceColor(int i, float fr, float fg, float fb)`
    `IMesh` | `faceColor(int i, float fr, float fg, float fb, float fa)`
    `IMesh` | `faceColor(int i, IColor c)`
    `IMesh` | `faceColor(int i, IColor c, double alpha)`
    `IMesh` | `faceColor(int i, IColor c, float alpha)`
    `IMesh` | `faceColor(int i, IColor c, int alpha)`
    `IMesh` | `faceColor(int i, int gray)`
    `IMesh` | `faceColor(int i, int gray, int alpha)`
    `IMesh` | `faceColor(int i, int r, int g, int b)`
    `IMesh` | `faceColor(int i, int r, int g, int b, int a)`
    `IMesh` | `faceColorHSB(int i, double dh, double ds, double db)`
    `IMesh` | `faceColorHSB(int i, double dh, double ds, double db, double da)`
    `IMesh` | `faceColorHSB(int i, float h, float s, float b)`
    `IMesh` | `faceColorHSB(int i, float h, float s, float b, float a)`
    `IMesh` | `faceHSB(int i, double dh, double ds, double db)`
    `IMesh` | `faceHSB(int i, double dh, double ds, double db, double da)`
    `IMesh` | `faceHSB(int i, float h, float s, float b)`
    `IMesh` | `faceHSB(int i, float h, float s, float b, float a)`
    `int` | `faceNum()`
    `int` | `faceNum(ISwitchE e)`
    `IIntegerI` | `faceNum(ISwitchR r)`
    `java.util.ArrayList<IFace>` | `faces()` return all faces
    `IMesh` | `flip()` alias of neg
    `IMeshGeo` | `get()`
    `IMesh` | `hide()`
    `IMesh` | `hsb(double h, double s, double b)`
    `IMesh` | `hsb(double h, double s, double b, double a)`
    `IMesh` | `hsb(float h, float s, float b)`
    `IMesh` | `hsb(float h, float s, float b, float a)`
    `void` | `initMesh(IServerI s)`
    `boolean` | `isClosed()`
    `boolean` | `isValid()` checking parameters validity.
    `IMesh` | `join(IMesh[] meshes)` join other meshes into the current one and remove duplicated edges and vertices
    `IMesh` | `join(IMesh[] meshes, double tolerance)` join other meshes into the current one and remove duplicated edges and vertices
    `static IMesh` | `joinMesh(IMesh[] meshes)` static method to join meshes.
    `IMesh` | `layer(ILayer l)` Set layer by ILayer object
    `IMesh` | `layer(java.lang.String l)` Set layer by layer name.
    `IMesh` | `loopSubD()` Loop-subdivision
    `IMesh` | `loopSubD(IVec[] fixedEdges)` Loop-subdivision
    `IMesh` | `loopSubdivide()` Loop-subdivision
    `IMesh` | `loopSubdivide(IVec[] fixedEdges)` Loop-subdivision
    `IMesh` | `mirror(IVecI planeDir)` mirror is alias of ref
    `IMesh` | `mirror(IVecI center, IVecI planeDir)`
    `IMesh` | `mul(double v)`
    `IMesh` | `mul(IDoubleI v)`
    `IMesh` | `mv(double x, double y, double z)` mv() is alias of add()
    `IMesh` | `mv(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IMesh` | `mv(IVecI v)`
    `IEdge[]` | `nakedEdges()` returns naked edges of the mesh
    `IMesh` | `name(java.lang.String nm)`
    `IMesh` | `neg()`
    `IMesh` | `offset(double offsetDist)` offset each vertex towards vertex normal and return the mesh.
    `IMesh` | `offset(double[] offsetList)` offset each vertex towards vertex normal and return the mesh.
    `static IMesh` | `polyhedron(IVecI[] pts)` create polyhedron mesh by delaunay triangulation around a center
    `static IMesh` | `polyhedron(IVecI[] pts, double threshold)` create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length
    `static IMesh` | `polyhedron(IVertex[] vtx)` create polyhedron mesh by delaunay triangulation around a center
    `static IMesh` | `polyhedron(IVertex[] vtx, double threshold)` create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length
    `IMesh` | `ref(IVecI planeDir)` reflect(mirror) 3 dimensionally to the other side of the plane
    `IMesh` | `ref(IVecI center, IVecI planeDir)`
    `IMesh` | `removeDuplicates()` remove uplicated edges and vertices
    `IMesh` | `removeDuplicates(double tolerance)` remove uplicated edges and vertices
    `IMesh` | `rev()` alias of neg
    `IMesh` | `rot(double angle)`
    `IMesh` | `rot(IDoubleI angle)` rotation around z-axis and origin
    `IMesh` | `rot(IVecI axis, double angle)`
    `IMesh` | `rot(IVecI axis, IDoubleI angle)` rotation around axis vector
    `IMesh` | `rot(IVecI axis, IVecI destDir)` rotate to destination direction vector
    `IMesh` | `rot(IVecI center, IVecI axis, double angle)`
    `IMesh` | `rot(IVecI center, IVecI axis, IDoubleI angle)` rotation around axis vector and center
    `IMesh` | `rot(IVecI center, IVecI axis, IVecI destPt)` rotate to destination point location
    `IMesh` | `rot2(double angle)` rotation on xy-plane around origin; same with rot(double)
    `IMesh` | `rot2(IDoubleI angle)` rotation on xy-plane around origin; same with rot(IDoubleI)
    `IMesh` | `rot2(IVecI destDir)` rotation on xy-plane to destination direction vector
    `IMesh` | `rot2(IVecI center, double angle)`
    `IMesh` | `rot2(IVecI center, IDoubleI angle)` rotation on xy-plane around center
    `IMesh` | `rot2(IVecI center, IVecI destPt)` rotation on xy-plane to destination point location
    `IMesh` | `scale(double f)`
    `IMesh` | `scale(IDoubleI f)` alias of mul
    `IMesh` | `scale(IVecI center, double f)`
    `IMesh` | `scale(IVecI center, IDoubleI f)`
    `IMesh` | `scale1d(IVecI axis, double f)` scale only in 1 direction
    `IMesh` | `scale1d(IVecI axis, IDoubleI f)`
    `IMesh` | `scale1d(IVecI center, IVecI axis, double f)`
    `IMesh` | `scale1d(IVecI center, IVecI axis, IDoubleI f)`
    `IMesh` | `setColor(java.awt.Color c)`
    `IMesh` | `setColor(java.awt.Color c, double alpha)`
    `IMesh` | `setColor(java.awt.Color c, float alpha)`
    `IMesh` | `setColor(java.awt.Color c, int alpha)`
    `IMesh` | `setColor(double dgray)`
    `IMesh` | `setColor(double dgray, double dalpha)`
    `IMesh` | `setColor(double dr, double dg, double db)`
    `IMesh` | `setColor(double dr, double dg, double db, double da)`
    `IMesh` | `setColor(float fgray)`
    `IMesh` | `setColor(float fgray, float falpha)`
    `IMesh` | `setColor(float fr, float fg, float fb)`
    `IMesh` | `setColor(float fr, float fg, float fb, float fa)`
    `IMesh` | `setColor(IColor c)`
    `IMesh` | `setColor(IColor c, double alpha)`
    `IMesh` | `setColor(IColor c, float alpha)`
    `IMesh` | `setColor(IColor c, int alpha)`
    `IMesh` | `setColor(int gray)`
    `IMesh` | `setColor(int gray, int alpha)`
    `IMesh` | `setColor(int r, int g, int b)`
    `IMesh` | `setColor(int r, int g, int b, int a)`
    `IMesh` | `setHSBColor(double h, double s, double b)`
    `IMesh` | `setHSBColor(double h, double s, double b, double a)`
    `IMesh` | `setHSBColor(float h, float s, float b)`
    `IMesh` | `setHSBColor(float h, float s, float b, float a)`
    `IMesh` | `shear(double sxy, double syx, double syz, double szy, double szx, double sxz)` shear operation
    `IMesh` | `shear(IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `IMesh` | `shear(IVecI center, double sxy, double syx, double syz, double szy, double szx, double sxz)`
    `IMesh` | `shear(IVecI center, IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `IMesh` | `shearXY(double sxy, double syx)`
    `IMesh` | `shearXY(IDoubleI sxy, IDoubleI syx)`
    `IMesh` | `shearXY(IVecI center, double sxy, double syx)`
    `IMesh` | `shearXY(IVecI center, IDoubleI sxy, IDoubleI syx)`
    `IMesh` | `shearYZ(double syz, double szy)`
    `IMesh` | `shearYZ(IDoubleI syz, IDoubleI szy)`
    `IMesh` | `shearYZ(IVecI center, double syz, double szy)`
    `IMesh` | `shearYZ(IVecI center, IDoubleI syz, IDoubleI szy)`
    `IMesh` | `shearZX(double szx, double sxz)`
    `IMesh` | `shearZX(IDoubleI szx, IDoubleI sxz)`
    `IMesh` | `shearZX(IVecI center, double szx, double sxz)`
    `IMesh` | `shearZX(IVecI center, IDoubleI szx, IDoubleI sxz)`
    `IMesh` | `show()`
    `IMesh` | `sub(double x, double y, double z)`
    `IMesh` | `sub(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IMesh` | `sub(IVecI v)`
    `IMesh` | `subdivide()` simply subdivide one trianlge into 4 triangles
    `IMesh` | `transform(IMatrix3I mat)`
    `IMesh` | `transform(IMatrix4I mat)`
    `IMesh` | `transform(IVecI xvec, IVecI yvec, IVecI zvec)`
    `IMesh` | `transform(IVecI xvec, IVecI yvec, IVecI zvec, IVecI translate)`
    `IMesh` | `translate(double x, double y, double z)` translate() is alias of add()
    `IMesh` | `translate(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IMesh` | `translate(IVecI v)`
    `IMesh` | `triangulate()` triangulate quad mesh to triangles
    `IMesh` | `triangulate(boolean triangulateDir)` triangulate quad mesh to triangles
    `IMesh` | `unifyNml()`
    `IMesh` | `unifyNml(int faceIdx)`
    `IMesh` | `unifyNormal()`
    `void` | `updateGraphic()` update graphic when control point location changes or some minor change.
    `IVertex` | `vertex(IIntegerI i)`
    `IVertex` | `vertex(int i)`
    `IColor` | `vertexColor(int i)` set vertex color
    `IMesh` | `vertexColor(int i, java.awt.Color c)`
    `IMesh` | `vertexColor(int i, java.awt.Color c, double alpha)`
    `IMesh` | `vertexColor(int i, java.awt.Color c, float alpha)`
    `IMesh` | `vertexColor(int i, java.awt.Color c, int alpha)`
    `IMesh` | `vertexColor(int i, double dgray)`
    `IMesh` | `vertexColor(int i, double dgray, double dalpha)`
    `IMesh` | `vertexColor(int i, double dr, double dg, double db)`
    `IMesh` | `vertexColor(int i, double dr, double dg, double db, double da)`
    `IMesh` | `vertexColor(int i, float fgray)`
    `IMesh` | `vertexColor(int i, float fgray, float falpha)`
    `IMesh` | `vertexColor(int i, float fr, float fg, float fb)`
    `IMesh` | `vertexColor(int i, float fr, float fg, float fb, float fa)`
    `IMesh` | `vertexColor(int i, IColor c)`
    `IMesh` | `vertexColor(int i, IColor c, double alpha)`
    `IMesh` | `vertexColor(int i, IColor c, float alpha)`
    `IMesh` | `vertexColor(int i, IColor c, int alpha)`
    `IMesh` | `vertexColor(int i, int gray)`
    `IMesh` | `vertexColor(int i, int gray, int alpha)`
    `IMesh` | `vertexColor(int i, int r, int g, int b)`
    `IMesh` | `vertexColor(int i, int r, int g, int b, int a)`
    `IMesh` | `vertexColorHSB(int i, double dh, double ds, double db)`
    `IMesh` | `vertexColorHSB(int i, double dh, double ds, double db, double da)`
    `IMesh` | `vertexColorHSB(int i, float h, float s, float b)`
    `IMesh` | `vertexColorHSB(int i, float h, float s, float b, float a)`
    `IMesh` | `vertexHSB(int i, double dh, double ds, double db)`
    `IMesh` | `vertexHSB(int i, double dh, double ds, double db, double da)`
    `IMesh` | `vertexHSB(int i, float h, float s, float b)`
    `IMesh` | `vertexHSB(int i, float h, float s, float b, float a)`
    `int` | `vertexNum()`
    `int` | `vertexNum(ISwitchE e)`
    `IIntegerI` | `vertexNum(ISwitchR r)`
    `java.util.ArrayList<IVertex>` | `vertices()` return all vertices
    `IMesh` | `weight(double w)`
    `IMesh` | `weight(float w)`

    - ### Methods inherited from class igeo.IObject

      `addDynamics, addUserData, addUserData, alpha, alphaInt, attr, attr, awtColor, blue, blueInt, brightness, castStringHashMap, clearDynamics, clearGraphics, clr, defaultAttribute, del, deletDynamics, deleteDynamics, deleteDynamics, deleteGraphic, dynamicsNum, getAWTColor, getColor, getDynamics, getGraphic, getGraphic, getParameter, graphicsNum, gray, grayInt, green, greenInt, grey, greyInt, hue, initGraphic, initObject, isVisible, layer, name, red, redInt, resetGraphic, saturation, server, setParameter, setTexture, syncColor, syncGraphic, syncVisibility, syncWeight, texture, userData, userData, userData, userDataNum, visible, weight`

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

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

- - ### Field Detail

    - #### mesh

          public IMeshGeo mesh

    - #### enableFaceColor

          public boolean enableFaceColor

    - #### enableVertexColor

          public boolean enableVertexColor

  - ### Constructor Detail

    - #### IMesh

          public IMesh()

    - #### IMesh

          public IMesh(IServerI s)

    - #### IMesh

          public IMesh(IMeshGeo m)

    - #### IMesh

          public IMesh(IServerI s,
                       IMeshGeo m)

    - #### IMesh

          public IMesh(IMesh m)

    - #### IMesh

          public IMesh(IServerI s,
                       IMesh m)

    - #### IMesh

          public IMesh(IServerI s,
                       ICurveI[] lines)

    - #### IMesh

          public IMesh(ICurveI[] lines)

    - #### IMesh

          public IMesh(IServerI s,
                       ISurfaceI[] faces)

      each input surface builds one 3 or 4 point face. trim is ignored.

    - #### IMesh

          public IMesh(ISurfaceI[] faces)

      each input surface builds one 3 or 4 point face. trim is ignored.

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[][] matrix)

    - #### IMesh

          public IMesh(IVec[][] matrix)

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[][] matrix,
                       boolean triangulateDir)

    - #### IMesh

          public IMesh(IVec[][] matrix,
                       boolean triangulateDir)

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[][] matrix,
                       boolean triangulateDir,
                       IMeshType creator)

    - #### IMesh

          public IMesh(IVec[][] matrix,
                       boolean triangulateDir,
                       IMeshType creator)

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[][] matrix,
                       int unum,
                       int vnum,
                       boolean triangulateDir)

    - #### IMesh

          public IMesh(IVec[][] matrix,
                       int unum,
                       int vnum,
                       boolean triangulateDir)

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[][] matrix,
                       int unum,
                       int vnum,
                       boolean triangulateDir,
                       IMeshType creator)

    - #### IMesh

          public IMesh(IVec[][] matrix,
                       int unum,
                       int vnum,
                       boolean triangulateDir,
                       IMeshType creator)

    - #### IMesh

          public IMesh(IServerI s,
                       java.util.ArrayList<IVertex> v,
                       java.util.ArrayList<IEdge> e,
                       java.util.ArrayList<IFace> f)

    - #### IMesh

          public IMesh(java.util.ArrayList<IVertex> v,
                       java.util.ArrayList<IEdge> e,
                       java.util.ArrayList<IFace> f)

    - #### IMesh

          public IMesh(IServerI s,
                       IVertex[] vtx,
                       IEdge[] edg,
                       IFace[] fcs)

    - #### IMesh

          public IMesh(IVertex[] vtx,
                       IEdge[] edg,
                       IFace[] fcs)

    - #### IMesh

          public IMesh(IServerI s,
                       IVec[] vert)

    - #### IMesh

          public IMesh(IVec[] vert)

    - #### IMesh

          public IMesh(IServerI s,
                       IVertex[] vert)

    - #### IMesh

          public IMesh(IVertex[] vert)

    - #### IMesh

          public IMesh(IServerI s,
                       IVertex v1,
                       IVertex v2,
                       IVertex v3)

    - #### IMesh

          public IMesh(IVertex v1,
                       IVertex v2,
                       IVertex v3)

    - #### IMesh

          public IMesh(IServerI s,
                       IVertex v1,
                       IVertex v2,
                       IVertex v3,
                       IVertex v4)

    - #### IMesh

          public IMesh(IVertex v1,
                       IVertex v2,
                       IVertex v3,
                       IVertex v4)

    - #### IMesh

          public IMesh(IServerI s,
                       IVecI v1,
                       IVecI v2,
                       IVecI v3)

    - #### IMesh

          public IMesh(IVecI v1,
                       IVecI v2,
                       IVecI v3)

    - #### IMesh

          public IMesh(IServerI s,
                       IVecI v1,
                       IVecI v2,
                       IVecI v3,
                       IVecI v4)

    - #### IMesh

          public IMesh(IVecI v1,
                       IVecI v2,
                       IVecI v3,
                       IVecI v4)

    - #### IMesh

          public IMesh(IServerI s,
                       double x1,
                       double y1,
                       double z1,
                       double x2,
                       double y2,
                       double z2,
                       double x3,
                       double y3,
                       double z3)

    - #### IMesh

          public IMesh(double x1,
                       double y1,
                       double z1,
                       double x2,
                       double y2,
                       double z2,
                       double x3,
                       double y3,
                       double z3)

    - #### IMesh

          public IMesh(IServerI s,
                       double x1,
                       double y1,
                       double z1,
                       double x2,
                       double y2,
                       double z2,
                       double x3,
                       double y3,
                       double z3,
                       double x4,
                       double y4,
                       double z4)

    - #### IMesh

          public IMesh(double x1,
                       double y1,
                       double z1,
                       double x2,
                       double y2,
                       double z2,
                       double x3,
                       double y3,
                       double z3,
                       double x4,
                       double y4,
                       double z4)

    - #### IMesh

          public IMesh(IServerI s,
                       IFace[] fcs)

    - #### IMesh

          public IMesh(IFace[] fcs)

  - ### Method Detail

    - #### get

          public IMeshGeo get()

      Specified by:
        `get` in interface `IMeshI`

    - #### dup

          public IMesh dup()

      Description copied from class: `IObject`
      duplicate object
      Specified by:
        `dup` in interface `IMeshI`
      Specified by:
        `dup` in interface `ITransformable`
      Overrides:
        `dup` in class `IGeometry`

    - #### isValid

          public boolean isValid()

      Description copied from class: `IObject`
      checking parameters validity. to be overriden.
      Specified by:
        `isValid` in interface `IMeshI`
      Overrides:
        `isValid` in class `IObject`

    - #### initMesh

          public void initMesh(IServerI s)

    - #### createGraphic

          public IGraphicObject createGraphic(IGraphicMode m)

      Overrides:
        `createGraphic` in class `IObject`

    - #### vertexNum

          public int vertexNum()

      Specified by:
        `vertexNum` in interface `IMeshI`

    - #### edgeNum

          public int edgeNum()

      Specified by:
        `edgeNum` in interface `IMeshI`

    - #### faceNum

          public int faceNum()

      Specified by:
        `faceNum` in interface `IMeshI`

    - #### vertexNum

          public int vertexNum(ISwitchE e)

      Specified by:
        `vertexNum` in interface `IMeshI`

    - #### edgeNum

          public int edgeNum(ISwitchE e)

      Specified by:
        `edgeNum` in interface `IMeshI`

    - #### faceNum

          public int faceNum(ISwitchE e)

      Specified by:
        `faceNum` in interface `IMeshI`

    - #### vertexNum

          public IIntegerI vertexNum(ISwitchR r)

      Specified by:
        `vertexNum` in interface `IMeshI`

    - #### edgeNum

          public IIntegerI edgeNum(ISwitchR r)

      Specified by:
        `edgeNum` in interface `IMeshI`

    - #### faceNum

          public IIntegerI faceNum(ISwitchR r)

      Specified by:
        `faceNum` in interface `IMeshI`

    - #### vertex

          public IVertex vertex(int i)

      Specified by:
        `vertex` in interface `IMeshI`

    - #### edge

          public IEdge edge(int i)

      Specified by:
        `edge` in interface `IMeshI`

    - #### face

          public IFace face(int i)

      Specified by:
        `face` in interface `IMeshI`

    - #### vertex

          public IVertex vertex(IIntegerI i)

      Specified by:
        `vertex` in interface `IMeshI`

    - #### edge

          public IEdge edge(IIntegerI i)

      Specified by:
        `edge` in interface `IMeshI`

    - #### face

          public IFace face(IIntegerI i)

      Specified by:
        `face` in interface `IMeshI`

    - #### vertices

          public java.util.ArrayList<IVertex> vertices()

      return all vertices
      Specified by:
        `vertices` in interface `IMeshI`

    - #### edges

          public java.util.ArrayList<IEdge> edges()

      return all edges
      Specified by:
        `edges` in interface `IMeshI`

    - #### faces

          public java.util.ArrayList<IFace> faces()

      return all faces
      Specified by:
        `faces` in interface `IMeshI`

    - #### enableVertexColor

          public IMesh enableVertexColor()

    - #### disableVertexColor

          public IMesh disableVertexColor()

    - #### enableFaceColor

          public IMesh enableFaceColor()

    - #### disableFaceColor

          public IMesh disableFaceColor()

    - #### vertexColor

          public IColor vertexColor(int i)

      set vertex color

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   IColor c)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   IColor c,
                                   int alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   IColor c,
                                   float alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   IColor c,
                                   double alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   java.awt.Color c)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   java.awt.Color c,
                                   int alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   java.awt.Color c,
                                   float alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   java.awt.Color c,
                                   double alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   int gray)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   double dgray)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   float fgray)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   int gray,
                                   int alpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   double dgray,
                                   double dalpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   float fgray,
                                   float falpha)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   int r,
                                   int g,
                                   int b)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   double dr,
                                   double dg,
                                   double db)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   float fr,
                                   float fg,
                                   float fb)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   int r,
                                   int g,
                                   int b,
                                   int a)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   double dr,
                                   double dg,
                                   double db,
                                   double da)

    - #### vertexColor

          public IMesh vertexColor(int i,
                                   float fr,
                                   float fg,
                                   float fb,
                                   float fa)

    - #### vertexHSB

          public IMesh vertexHSB(int i,
                                 double dh,
                                 double ds,
                                 double db,
                                 double da)

    - #### vertexColorHSB

          public IMesh vertexColorHSB(int i,
                                      double dh,
                                      double ds,
                                      double db,
                                      double da)

    - #### vertexHSB

          public IMesh vertexHSB(int i,
                                 float h,
                                 float s,
                                 float b,
                                 float a)

    - #### vertexColorHSB

          public IMesh vertexColorHSB(int i,
                                      float h,
                                      float s,
                                      float b,
                                      float a)

    - #### vertexHSB

          public IMesh vertexHSB(int i,
                                 double dh,
                                 double ds,
                                 double db)

    - #### vertexColorHSB

          public IMesh vertexColorHSB(int i,
                                      double dh,
                                      double ds,
                                      double db)

    - #### vertexHSB

          public IMesh vertexHSB(int i,
                                 float h,
                                 float s,
                                 float b)

    - #### vertexColorHSB

          public IMesh vertexColorHSB(int i,
                                      float h,
                                      float s,
                                      float b)

    - #### faceColor

          public IColor faceColor(int i)

      set face color

    - #### faceColor

          public IMesh faceColor(int i,
                                 IColor c)

    - #### faceColor

          public IMesh faceColor(int i,
                                 IColor c,
                                 int alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 IColor c,
                                 float alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 IColor c,
                                 double alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 java.awt.Color c)

    - #### faceColor

          public IMesh faceColor(int i,
                                 java.awt.Color c,
                                 int alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 java.awt.Color c,
                                 float alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 java.awt.Color c,
                                 double alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 int gray)

    - #### faceColor

          public IMesh faceColor(int i,
                                 double dgray)

    - #### faceColor

          public IMesh faceColor(int i,
                                 float fgray)

    - #### faceColor

          public IMesh faceColor(int i,
                                 int gray,
                                 int alpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 double dgray,
                                 double dalpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 float fgray,
                                 float falpha)

    - #### faceColor

          public IMesh faceColor(int i,
                                 int r,
                                 int g,
                                 int b)

    - #### faceColor

          public IMesh faceColor(int i,
                                 double dr,
                                 double dg,
                                 double db)

    - #### faceColor

          public IMesh faceColor(int i,
                                 float fr,
                                 float fg,
                                 float fb)

    - #### faceColor

          public IMesh faceColor(int i,
                                 int r,
                                 int g,
                                 int b,
                                 int a)

    - #### faceColor

          public IMesh faceColor(int i,
                                 double dr,
                                 double dg,
                                 double db,
                                 double da)

    - #### faceColor

          public IMesh faceColor(int i,
                                 float fr,
                                 float fg,
                                 float fb,
                                 float fa)

    - #### faceHSB

          public IMesh faceHSB(int i,
                               double dh,
                               double ds,
                               double db,
                               double da)

    - #### faceColorHSB

          public IMesh faceColorHSB(int i,
                                    double dh,
                                    double ds,
                                    double db,
                                    double da)

    - #### faceHSB

          public IMesh faceHSB(int i,
                               float h,
                               float s,
                               float b,
                               float a)

    - #### faceColorHSB

          public IMesh faceColorHSB(int i,
                                    float h,
                                    float s,
                                    float b,
                                    float a)

    - #### faceHSB

          public IMesh faceHSB(int i,
                               double dh,
                               double ds,
                               double db)

    - #### faceColorHSB

          public IMesh faceColorHSB(int i,
                                    double dh,
                                    double ds,
                                    double db)

    - #### faceHSB

          public IMesh faceHSB(int i,
                               float h,
                               float s,
                               float b)

    - #### faceColorHSB

          public IMesh faceColorHSB(int i,
                                    float h,
                                    float s,
                                    float b)

    - #### center

          public IVec center()

      center of mesh, calculated by average of all vertices
      Specified by:
        `center` in interface `IMeshI`
      Specified by:
        `center` in class `IGeometry`

    - #### addFace

          public IMesh addFace(IFace f)

    - #### addFace

          public IMesh addFace(IFace f,
                               boolean checkExistingVertex,
                               boolean checkExistingEdge,
                               boolean checkExistingFace)

    - #### addTriangles

          public IMesh addTriangles(IVertex[] v)

    - #### addTriangles

          public IMesh addTriangles(IVec[] v)

    - #### addQuads

          public IMesh addQuads(IVertex[] v)

    - #### addQuads

          public IMesh addQuads(IVec[] v)

    - #### addPolygon

          public IMesh addPolygon(IVertex[] v)

    - #### addPolygon

          public IMesh addPolygon(IVec[] v)

    - #### addTriangleStrip

          public IMesh addTriangleStrip(IVertex[] v)

    - #### addTriangleStrip

          public IMesh addTriangleStrip(IVec[] v)

    - #### addQuadStrip

          public IMesh addQuadStrip(IVertex[] v)

    - #### addQuadStrip

          public IMesh addQuadStrip(IVec[] v)

    - #### addTriangleFan

          public IMesh addTriangleFan(IVertex[] v)

    - #### addTriangleFan

          public IMesh addTriangleFan(IVec[] v)

    - #### triangulate

          public IMesh triangulate()

      triangulate quad mesh to triangles

    - #### triangulate

          public IMesh triangulate(boolean triangulateDir)

      triangulate quad mesh to triangles

    - #### nakedEdges

          public IEdge[] nakedEdges()

      returns naked edges of the mesh

    - #### subdivide

          public IMesh subdivide()

      simply subdivide one trianlge into 4 triangles

    - #### loopSubD

          public IMesh loopSubD()

      Loop-subdivision

    - #### loopSubdivide

          public IMesh loopSubdivide()

      Loop-subdivision

    - #### loopSubD

          public IMesh loopSubD(IVec[] fixedEdges)

      Loop-subdivision

    - #### loopSubdivide

          public IMesh loopSubdivide(IVec[] fixedEdges)

      Loop-subdivision

    - #### offset

          public IMesh offset(double[] offsetList)

      offset each vertex towards vertex normal and return the mesh. It modifies the exisiting mesh instead of creating new one.
      Parameters:
        `offsetList` - An array of offset distance of each vertex. Size and order of the array needs to match with vertex size and order. If the array size is smaller than vertex size, the last member is applied to the remaining.

    - #### offset

          public IMesh offset(double offsetDist)

      offset each vertex towards vertex normal and return the mesh. It modifies the exisiting mesh instead of creating new one.
      Parameters:
        `offsetDist` - offset distance.

    - #### unifyNormal

          public IMesh unifyNormal()

    - #### unifyNml

          public IMesh unifyNml()

    - #### unifyNml

          public IMesh unifyNml(int faceIdx)

    - #### name

          public IMesh name(java.lang.String nm)

      Overrides:
        `name` in class `IObject`

    - #### layer

          public IMesh layer(ILayer l)

      Description copied from class: `IGeometry`
      Set layer by ILayer object
      Overrides:
        `layer` in class `IGeometry`

    - #### layer

          public IMesh layer(java.lang.String l)

      Description copied from class: `IGeometry`
      Set layer by layer name. If the layer specified by the name is not existing in the server, a new layer is automatically created in the server
      Overrides:
        `layer` in class `IGeometry`

    - #### attr

          public IMesh attr(IAttribute at)

      Description copied from class: `IObject`
      set attributes
      Overrides:
        `attr` in class `IGeometry`

    - #### hide

          public IMesh hide()

      Overrides:
        `hide` in class `IGeometry`

    - #### show

          public IMesh show()

      Overrides:
        `show` in class `IGeometry`

    - #### clr

          public IMesh clr(IColor c)

      Description copied from class: `IObject`
      to set an object color
      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(IColor c,
                           int alpha)

      Description copied from class: `IObject`
      to set color, with alpha value overwritten
      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(IColor c,
                           float alpha)

      Description copied from class: `IObject`
      to set color, with alpha value overwritten
      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(IColor c,
                           double alpha)

      Description copied from class: `IObject`
      to set color, with alpha value overwritten
      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(IObject o)

      Description copied from class: `IObject`
      to set the same color with the object
      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(java.awt.Color c)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(java.awt.Color c,
                           int alpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(java.awt.Color c,
                           float alpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(java.awt.Color c,
                           double alpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(int gray)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(float fgray)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(double dgray)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(int gray,
                           int alpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(float fgray,
                           float falpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(double dgray,
                           double dalpha)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(int r,
                           int g,
                           int b)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(float fr,
                           float fg,
                           float fb)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(double dr,
                           double dg,
                           double db)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(int r,
                           int g,
                           int b,
                           int a)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(float fr,
                           float fg,
                           float fb,
                           float fa)

      Overrides:
        `clr` in class `IGeometry`

    - #### clr

          public IMesh clr(double dr,
                           double dg,
                           double db,
                           double da)

      Overrides:
        `clr` in class `IGeometry`

    - #### hsb

          public IMesh hsb(float h,
                           float s,
                           float b,
                           float a)

      Overrides:
        `hsb` in class `IGeometry`

    - #### hsb

          public IMesh hsb(double h,
                           double s,
                           double b,
                           double a)

      Overrides:
        `hsb` in class `IGeometry`

    - #### hsb

          public IMesh hsb(float h,
                           float s,
                           float b)

      Overrides:
        `hsb` in class `IGeometry`

    - #### hsb

          public IMesh hsb(double h,
                           double s,
                           double b)

      Overrides:
        `hsb` in class `IGeometry`

    - #### setColor

          public IMesh setColor(IColor c)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(IColor c,
                                int alpha)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(IColor c,
                                float alpha)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(IColor c,
                                double alpha)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(java.awt.Color c)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(java.awt.Color c,
                                int alpha)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(java.awt.Color c,
                                float alpha)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(java.awt.Color c,
                                double alpha)

      Overrides:
        `setColor` in class `IObject`

    - #### setColor

          public IMesh setColor(int gray)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(float fgray)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(double dgray)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(int gray,
                                int alpha)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(float fgray,
                                float falpha)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(double dgray,
                                double dalpha)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(int r,
                                int g,
                                int b)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(float fr,
                                float fg,
                                float fb)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(double dr,
                                double dg,
                                double db)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(int r,
                                int g,
                                int b,
                                int a)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(float fr,
                                float fg,
                                float fb,
                                float fa)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setColor

          public IMesh setColor(double dr,
                                double dg,
                                double db,
                                double da)

      Overrides:
        `setColor` in class `IGeometry`

    - #### setHSBColor

          public IMesh setHSBColor(float h,
                                   float s,
                                   float b,
                                   float a)

      Overrides:
        `setHSBColor` in class `IGeometry`

    - #### setHSBColor

          public IMesh setHSBColor(double h,
                                   double s,
                                   double b,
                                   double a)

      Overrides:
        `setHSBColor` in class `IGeometry`

    - #### setHSBColor

          public IMesh setHSBColor(float h,
                                   float s,
                                   float b)

      Overrides:
        `setHSBColor` in class `IGeometry`

    - #### setHSBColor

          public IMesh setHSBColor(double h,
                                   double s,
                                   double b)

      Overrides:
        `setHSBColor` in class `IGeometry`

    - #### weight

          public IMesh weight(double w)

      Overrides:
        `weight` in class `IGeometry`

    - #### weight

          public IMesh weight(float w)

      Overrides:
        `weight` in class `IGeometry`

    - #### joinMesh

          public static IMesh joinMesh(IMesh[] meshes)

      static method to join meshes. it's renamed from join to joinMesh. now method "join" is an instance method

    - #### polyhedron

          public static IMesh polyhedron(IVertex[] vtx)

      create polyhedron mesh by delaunay triangulation around a center

    - #### createPolyhedron

          public static IMesh createPolyhedron(IVertex[] vtx)

      create polyhedron mesh by delaunay triangulation around a center

    - #### polyhedron

          public static IMesh polyhedron(IVecI[] pts)

      create polyhedron mesh by delaunay triangulation around a center

    - #### createPolyhedron

          public static IMesh createPolyhedron(IVecI[] pts)

      create polyhedron mesh by delaunay triangulation around a center

    - #### polyhedron

          public static IMesh polyhedron(IVertex[] vtx,
                                         double threshold)

      create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length

    - #### createPolyhedron

          public static IMesh createPolyhedron(IVertex[] vtx,
                                               double threshold)

      create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length

    - #### polyhedron

          public static IMesh polyhedron(IVecI[] pts,
                                         double threshold)

      create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length

    - #### createPolyhedron

          public static IMesh createPolyhedron(IVecI[] pts,
                                               double threshold)

      create polyhedron mesh by delaunay triangulation around a center with maximum threshold of edge length

    - #### connectVertex

          public static IMesh connectVertex(IMesh mesh1,
                                            IMesh mesh2)

      connect closest vertex

    - #### connectVertex

          public static IMesh connectVertex(IMesh mesh1,
                                            IVertex v1,
                                            IMesh mesh2,
                                            IVertex v2)

      connect faces over a vertex

    - #### close

          public IMesh close()

      only setting value to closed. checking no connection of mesh
      Specified by:
        `close` in interface `IMeshI`

    - #### isClosed

          public boolean isClosed()

      Specified by:
        `isClosed` in interface `IMeshI`

    - #### deleteVertex

          public IMesh deleteVertex(int i)

      Specified by:
        `deleteVertex` in interface `IMeshI`

    - #### deleteEdge

          public IMesh deleteEdge(int i)

      Specified by:
        `deleteEdge` in interface `IMeshI`

    - #### deleteFace

          public IMesh deleteFace(int i)

      Specified by:
        `deleteFace` in interface `IMeshI`

    - #### deleteVertex

          public IMesh deleteVertex(IIntegerI i)

      Specified by:
        `deleteVertex` in interface `IMeshI`

    - #### deleteEdge

          public IMesh deleteEdge(IIntegerI i)

      Specified by:
        `deleteEdge` in interface `IMeshI`

    - #### deleteFace

          public IMesh deleteFace(IIntegerI i)

      Specified by:
        `deleteFace` in interface `IMeshI`

    - #### deleteVertex

          public IMesh deleteVertex(IVertex v)

      Specified by:
        `deleteVertex` in interface `IMeshI`

    - #### deleteEdge

          public IMesh deleteEdge(IEdge e)

      Specified by:
        `deleteEdge` in interface `IMeshI`

    - #### deleteFace

          public IMesh deleteFace(IFace f)

      Specified by:
        `deleteFace` in interface `IMeshI`

    - #### removeDuplicates

          public IMesh removeDuplicates()

      remove uplicated edges and vertices

    - #### removeDuplicates

          public IMesh removeDuplicates(double tolerance)

      remove uplicated edges and vertices

    - #### join

          public IMesh join(IMesh[] meshes)

      join other meshes into the current one and remove duplicated edges and vertices

    - #### join

          public IMesh join(IMesh[] meshes,
                            double tolerance)

      join other meshes into the current one and remove duplicated edges and vertices

    - #### updateGraphic

          public void updateGraphic()

      update graphic when control point location changes or some minor change. This method in IMesh also updates normal vectors.
      Overrides:
        `updateGraphic` in class `IObject`

    - #### add

          public IMesh add(double x,
                           double y,
                           double z)

      ITransformable methods
      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### add

          public IMesh add(IDoubleI x,
                           IDoubleI y,
                           IDoubleI z)

      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### add

          public IMesh add(IVecI v)

      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### sub

          public IMesh sub(double x,
                           double y,
                           double z)

      Specified by:
        `sub` in interface `ITransformable`
      Specified by:
        `sub` in class `IGeometry`

    - #### sub

          public IMesh sub(IDoubleI x,
                           IDoubleI y,
                           IDoubleI z)

      Specified by:
        `sub` in interface `ITransformable`
      Specified by:
        `sub` in class `IGeometry`

    - #### sub

          public IMesh sub(IVecI v)

      Specified by:
        `sub` in interface `ITransformable`
      Specified by:
        `sub` in class `IGeometry`

    - #### mul

          public IMesh mul(IDoubleI v)

      Specified by:
        `mul` in interface `ITransformable`
      Specified by:
        `mul` in class `IGeometry`

    - #### mul

          public IMesh mul(double v)

      Specified by:
        `mul` in interface `ITransformable`
      Specified by:
        `mul` in class `IGeometry`

    - #### div

          public IMesh div(IDoubleI v)

      Specified by:
        `div` in interface `ITransformable`
      Specified by:
        `div` in class `IGeometry`

    - #### div

          public IMesh div(double v)

      Specified by:
        `div` in interface `ITransformable`
      Specified by:
        `div` in class `IGeometry`

    - #### neg

          public IMesh neg()

      Specified by:
        `neg` in interface `ITransformable`
      Specified by:
        `neg` in class `IGeometry`

    - #### rev

          public IMesh rev()

      alias of neg

    - #### flip

          public IMesh flip()

      alias of neg
      Specified by:
        `flip` in interface `ITransformable`
      Specified by:
        `flip` in class `IGeometry`

    - #### add

          public IMesh add(IVecI v,
                           double f)

      scale add
      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### add

          public IMesh add(IVecI v,
                           IDoubleI f)

      scale add
      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### add

          public IMesh add(double f,
                           IVecI v)

      scale add alias
      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### add

          public IMesh add(IDoubleI f,
                           IVecI v)

      scale add alias
      Specified by:
        `add` in interface `ITransformable`
      Specified by:
        `add` in class `IGeometry`

    - #### rot

          public IMesh rot(IDoubleI angle)

      rotation around z-axis and origin
      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(double angle)

      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI axis,
                           IDoubleI angle)

      rotation around axis vector
      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI axis,
                           double angle)

      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI center,
                           IVecI axis,
                           IDoubleI angle)

      rotation around axis vector and center
      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI center,
                           IVecI axis,
                           double angle)

      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI axis,
                           IVecI destDir)

      rotate to destination direction vector
      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot

          public IMesh rot(IVecI center,
                           IVecI axis,
                           IVecI destPt)

      rotate to destination point location
      Specified by:
        `rot` in interface `ITransformable`
      Specified by:
        `rot` in class `IGeometry`

    - #### rot2

          public IMesh rot2(IDoubleI angle)

      rotation on xy-plane around origin; same with rot(IDoubleI)
      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### rot2

          public IMesh rot2(double angle)

      rotation on xy-plane around origin; same with rot(double)
      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### rot2

          public IMesh rot2(IVecI center,
                            IDoubleI angle)

      rotation on xy-plane around center
      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### rot2

          public IMesh rot2(IVecI center,
                            double angle)

      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### rot2

          public IMesh rot2(IVecI destDir)

      rotation on xy-plane to destination direction vector
      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### rot2

          public IMesh rot2(IVecI center,
                            IVecI destPt)

      rotation on xy-plane to destination point location
      Specified by:
        `rot2` in interface `ITransformable`
      Specified by:
        `rot2` in class `IGeometry`

    - #### scale

          public IMesh scale(IDoubleI f)

      alias of mul
      Specified by:
        `scale` in interface `ITransformable`
      Specified by:
        `scale` in class `IGeometry`

    - #### scale

          public IMesh scale(double f)

      Specified by:
        `scale` in interface `ITransformable`
      Specified by:
        `scale` in class `IGeometry`

    - #### scale

          public IMesh scale(IVecI center,
                             IDoubleI f)

      Specified by:
        `scale` in interface `ITransformable`
      Specified by:
        `scale` in class `IGeometry`

    - #### scale

          public IMesh scale(IVecI center,
                             double f)

      Specified by:
        `scale` in interface `ITransformable`
      Specified by:
        `scale` in class `IGeometry`

    - #### scale1d

          public IMesh scale1d(IVecI axis,
                               double f)

      scale only in 1 direction
      Specified by:
        `scale1d` in interface `ITransformable`
      Specified by:
        `scale1d` in class `IGeometry`

    - #### scale1d

          public IMesh scale1d(IVecI axis,
                               IDoubleI f)

      Specified by:
        `scale1d` in interface `ITransformable`
      Specified by:
        `scale1d` in class `IGeometry`

    - #### scale1d

          public IMesh scale1d(IVecI center,
                               IVecI axis,
                               double f)

      Specified by:
        `scale1d` in interface `ITransformable`
      Specified by:
        `scale1d` in class `IGeometry`

    - #### scale1d

          public IMesh scale1d(IVecI center,
                               IVecI axis,
                               IDoubleI f)

      Specified by:
        `scale1d` in interface `ITransformable`
      Specified by:
        `scale1d` in class `IGeometry`

    - #### ref

          public IMesh ref(IVecI planeDir)

      reflect(mirror) 3 dimensionally to the other side of the plane
      Specified by:
        `ref` in interface `ITransformable`
      Specified by:
        `ref` in class `IGeometry`

    - #### ref

          public IMesh ref(IVecI center,
                           IVecI planeDir)

      Specified by:
        `ref` in interface `ITransformable`
      Specified by:
        `ref` in class `IGeometry`

    - #### mirror

          public IMesh mirror(IVecI planeDir)

      mirror is alias of ref
      Specified by:
        `mirror` in interface `ITransformable`
      Specified by:
        `mirror` in class `IGeometry`

    - #### mirror

          public IMesh mirror(IVecI center,
                              IVecI planeDir)

      Specified by:
        `mirror` in interface `ITransformable`
      Specified by:
        `mirror` in class `IGeometry`

    - #### shear

          public IMesh shear(double sxy,
                             double syx,
                             double syz,
                             double szy,
                             double szx,
                             double sxz)

      shear operation
      Specified by:
        `shear` in interface `ITransformable`
      Specified by:
        `shear` in class `IGeometry`

    - #### shear

          public IMesh shear(IDoubleI sxy,
                             IDoubleI syx,
                             IDoubleI syz,
                             IDoubleI szy,
                             IDoubleI szx,
                             IDoubleI sxz)

      Specified by:
        `shear` in interface `ITransformable`
      Specified by:
        `shear` in class `IGeometry`

    - #### shear

          public IMesh shear(IVecI center,
                             double sxy,
                             double syx,
                             double syz,
                             double szy,
                             double szx,
                             double sxz)

      Specified by:
        `shear` in interface `ITransformable`
      Specified by:
        `shear` in class `IGeometry`

    - #### shear

          public IMesh shear(IVecI center,
                             IDoubleI sxy,
                             IDoubleI syx,
                             IDoubleI syz,
                             IDoubleI szy,
                             IDoubleI szx,
                             IDoubleI sxz)

      Specified by:
        `shear` in interface `ITransformable`
      Specified by:
        `shear` in class `IGeometry`

    - #### shearXY

          public IMesh shearXY(double sxy,
                               double syx)

      Specified by:
        `shearXY` in interface `ITransformable`
      Specified by:
        `shearXY` in class `IGeometry`

    - #### shearXY

          public IMesh shearXY(IDoubleI sxy,
                               IDoubleI syx)

      Specified by:
        `shearXY` in interface `ITransformable`
      Specified by:
        `shearXY` in class `IGeometry`

    - #### shearXY

          public IMesh shearXY(IVecI center,
                               double sxy,
                               double syx)

      Specified by:
        `shearXY` in interface `ITransformable`
      Specified by:
        `shearXY` in class `IGeometry`

    - #### shearXY

          public IMesh shearXY(IVecI center,
                               IDoubleI sxy,
                               IDoubleI syx)

      Specified by:
        `shearXY` in interface `ITransformable`
      Specified by:
        `shearXY` in class `IGeometry`

    - #### shearYZ

          public IMesh shearYZ(double syz,
                               double szy)

      Specified by:
        `shearYZ` in interface `ITransformable`
      Specified by:
        `shearYZ` in class `IGeometry`

    - #### shearYZ

          public IMesh shearYZ(IDoubleI syz,
                               IDoubleI szy)

      Specified by:
        `shearYZ` in interface `ITransformable`
      Specified by:
        `shearYZ` in class `IGeometry`

    - #### shearYZ

          public IMesh shearYZ(IVecI center,
                               double syz,
                               double szy)

      Specified by:
        `shearYZ` in interface `ITransformable`
      Specified by:
        `shearYZ` in class `IGeometry`

    - #### shearYZ

          public IMesh shearYZ(IVecI center,
                               IDoubleI syz,
                               IDoubleI szy)

      Specified by:
        `shearYZ` in interface `ITransformable`
      Specified by:
        `shearYZ` in class `IGeometry`

    - #### shearZX

          public IMesh shearZX(double szx,
                               double sxz)

      Specified by:
        `shearZX` in interface `ITransformable`
      Specified by:
        `shearZX` in class `IGeometry`

    - #### shearZX

          public IMesh shearZX(IDoubleI szx,
                               IDoubleI sxz)

      Specified by:
        `shearZX` in interface `ITransformable`
      Specified by:
        `shearZX` in class `IGeometry`

    - #### shearZX

          public IMesh shearZX(IVecI center,
                               double szx,
                               double sxz)

      Specified by:
        `shearZX` in interface `ITransformable`
      Specified by:
        `shearZX` in class `IGeometry`

    - #### shearZX

          public IMesh shearZX(IVecI center,
                               IDoubleI szx,
                               IDoubleI sxz)

      Specified by:
        `shearZX` in interface `ITransformable`
      Specified by:
        `shearZX` in class `IGeometry`

    - #### mv

          public IMesh mv(double x,
                          double y,
                          double z)

      mv() is alias of add()
      Specified by:
        `mv` in interface `ITransformable`
      Specified by:
        `mv` in class `IGeometry`

    - #### mv

          public IMesh mv(IDoubleI x,
                          IDoubleI y,
                          IDoubleI z)

      Specified by:
        `mv` in interface `ITransformable`
      Specified by:
        `mv` in class `IGeometry`

    - #### mv

          public IMesh mv(IVecI v)

      Specified by:
        `mv` in interface `ITransformable`
      Specified by:
        `mv` in class `IGeometry`

    - #### cp

          public IMesh cp()

      cp() is alias of dup()
      Specified by:
        `cp` in interface `IMeshI`
      Specified by:
        `cp` in interface `ITransformable`
      Overrides:
        `cp` in class `IGeometry`

    - #### cp

          public IMesh cp(double x,
                          double y,
                          double z)

      cp() is alias of dup().add()
      Specified by:
        `cp` in interface `IMeshI`
      Specified by:
        `cp` in interface `ITransformable`
      Specified by:
        `cp` in class `IGeometry`

    - #### cp

          public IMesh cp(IDoubleI x,
                          IDoubleI y,
                          IDoubleI z)

      Specified by:
        `cp` in interface `IMeshI`
      Specified by:
        `cp` in interface `ITransformable`
      Specified by:
        `cp` in class `IGeometry`

    - #### cp

          public IMesh cp(IVecI v)

      Specified by:
        `cp` in interface `IMeshI`
      Specified by:
        `cp` in interface `ITransformable`
      Specified by:
        `cp` in class `IGeometry`

    - #### translate

          public IMesh translate(double x,
                                 double y,
                                 double z)

      translate() is alias of add()
      Specified by:
        `translate` in interface `ITransformable`
      Specified by:
        `translate` in class `IGeometry`

    - #### translate

          public IMesh translate(IDoubleI x,
                                 IDoubleI y,
                                 IDoubleI z)

      Specified by:
        `translate` in interface `ITransformable`
      Specified by:
        `translate` in class `IGeometry`

    - #### translate

          public IMesh translate(IVecI v)

      Specified by:
        `translate` in interface `ITransformable`
      Specified by:
        `translate` in class `IGeometry`

    - #### transform

          public IMesh transform(IMatrix3I mat)

      Specified by:
        `transform` in interface `ITransformable`
      Specified by:
        `transform` in class `IGeometry`

    - #### transform

          public IMesh transform(IMatrix4I mat)

      Specified by:
        `transform` in interface `ITransformable`
      Specified by:
        `transform` in class `IGeometry`

    - #### transform

          public IMesh transform(IVecI xvec,
                                 IVecI yvec,
                                 IVecI zvec)

      Specified by:
        `transform` in interface `ITransformable`
      Specified by:
        `transform` in class `IGeometry`

    - #### transform

          public IMesh transform(IVecI xvec,
                                 IVecI yvec,
                                 IVecI zvec,
                                 IVecI translate)

      Specified by:
        `transform` in interface `ITransformable`
      Specified by:
        `transform` in class `IGeometry`