igeo

## Class IG

- java.lang.Object
- - igeo.IG

- All Implemented Interfaces:
    IServerI

      public class IG
      extends java.lang.Object
      implements IServerI

  A main interface to background process of iGeo. A single IG instance can be accessed through static methods although multiple IG instance also can be contained in the static variable iglist in case multiple object servers are needed or simultaneous execution of multiple applets. One IG instance contains one IServer as object database and one IPanel as display window. The member variable of IPanel can be null when no display window is needed.
  Author:
    Satoru Sugihara
  See Also:
    `IServer`, `IPanel`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `java.lang.String` | `basePath` base file path for file I/O
    `protected static int` | `currentId`
    `static java.lang.String` | `GL`
    `static java.lang.String` | `GL1` Processing Graphics using OpenGL to be put in size() method in Processing
    `static java.lang.String` | `GL2`
    `static java.lang.String` | `GL3`
    `protected static java.util.ArrayList<IG>` | `iglist` multiple IG instances are stored in iglist and switched by IG static methods in case of applet execution or other occasion but handling of multiple IG instances and switching are not really tested.
    `java.lang.String` | `inputFile`
    `IInputWrapper` | `inputWrapper` wrapping inputs in different environment.
    `static java.lang.Object` | `lock` static system variables
    `static IVec` | `o` alias of origin vector
    `boolean` | `online` if it's applet.
    `static IVec` | `origin` origin vector.
    `java.lang.String` | `outputFile`
    `static java.lang.String` | `P` alias of IG.P3D
    `static java.lang.String` | `P3` alias of IG.P3D
    `static java.lang.String` | `P3D` Processing Graphics using P3D to be put in size() method in Processing; under development.
    `IPanelI` | `panel`
    `IServer` | `server` object variables
    `static IVec` | `x` alias of x-axis vector
    `static IVec` | `xaxis` x-axis vector.
    `static IVec` | `y` alias of y-axis vector
    `static IVec` | `yaxis` y-axis vector.
    `static IVec` | `z` alias of z-axis vector
    `static IVec` | `zaxis` z-axis vector.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `IG()` object methods
    `IG(IPanelI p)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T> T[]` | `a(int length, T... vals)` create array of any class.
    `static <T> T[]` | `a(T... vals)` create array of any class.
    `static <T> T[][]` | `a2(int length1, int length2, T... vals)` create 2D array of any class.
    `static <T> T[][]` | `a2(int length2, T... vals)` create 2D array of any class.
    `static <T> T[][][]` | `a3(int length1, int length2, int length3, T... vals)` create 3D array of any class.
    `static <T> T[][][]` | `a3(int length2, int length3, T... vals)` create 3D array of any class.
    `static IArc` | `arc(double x, double y, double z, double startX, double startY, double startZ, double angle)`
    `static IArc` | `arc(IVecI center, IVecI startPt, double angle)`
    `static IArc` | `arc(IVecI center, IVecI startPt, IDoubleI angle)`
    `static IArc` | `arc(IVecI center, IVecI startPt, IVecI endPt, boolean flipArcSide)`
    `static IArc` | `arc(IVecI center, IVecI normal, IVecI startPt, double angle)` arc
    `static IArc` | `arc(IVecI center, IVecI startPt, IVecI endPt, IBoolI flipArcSide)`
    `static IArc` | `arc(IVecI center, IVecI normal, IVecI startPt, IDoubleI angle)`
    `static IArc` | `arc(IVecI center, IVecI startPt, IVecI midPt, IVecI endPt, IVecI normal)`
    `static <T> T[]` | `arr(int length, T... vals)` create array of any class.
    `static <T> T[]` | `arr(T... vals)` create array of any class.
    `static <T> T[][]` | `arr2(int length1, int length2, T... vals)` create 2D array of any class.
    `static <T> T[][]` | `arr2(int length2, T... vals)` create 2D array of any class.
    `static <T> T[][][]` | `arr3(int length1, int length2, int length3, T... vals)` create 3D array of any class.
    `static <T> T[][][]` | `arr3(int length2, int length3, T... vals)` create 3D array of any class.
    `static <T> T[]` | `array(int length, T... vals)` create array of any class.
    `static <T> T[]` | `array(T... vals)` create array of any class.
    `static <T> T[][]` | `array2(int length1, int length2, T... vals)` create 2D array of any class.
    `static <T> T[][]` | `array2(int length2, T... vals)` create 2D array of any class.
    `static <T> T[][][]` | `array3(int length1, int length2, int length3, T... vals)` create 3D array of any class.
    `static <T> T[][][]` | `array3(int length2, int length3, T... vals)` create 3D array of any class.
    `static void` | `axon()`
    `static void` | `axon(double x, double y, double z)`
    `static void` | `axon(double x, double y, double z, double axonRatio)`
    `static void` | `axon(double x, double y, double z, double yaw, double pitch)`
    `static void` | `axon(double x, double y, double z, double yaw, double pitch, double axonRatio)`
    `static void` | `axon(IVecI pos, IVecI dir)`
    `static void` | `axon(IVecI pos, IVecI dir, double axonRatio)`
    `static IVec` | `axonDir()` get camera direction vector in axonometric view pane (same pane with perspective pane)
    `static void` | `axonometric()` put axonometric view on the full screen inside the window
    `static void` | `axonometric(double x, double y, double z)`
    `static void` | `axonometric(double x, double y, double z, double axonRatio)`
    `static void` | `axonometric(double x, double y, double z, double yaw, double pitch)`
    `static void` | `axonometric(double x, double y, double z, double yaw, double pitch, double axonRatio)`
    `static void` | `axonometric(IVecI pos, IVecI dir)`
    `static void` | `axonometric(IVecI pos, IVecI dir, double axonRatio)`
    `static IPane` | `axonometricPane()` axonometric pane is identical with perspective pane in IGridPanel
    `static void` | `axonometricView()`
    `static void` | `axonometricView(double x, double y, double z)`
    `static void` | `axonometricView(double x, double y, double z, double axonRatio)`
    `static void` | `axonometricView(double x, double y, double z, double yaw, double pitch)`
    `static void` | `axonometricView(double x, double y, double z, double yaw, double pitch, double axonRatio)`
    `static void` | `axonometricView(IVecI pos, IVecI dir)`
    `static void` | `axonometricView(IVecI pos, IVecI dir, double axonRatio)`
    `static double` | `axonPitch()` get camera direction pitch angle in axonometric view pane (same pane with perspective pane)
    `static IVec` | `axonPos()` get camera position in axonometric view pane (same pane with perspective pane)
    `static double` | `axonRoll()` get camera direction roll angle in axonometric view pane (same pane with perspective pane)
    `static IVec` | `axonTarget()` get camera target position in axonometric view pane (same pane with perspective pane)
    `static double` | `axonYaw()` get camera direction yaw angle in axonometric view pane (same pane with perspective pane)
    `static void` | `back()` put back view on the full screen inside the window
    `static void` | `back(double x, double z)`
    `static void` | `back(double x, double y, double z)`
    `static void` | `back(double x, double y, double z, double axonRatio)`
    `static IVec` | `backDir()` get camera direction vector in back view pane
    `static void` | `background(java.awt.Color c)`
    `static void` | `background(java.awt.Color c1, java.awt.Color c2, java.awt.Color c3, java.awt.Color c4)`
    `static void` | `background(double gray)`
    `static void` | `background(double r, double g, double b)`
    `static void` | `background(double gray1, double gray2, double gray3, double gray4)`
    `static void` | `background(double r1, double g1, double b1, double r2, double g2, double b2, double r3, double g3, double b3, double r4, double g4, double b4)`
    `static void` | `background(float gray)`
    `static void` | `background(float r, float g, float b)`
    `static void` | `background(float gray1, float gray2, float gray3, float gray4)`
    `static void` | `background(float r1, float g1, float b1, float r2, float g2, float b2, float r3, float g3, float b3, float r4, float g4, float b4)`
    `static void` | `background(IColor c1, IColor c2, IColor c3, IColor c4)`
    `static void` | `background(int gray)`
    `static void` | `background(int r, int g, int b)`
    `static void` | `background(int gray1, int gray2, int gray3, int gray4)`
    `static void` | `background(int r1, int g1, int b1, int r2, int g2, int b2, int r3, int g3, int b3, int r4, int g4, int b4)`
    `static void` | `background(java.lang.String imageFilename)`
    `static IPane` | `backPane()` back pane is identical with front pane in IGridPanel
    `static double` | `backPitch()` get camera direction pitch angle in back view pane
    `static IVec` | `backPos()` get camera position in back view pane
    `static double` | `backRoll()` get camera direction roll angle in back view pane
    `static IVec` | `backTarget()` get camera target position in back view pane
    `static void` | `backView()`
    `static void` | `backView(double x, double z)`
    `static void` | `backView(double x, double y, double z)`
    `static void` | `backView(double x, double y, double z, double axonRatio)`
    `static double` | `backYaw()` get camera direction yaw angle in back view pane
    `static void` | `bg(java.awt.Color c)`
    `static void` | `bg(java.awt.Color c1, java.awt.Color c2, java.awt.Color c3, java.awt.Color c4)`
    `static void` | `bg(double gray)`
    `static void` | `bg(double r, double g, double b)`
    `static void` | `bg(double gray1, double gray2, double gray3, double gray4)`
    `static void` | `bg(double r1, double g1, double b1, double r2, double g2, double b2, double r3, double g3, double b3, double r4, double g4, double b4)`
    `static void` | `bg(float gray)`
    `static void` | `bg(float r, float g, float b)`
    `static void` | `bg(float gray1, float gray2, float gray3, float gray4)`
    `static void` | `bg(float r1, float g1, float b1, float r2, float g2, float b2, float r3, float g3, float b3, float r4, float g4, float b4)`
    `static void` | `bg(IColor c1, IColor c2, IColor c3, IColor c4)` background color
    `static void` | `bg(int gray)`
    `static void` | `bg(int r, int g, int b)`
    `static void` | `bg(int gray1, int gray2, int gray3, int gray4)`
    `static void` | `bg(int r1, int g1, int b1, int r2, int g2, int b2, int r3, int g3, int b3, int r4, int g4, int b4)`
    `static void` | `bg(java.lang.String imageFilename)`
    `static void` | `blackBG()`
    `static void` | `blueBG()`
    `static void` | `bottom()` put bottom view on the full screen inside the window
    `static void` | `bottom(double x, double y)`
    `static void` | `bottom(double x, double y, double z)`
    `static void` | `bottom(double x, double y, double z, double axonRatio)`
    `static IVec` | `bottomDir()` get camera direction vector in bottom view pane
    `static IPane` | `bottomPane()` bottom pane is identical with top pane in IGridPanel
    `static double` | `bottomPitch()` get camera direction pitch angle in bottom view pane
    `static IVec` | `bottomPos()` get camera position in bottom view pane
    `static double` | `bottomRoll()` get camera direction roll angle in bottom view pane
    `static IVec` | `bottomTarget()` get camera target position in bottom view pane
    `static void` | `bottomView()`
    `static void` | `bottomView(double x, double y)`
    `static void` | `bottomView(double x, double y, double z)`
    `static void` | `bottomView(double x, double y, double z, double axonRatio)`
    `static double` | `bottomYaw()` get camera direction yaw angle in bottom view pane
    `static IBox` | `box(double x, double y, double z, double size)` box
    `static IBox` | `box(double x, double y, double z, double width, double height, double depth)`
    `static IBox` | `box(IVecI[][][] corners)`
    `static IBox` | `box(IVecI origin, double size)`
    `static IBox` | `box(IVecI origin, double width, double height, double depth)`
    `static IBox` | `box(IVecI origin, IVecI xvec, IVecI yvec, IVecI zvec)`
    `static IBox` | `box(IVecI pt1, IVecI pt2, IVecI pt3, IVecI pt4, IVecI pt5, IVecI pt6, IVecI pt7, IVecI pt8)`
    `static IBrep` | `brep(int i)` get a brep in the current server
    `static int` | `brepNum()` number of breps in the current server
    `static IBrep[]` | `breps()` get all breps in the current server
    `static int` | `buildVersion()`
    `static IBrep` | `cap(ISurfaceI surface)` cap a surface which is cyclically closed in u or v direction.
    `static ICircle` | `circle(double x, double y, double z, double radius)`
    `static ICircle` | `circle(double x, double y, double z, double radius, boolean approx)`
    `static ICircle` | `circle(double x, double y, double z, double xradius, double yradius)`
    `static ICircle` | `circle(double x, double y, double z, double xradius, double yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, double radius)`
    `static ICircle` | `circle(IVecI center, double radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, double xradius, double yradius)`
    `static ICircle` | `circle(IVecI center, double xradius, double yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IDoubleI radius)`
    `static ICircle` | `circle(IVecI center, IDoubleI radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IDoubleI xradius, IDoubleI yradius)`
    `static ICircle` | `circle(IVecI center, IDoubleI xradius, IDoubleI yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, double radius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, double radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, double xradius, double yradius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, double xradius, double yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IDoubleI radius)` circle
    `static ICircle` | `circle(IVecI center, IVecI normal, IDoubleI radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IDoubleI xradius, IDoubleI yradius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IDoubleI xradius, IDoubleI yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI xradiusVec, IVecI yradiusVec)`
    `static ICircle` | `circle(IVecI center, IVecI xradiusVec, IVecI yradiusVec, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, double radius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, double radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, double xradius, double yradius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, double xradius, double yradius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, IDoubleI radius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, IDoubleI radius, boolean approx)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, IDoubleI xradius, IDoubleI yradius)`
    `static ICircle` | `circle(IVecI center, IVecI normal, IVecI rollDir, IDoubleI xradius, IDoubleI yradius, boolean approx)`
    `static void` | `clear()`
    `void` | `clearServer()`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, java.awt.Color c)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, java.awt.Color c, double alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, java.awt.Color c, float alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, java.awt.Color c, int alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, double gray)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, double gray, double alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, double r, double g, double b)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, double r, double g, double b, double a)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, float gray)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, float gray, float alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, float r, float g, float b)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, float r, float g, float b, float a)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, IColor c)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, IColor c, double alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, IColor c, float alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, IColor c, int alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, int gray)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, int gray, int alpha)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, int r, int g, int b)`
    `static java.util.ArrayList<IObject>` | `clr(java.util.ArrayList<IObject> objs, int r, int g, int b, int a)`
    `static IObject[]` | `clr(IObject[] objs, java.awt.Color c)`
    `static IObject[]` | `clr(IObject[] objs, java.awt.Color c, double alpha)`
    `static IObject[]` | `clr(IObject[] objs, java.awt.Color c, float alpha)`
    `static IObject[]` | `clr(IObject[] objs, java.awt.Color c, int alpha)`
    `static IObject[]` | `clr(IObject[] objs, double gray)`
    `static IObject[]` | `clr(IObject[] objs, double gray, double alpha)`
    `static IObject[]` | `clr(IObject[] objs, double r, double g, double b)`
    `static IObject[]` | `clr(IObject[] objs, double r, double g, double b, double a)`
    `static IObject[]` | `clr(IObject[] objs, float gray)`
    `static IObject[]` | `clr(IObject[] objs, float gray, float alpha)`
    `static IObject[]` | `clr(IObject[] objs, float r, float g, float b)`
    `static IObject[]` | `clr(IObject[] objs, float r, float g, float b, float a)`
    `static IObject[]` | `clr(IObject[] objs, IColor c)`
    `static IObject[]` | `clr(IObject[] objs, IColor c, double alpha)`
    `static IObject[]` | `clr(IObject[] objs, IColor c, float alpha)`
    `static IObject[]` | `clr(IObject[] objs, IColor c, int alpha)`
    `static IObject[]` | `clr(IObject[] objs, int gray)`
    `static IObject[]` | `clr(IObject[] objs, int gray, int alpha)`
    `static IObject[]` | `clr(IObject[] objs, int r, int g, int b)`
    `static IObject[]` | `clr(IObject[] objs, int r, int g, int b, int a)`
    `static IObject` | `clr(IObject obj, java.awt.Color c)`
    `static IObject` | `clr(IObject obj, java.awt.Color c, double alpha)`
    `static IObject` | `clr(IObject obj, java.awt.Color c, float alpha)`
    `static IObject` | `clr(IObject obj, java.awt.Color c, int alpha)`
    `static IObject` | `clr(IObject obj, double gray)`
    `static IObject` | `clr(IObject obj, double gray, double alpha)`
    `static IObject` | `clr(IObject obj, double r, double g, double b)`
    `static IObject` | `clr(IObject obj, double r, double g, double b, double a)`
    `static IObject` | `clr(IObject obj, float gray)`
    `static IObject` | `clr(IObject obj, float gray, float alpha)`
    `static IObject` | `clr(IObject obj, float r, float g, float b)`
    `static IObject` | `clr(IObject obj, float r, float g, float b, float a)`
    `static IObject` | `clr(IObject obj, IColor c)`
    `static IObject` | `clr(IObject obj, IColor c, double alpha)`
    `static IObject` | `clr(IObject obj, IColor c, float alpha)`
    `static IObject` | `clr(IObject obj, IColor c, int alpha)`
    `static IObject` | `clr(IObject obj, int gray)`
    `static IObject` | `clr(IObject obj, int gray, int alpha)`
    `static IObject` | `clr(IObject obj, int r, int g, int b)`
    `static IObject` | `clr(IObject obj, int r, int g, int b, int a)`
    `static ICylinder` | `cone(IVecI pt1, IVecI pt2, double radius)`
    `static ICylinder` | `cone(IVecI pt1, IVecI pt2, IDoubleI radius)`
    `static IVec[]` | `copy(IVec... vecarray)`
    `static IVec2[]` | `copy(IVec2... vecarray)`
    `static IVec2I[]` | `copy(IVec2I... vecarray)`
    `static IVec4[]` | `copy(IVec4... vecarray)`
    `static IVecI[]` | `copy(IVecI... vecarray)`
    `static IVec[]` | `cp(IVec... vecarray)`
    `static IVec2[]` | `cp(IVec2... vecarray)`
    `static IVec2I[]` | `cp(IVec2I... vecarray)`
    `static IVec4[]` | `cp(IVec4... vecarray)`
    `static IVecI[]` | `cp(IVecI... vecarray)` generic vector array copy
    `static ICurve` | `crv(double[][] xyzValues)`
    `static ICurve` | `crv(double[][] xyzValues, boolean close)`
    `static ICurve` | `crv(double[][] xyzValues, int degree)`
    `static ICurve` | `crv(double[][] xyzValues, int degree, boolean close)`
    `static ICurve` | `crv(double x1, double y1, double z1, double x2, double y2, double z2)`
    `static ICurve` | `crv(ICurveI crv)`
    `static ICurve` | `crv(int i)` get a curve in the current server; alias
    `static ICurve` | `crv(IVecI pt)` this creates a line between a same point
    `static ICurve` | `crv(IVecI[] cpts)`
    `static ICurve` | `crv(IVecI[] cpts, boolean close)`
    `static ICurve` | `crv(IVecI[] cpts, int degree)`
    `static ICurve` | `crv(IVecI[] cpts, int degree, boolean close)`
    `static ICurve` | `crv(IVecI[] cpts, int degree, double[] knots)`
    `static ICurve` | `crv(IVecI[] cpts, int degree, double[] knots, double ustart, double uend)` curve short name : crv
    `static ICurve` | `crv(IVecI pt1, IVecI pt2)`
    `static int` | `crvNum()` number of curves in the current server; alias
    `static ICurve[]` | `crvs()` get all curves in the current server; alias
    `static IG` | `cur()` Find the IG instance which is likely to be the current.
    `static IG` | `current()` alias of cur()
    `static ICurve` | `curve(double[][] xyzValues)`
    `static ICurve` | `curve(double[][] xyzValues, boolean close)`
    `static ICurve` | `curve(double[][] xyzValues, int degree)`
    `static ICurve` | `curve(double[][] xyzValues, int degree, boolean close)`
    `static ICurve` | `curve(double x1, double y1, double z1, double x2, double y2, double z2)`
    `static ICurve` | `curve(ICurveI crv)`
    `static ICurve` | `curve(int i)` get a curve in the current server
    `static ICurve` | `curve(IVecI pt)` this creates a line between a same point
    `static ICurve` | `curve(IVecI[] cpts)`
    `static ICurve` | `curve(IVecI[] cpts, boolean close)`
    `static ICurve` | `curve(IVecI[] cpts, int degree)`
    `static ICurve` | `curve(IVecI[] cpts, int degree, boolean close)`
    `static ICurve` | `curve(IVecI[] cpts, int degree, double[] knots)`
    `static ICurve` | `curve(IVecI[] cpts, int degree, double[] knots, double ustart, double uend)`
    `static ICurve` | `curve(IVecI pt1, IVecI pt2)`
    `static int` | `curveNum()` number of curves in the current server
    `static ICurve[]` | `curves()` get all curves in the current server
    `static ICylinder` | `cylinder(IVecI pt1, IVecI pt2, double radius)`
    `static ICylinder` | `cylinder(IVecI pt1, IVecI pt2, double radius1, double radius2)`
    `static ICylinder` | `cylinder(IVecI pt1, IVecI pt2, IDoubleI radius)`
    `static ICylinder` | `cylinder(IVecI pt1, IVecI pt2, IDoubleI radius1, IDoubleI radius2)`
    `static void` | `darkBG()`
    `static void` | `debug()` turns on all debug output
    `static void` | `debug(int level)` alias of debugLevel
    `static int` | `debugLevel()` returns the current debugLevel
    `static void` | `debugLevel(int level)` change the debug level of IOut
    `static void` | `defaultBG()`
    `static IG` | `defaultThread()` object to be used to lock in "synchronized" statement
    `static void` | `del(java.util.ArrayList<IObject> o)`
    `static void` | `del(java.lang.Class cls)`
    `static void` | `del(IObject o)`
    `static void` | `del(IObject[] o)`
    `static void` | `delAll()`
    `void` | `deleteLayer(ILayer layer)`
    `void` | `deleteLayer(java.lang.String layerName)`
    `static void` | `delLayer(ILayer layer)`
    `static void` | `delLayer(java.lang.String layerName)`
    `static void` | `disableErrorPrefix()` disable error print prefix (executing method name)
    `static void` | `disableFullScreen()` put the specified pane on the full screen inside the window if the panel is IGridPanel with 2x2 grid
    `static void` | `disablePrintPrefix()` disble print prefix (executing method name)
    `static int` | `duration()` get duration of dynamics update
    `static void` | `duration(int dur)` set duration of dynamics update
    `IDynamicServer` | `dynamicServer()`
    `static IDynamicServer` | `dynamicThread()` object to be used to lock in "synchronized" statement
    `static ICircle` | `ellipse(double x, double y, double z, double xradius, double yradius)`
    `static ICircle` | `ellipse(IVecI center, double xradius, double yradius)`
    `static ICircle` | `ellipse(IVecI center, IDoubleI xradius, IDoubleI yradius)`
    `static ICircle` | `ellipse(IVecI center, IVecI xradiusVec, IVecI yradiusVec)` ellipse (alias of some of circle)
    `static void` | `enabeErrorPrefix()` enable error print prefix (executing method name)
    `static void` | `enabePrintPrefix()` enable print prefix (executing method name)
    `static boolean` | `eq(double v1, double v2)` create 3D array of any class.
    `static boolean` | `eq(double v1, double v2, double tolerance)`
    `static void` | `err()` Error print method only with header and new line.
    `static void` | `err(java.lang.Object obj)` Error print method with header and new line.
    `static void` | `error(java.lang.Object obj)` Error print method without header nor new line.
    `static ISurface` | `extrude(ICurveI profile, double extrudeDepth)`
    `static ISurface` | `extrude(ICurveI profile, ICurveI rail)`
    `static ISurface` | `extrude(ICurveI profile, IDoubleI extrudeDepth)`
    `static ISurface` | `extrude(ICurveI profile, IVecI extrudeDir)`
    `static ISurface` | `extrude(IVecI[] profile, double extrudeDepth)` one directional extrusion
    `static ISurface` | `extrude(IVecI[] profile, ICurve rail)`
    `static ISurface` | `extrude(IVecI[] profile, IDoubleI extrudeDepth)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, boolean closeProfile, double extrudeDepth)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, boolean closeProfile, ICurve rail)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, boolean closeProfile, IDoubleI extrudeDepth)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI extrudeDir)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, double extrudeDepth)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, double[] profileKnots, ICurve rail)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, double[] profileKnots, IVecI extrudeDir)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, double[] profileKnots, IVecI[] rail, int railDeg, double[] railKnots)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, ICurve rail)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, IDoubleI extrudeDepth)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, IVecI extrudeDir)`
    `static ISurface` | `extrude(IVecI[] profile, int profileDeg, IVecI[] rail, int railDeg)`
    `static ISurface` | `extrude(IVecI[] profile, IVecI extrudeDir)`
    `static ISurface` | `extrude(IVecI[] profile, IVecI[] rail)` extrusion along path (profile control points are copied parallely)
    `static void` | `fill()` set fill graphic mode
    `static void` | `fillWire()` set fill+wireframe graphic mode
    `static void` | `fillWireframe()` set fill+wireframe graphic mode
    `static void` | `fillWithWireframe()` set fill+wireframe graphic mode
    `static ICurve` | `flatten(ICurveI curve)`
    `static ICurve` | `flatten(ICurveI curve, IVecI planeDir)`
    `static ICurve` | `flatten(ICurveI curve, IVecI planeDir, IVecI planePt)` flattening
    `static ISurface` | `flatten(ISurfaceI surface)`
    `static ISurface` | `flatten(ISurfaceI surface, IVecI planeDir)`
    `static ISurface` | `flatten(ISurfaceI surface, IVecI planeDir, IVecI planePt)`
    `static void` | `focus()`
    `void` | `focusView()`
    `java.lang.String` | `formatOutputFilePath(java.lang.String file)`
    `static void` | `front()` put front view on the full screen inside the window
    `static void` | `front(double x, double z)`
    `static void` | `front(double x, double y, double z)`
    `static void` | `front(double x, double y, double z, double axonRatio)`
    `static IVec` | `frontDir()` get camera direction vector in front view pane
    `static IPane` | `frontPane()` put front pane on the full screen inside the window if the panel is IGridPanel
    `static double` | `frontPitch()` get camera direction pitch angle in front view pane
    `static IVec` | `frontPos()` get camera position in front view pane
    `static double` | `frontRoll()` get camera direction roll angle in front view pane
    `static IVec` | `frontTarget()` get camera target position in front view pane
    `static void` | `frontView()`
    `static void` | `frontView(double x, double z)`
    `static void` | `frontView(double x, double y, double z)`
    `static void` | `frontView(double x, double y, double z, double axonRatio)`
    `static double` | `frontYaw()` get camera direction yaw angle in front view pane
    `static IGeometry` | `geo(int i)` get a geometry in the current server
    `static IGeometry[]` | `geometries()` get all geometry objects in the current server
    `static IGeometry` | `geometry(int i)` get a geometry in the current server
    `static int` | `geometryNum()` number of geometries in the cubrrent server
    `static int` | `geoNum()` alias of geometryNum()
    `static IGeometry[]` | `geos()` get all geometry objects in the current server
    `ILayer[]` | `getAllLayers()`
    `java.lang.String` | `getBasePath()`
    `IBrep` | `getBrep(int i)`
    `int` | `getBrepNum()`
    `IBrep[]` | `getBreps()`
    `ICurve` | `getCurve(int i)`
    `int` | `getCurveNum()`
    `ICurve[]` | `getCurves()`
    `int` | `getDuration()`
    `IGeometry[]` | `getGeometries()`
    `IGeometry` | `getGeometry(int i)`
    `int` | `getGeometryNum()`
    `static IG` | `getIG(IPanelI owner)` Find IG instance linked with the specified IPanel instance.
    `java.lang.String` | `getInputFile()`
    `ILayer` | `getLayer(int i)`
    `ILayer` | `getLayer(java.lang.String layerName)`
    `int` | `getLayerNum()`
    `IMesh` | `getMesh(int i)`
    `IMesh[]` | `getMeshes()`
    `int` | `getMeshNum()`
    `IObject` | `getObject(java.lang.Class cls, int i)`
    `IObject` | `getObject(int i)`
    `int` | `getObjectNum()`
    `int` | `getObjectNum(java.lang.Class cls)`
    `IObject[]` | `getObjects()`
    `IObject[]` | `getObjects(java.lang.Class cls)`
    `java.lang.String` | `getOutputFile()`
    `IPoint` | `getPoint(int i)`
    `int` | `getPointNum()`
    `IPoint[]` | `getPoints()`
    `IPolycurve` | `getPolycurve(int i)`
    `int` | `getPolycurveNum()`
    `IPolycurve[]` | `getPolycurves()`
    `ISurface` | `getSurface(int i)`
    `int` | `getSurfaceNum()`
    `ISurface[]` | `getSurfaces()`
    `IText` | `getText(int i)`
    `int` | `getTextNum()`
    `IText[]` | `getTexts()`
    `int` | `getTime()`
    `static IVec` | `getViewDir(IPane pane)` get camera direction out of pane
    `static double` | `getViewPitch(IPane pane)` get camera directio pitch angle out of pane
    `static IVec` | `getViewPos(IPane pane)` get camera position out of pane
    `static double` | `getViewRoll(IPane pane)` get camera directio roll angle out of pane
    `static IVec` | `getViewTarget(IPane pane)` get camera target position out of pane
    `static double` | `getViewYaw(IPane pane)` get camera directio yaw angle out of pane
    `static void` | `graphicMode(IGraphicMode mode)`
    `static IPane` | `gridPane(int xindex, int yindex)` put the specified pane on the full screen inside the window if the panel is IGridPanel with 2x2 grid
    `static java.util.ArrayList<IObject>` | `hide(java.util.ArrayList<IObject> objs)`
    `static IObject` | `hide(IObject obj)`
    `static IObject[]` | `hide(IObject[] objs)`
    `static java.util.ArrayList<IObject>` | `hsb(java.util.ArrayList<IObject> objs, double h, double s, double b)`
    `static java.util.ArrayList<IObject>` | `hsb(java.util.ArrayList<IObject> objs, double h, double s, double b, double a)`
    `static java.util.ArrayList<IObject>` | `hsb(java.util.ArrayList<IObject> objs, float h, float s, float b)`
    `static java.util.ArrayList<IObject>` | `hsb(java.util.ArrayList<IObject> objs, float h, float s, float b, float a)`
    `static IObject[]` | `hsb(IObject[] objs, double h, double s, double b)`
    `static IObject[]` | `hsb(IObject[] objs, double h, double s, double b, double a)`
    `static IObject[]` | `hsb(IObject[] objs, float h, float s, float b)`
    `static IObject[]` | `hsb(IObject[] objs, float h, float s, float b, float a)`
    `static IObject` | `hsb(IObject obj, double h, double s, double b)`
    `static IObject` | `hsb(IObject obj, double h, double s, double b, double a)`
    `static IObject` | `hsb(IObject obj, float h, float s, float b)`
    `static IObject` | `hsb(IObject obj, float h, float s, float b, float a)`
    `static IG` | `init()` Initialize whole IG system in non-graphic mode.
    `static IG` | `init(IPanelI owner)` Initialize whole IG system in graphic mode.
    `static void` | `initRand()`
    `static void` | `initRand(int seed)` random number
    `static void` | `initRandByTime()`
    `static java.lang.String` | `inputFile()`
    `static void` | `inputFile(java.lang.String filename)`
    `boolean` | `isDynamicsRunning()` check if dynamics is running
    `static boolean` | `isGL()`
    `boolean` | `isOnline()`
    `static boolean` | `isRunning()` check if dynamics is running
    `static ILayer` | `layer(int i)`
    `static ILayer` | `layer(java.lang.String layerName)`
    `static int` | `layerNum()`
    `static ILayer[]` | `layers()`
    `static void` | `left()` put left view on the full screen inside the window
    `static void` | `left(double y, double z)`
    `static void` | `left(double x, double y, double z)`
    `static void` | `left(double x, double y, double z, double axonRatio)`
    `static IVec` | `leftDir()` get camera direction vector in left view pane
    `static IPane` | `leftPane()` left pane is identical with front pane in IGridPanel
    `static double` | `leftPitch()` get camera direction pitch angle in left view pane
    `static IVec` | `leftPos()` get camera position in left view pane
    `static double` | `leftRoll()` get camera direction roll angle in left view pane
    `static IVec` | `leftTarget()` get camera target position in left view pane
    `static void` | `leftView()`
    `static void` | `leftView(double y, double z)`
    `static void` | `leftView(double x, double y, double z)`
    `static void` | `leftView(double x, double y, double z, double axonRatio)`
    `static double` | `leftYaw()` get camera direction yaw angle in left view pane
    `static void` | `lightBG()`
    `static ICurve` | `line(double x1, double y1, double z1, double x2, double y2, double z2)`
    `static ICurve` | `line(IVecI pt)` this creates a line between a same point
    `static ICurve` | `line(IVecI pt1, IVecI pt2)` line : type of curve.
    `static ISurface` | `loft(ICurveI[] curves)` loft
    `static ISurface` | `loft(ICurveI[] curves, int deg)`
    `static ISurface` | `loft(ICurveI[] curves, int deg, boolean close)`
    `static ISurface` | `loft(ICurveI curve1, ICurveI curve2)`
    `static ISurface` | `loft(IVecI[][] pts)`
    `static ISurface` | `loft(IVecI[][] pts, boolean closeLoft, boolean closePts)`
    `static ISurface` | `loft(IVecI[][] pts, int loftDeg, int ptsDeg)`
    `static ISurface` | `loft(IVecI[][] pts, int loftDeg, int ptsDeg, boolean closeLoft, boolean closePts)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, boolean closePts)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, int ptsDeg)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, int ptsDeg, boolean closePts)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, IVecI[] pts3)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, IVecI[] pts3, boolean closePts)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, IVecI[] pts3, int loftDeg, int ptsDeg)`
    `static ISurface` | `loft(IVecI[] pts1, IVecI[] pts2, IVecI[] pts3, int loftDeg, int ptsDeg, boolean closePts)`
    `static ISurface` | `loftX(ICurveI[] curves)` loft with sorted curves in x
    `static ISurface` | `loftX(ICurveI[] curves, int deg)`
    `static ISurface` | `loftX(ICurveI[] curves, int deg, boolean close)`
    `static ISurface` | `loftY(ICurveI[] curves)` loft with sorted curves in y
    `static ISurface` | `loftY(ICurveI[] curves, int deg)`
    `static ISurface` | `loftY(ICurveI[] curves, int deg, boolean close)`
    `static ISurface` | `loftZ(ICurveI[] curves)` loft with sorted curves in z
    `static ISurface` | `loftZ(ICurveI[] curves, int deg)`
    `static ISurface` | `loftZ(ICurveI[] curves, int deg, boolean close)`
    `static int` | `majorVersion()`
    `static IMesh` | `mesh()`
    `static IMesh` | `mesh(java.util.ArrayList<ICurveI> lines)`
    `static IMesh` | `mesh(java.util.ArrayList<IVertex> v, java.util.ArrayList<IEdge> e, java.util.ArrayList<IFace> f)`
    `static IMesh` | `mesh(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `static IMesh` | `mesh(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `static IMesh` | `mesh(ICurveI[] lines)`
    `static IMesh` | `mesh(IFace[] fcs)`
    `static IMesh` | `mesh(IMesh m)`
    `static IMesh` | `mesh(IMeshGeo m)`
    `static IMesh` | `mesh(int i)` get a mesh in the current server
    `static IMesh` | `mesh(IVec[] vert)`
    `static IMesh` | `mesh(IVec[][] matrix)`
    `static IMesh` | `mesh(IVec[][] matrix, boolean triangulateDir)`
    `static IMesh` | `mesh(IVec[][] matrix, int unum, int vnum, boolean triangulateDir)`
    `static IMesh` | `mesh(IVecI v1, IVecI v2, IVecI v3)`
    `static IMesh` | `mesh(IVecI v1, IVecI v2, IVecI v3, IVecI v4)`
    `static IMesh` | `mesh(IVertex[] vert)`
    `static IMesh` | `mesh(IVertex[] vtx, IEdge[] edg, IFace[] fcs)`
    `static IMesh` | `mesh(IVertex v1, IVertex v2, IVertex v3)`
    `static IMesh` | `mesh(IVertex v1, IVertex v2, IVertex v3, IVertex v4)`
    `static IMesh` | `meshBox(double x, double y, double z, double size)` creating mesh box
    `static IMesh` | `meshBox(double x, double y, double z, double width, double height, double depth)`
    `static IMesh` | `meshBox(IVecI[][][] corners)`
    `static IMesh` | `meshBox(IVecI origin, double size)`
    `static IMesh` | `meshBox(IVecI origin, double width, double height, double depth)`
    `static IMesh` | `meshBox(IVecI origin, IVecI xvec, IVecI yvec, IVecI zvec)`
    `static IMesh` | `meshBox(IVecI pt1, IVecI pt2, IVecI pt3, IVecI pt4, IVecI pt5, IVecI pt6, IVecI pt7, IVecI pt8)`
    `static IMesh` | `meshBox(IVertex[][][] corners)`
    `static IMesh[]` | `meshes()` get all meshes in the current server
    `static IMesh` | `meshFromTriangles(IVecI[][] trianglePts)` create polygon mesh out of array of triangle points which is array of 3 IVec
    `static int` | `meshNum()` number of meshes in the current server
    `static IMesh` | `meshPolygonStick(ICurveI railCurve, double radius, int polygonVertexNum)`
    `static IMesh` | `meshPolygonStick(ICurveI railCurve, double radius, int polygonVertexNum, int railSegmentNum)`
    `static IMesh` | `meshPolygonStick(IVecI pt1, IVecI pt2, double radius1, double radius2, int polygonVertexNum)` creates closed mesh stick with polygon profile
    `static IMesh` | `meshPolygonStick(IVecI pt1, IVecI pt2, double radius1, double radius2, int polygonVertexNum, IVecI heightDir)` creates closed mesh stick with polygon profile
    `static IMesh` | `meshPolygonStick(IVecI pt1, IVecI pt2, double radius, int polygonVertexNum)` creates closed mesh stick with polygon profile
    `static IMesh` | `meshPolygonStick(IVecI pt1, IVecI pt2, double radius, int polygonVertexNum, IVecI heightDir)` creates closed mesh stick with polygon profile
    `static IMesh` | `meshRectPipe(IVecI pt1, IVecI pt2, double width, double height)` creating open mesh pipe.
    `static IMesh` | `meshRectPipe(IVecI pt1, IVecI pt2, double width, double height, IVecI heightDir)` creating open mesh pipe with 2 points and with and height
    `static IMesh` | `meshRectPipe(IVecI pt1, IVecI pt2, IVecI udir, IVecI vdir)` open pipe mesh
    `static IMesh` | `meshRectStick(IVecI pt1, IVecI pt2, double width, double height)` creating closed mesh stick.
    `static IMesh` | `meshRectStick(IVecI pt1, IVecI pt2, double width, double height, IVecI heightDir)` creating closed mesh stick with 2 points and with and height
    `static IMesh` | `meshRectStick(IVecI pt1, IVecI pt2, IVecI udir, IVecI vdir)`
    `static IMesh` | `meshRoundStick(ICurveI railCurve, double radius)` round stick
    `static IMesh` | `meshRoundStick(ICurveI railCurve, double radius, int railSegmentNum)` round stick
    `static IMesh` | `meshRoundStick(IVecI pt1, IVecI pt2, double radius)` round stick (alias of stick())
    `static IMesh` | `meshRoundStick(IVecI pt1, IVecI pt2, double radius1, double radius2)` round stick (alias of stick())
    `static IMesh` | `meshSphere(IVecI center, double radius)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, double zradius, double xyradius)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, double zradius, double xyradius, int resolution)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, double radius, int resolution)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, double radius)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, double topRadius, double sideRadius)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, double topRadius, double sideRadius, int resolution)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, double radius, int resolution)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, int resolution)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, IVecI sideDir)` mesh sphere
    `static IMesh` | `meshSphere(IVecI center, IVecI topDir, IVecI sideDir, int resolution)` mesh sphere
    `static IMesh` | `meshSquarePipe(IVecI pt1, IVecI pt2, double width)` creating open mesh stick.
    `static IMesh` | `meshSquarePipe(IVecI pt1, IVecI pt2, double width, IVecI heightDir)` creating open mesh pipe with square profile.
    `static IMesh` | `meshSquareStick(ICurveI railCurve, double radius)` square stick
    `static IMesh` | `meshSquareStick(ICurveI railCurve, double radius, int railSegmentNum)` square stick
    `static IMesh` | `meshSquareStick(IVecI pt1, IVecI pt2, double width)` creating closed mesh stick.
    `static IMesh` | `meshSquareStick(IVecI pt1, IVecI pt2, double width, IVecI heightDir)` creating closed mesh stick with square profile.
    `static IMesh` | `meshStick(ICurveI railCurve, double radius)` round stick
    `static IMesh` | `meshStick(ICurveI railCurve, double radius, int railSegmentNum)` round stick
    `static IMesh` | `meshStick(IVecI pt1, IVecI pt2, double radius)` round stick
    `static IMesh` | `meshStick(IVecI pt1, IVecI pt2, double radius1, double radius2)` round stick
    `static IMesh` | `meshTetrahedron(IVecI[] vtx)`
    `static IMesh` | `meshTetrahedron(IVecI v1, IVecI v2, IVecI v3, IVecI v4)`
    `static IMesh` | `meshTetrahedron(IVertex[] vtx)`
    `static IMesh` | `meshTetrahedron(IVertex v1, IVertex v2, IVertex v3, IVertex v4)`
    `static IMeshType` | `meshType()` get the current mesh type (class of vertex, edge, face)
    `static void` | `meshType(IMeshType type)` set mesh type (class of vertex, edge, face)
    `static int` | `minorVersion()`
    `static void` | `noGraphic()`
    `static IObject` | `obj(java.lang.Class cls, int i)` get a object of the specified class in the current server; alias
    `static IObject` | `obj(int i)` get a object in the current server; alias
    `static IObject` | `object(java.lang.Class cls, int i)` get a object of the specified class in the current server
    `static IObject` | `object(int i)` get a object in the current server
    `static int` | `objectNum()` number of objects in the current server
    `static int` | `objectNum(java.lang.Class cls)` number of objects of the specified class in the current server
    `static IObject[]` | `objects()` get all objects in the current server
    `static IObject[]` | `objects(java.lang.Class cls)` get all objects of the specified class in the current server
    `static int` | `objNum()` number of objects in the current server; alias
    `static int` | `objNum(java.lang.Class cls)` number of objects of the specified class in the current server; alias
    `static IObject[]` | `objs()` get all objects in the current server; alias
    `static IObject[]` | `objs(java.lang.Class cls)` get all objects of the specified class in the current server; alias
    `static ICurve` | `offset(ICurveI curve, double width)`
    `static ICurve` | `offset(ICurveI curve, double width, IVecI planeNormal)` offset curve
    `static ICurve` | `offset(ICurveI curve, IDoubleI width)`
    `static ICurve` | `offset(ICurveI curve, IDoubleI width, IVecI planeNormal)`
    `static IVec[]` | `offset(IVec[] pts, double width)` offset points.
    `static IVec[]` | `offset(IVec[] pts, double width, boolean close)`
    `static IVec[]` | `offset(IVec[] pts, double width, IVecI planeNormal)` offset points with specific normal direction
    `static IVec[]` | `offset(IVec[] pts, double width, IVecI[] normals)` offset points with specific normal vector for each point
    `static IVec[]` | `offset(IVec[] pts, double width, IVecI[] normals, boolean close)`
    `static IVec[]` | `offset(IVec[] pts, double width, IVecI planeNormal, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, double width)`
    `static IVecI[]` | `offset(IVecI[] pts, double width, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, double width, IVecI planeNormal)`
    `static IVecI[]` | `offset(IVecI[] pts, double width, IVecI[] normals)`
    `static IVecI[]` | `offset(IVecI[] pts, double width, IVecI[] normals, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, double width, IVecI planeNormal, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width, IVecI planeNormal)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width, IVecI[] normals)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width, IVecI[] normals, boolean close)`
    `static IVecI[]` | `offset(IVecI[] pts, IDoubleI width, IVecI planeNormal, boolean close)`
    `static IObject[]` | `open(java.lang.String file)`
    `java.util.ArrayList<IObject>` | `openFile(java.lang.String file)`
    `static java.lang.String` | `outputFile()`
    `static void` | `outputFile(java.lang.String filename)` to set the name first and save later (likely by key event)
    `static void` | `p()` Print method only with header and new line.
    `static void` | `p(java.lang.Object obj)` Print method with header and new line.
    `static void` | `pause()` pause dynamics update.
    `void` | `pauseDynamics()`
    `static boolean` | `pct(double percent)`
    `static boolean` | `percent(double percent)`
    `static void` | `pers()`
    `static void` | `pers(double perspectiveAngle)`
    `static void` | `pers(double x, double y, double z)`
    `static void` | `pers(double x, double y, double z, double perspectiveAngle)`
    `static void` | `pers(double x, double y, double z, double yaw, double pitch)`
    `static void` | `pers(double x, double y, double z, double yaw, double pitch, double perspectiveAngle)`
    `static void` | `pers(IVecI pos, IVecI dir)`
    `static void` | `pers(IVecI pos, IVecI dir, double perspectiveAngle)`
    `static IVec` | `persDir()` get camera direction vector in perspective view pane
    `static void` | `perspective()` put perspective view on the full screen inside the window
    `static void` | `perspective(double perspectiveAngle)` put perspective view on the full screen inside the window
    `static void` | `perspective(double x, double y, double z)`
    `static void` | `perspective(double x, double y, double z, double perspectiveAngle)`
    `static void` | `perspective(double x, double y, double z, double yaw, double pitch)`
    `static void` | `perspective(double x, double y, double z, double yaw, double pitch, double perspectiveAngle)`
    `static void` | `perspective(IVecI pos, IVecI dir)`
    `static void` | `perspective(IVecI pos, IVecI dir, double perspectiveAngle)`
    `static IPane` | `perspectivePane()` put perspective pane on the full screen inside the window if the panel is IGridPanel
    `static void` | `perspectiveView()`
    `static void` | `perspectiveView(double perspectiveAngle)`
    `static void` | `perspectiveView(double x, double y, double z)`
    `static void` | `perspectiveView(double x, double y, double z, double perspectiveAngle)`
    `static void` | `perspectiveView(double x, double y, double z, double yaw, double pitch)`
    `static void` | `perspectiveView(double x, double y, double z, double yaw, double pitch, double perspectiveAngle)`
    `static void` | `perspectiveView(IVecI pos, IVecI dir)`
    `static void` | `perspectiveView(IVecI pos, IVecI dir, double perspectiveAngle)`
    `static double` | `persPitch()` get camera direction pitch angle in perspective view pane
    `static IVec` | `persPos()` get camera position in perspective view pane
    `static double` | `persRoll()` get camera direction roll angle in perspective view pane
    `static IVec` | `persTarget()` get camera target position in perspective view pane
    `static double` | `persYaw()` get camera direction yaw angle in perspective view pane
    `static ISurface` | `pipe(ICurveI rail, double radius)`
    `static ISurface` | `pipe(IVecI[] rail, double radius)`
    `static ISurface` | `pipe(IVecI[] rail, int railDeg, boolean close, double radius)`
    `static ISurface` | `pipe(IVecI[] rail, int railDeg, double radius)`
    `static ISurface` | `pipe(IVecI[] rail, int railDeg, double[] railKnots, double radius)`
    `static ISurface` | `pipe(IVecI pt1, IVecI pt2, double radius)` pipe
    `static ISurface` | `plane(double x, double y, double z, double xwidth, double yheight)`
    `static ISurface` | `plane(IVecI corner, double xwidth, double yheight)`
    `static ISurface` | `plane(IVecI corner, IVecI widthVec, IVecI heightVec)`
    `static IPoint` | `point(double x, double y)`
    `static IPoint` | `point(double x, double y, double z)`
    `static IPoint` | `point(int i)` get a point in the current server
    `static IPoint` | `point(IVec v)`
    `static IPoint` | `point(IVecI v)` point creation
    `static ISurface` | `pointLoft(ICurveI profile, IVecI center)` surface by lofting profile into the specified point
    `static ISurface` | `pointLoft(IVecI[] cps, int deg, double[] knots, IVecI center)` surface by lofting profile into the specified point
    `static int` | `pointNum()` number of points in the current server
    `static IPoint[]` | `points()` get all points in the current server
    `static IPolycurve` | `polycurve(int i)` get a polycurve in the current server Note that IPolycurve contains multiple ICurve and they show up in curves() as well.
    `static int` | `polycurveNum()` number of polycurves in the current server.
    `static IPolycurve[]` | `polycurves()` get all curves in the current server Note that IPolycurve contains multiple ICurve and they show up in curves() as well.
    `static void` | `print(java.lang.Object obj)` Print method without header nor new line This is a wrapper of IOut.p(), which is also a wrapper of System.out.print().
    `static ISurface` | `profileSurface(ICurveI profile)` surface defined by closed profile.if the profile is flat, planar surface is created.
    `static ISurface` | `profileSurface(IVecI[] cps, int deg, double[] knots)` surface defined by closed profile.if the profile is flat, planar surface is created.
    `static IPoint` | `pt(double x, double y)`
    `static IPoint` | `pt(double x, double y, double z)`
    `static IPoint` | `pt(int i)` get a point in the current server; alias
    `static IPoint` | `pt(IVec v)`
    `static IPoint` | `pt(IVecI v)` point creation shorter name
    `static int` | `ptNum()` number of points in the current server; alias
    `static IPoint[]` | `pts()` get all points in the current server; alias
    `static ISurface` | `radialSurface(ICurveI profile)` surface by lofting profile into the center of the profile
    `static ISurface` | `radialSurface(IVecI[] cps, int deg, double[] knots)` surface by lofting profile into the center of the profile
    `static double` | `rand()`
    `static double` | `rand(double max)`
    `static double` | `rand(double min, double max)`
    `static float` | `rand(float max)`
    `static float` | `rand(float min, float max)`
    `static int` | `rand(int max)`
    `static int` | `rand(int min, int max)`
    `static <T> T` | `rand(java.util.List<T> array)`
    `static <T> T` | `rand(T[] array)`
    `static IColor` | `randClr()`
    `static IColor` | `randClr(float alpha)`
    `static IColor` | `randClr(int alpha)`
    `static IColor` | `randColor()`
    `static IColor` | `randColor(float alpha)`
    `static IColor` | `randColor(int alpha)`
    `static IVec` | `randDir()`
    `static IVec` | `randDir(double len)`
    `static IVec` | `randDir(IVecI perpendicularAxis)`
    `static IVec` | `randDir(IVecI perpendicularAxis, double length)`
    `static IColor` | `randGray()`
    `static IColor` | `randGray(float alpha)`
    `static IColor` | `randGray(int alpha)`
    `static boolean` | `randPct(double percent)`
    `static boolean` | `randPercent(double percent)`
    `static IVec` | `randPt()`
    `static IVec` | `randPt(double max)`
    `static IVec` | `randPt(double min, double max)`
    `static IVec` | `randPt(double maxx, double maxy, double maxz)`
    `static IVec` | `randPt(double minx, double miny, double maxx, double maxy)`
    `static IVec` | `randPt(double minx, double miny, double minz, double maxx, double maxy, double maxz)`
    `static double` | `rate()` alias of updateRate()
    `static void` | `rate(double second)` alias of updateRate()
    `static ICurve` | `rect(double x, double y, double z, double xwidth, double yheight)`
    `static ICurve` | `rect(IVecI corner, double xwidth, double yheight)` rectangle
    `static ICurve` | `rect(IVecI corner, IVecI width, IVecI height)`
    `static ISurface` | `rectPipe(ICurveI rail, double width, double height)`
    `static ISurface` | `rectPipe(ICurveI rail, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI[] rail, double width, double height)`
    `static ISurface` | `rectPipe(IVecI[] rail, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, boolean close, double width, double height)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, boolean close, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, double[] knots, double width, double height)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, double[] knots, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, double width, double height)`
    `static ISurface` | `rectPipe(IVecI[] rail, int deg, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI pt1, IVecI pt2, double width, double height)`
    `static ISurface` | `rectPipe(IVecI pt1, IVecI pt2, double left, double right, double bottom, double top)`
    `static ISurface` | `rectPipe(IVecI pt1, IVecI pt2, IVecI widthDir, double width, double height)`
    `static ISurface` | `rectPipe(IVecI pt1, IVecI pt2, IVecI widthDir, double left, double right, double bottom, double top)`
    `static void` | `resume()` resume dynamics update.
    `void` | `resumeDynamics()`
    `static int` | `revisionVersion()`
    `static void` | `right()` put right view on the full screen inside the window
    `static void` | `right(double y, double z)`
    `static void` | `right(double x, double y, double z)`
    `static void` | `right(double x, double y, double z, double axonRatio)`
    `static IVec` | `rightDir()` get camera direction vector in right view pane
    `static IPane` | `rightPane()` put right pane on the full screen inside the window if the panel is IGridPanel
    `static double` | `rightPitch()` get camera direction pitch angle in right view pane
    `static IVec` | `rightPos()` get camera position in right view pane
    `static double` | `rightRoll()` get camera direction roll angle in right view pane
    `static IVec` | `rightTarget()` get camera target position in right view pane
    `static void` | `rightView()`
    `static void` | `rightView(double y, double z)`
    `static void` | `rightView(double x, double y, double z)`
    `static void` | `rightView(double x, double y, double z, double axonRatio)`
    `static double` | `rightYaw()` get camera direction yaw angle in right view pane
    `boolean` | `save()`
    `static boolean` | `save(java.lang.String file)`
    `boolean` | `saveFile(java.lang.String file)`
    `static void` | `seed(int seed)`
    `static void` | `seedByTime()`
    `static void` | `seedRand()`
    `IServer` | `server()`
    `java.lang.String` | `setBasePath(java.lang.String path)`
    `static void` | `setCurrent(IG ig)`
    `static void` | `setCurrent(IPanelI owner)`
    `void` | `setDuration(int dur)`
    `void` | `setInputFile(java.lang.String filename)`
    `void` | `setInputWrapper(IInputWrapper wrapper)`
    `void` | `setOnline(boolean f)`
    `void` | `setOutputFile(java.lang.String filename)`
    `static void` | `setPrint(IPrintWrapper pw)` redirect print to print wrapper
    `static void` | `setPrint(IPrintWrapper pw, IPrintWrapper errpw)` redirect print to print wrapper
    `static void` | `setPrint(IPrintWrapper pw, IPrintWrapper errpw, IPrintWrapper debugpw)` redirect print to print wrapper
    `static void` | `setPrintStream(java.io.PrintStream ps)` redirect print to print stream
    `static void` | `setPrintStream(java.io.PrintStream ps, java.io.PrintStream errps)` redirect print to print stream
    `static void` | `setPrintStream(java.io.PrintStream ps, java.io.PrintStream errps, java.io.PrintStream debugps)` redirect print to print stream
    `void` | `setTime(int tm)`
    `static java.util.ArrayList<IObject>` | `show(java.util.ArrayList<IObject> objs)`
    `static IObject` | `show(IObject obj)`
    `static IObject[]` | `show(IObject[] objs)`
    `static void` | `showTime()` enable printing time to console
    `static void` | `showTime(boolean flag)` enable/disable printing time to console
    `static double` | `speed()` alias of updateRate()
    `static void` | `speed(double second)` alias of updateRate()
    `static ISphere` | `sphere(double x, double y, double z, double radius)` sphere
    `static ISphere` | `sphere(IVecI center, double radius)`
    `static ISphere` | `sphere(IVecI center, IDoubleI radius)`
    `static ISurface` | `squarePipe(ICurveI rail, double size)`
    `static ISurface` | `squarePipe(IVecI[] rail, double size)`
    `static ISurface` | `squarePipe(IVecI[] rail, int deg, boolean close, double size)`
    `static ISurface` | `squarePipe(IVecI[] rail, int deg, double size)`
    `static ISurface` | `squarePipe(IVecI[] rail, int deg, double[] knots, double size)`
    `static ISurface` | `squarePipe(IVecI pt1, IVecI pt2, double size)`
    `static ISurface` | `squarePipe(IVecI pt1, IVecI pt2, IVecI widthDir, double size)`
    `static ISurface` | `srf(double[][][] xyzValues)`
    `static ISurface` | `srf(double[][][] xyzValues, boolean closeU, boolean closeV)`
    `static ISurface` | `srf(double[][][] xyzValues, int udeg, int vdeg)`
    `static ISurface` | `srf(double[][][] xyzValues, int udeg, int vdeg, boolean closeU, boolean closeV)`
    `static ISurface` | `srf(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `static ISurface` | `srf(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `static ISurface` | `srf(ICurveI trimCurve)` planar surface with trim
    `static ISurface` | `srf(ICurveI[] trimCurves)`
    `static ISurface` | `srf(ICurveI outerTrimCurve, ICurveI innerTrimCurve)`
    `static ISurface` | `srf(ICurveI outerTrimCurve, ICurveI[] innerTrimCurves)`
    `static ISurface` | `srf(int i)` get a surface in the current server; alias
    `static ISurface` | `srf(ISurfaceI srf)`
    `static ISurface` | `srf(IVecI[] trimCrvPts)`
    `static ISurface` | `srf(IVecI[][] cpts)`
    `static ISurface` | `srf(IVecI[][] cpts, boolean closeU, boolean closeV)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, boolean closeV)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, double[] vk)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree, double[] uk, boolean closeV)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots)`
    `static ISurface` | `srf(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots, double ustart, double uend, double vstart, double vend)` srf : short name of surfaces
    `static ISurface` | `srf(IVecI[] trimCrvPts, int trimCrvDeg)`
    `static ISurface` | `srf(IVecI[] trimCrvPts, int trimCrvDeg, double[] trimCrvKnots)`
    `static ISurface` | `srf(IVecI pt1, IVecI pt2, IVecI pt3)`
    `static ISurface` | `srf(IVecI pt1, IVecI pt2, IVecI pt3, IVecI pt4)`
    `static int` | `srfNum()` number of surfaces in the current server; alias
    `static ISurface[]` | `srfs()` get all surfaces in the current server; alias
    `static void` | `start()` start dynamics update.
    `void` | `startDynamics()`
    `static void` | `stop()` stop dynamics update.
    `void` | `stopDynamics()`
    `static ISurface` | `surface(double[][][] xyzValues)`
    `static ISurface` | `surface(double[][][] xyzValues, boolean closeU, boolean closeV)`
    `static ISurface` | `surface(double[][][] xyzValues, int udeg, int vdeg)`
    `static ISurface` | `surface(double[][][] xyzValues, int udeg, int vdeg, boolean closeU, boolean closeV)`
    `static ISurface` | `surface(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `static ISurface` | `surface(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `static ISurface` | `surface(ICurveI trimCurve)`
    `static ISurface` | `surface(ICurveI[] trimCurves)`
    `static ISurface` | `surface(ICurveI outerTrimCurve, ICurveI innerTrimCurve)`
    `static ISurface` | `surface(ICurveI outerTrimCurve, ICurveI[] innerTrimCurves)`
    `static ISurface` | `surface(int i)` get a surface in the current server
    `static ISurface` | `surface(ISurfaceI srf)`
    `static ISurface` | `surface(IVecI[] trimCrvPts)`
    `static ISurface` | `surface(IVecI[][] cpts)`
    `static ISurface` | `surface(IVecI[][] cpts, boolean closeU, boolean closeV)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, boolean closeV)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, double[] vk)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree, double[] uk, boolean closeV)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots)`
    `static ISurface` | `surface(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots, double ustart, double uend, double vstart, double vend)` surfaces
    `static ISurface` | `surface(IVecI[] trimCrvPts, int trimCrvDeg)`
    `static ISurface` | `surface(IVecI[] trimCrvPts, int trimCrvDeg, double[] trimCrvKnots)`
    `static ISurface` | `surface(IVecI pt1, IVecI pt2, IVecI pt3)`
    `static ISurface` | `surface(IVecI pt1, IVecI pt2, IVecI pt3, IVecI pt4)`
    `static int` | `surfaceNum()` number of surfaces in the current server
    `static ISurface[]` | `surfaces()` get all surfaces in the current server
    `static ISurface` | `sweep(ICurveI profile, ICurveI rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI[] rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(ICurveI profile, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, ICurveI rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI[] rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI profileDir, ICurveI rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI profileDir, IVecI[] rail)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI profileDir, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(ICurveI profile, IVecI profileCenter, IVecI profileDir, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(IVecI[] profile, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI profileCenter, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI profileCenter, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI profileCenter, IVecI profileDir, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, boolean closeProfile, IVecI profileCenter, IVecI profileDir, IVecI[] rail, int railDeg, boolean closeRail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, double[] profileKnots, IVecI[] rail, int railDeg, double[] railKnots)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, double[] profileKnots, IVecI profileCenter, IVecI[] rail, int railDeg, double[] railKnots)` sweep.
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, double[] profileKnots, IVecI profileCenter, IVecI profileDir, IVecI[] rail, int railDeg, double[] railKnots)` sweep.
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, IVecI profileCenter, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, IVecI profileCenter, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, IVecI profileCenter, IVecI profileDir, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, int profileDeg, IVecI profileCenter, IVecI profileDir, IVecI[] rail, int railDeg)`
    `static ISurface` | `sweep(IVecI[] profile, IVecI[] rail)` sweep (profile is redirected perpendicular to rail and centered(actually just on bisector of control points))
    `static ISurface` | `sweep(IVecI[] profile, IVecI profileCenter, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, IVecI profileCenter, IVecI[] rail)`
    `static ISurface` | `sweep(IVecI[] profile, IVecI profileCenter, IVecI profileDir, ICurveI rail)`
    `static ISurface` | `sweep(IVecI[] profile, IVecI profileCenter, IVecI profileDir, IVecI[] rail)`
    `static IText` | `text(int i)` get a text in the current server
    `static int` | `textNum()` number of texts in the current server
    `static IText[]` | `texts()` get all texts in the current server
    `static int` | `time()` get current time count of dynamics update
    `static void` | `time(int tm)` set current time count of dynamics update.
    `static void` | `top()` put top view on the full screen inside the window
    `static void` | `top(double x, double y)`
    `static void` | `top(double x, double y, double z)`
    `static void` | `top(double x, double y, double z, double axonRatio)`
    `static IVec` | `topDir()` get camera direction vector in top view pane
    `static IPane` | `topPane()` put top pane on the full screen inside the window if the panel is IGridPanel
    `static double` | `topPitch()` get camera direction pitch angle in top view pane
    `static IVec` | `topPos()` get camera position in top view pane
    `static double` | `topRoll()` get camera direction roll angle in top view pane
    `static IVec` | `topTarget()` get camera target position in top view pane
    `static void` | `topView()`
    `static void` | `topView(double x, double y)`
    `static void` | `topView(double x, double y, double z)`
    `static void` | `topView(double x, double y, double z, double axonRatio)`
    `static double` | `topYaw()` get camera direction yaw angle in top view pane
    `static void` | `trans()` alias of transparent()
    `static void` | `transFill()` set transparent fill graphic mode
    `static void` | `transparent()` set transparent fill graphic mode
    `static void` | `transparentFill()` set transparent fill graphic mode
    `static void` | `transparentFillWithWireframe()` set transparent fill+wireframe graphic mode
    `static void` | `transparentWireframe()` set transparent fill+wireframe graphic mode
    `static void` | `transWire()` alias of wireframeTransparent()
    `static IUnit` | `unit()` getting unit of current IG server
    `static void` | `unit(IUnit.Type u)` setting unit of current IG server
    `static void` | `unit(IUnit u)` setting unit of current IG server
    `static void` | `unit(java.lang.String unitName)` setting unit of current IG server
    `static double` | `updateRate()` getting update rate time interval in second
    `static void` | `updateRate(double second)` setting update rate time interval in second
    `static double` | `updateSpeed()` alias of updateRate()
    `static void` | `updateSpeed(double second)` alias of updateRate()
    `static IDynamicServer` | `updateThread()` alias of dynamicThread()
    `static IVec` | `v()` vector shorter name
    `static IVec` | `v(double x, double y)`
    `static IVec` | `v(double x, double y, double z)`
    `static IVec[]` | `v(double x, double y, double z, double... xyzvals)` vector array shorter name
    `static IVec` | `v(IDoubleI x, IDoubleI y)`
    `static IVec` | `v(IDoubleI x, IDoubleI y, IDoubleI z)`
    `static IVec[]` | `v(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI... xyzvals)`
    `static IVec[]` | `v(IVec... v)`
    `static IVec` | `v(IVec v)`
    `static IVec[][]` | `v(IVec[]... v)` IVec 2d array
    `static IVec[][][]` | `v(IVec[][]... v)` IVec 3d array
    `static IVec[]` | `v(IVec2I... v)`
    `static IVec` | `v(IVec2I v)`
    `static IVecI[]` | `v(IVecI... v)`
    `static IVec` | `v(IVecI v)`
    `static IVecI[][]` | `v(IVecI[]... v)`
    `static IVecI[][][]` | `v(IVecI[][]... v)`
    `static IVec2` | `v2()` 2d vector shorter name
    `static IVec2` | `v2(double x, double y)`
    `static IVec2[]` | `v2(double x, double y, double... xyvals)`
    `static IVec2` | `v2(IDoubleI x, IDoubleI y)`
    `static IVec2[]` | `v2(IDoubleI x, IDoubleI y, IDoubleI... xyvals)`
    `static IVec2[]` | `v2(IVec... v)` IVec2 array from IVec (projection)
    `static IVec2[]` | `v2(IVec2... v)`
    `static IVec2` | `v2(IVec2 v)`
    `static IVec2[][]` | `v2(IVec2[]... v)` IVec4 2d array
    `static IVec2[][][]` | `v2(IVec2[][]... v)` IVec4 3d array
    `static IVec2I[]` | `v2(IVec2I... v)`
    `static IVec2I[][]` | `v2(IVec2I[]... v)`
    `static IVec2I[][][]` | `v2(IVec2I[][]... v)`
    `static IVec2I[]` | `v2(IVecI... v)` IVec2I array from IVecI (projection)
    `static IVec2` | `v2(IVecI v)`
    `static IVec4` | `v4()` 4d vector shorter name
    `static IVec4` | `v4(double x, double y, double z, double w)`
    `static IVec4[]` | `v4(double x, double y, double z, double w, double... xyzwvals)`
    `static IVec4` | `v4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w)`
    `static IVec4[]` | `v4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w, IDoubleI... xyzwvals)`
    `static IVec4[]` | `v4(IVec4... v)`
    `static IVec4` | `v4(IVec4 v)`
    `static IVec4[][]` | `v4(IVec4[]... v)` IVec4 2d array
    `static IVec4[][][]` | `v4(IVec4[][]... v)` IVec4 3d array
    `static IVec4I[]` | `v4(IVec4I... v)`
    `static IVec4I[][]` | `v4(IVec4I[]... v)`
    `static IVec4I[][][]` | `v4(IVec4I[][]... v)`
    `static IVec4` | `v4(IVec v, double w)`
    `static IVec4` | `v4(IVecI v)`
    `static IVec4` | `v4(IVecI v, double w)`
    `static IVec4` | `v4(IVecI v, IDoubleI w)`
    `static IVec` | `vec()` creating vector
    `static IVec` | `vec(double x, double y)`
    `static IVec` | `vec(double x, double y, double z)`
    `static IVec[]` | `vec(double x, double y, double z, double... xyzvals)` vector array
    `static IVec` | `vec(IDoubleI x, IDoubleI y)`
    `static IVec` | `vec(IDoubleI x, IDoubleI y, IDoubleI z)`
    `static IVec[]` | `vec(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI... xyzvals)`
    `static IVec[]` | `vec(IVec... v)`
    `static IVec` | `vec(IVec v)`
    `static IVec[][]` | `vec(IVec[]... v)`
    `static IVec[][][]` | `vec(IVec[][]... v)`
    `static IVec[]` | `vec(IVec2I... v)`
    `static IVec` | `vec(IVec2I v)`
    `static IVecI[]` | `vec(IVecI... v)`
    `static IVec` | `vec(IVecI v)`
    `static IVecI[][]` | `vec(IVecI[]... v)`
    `static IVecI[][][]` | `vec(IVecI[][]... v)`
    `static IVec2` | `vec2()` creating 2 dimensional vector
    `static IVec2` | `vec2(double x, double y)`
    `static IVec2[]` | `vec2(double x, double y, double... xyvals)` vector (IVec2) array
    `static IVec2` | `vec2(IDoubleI x, IDoubleI y)`
    `static IVec2[]` | `vec2(IDoubleI x, IDoubleI y, IDoubleI... xyvals)`
    `static IVec2[]` | `vec2(IVec... v)` IVec2 2d array from IVecI
    `static IVec2[]` | `vec2(IVec2... v)`
    `static IVec2` | `vec2(IVec2 v)`
    `static IVec2[][]` | `vec2(IVec2[]... v)` IVec2 2d array
    `static IVec2[][][]` | `vec2(IVec2[][]... v)` IVec2 3d array
    `static IVec2I[]` | `vec2(IVec2I... v)`
    `static IVec2I[][]` | `vec2(IVec2I[]... v)`
    `static IVec2I[][][]` | `vec2(IVec2I[][]... v)`
    `static IVec2I[]` | `vec2(IVecI... v)` IVec2 2d array from IVecI
    `static IVec2` | `vec2(IVecI v)`
    `static IVec4` | `vec4()` creating 4 dimensional vector with weight
    `static IVec4` | `vec4(double x, double y, double z, double w)`
    `static IVec4[]` | `vec4(double x, double y, double z, double w, double... xyzwvals)` vector (IVec4) array
    `static IVec4` | `vec4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w)`
    `static IVec4[]` | `vec4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w, IDoubleI... xyzwvals)`
    `static IVec4[]` | `vec4(IVec4... v)`
    `static IVec4` | `vec4(IVec4 v)`
    `static IVec4[][]` | `vec4(IVec4[]... v)` IVec4 2d array
    `static IVec4[][][]` | `vec4(IVec4[][]... v)` IVec4 3d array
    `static IVec4I[]` | `vec4(IVec4I... v)`
    `static IVec4I[][]` | `vec4(IVec4I[]... v)`
    `static IVec4I[][][]` | `vec4(IVec4I[][]... v)`
    `static IVec4` | `vec4(IVec v, double w)`
    `static IVec4` | `vec4(IVecI v)`
    `static IVec4` | `vec4(IVecI v, double w)`
    `static IVec4` | `vec4(IVecI v, IDoubleI w)`
    `static IVec` | `vector()` vector longer name
    `static IVec` | `vector(double x, double y)`
    `static IVec` | `vector(double x, double y, double z)`
    `static IVec[]` | `vector(double x, double y, double z, double... xyzvals)` vector array longer name
    `static IVec` | `vector(IDoubleI x, IDoubleI y)`
    `static IVec` | `vector(IDoubleI x, IDoubleI y, IDoubleI z)`
    `static IVec[]` | `vector(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI... xyzvals)`
    `static IVec[]` | `vector(IVec... v)`
    `static IVec` | `vector(IVec v)`
    `static IVec[][]` | `vector(IVec[]... v)`
    `static IVec[][][]` | `vector(IVec[][]... v)`
    `static IVec[]` | `vector(IVec2I... v)`
    `static IVec` | `vector(IVec2I v)`
    `static IVecI[]` | `vector(IVecI... v)`
    `static IVec` | `vector(IVecI v)`
    `static IVecI[][]` | `vector(IVecI[]... v)`
    `static IVecI[][][]` | `vector(IVecI[][]... v)`
    `static IVec2` | `vector2()` 2d vector longer name
    `static IVec2` | `vector2(double x, double y)`
    `static IVec2[]` | `vector2(double x, double y, double... xyvals)`
    `static IVec2` | `vector2(IDoubleI x, IDoubleI y)`
    `static IVec2[]` | `vector2(IDoubleI x, IDoubleI y, IDoubleI... xyvals)`
    `static IVec2[]` | `vector2(IVec2... v)`
    `static IVec2` | `vector2(IVec2 v)`
    `static IVec2[][]` | `vector2(IVec2[]... v)` IVec4 2d array
    `static IVec2[][][]` | `vector2(IVec2[][]... v)` IVec4 3d array
    `static IVec2I[]` | `vector2(IVec2I... v)`
    `static IVec2I[][]` | `vector2(IVec2I[]... v)`
    `static IVec2I[][][]` | `vector2(IVec2I[][]... v)`
    `static IVec2` | `vector2(IVecI v)`
    `static IVec4` | `vector4()` 4d vector longer name
    `static IVec4` | `vector4(double x, double y, double z, double w)`
    `static IVec4[]` | `vector4(double x, double y, double z, double w, double... xyzwvals)`
    `static IVec4` | `vector4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w)`
    `static IVec4[]` | `vector4(IDoubleI x, IDoubleI y, IDoubleI z, IDoubleI w, IDoubleI... xyzwvals)`
    `static IVec4[]` | `vector4(IVec4... v)`
    `static IVec4` | `vector4(IVec4 v)`
    `static IVec4[][]` | `vector4(IVec4[]... v)` IVec4 2d array
    `static IVec4[][][]` | `vector4(IVec4[][]... v)` IVec4 3d array
    `static IVec4I[]` | `vector4(IVec4I... v)`
    `static IVec4I[][]` | `vector4(IVec4I[]... v)`
    `static IVec4I[][][]` | `vector4(IVec4I[][]... v)`
    `static IVec4` | `vector4(IVec v, double w)`
    `static IVec4` | `vector4(IVecI v)`
    `static IVec4` | `vector4(IVecI v, double w)`
    `static IVec4` | `vector4(IVecI v, IDoubleI w)`
    `static java.lang.String` | `version()`
    `static java.util.Calendar` | `versionDate()`
    `static IView` | `view(int paneIndex)`
    `static java.util.ArrayList<IObject>` | `weight(java.util.ArrayList<IObject> objs, double w)`
    `static java.util.ArrayList<IObject>` | `weight(java.util.ArrayList<IObject> objs, float w)`
    `static IObject[]` | `weight(IObject[] objs, double w)`
    `static IObject[]` | `weight(IObject[] objs, float w)`
    `static IObject` | `weight(IObject obj, double w)`
    `static IObject` | `weight(IObject obj, float w)`
    `static void` | `whiteBG()`
    `static void` | `wire()` alias of wireframe()
    `static void` | `wireFill()` set fill+wireframe graphic mode
    `static void` | `wireframe()` set wireframe graphic mode
    `static void` | `wireframeFill()` set fill+wireframe graphic mode
    `static void` | `wireframeTransparent()` set transparent fill+wireframe graphic mode
    `static void` | `wireTrans()` alias of wireframeTransparent()

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

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

- - ### Field Detail

    - #### lock

          public static final java.lang.Object lock

      static system variables

    - #### GL1

          public static final java.lang.String GL1

      Processing Graphics using OpenGL to be put in size() method in Processing
      See Also:
        Constant Field Values

    - #### GL2

          public static final java.lang.String GL2

      See Also:
        Constant Field Values

    - #### GL3

          public static final java.lang.String GL3

      See Also:
        Constant Field Values

    - #### GL

          public static final java.lang.String GL

      See Also:
        Constant Field Values

    - #### P3D

          public static final java.lang.String P3D

      Processing Graphics using P3D to be put in size() method in Processing; under development. do not use yet.
      See Also:
        Constant Field Values

    - #### P3

          public static final java.lang.String P3

      alias of IG.P3D
      See Also:
        Constant Field Values

    - #### P

          public static final java.lang.String P

      alias of IG.P3D
      See Also:
        Constant Field Values

    - #### iglist

          protected static java.util.ArrayList<IG> iglist

      multiple IG instances are stored in iglist and switched by IG static methods in case of applet execution or other occasion but handling of multiple IG instances and switching are not really tested.

    - #### currentId

          protected static int currentId

    - #### xaxis

          public static final IVec xaxis

      x-axis vector. do not modify the content.

    - #### yaxis

          public static final IVec yaxis

      y-axis vector. do not modify the content.

    - #### zaxis

          public static final IVec zaxis

      z-axis vector. do not modify the content.

    - #### origin

          public static final IVec origin

      origin vector. do not modify the content.

    - #### x

          public static final IVec x

      alias of x-axis vector

    - #### y

          public static final IVec y

      alias of y-axis vector

    - #### z

          public static final IVec z

      alias of z-axis vector

    - #### o

          public static final IVec o

      alias of origin vector

    - #### server

          public IServer server

      object variables

    - #### panel

          public IPanelI panel

    - #### inputFile

          public java.lang.String inputFile

    - #### outputFile

          public java.lang.String outputFile

    - #### basePath

          public java.lang.String basePath

      base file path for file I/O

    - #### inputWrapper

          public IInputWrapper inputWrapper

      wrapping inputs in different environment. replacing basePath.

    - #### online

          public boolean online

      if it's applet. online == true

  - ### Constructor Detail

    - #### IG

          public IG()

      object methods

    - #### IG

          public IG(IPanelI p)

  - ### Method Detail

    - #### majorVersion

          public static int majorVersion()

    - #### minorVersion

          public static int minorVersion()

    - #### buildVersion

          public static int buildVersion()

    - #### revisionVersion

          public static int revisionVersion()

    - #### versionDate

          public static java.util.Calendar versionDate()

    - #### version

          public static java.lang.String version()

    - #### init

          public static IG init()

      Initialize whole IG system in non-graphic mode.

    - #### init

          public static IG init(IPanelI owner)

      Initialize whole IG system in graphic mode. Please instantiate IPanel beforehand.

    - #### current

          public static IG current()

      alias of cur()

    - #### cur

          public static IG cur()

      Find the IG instance which is likely to be the current.

    - #### defaultThread

          public static IG defaultThread()

      object to be used to lock in "synchronized" statement

    - #### dynamicThread

          public static IDynamicServer dynamicThread()

      object to be used to lock in "synchronized" statement

    - #### updateThread

          public static IDynamicServer updateThread()

      alias of dynamicThread()

    - #### setCurrent

          public static void setCurrent(IG ig)

    - #### setCurrent

          public static void setCurrent(IPanelI owner)

    - #### getIG

          public static IG getIG(IPanelI owner)

      Find IG instance linked with the specified IPanel instance.

    - #### open

          public static IObject[] open(java.lang.String file)

    - #### save

          public static boolean save(java.lang.String file)

    - #### duration

          public static void duration(int dur)

      set duration of dynamics update

    - #### duration

          public static int duration()

      get duration of dynamics update

    - #### time

          public static void time(int tm)

      set current time count of dynamics update. recommeded not to chage time.

    - #### time

          public static int time()

      get current time count of dynamics update

    - #### pause

          public static void pause()

      pause dynamics update.

    - #### resume

          public static void resume()

      resume dynamics update.

    - #### isRunning

          public static boolean isRunning()

      check if dynamics is running

    - #### start

          public static void start()

      start dynamics update. if IConfig.autoStart is true, this should not be used.

    - #### stop

          public static void stop()

      stop dynamics update. recommended not to use this because stopping should be done by setting duration.

    - #### updateRate

          public static void updateRate(double second)

      setting update rate time interval in second

    - #### updateSpeed

          public static void updateSpeed(double second)

      alias of updateRate()

    - #### rate

          public static void rate(double second)

      alias of updateRate()

    - #### speed

          public static void speed(double second)

      alias of updateRate()

    - #### updateRate

          public static double updateRate()

      getting update rate time interval in second

    - #### updateSpeed

          public static double updateSpeed()

      alias of updateRate()

    - #### rate

          public static double rate()

      alias of updateRate()

    - #### speed

          public static double speed()

      alias of updateRate()

    - #### unit

          public static IUnit unit()

      getting unit of current IG server

    - #### unit

          public static void unit(IUnit u)

      setting unit of current IG server

    - #### unit

          public static void unit(IUnit.Type u)

      setting unit of current IG server

    - #### unit

          public static void unit(java.lang.String unitName)

      setting unit of current IG server

    - #### outputFile

          public static void outputFile(java.lang.String filename)

      to set the name first and save later (likely by key event)

    - #### outputFile

          public static java.lang.String outputFile()

    - #### inputFile

          public static void inputFile(java.lang.String filename)

    - #### inputFile

          public static java.lang.String inputFile()

    - #### points

          public static IPoint[] points()

      get all points in the current server

    - #### pts

          public static IPoint[] pts()

      get all points in the current server; alias

    - #### curves

          public static ICurve[] curves()

      get all curves in the current server

    - #### crvs

          public static ICurve[] crvs()

      get all curves in the current server; alias

    - #### polycurves

          public static IPolycurve[] polycurves()

      get all curves in the current server Note that IPolycurve contains multiple ICurve and they show up in curves() as well. ICurve - IPolycurve relationship is still under work. This is temporary measure.

    - #### surfaces

          public static ISurface[] surfaces()

      get all surfaces in the current server

    - #### srfs

          public static ISurface[] srfs()

      get all surfaces in the current server; alias

    - #### meshes

          public static IMesh[] meshes()

      get all meshes in the current server

    - #### breps

          public static IBrep[] breps()

      get all breps in the current server

    - #### texts

          public static IText[] texts()

      get all texts in the current server

    - #### geometries

          public static IGeometry[] geometries()

      get all geometry objects in the current server

    - #### geos

          public static IGeometry[] geos()

      get all geometry objects in the current server

    - #### objects

          public static IObject[] objects(java.lang.Class cls)

      get all objects of the specified class in the current server

    - #### objs

          public static IObject[] objs(java.lang.Class cls)

      get all objects of the specified class in the current server; alias

    - #### objects

          public static IObject[] objects()

      get all objects in the current server

    - #### objs

          public static IObject[] objs()

      get all objects in the current server; alias

    - #### point

          public static IPoint point(int i)

      get a point in the current server

    - #### pt

          public static IPoint pt(int i)

      get a point in the current server; alias

    - #### curve

          public static ICurve curve(int i)

      get a curve in the current server

    - #### crv

          public static ICurve crv(int i)

      get a curve in the current server; alias

    - #### polycurve

          public static IPolycurve polycurve(int i)

      get a polycurve in the current server Note that IPolycurve contains multiple ICurve and they show up in curves() as well. ICurve - IPolycurve relationship is still under work. This is temporary measure.

    - #### surface

          public static ISurface surface(int i)

      get a surface in the current server

    - #### srf

          public static ISurface srf(int i)

      get a surface in the current server; alias

    - #### mesh

          public static IMesh mesh(int i)

      get a mesh in the current server

    - #### brep

          public static IBrep brep(int i)

      get a brep in the current server

    - #### text

          public static IText text(int i)

      get a text in the current server

    - #### geometry

          public static IGeometry geometry(int i)

      get a geometry in the current server

    - #### geo

          public static IGeometry geo(int i)

      get a geometry in the current server

    - #### object

          public static IObject object(java.lang.Class cls,
                                       int i)

      get a object of the specified class in the current server

    - #### obj

          public static IObject obj(java.lang.Class cls,
                                    int i)

      get a object of the specified class in the current server; alias

    - #### object

          public static IObject object(int i)

      get a object in the current server

    - #### obj

          public static IObject obj(int i)

      get a object in the current server; alias

    - #### pointNum

          public static int pointNum()

      number of points in the current server

    - #### ptNum

          public static int ptNum()

      number of points in the current server; alias

    - #### curveNum

          public static int curveNum()

      number of curves in the current server

    - #### crvNum

          public static int crvNum()

      number of curves in the current server; alias

    - #### polycurveNum

          public static int polycurveNum()

      number of polycurves in the current server. Note that IPolycurve contains multiple ICurve and they show up in curves() as well. ICurve - IPolycurve relationship is still under work. This is temporary measure.

    - #### surfaceNum

          public static int surfaceNum()

      number of surfaces in the current server

    - #### srfNum

          public static int srfNum()

      number of surfaces in the current server; alias

    - #### meshNum

          public static int meshNum()

      number of meshes in the current server

    - #### brepNum

          public static int brepNum()

      number of breps in the current server

    - #### textNum

          public static int textNum()

      number of texts in the current server

    - #### geometryNum

          public static int geometryNum()

      number of geometries in the cubrrent server

    - #### geoNum

          public static int geoNum()

      alias of geometryNum()

    - #### objectNum

          public static int objectNum(java.lang.Class cls)

      number of objects of the specified class in the current server

    - #### objNum

          public static int objNum(java.lang.Class cls)

      number of objects of the specified class in the current server; alias

    - #### objectNum

          public static int objectNum()

      number of objects in the current server

    - #### objNum

          public static int objNum()

      number of objects in the current server; alias

    - #### del

          public static void del(IObject o)

    - #### del

          public static void del(IObject[] o)

    - #### del

          public static void del(java.util.ArrayList<IObject> o)

    - #### del

          public static void del(java.lang.Class cls)

    - #### delAll

          public static void delAll()

    - #### clear

          public static void clear()

    - #### layer

          public static ILayer layer(java.lang.String layerName)

    - #### layer

          public static ILayer layer(int i)

    - #### layers

          public static ILayer[] layers()

    - #### delLayer

          public static void delLayer(java.lang.String layerName)

    - #### delLayer

          public static void delLayer(ILayer layer)

    - #### layerNum

          public static int layerNum()

    - #### focus

          public static void focus()

    - #### isGL

          public static boolean isGL()

    - #### graphicMode

          public static void graphicMode(IGraphicMode mode)

    - #### wireframe

          public static void wireframe()

      set wireframe graphic mode

    - #### wire

          public static void wire()

      alias of wireframe()

    - #### fill

          public static void fill()

      set fill graphic mode

    - #### fillWithWireframe

          public static void fillWithWireframe()

      set fill+wireframe graphic mode

    - #### fillWireframe

          public static void fillWireframe()

      set fill+wireframe graphic mode

    - #### fillWire

          public static void fillWire()

      set fill+wireframe graphic mode

    - #### wireframeFill

          public static void wireframeFill()

      set fill+wireframe graphic mode

    - #### wireFill

          public static void wireFill()

      set fill+wireframe graphic mode

    - #### transparentFill

          public static void transparentFill()

      set transparent fill graphic mode

    - #### transFill

          public static void transFill()

      set transparent fill graphic mode

    - #### transparent

          public static void transparent()

      set transparent fill graphic mode

    - #### trans

          public static void trans()

      alias of transparent()

    - #### transparentFillWithWireframe

          public static void transparentFillWithWireframe()

      set transparent fill+wireframe graphic mode

    - #### transparentWireframe

          public static void transparentWireframe()

      set transparent fill+wireframe graphic mode

    - #### wireframeTransparent

          public static void wireframeTransparent()

      set transparent fill+wireframe graphic mode

    - #### wireTrans

          public static void wireTrans()

      alias of wireframeTransparent()

    - #### transWire

          public static void transWire()

      alias of wireframeTransparent()

    - #### noGraphic

          public static void noGraphic()

    - #### view

          public static IView view(int paneIndex)

    - #### gridPane

          public static IPane gridPane(int xindex,
                                       int yindex)

      put the specified pane on the full screen inside the window if the panel is IGridPanel with 2x2 grid

    - #### disableFullScreen

          public static void disableFullScreen()

      put the specified pane on the full screen inside the window if the panel is IGridPanel with 2x2 grid

    - #### topPane

          public static IPane topPane()

      put top pane on the full screen inside the window if the panel is IGridPanel

    - #### bottomPane

          public static IPane bottomPane()

      bottom pane is identical with top pane in IGridPanel

    - #### perspectivePane

          public static IPane perspectivePane()

      put perspective pane on the full screen inside the window if the panel is IGridPanel

    - #### axonometricPane

          public static IPane axonometricPane()

      axonometric pane is identical with perspective pane in IGridPanel

    - #### frontPane

          public static IPane frontPane()

      put front pane on the full screen inside the window if the panel is IGridPanel

    - #### backPane

          public static IPane backPane()

      back pane is identical with front pane in IGridPanel

    - #### rightPane

          public static IPane rightPane()

      put right pane on the full screen inside the window if the panel is IGridPanel

    - #### leftPane

          public static IPane leftPane()

      left pane is identical with front pane in IGridPanel

    - #### top

          public static void top()

      put top view on the full screen inside the window

    - #### top

          public static void top(double x,
                                 double y)

    - #### top

          public static void top(double x,
                                 double y,
                                 double z)

    - #### top

          public static void top(double x,
                                 double y,
                                 double z,
                                 double axonRatio)

    - #### topView

          public static void topView()

    - #### topView

          public static void topView(double x,
                                     double y)

    - #### topView

          public static void topView(double x,
                                     double y,
                                     double z)

    - #### topView

          public static void topView(double x,
                                     double y,
                                     double z,
                                     double axonRatio)

    - #### topPos

          public static IVec topPos()

      get camera position in top view pane

    - #### topDir

          public static IVec topDir()

      get camera direction vector in top view pane

    - #### topTarget

          public static IVec topTarget()

      get camera target position in top view pane

    - #### topYaw

          public static double topYaw()

      get camera direction yaw angle in top view pane

    - #### topPitch

          public static double topPitch()

      get camera direction pitch angle in top view pane

    - #### topRoll

          public static double topRoll()

      get camera direction roll angle in top view pane

    - #### bottom

          public static void bottom()

      put bottom view on the full screen inside the window

    - #### bottom

          public static void bottom(double x,
                                    double y)

    - #### bottom

          public static void bottom(double x,
                                    double y,
                                    double z)

    - #### bottom

          public static void bottom(double x,
                                    double y,
                                    double z,
                                    double axonRatio)

    - #### bottomView

          public static void bottomView()

    - #### bottomView

          public static void bottomView(double x,
                                        double y)

    - #### bottomView

          public static void bottomView(double x,
                                        double y,
                                        double z)

    - #### bottomView

          public static void bottomView(double x,
                                        double y,
                                        double z,
                                        double axonRatio)

    - #### bottomPos

          public static IVec bottomPos()

      get camera position in bottom view pane

    - #### bottomDir

          public static IVec bottomDir()

      get camera direction vector in bottom view pane

    - #### bottomTarget

          public static IVec bottomTarget()

      get camera target position in bottom view pane

    - #### bottomYaw

          public static double bottomYaw()

      get camera direction yaw angle in bottom view pane

    - #### bottomPitch

          public static double bottomPitch()

      get camera direction pitch angle in bottom view pane

    - #### bottomRoll

          public static double bottomRoll()

      get camera direction roll angle in bottom view pane

    - #### perspective

          public static void perspective()

      put perspective view on the full screen inside the window

    - #### perspective

          public static void perspective(double x,
                                         double y,
                                         double z)

    - #### perspective

          public static void perspective(double x,
                                         double y,
                                         double z,
                                         double yaw,
                                         double pitch)

    - #### perspective

          public static void perspective(IVecI pos,
                                         IVecI dir)

    - #### perspectiveView

          public static void perspectiveView()

    - #### perspectiveView

          public static void perspectiveView(double x,
                                             double y,
                                             double z)

    - #### perspectiveView

          public static void perspectiveView(double x,
                                             double y,
                                             double z,
                                             double yaw,
                                             double pitch)

    - #### perspectiveView

          public static void perspectiveView(IVecI pos,
                                             IVecI dir)

    - #### pers

          public static void pers()

    - #### pers

          public static void pers(double x,
                                  double y,
                                  double z)

    - #### pers

          public static void pers(double x,
                                  double y,
                                  double z,
                                  double yaw,
                                  double pitch)

    - #### pers

          public static void pers(IVecI pos,
                                  IVecI dir)

    - #### perspective

          public static void perspective(double perspectiveAngle)

      put perspective view on the full screen inside the window

    - #### perspective

          public static void perspective(double x,
                                         double y,
                                         double z,
                                         double perspectiveAngle)

    - #### perspective

          public static void perspective(double x,
                                         double y,
                                         double z,
                                         double yaw,
                                         double pitch,
                                         double perspectiveAngle)

    - #### perspective

          public static void perspective(IVecI pos,
                                         IVecI dir,
                                         double perspectiveAngle)

    - #### perspectiveView

          public static void perspectiveView(double perspectiveAngle)

    - #### perspectiveView

          public static void perspectiveView(double x,
                                             double y,
                                             double z,
                                             double perspectiveAngle)

    - #### perspectiveView

          public static void perspectiveView(double x,
                                             double y,
                                             double z,
                                             double yaw,
                                             double pitch,
                                             double perspectiveAngle)

    - #### perspectiveView

          public static void perspectiveView(IVecI pos,
                                             IVecI dir,
                                             double perspectiveAngle)

    - #### pers

          public static void pers(double perspectiveAngle)

    - #### pers

          public static void pers(double x,
                                  double y,
                                  double z,
                                  double perspectiveAngle)

    - #### pers

          public static void pers(double x,
                                  double y,
                                  double z,
                                  double yaw,
                                  double pitch,
                                  double perspectiveAngle)

    - #### pers

          public static void pers(IVecI pos,
                                  IVecI dir,
                                  double perspectiveAngle)

    - #### getViewPos

          public static IVec getViewPos(IPane pane)

      get camera position out of pane

    - #### getViewDir

          public static IVec getViewDir(IPane pane)

      get camera direction out of pane

    - #### getViewTarget

          public static IVec getViewTarget(IPane pane)

      get camera target position out of pane

    - #### getViewYaw

          public static double getViewYaw(IPane pane)

      get camera directio yaw angle out of pane

    - #### getViewPitch

          public static double getViewPitch(IPane pane)

      get camera directio pitch angle out of pane

    - #### getViewRoll

          public static double getViewRoll(IPane pane)

      get camera directio roll angle out of pane

    - #### persPos

          public static IVec persPos()

      get camera position in perspective view pane

    - #### persDir

          public static IVec persDir()

      get camera direction vector in perspective view pane

    - #### persTarget

          public static IVec persTarget()

      get camera target position in perspective view pane

    - #### persYaw

          public static double persYaw()

      get camera direction yaw angle in perspective view pane

    - #### persPitch

          public static double persPitch()

      get camera direction pitch angle in perspective view pane

    - #### persRoll

          public static double persRoll()

      get camera direction roll angle in perspective view pane

    - #### axonometric

          public static void axonometric()

      put axonometric view on the full screen inside the window

    - #### axonometric

          public static void axonometric(double x,
                                         double y,
                                         double z)

    - #### axonometric

          public static void axonometric(double x,
                                         double y,
                                         double z,
                                         double axonRatio)

    - #### axonometric

          public static void axonometric(double x,
                                         double y,
                                         double z,
                                         double yaw,
                                         double pitch)

    - #### axonometric

          public static void axonometric(double x,
                                         double y,
                                         double z,
                                         double yaw,
                                         double pitch,
                                         double axonRatio)

    - #### axonometric

          public static void axonometric(IVecI pos,
                                         IVecI dir)

    - #### axonometric

          public static void axonometric(IVecI pos,
                                         IVecI dir,
                                         double axonRatio)

    - #### axonometricView

          public static void axonometricView()

    - #### axonometricView

          public static void axonometricView(double x,
                                             double y,
                                             double z)

    - #### axonometricView

          public static void axonometricView(double x,
                                             double y,
                                             double z,
                                             double axonRatio)

    - #### axonometricView

          public static void axonometricView(double x,
                                             double y,
                                             double z,
                                             double yaw,
                                             double pitch)

    - #### axonometricView

          public static void axonometricView(double x,
                                             double y,
                                             double z,
                                             double yaw,
                                             double pitch,
                                             double axonRatio)

    - #### axonometricView

          public static void axonometricView(IVecI pos,
                                             IVecI dir)

    - #### axonometricView

          public static void axonometricView(IVecI pos,
                                             IVecI dir,
                                             double axonRatio)

    - #### axon

          public static void axon()

    - #### axon

          public static void axon(double x,
                                  double y,
                                  double z)

    - #### axon

          public static void axon(double x,
                                  double y,
                                  double z,
                                  double axonRatio)

    - #### axon

          public static void axon(double x,
                                  double y,
                                  double z,
                                  double yaw,
                                  double pitch)

    - #### axon

          public static void axon(double x,
                                  double y,
                                  double z,
                                  double yaw,
                                  double pitch,
                                  double axonRatio)

    - #### axon

          public static void axon(IVecI pos,
                                  IVecI dir)

    - #### axon

          public static void axon(IVecI pos,
                                  IVecI dir,
                                  double axonRatio)

    - #### axonPos

          public static IVec axonPos()

      get camera position in axonometric view pane (same pane with perspective pane)

    - #### axonDir

          public static IVec axonDir()

      get camera direction vector in axonometric view pane (same pane with perspective pane)

    - #### axonTarget

          public static IVec axonTarget()

      get camera target position in axonometric view pane (same pane with perspective pane)

    - #### axonYaw

          public static double axonYaw()

      get camera direction yaw angle in axonometric view pane (same pane with perspective pane)

    - #### axonPitch

          public static double axonPitch()

      get camera direction pitch angle in axonometric view pane (same pane with perspective pane)

    - #### axonRoll

          public static double axonRoll()

      get camera direction roll angle in axonometric view pane (same pane with perspective pane)

    - #### front

          public static void front()

      put front view on the full screen inside the window

    - #### front

          public static void front(double x,
                                   double z)

    - #### front

          public static void front(double x,
                                   double y,
                                   double z)

    - #### front

          public static void front(double x,
                                   double y,
                                   double z,
                                   double axonRatio)

    - #### frontView

          public static void frontView()

    - #### frontView

          public static void frontView(double x,
                                       double z)

    - #### frontView

          public static void frontView(double x,
                                       double y,
                                       double z)

    - #### frontView

          public static void frontView(double x,
                                       double y,
                                       double z,
                                       double axonRatio)

    - #### frontPos

          public static IVec frontPos()

      get camera position in front view pane

    - #### frontDir

          public static IVec frontDir()

      get camera direction vector in front view pane

    - #### frontTarget

          public static IVec frontTarget()

      get camera target position in front view pane

    - #### frontYaw

          public static double frontYaw()

      get camera direction yaw angle in front view pane

    - #### frontPitch

          public static double frontPitch()

      get camera direction pitch angle in front view pane

    - #### frontRoll

          public static double frontRoll()

      get camera direction roll angle in front view pane

    - #### back

          public static void back()

      put back view on the full screen inside the window

    - #### back

          public static void back(double x,
                                  double z)

    - #### back

          public static void back(double x,
                                  double y,
                                  double z)

    - #### back

          public static void back(double x,
                                  double y,
                                  double z,
                                  double axonRatio)

    - #### backView

          public static void backView()

    - #### backView

          public static void backView(double x,
                                      double z)

    - #### backView

          public static void backView(double x,
                                      double y,
                                      double z)

    - #### backView

          public static void backView(double x,
                                      double y,
                                      double z,
                                      double axonRatio)

    - #### backPos

          public static IVec backPos()

      get camera position in back view pane

    - #### backDir

          public static IVec backDir()

      get camera direction vector in back view pane

    - #### backTarget

          public static IVec backTarget()

      get camera target position in back view pane

    - #### backYaw

          public static double backYaw()

      get camera direction yaw angle in back view pane

    - #### backPitch

          public static double backPitch()

      get camera direction pitch angle in back view pane

    - #### backRoll

          public static double backRoll()

      get camera direction roll angle in back view pane

    - #### right

          public static void right()

      put right view on the full screen inside the window

    - #### right

          public static void right(double y,
                                   double z)

    - #### right

          public static void right(double x,
                                   double y,
                                   double z)

    - #### right

          public static void right(double x,
                                   double y,
                                   double z,
                                   double axonRatio)

    - #### rightView

          public static void rightView()

    - #### rightView

          public static void rightView(double y,
                                       double z)

    - #### rightView

          public static void rightView(double x,
                                       double y,
                                       double z)

    - #### rightView

          public static void rightView(double x,
                                       double y,
                                       double z,
                                       double axonRatio)

    - #### rightPos

          public static IVec rightPos()

      get camera position in right view pane

    - #### rightDir

          public static IVec rightDir()

      get camera direction vector in right view pane

    - #### rightTarget

          public static IVec rightTarget()

      get camera target position in right view pane

    - #### rightYaw

          public static double rightYaw()

      get camera direction yaw angle in right view pane

    - #### rightPitch

          public static double rightPitch()

      get camera direction pitch angle in right view pane

    - #### rightRoll

          public static double rightRoll()

      get camera direction roll angle in right view pane

    - #### left

          public static void left()

      put left view on the full screen inside the window

    - #### left

          public static void left(double y,
                                  double z)

    - #### left

          public static void left(double x,
                                  double y,
                                  double z)

    - #### left

          public static void left(double x,
                                  double y,
                                  double z,
                                  double axonRatio)

    - #### leftView

          public static void leftView()

    - #### leftView

          public static void leftView(double y,
                                      double z)

    - #### leftView

          public static void leftView(double x,
                                      double y,
                                      double z)

    - #### leftView

          public static void leftView(double x,
                                      double y,
                                      double z,
                                      double axonRatio)

    - #### leftPos

          public static IVec leftPos()

      get camera position in left view pane

    - #### leftDir

          public static IVec leftDir()

      get camera direction vector in left view pane

    - #### leftTarget

          public static IVec leftTarget()

      get camera target position in left view pane

    - #### leftYaw

          public static double leftYaw()

      get camera direction yaw angle in left view pane

    - #### leftPitch

          public static double leftPitch()

      get camera direction pitch angle in left view pane

    - #### leftRoll

          public static double leftRoll()

      get camera direction roll angle in left view pane

    - #### bg

          public static void bg(IColor c1,
                                IColor c2,
                                IColor c3,
                                IColor c4)

      background color

    - #### background

          public static void background(IColor c1,
                                        IColor c2,
                                        IColor c3,
                                        IColor c4)

    - #### bg

          public static void bg(java.awt.Color c1,
                                java.awt.Color c2,
                                java.awt.Color c3,
                                java.awt.Color c4)

    - #### background

          public static void background(java.awt.Color c1,
                                        java.awt.Color c2,
                                        java.awt.Color c3,
                                        java.awt.Color c4)

    - #### bg

          public static void bg(java.awt.Color c)

    - #### background

          public static void background(java.awt.Color c)

    - #### bg

          public static void bg(java.lang.String imageFilename)

    - #### background

          public static void background(java.lang.String imageFilename)

    - #### defaultBG

          public static void defaultBG()

    - #### blueBG

          public static void blueBG()

    - #### lightBG

          public static void lightBG()

    - #### darkBG

          public static void darkBG()

    - #### whiteBG

          public static void whiteBG()

    - #### blackBG

          public static void blackBG()

    - #### bg

          public static void bg(int r1,
                                int g1,
                                int b1,
                                int r2,
                                int g2,
                                int b2,
                                int r3,
                                int g3,
                                int b3,
                                int r4,
                                int g4,
                                int b4)

    - #### background

          public static void background(int r1,
                                        int g1,
                                        int b1,
                                        int r2,
                                        int g2,
                                        int b2,
                                        int r3,
                                        int g3,
                                        int b3,
                                        int r4,
                                        int g4,
                                        int b4)

    - #### bg

          public static void bg(int r,
                                int g,
                                int b)

    - #### background

          public static void background(int r,
                                        int g,
                                        int b)

    - #### bg

          public static void bg(int gray1,
                                int gray2,
                                int gray3,
                                int gray4)

    - #### background

          public static void background(int gray1,
                                        int gray2,
                                        int gray3,
                                        int gray4)

    - #### bg

          public static void bg(int gray)

    - #### background

          public static void background(int gray)

    - #### bg

          public static void bg(float r1,
                                float g1,
                                float b1,
                                float r2,
                                float g2,
                                float b2,
                                float r3,
                                float g3,
                                float b3,
                                float r4,
                                float g4,
                                float b4)

    - #### background

          public static void background(float r1,
                                        float g1,
                                        float b1,
                                        float r2,
                                        float g2,
                                        float b2,
                                        float r3,
                                        float g3,
                                        float b3,
                                        float r4,
                                        float g4,
                                        float b4)

    - #### bg

          public static void bg(float r,
                                float g,
                                float b)

    - #### background

          public static void background(float r,
                                        float g,
                                        float b)

    - #### bg

          public static void bg(float gray1,
                                float gray2,
                                float gray3,
                                float gray4)

    - #### background

          public static void background(float gray1,
                                        float gray2,
                                        float gray3,
                                        float gray4)

    - #### bg

          public static void bg(float gray)

    - #### background

          public static void background(float gray)

    - #### bg

          public static void bg(double r1,
                                double g1,
                                double b1,
                                double r2,
                                double g2,
                                double b2,
                                double r3,
                                double g3,
                                double b3,
                                double r4,
                                double g4,
                                double b4)

    - #### background

          public static void background(double r1,
                                        double g1,
                                        double b1,
                                        double r2,
                                        double g2,
                                        double b2,
                                        double r3,
                                        double g3,
                                        double b3,
                                        double r4,
                                        double g4,
                                        double b4)

    - #### bg

          public static void bg(double r,
                                double g,
                                double b)

    - #### background

          public static void background(double r,
                                        double g,
                                        double b)

    - #### bg

          public static void bg(double gray1,
                                double gray2,
                                double gray3,
                                double gray4)

    - #### background

          public static void background(double gray1,
                                        double gray2,
                                        double gray3,
                                        double gray4)

    - #### bg

          public static void bg(double gray)

    - #### background

          public static void background(double gray)

    - #### p

          public static void p(java.lang.Object obj)

      Print method with header and new line. This is a wrapper of IOut.p(), which is also a wrapper of System.out.println().

    - #### p

          public static void p()

      Print method only with header and new line.

    - #### print

          public static void print(java.lang.Object obj)

      Print method without header nor new line This is a wrapper of IOut.p(), which is also a wrapper of System.out.print().

    - #### enabePrintPrefix

          public static void enabePrintPrefix()

      enable print prefix (executing method name)

    - #### disablePrintPrefix

          public static void disablePrintPrefix()

      disble print prefix (executing method name)

    - #### err

          public static void err(java.lang.Object obj)

      Error print method with header and new line. This is a wrapper of IOut.err()

    - #### err

          public static void err()

      Error print method only with header and new line.

    - #### error

          public static void error(java.lang.Object obj)

      Error print method without header nor new line.

    - #### enabeErrorPrefix

          public static void enabeErrorPrefix()

      enable error print prefix (executing method name)

    - #### disableErrorPrefix

          public static void disableErrorPrefix()

      disable error print prefix (executing method name)

    - #### debugLevel

          public static void debugLevel(int level)

      change the debug level of IOut

    - #### debug

          public static void debug(int level)

      alias of debugLevel

    - #### debug

          public static void debug()

      turns on all debug output

    - #### debugLevel

          public static int debugLevel()

      returns the current debugLevel

    - #### showTime

          public static void showTime()

      enable printing time to console

    - #### showTime

          public static void showTime(boolean flag)

      enable/disable printing time to console

    - #### setPrint

          public static void setPrint(IPrintWrapper pw)

      redirect print to print wrapper

    - #### setPrint

          public static void setPrint(IPrintWrapper pw,
                                      IPrintWrapper errpw)

      redirect print to print wrapper

    - #### setPrint

          public static void setPrint(IPrintWrapper pw,
                                      IPrintWrapper errpw,
                                      IPrintWrapper debugpw)

      redirect print to print wrapper

    - #### setPrintStream

          public static void setPrintStream(java.io.PrintStream ps)

      redirect print to print stream

    - #### setPrintStream

          public static void setPrintStream(java.io.PrintStream ps,
                                            java.io.PrintStream errps)

      redirect print to print stream

    - #### setPrintStream

          public static void setPrintStream(java.io.PrintStream ps,
                                            java.io.PrintStream errps,
                                            java.io.PrintStream debugps)

      redirect print to print stream

    - #### openFile

          public java.util.ArrayList<IObject> openFile(java.lang.String file)

    - #### formatOutputFilePath

          public java.lang.String formatOutputFilePath(java.lang.String file)

    - #### saveFile

          public boolean saveFile(java.lang.String file)

    - #### save

          public boolean save()

    - #### setInputFile

          public void setInputFile(java.lang.String filename)

    - #### setOutputFile

          public void setOutputFile(java.lang.String filename)

    - #### getInputFile

          public java.lang.String getInputFile()

    - #### getOutputFile

          public java.lang.String getOutputFile()

    - #### getBasePath

          public java.lang.String getBasePath()

    - #### setBasePath

          public java.lang.String setBasePath(java.lang.String path)

    - #### setOnline

          public void setOnline(boolean f)

    - #### isOnline

          public boolean isOnline()

    - #### setInputWrapper

          public void setInputWrapper(IInputWrapper wrapper)

    - #### getLayer

          public ILayer getLayer(java.lang.String layerName)

    - #### getLayer

          public ILayer getLayer(int i)

    - #### getAllLayers

          public ILayer[] getAllLayers()

    - #### deleteLayer

          public void deleteLayer(java.lang.String layerName)

    - #### deleteLayer

          public void deleteLayer(ILayer layer)

    - #### getLayerNum

          public int getLayerNum()

    - #### getPoints

          public IPoint[] getPoints()

    - #### getCurves

          public ICurve[] getCurves()

    - #### getPolycurves

          public IPolycurve[] getPolycurves()

    - #### getSurfaces

          public ISurface[] getSurfaces()

    - #### getMeshes

          public IMesh[] getMeshes()

    - #### getBreps

          public IBrep[] getBreps()

    - #### getTexts

          public IText[] getTexts()

    - #### getGeometries

          public IGeometry[] getGeometries()

    - #### getObjects

          public IObject[] getObjects(java.lang.Class cls)

    - #### getObjects

          public IObject[] getObjects()

    - #### getPoint

          public IPoint getPoint(int i)

    - #### getCurve

          public ICurve getCurve(int i)

    - #### getPolycurve

          public IPolycurve getPolycurve(int i)

    - #### getSurface

          public ISurface getSurface(int i)

    - #### getMesh

          public IMesh getMesh(int i)

    - #### getBrep

          public IBrep getBrep(int i)

    - #### getText

          public IText getText(int i)

    - #### getGeometry

          public IGeometry getGeometry(int i)

    - #### getObject

          public IObject getObject(java.lang.Class cls,
                                   int i)

    - #### getObject

          public IObject getObject(int i)

    - #### getPointNum

          public int getPointNum()

    - #### getCurveNum

          public int getCurveNum()

    - #### getPolycurveNum

          public int getPolycurveNum()

    - #### getSurfaceNum

          public int getSurfaceNum()

    - #### getMeshNum

          public int getMeshNum()

    - #### getBrepNum

          public int getBrepNum()

    - #### getTextNum

          public int getTextNum()

    - #### getGeometryNum

          public int getGeometryNum()

    - #### getObjectNum

          public int getObjectNum(java.lang.Class cls)

    - #### getObjectNum

          public int getObjectNum()

    - #### focusView

          public void focusView()

    - #### server

          public IServer server()

      Specified by:
        `server` in interface `IServerI`

    - #### dynamicServer

          public IDynamicServer dynamicServer()

    - #### setDuration

          public void setDuration(int dur)

    - #### getDuration

          public int getDuration()

    - #### setTime

          public void setTime(int tm)

    - #### getTime

          public int getTime()

    - #### pauseDynamics

          public void pauseDynamics()

    - #### resumeDynamics

          public void resumeDynamics()

    - #### isDynamicsRunning

          public boolean isDynamicsRunning()

      check if dynamics is running

    - #### startDynamics

          public void startDynamics()

    - #### stopDynamics

          public void stopDynamics()

    - #### clearServer

          public void clearServer()

    - #### point

          public static IPoint point(IVecI v)

      point creation

    - #### point

          public static IPoint point(IVec v)

    - #### point

          public static IPoint point(double x,
                                     double y,
                                     double z)

    - #### point

          public static IPoint point(double x,
                                     double y)

    - #### pt

          public static IPoint pt(IVecI v)

      point creation shorter name

    - #### pt

          public static IPoint pt(IVec v)

    - #### pt

          public static IPoint pt(double x,
                                  double y,
                                  double z)

    - #### pt

          public static IPoint pt(double x,
                                  double y)

    - #### curve

          public static ICurve curve(IVecI[] cpts,
                                     int degree,
                                     double[] knots,
                                     double ustart,
                                     double uend)

    - #### curve

          public static ICurve curve(IVecI[] cpts,
                                     int degree,
                                     double[] knots)

    - #### curve

          public static ICurve curve(IVecI[] cpts,
                                     int degree)

    - #### curve

          public static ICurve curve(IVecI[] cpts)

    - #### curve

          public static ICurve curve(IVecI[] cpts,
                                     int degree,
                                     boolean close)

    - #### curve

          public static ICurve curve(IVecI[] cpts,
                                     boolean close)

    - #### curve

          public static ICurve curve(IVecI pt1,
                                     IVecI pt2)

    - #### curve

          public static ICurve curve(IVecI pt)

      this creates a line between a same point

    - #### curve

          public static ICurve curve(double x1,
                                     double y1,
                                     double z1,
                                     double x2,
                                     double y2,
                                     double z2)

    - #### curve

          public static ICurve curve(double[][] xyzValues)

    - #### curve

          public static ICurve curve(double[][] xyzValues,
                                     int degree)

    - #### curve

          public static ICurve curve(double[][] xyzValues,
                                     boolean close)

    - #### curve

          public static ICurve curve(double[][] xyzValues,
                                     int degree,
                                     boolean close)

    - #### curve

          public static ICurve curve(ICurveI crv)

    - #### crv

          public static ICurve crv(IVecI[] cpts,
                                   int degree,
                                   double[] knots,
                                   double ustart,
                                   double uend)

      curve short name : crv

    - #### crv

          public static ICurve crv(IVecI[] cpts,
                                   int degree,
                                   double[] knots)

    - #### crv

          public static ICurve crv(IVecI[] cpts,
                                   int degree)

    - #### crv

          public static ICurve crv(IVecI[] cpts)

    - #### crv

          public static ICurve crv(IVecI[] cpts,
                                   int degree,
                                   boolean close)

    - #### crv

          public static ICurve crv(IVecI[] cpts,
                                   boolean close)

    - #### crv

          public static ICurve crv(IVecI pt1,
                                   IVecI pt2)

    - #### crv

          public static ICurve crv(IVecI pt)

      this creates a line between a same point

    - #### crv

          public static ICurve crv(double x1,
                                   double y1,
                                   double z1,
                                   double x2,
                                   double y2,
                                   double z2)

    - #### crv

          public static ICurve crv(double[][] xyzValues)

    - #### crv

          public static ICurve crv(double[][] xyzValues,
                                   int degree)

    - #### crv

          public static ICurve crv(double[][] xyzValues,
                                   boolean close)

    - #### crv

          public static ICurve crv(double[][] xyzValues,
                                   int degree,
                                   boolean close)

    - #### crv

          public static ICurve crv(ICurveI crv)

    - #### line

          public static ICurve line(IVecI pt1,
                                    IVecI pt2)

      line : type of curve.

    - #### line

          public static ICurve line(IVecI pt)

      this creates a line between a same point

    - #### line

          public static ICurve line(double x1,
                                    double y1,
                                    double z1,
                                    double x2,
                                    double y2,
                                    double z2)

    - #### rect

          public static ICurve rect(IVecI corner,
                                    double xwidth,
                                    double yheight)

      rectangle

    - #### rect

          public static ICurve rect(IVecI corner,
                                    IVecI width,
                                    IVecI height)

    - #### rect

          public static ICurve rect(double x,
                                    double y,
                                    double z,
                                    double xwidth,
                                    double yheight)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IDoubleI radius)

      circle

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       double radius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IDoubleI radius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       double radius)

    - #### circle

          public static ICircle circle(double x,
                                       double y,
                                       double z,
                                       double radius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IDoubleI xradius,
                                       IDoubleI yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       double xradius,
                                       double yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IDoubleI xradius,
                                       IDoubleI yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       double xradius,
                                       double yradius)

    - #### circle

          public static ICircle circle(double x,
                                       double y,
                                       double z,
                                       double xradius,
                                       double yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       double radius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       IDoubleI radius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       double xradius,
                                       double yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       IDoubleI xradius,
                                       IDoubleI yradius)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI xradiusVec,
                                       IVecI yradiusVec)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IDoubleI radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       double radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IDoubleI radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       double radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(double x,
                                       double y,
                                       double z,
                                       double radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       double xradius,
                                       double yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IDoubleI xradius,
                                       IDoubleI yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       double xradius,
                                       double yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IDoubleI xradius,
                                       IDoubleI yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(double x,
                                       double y,
                                       double z,
                                       double xradius,
                                       double yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       double radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       IDoubleI radius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       double xradius,
                                       double yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI normal,
                                       IVecI rollDir,
                                       IDoubleI xradius,
                                       IDoubleI yradius,
                                       boolean approx)

    - #### circle

          public static ICircle circle(IVecI center,
                                       IVecI xradiusVec,
                                       IVecI yradiusVec,
                                       boolean approx)

    - #### ellipse

          public static ICircle ellipse(IVecI center,
                                        IVecI xradiusVec,
                                        IVecI yradiusVec)

      ellipse (alias of some of circle)

    - #### ellipse

          public static ICircle ellipse(IVecI center,
                                        IDoubleI xradius,
                                        IDoubleI yradius)

    - #### ellipse

          public static ICircle ellipse(IVecI center,
                                        double xradius,
                                        double yradius)

    - #### ellipse

          public static ICircle ellipse(double x,
                                        double y,
                                        double z,
                                        double xradius,
                                        double yradius)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI normal,
                                 IVecI startPt,
                                 double angle)

      arc

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI normal,
                                 IVecI startPt,
                                 IDoubleI angle)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI startPt,
                                 double angle)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI startPt,
                                 IDoubleI angle)

    - #### arc

          public static IArc arc(double x,
                                 double y,
                                 double z,
                                 double startX,
                                 double startY,
                                 double startZ,
                                 double angle)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI startPt,
                                 IVecI endPt,
                                 IBoolI flipArcSide)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI startPt,
                                 IVecI endPt,
                                 boolean flipArcSide)

    - #### arc

          public static IArc arc(IVecI center,
                                 IVecI startPt,
                                 IVecI midPt,
                                 IVecI endPt,
                                 IVecI normal)

    - #### offset

          public static ICurve offset(ICurveI curve,
                                      double width,
                                      IVecI planeNormal)

      offset curve

    - #### offset

          public static ICurve offset(ICurveI curve,
                                      IDoubleI width,
                                      IVecI planeNormal)

    - #### offset

          public static ICurve offset(ICurveI curve,
                                      double width)

    - #### offset

          public static ICurve offset(ICurveI curve,
                                      IDoubleI width)

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width)

      offset points. normal direction is automatically detected.

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width,
                                      boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width,
                                       boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width,
                                       boolean close)

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width,
                                      IVecI planeNormal)

      offset points with specific normal direction

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width,
                                      IVecI planeNormal,
                                      boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width,
                                       IVecI planeNormal)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width,
                                       IVecI planeNormal,
                                       boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width,
                                       IVecI planeNormal)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width,
                                       IVecI planeNormal,
                                       boolean close)

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width,
                                      IVecI[] normals)

      offset points with specific normal vector for each point

    - #### offset

          public static IVec[] offset(IVec[] pts,
                                      double width,
                                      IVecI[] normals,
                                      boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width,
                                       IVecI[] normals)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       double width,
                                       IVecI[] normals,
                                       boolean close)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width,
                                       IVecI[] normals)

    - #### offset

          public static IVecI[] offset(IVecI[] pts,
                                       IDoubleI width,
                                       IVecI[] normals,
                                       boolean close)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree,
                                         double[] uknots,
                                         double[] vknots,
                                         double ustart,
                                         double uend,
                                         double vstart,
                                         double vend)

      surfaces

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree,
                                         double[] uknots,
                                         double[] vknots)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree)

    - #### surface

          public static ISurface surface(IVecI[][] cpts)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree,
                                         boolean closeU,
                                         boolean closeV)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree,
                                         boolean closeU,
                                         double[] vk)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         int udegree,
                                         int vdegree,
                                         double[] uk,
                                         boolean closeV)

    - #### surface

          public static ISurface surface(IVecI[][] cpts,
                                         boolean closeU,
                                         boolean closeV)

    - #### surface

          public static ISurface surface(IVecI pt1,
                                         IVecI pt2,
                                         IVecI pt3,
                                         IVecI pt4)

    - #### surface

          public static ISurface surface(IVecI pt1,
                                         IVecI pt2,
                                         IVecI pt3)

    - #### surface

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

    - #### surface

          public static ISurface surface(double x1,
                                         double y1,
                                         double z1,
                                         double x2,
                                         double y2,
                                         double z2,
                                         double x3,
                                         double y3,
                                         double z3)

    - #### surface

          public static ISurface surface(double[][][] xyzValues)

    - #### surface

          public static ISurface surface(double[][][] xyzValues,
                                         int udeg,
                                         int vdeg)

    - #### surface

          public static ISurface surface(double[][][] xyzValues,
                                         boolean closeU,
                                         boolean closeV)

    - #### surface

          public static ISurface surface(double[][][] xyzValues,
                                         int udeg,
                                         int vdeg,
                                         boolean closeU,
                                         boolean closeV)

    - #### surface

          public static ISurface surface(ISurfaceI srf)

    - #### surface

          public static ISurface surface(ICurveI trimCurve)

    - #### surface

          public static ISurface surface(ICurveI outerTrimCurve,
                                         ICurveI[] innerTrimCurves)

    - #### surface

          public static ISurface surface(ICurveI outerTrimCurve,
                                         ICurveI innerTrimCurve)

    - #### surface

          public static ISurface surface(ICurveI[] trimCurves)

    - #### surface

          public static ISurface surface(IVecI[] trimCrvPts)

    - #### surface

          public static ISurface surface(IVecI[] trimCrvPts,
                                         int trimCrvDeg)

    - #### surface

          public static ISurface surface(IVecI[] trimCrvPts,
                                         int trimCrvDeg,
                                         double[] trimCrvKnots)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree,
                                     double[] uknots,
                                     double[] vknots,
                                     double ustart,
                                     double uend,
                                     double vstart,
                                     double vend)

      srf : short name of surfaces

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree,
                                     double[] uknots,
                                     double[] vknots)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree)

    - #### srf

          public static ISurface srf(IVecI[][] cpts)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree,
                                     boolean closeU,
                                     boolean closeV)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree,
                                     boolean closeU,
                                     double[] vk)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     int udegree,
                                     int vdegree,
                                     double[] uk,
                                     boolean closeV)

    - #### srf

          public static ISurface srf(IVecI[][] cpts,
                                     boolean closeU,
                                     boolean closeV)

    - #### srf

          public static ISurface srf(IVecI pt1,
                                     IVecI pt2,
                                     IVecI pt3,
                                     IVecI pt4)

    - #### srf

          public static ISurface srf(IVecI pt1,
                                     IVecI pt2,
                                     IVecI pt3)

    - #### srf

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

    - #### srf

          public static ISurface srf(double x1,
                                     double y1,
                                     double z1,
                                     double x2,
                                     double y2,
                                     double z2,
                                     double x3,
                                     double y3,
                                     double z3)

    - #### srf

          public static ISurface srf(double[][][] xyzValues)

    - #### srf

          public static ISurface srf(double[][][] xyzValues,
                                     int udeg,
                                     int vdeg)

    - #### srf

          public static ISurface srf(double[][][] xyzValues,
                                     boolean closeU,
                                     boolean closeV)

    - #### srf

          public static ISurface srf(double[][][] xyzValues,
                                     int udeg,
                                     int vdeg,
                                     boolean closeU,
                                     boolean closeV)

    - #### srf

          public static ISurface srf(ISurfaceI srf)

    - #### srf

          public static ISurface srf(ICurveI trimCurve)

      planar surface with trim

    - #### srf

          public static ISurface srf(ICurveI outerTrimCurve,
                                     ICurveI[] innerTrimCurves)

    - #### srf

          public static ISurface srf(ICurveI outerTrimCurve,
                                     ICurveI innerTrimCurve)

    - #### srf

          public static ISurface srf(ICurveI[] trimCurves)

    - #### srf

          public static ISurface srf(IVecI[] trimCrvPts)

    - #### srf

          public static ISurface srf(IVecI[] trimCrvPts,
                                     int trimCrvDeg)

    - #### srf

          public static ISurface srf(IVecI[] trimCrvPts,
                                     int trimCrvDeg,
                                     double[] trimCrvKnots)

    - #### box

          public static IBox box(double x,
                                 double y,
                                 double z,
                                 double size)

      box

    - #### box

          public static IBox box(double x,
                                 double y,
                                 double z,
                                 double width,
                                 double height,
                                 double depth)

    - #### box

          public static IBox box(IVecI origin,
                                 double size)

    - #### box

          public static IBox box(IVecI origin,
                                 double width,
                                 double height,
                                 double depth)

    - #### box

          public static IBox box(IVecI origin,
                                 IVecI xvec,
                                 IVecI yvec,
                                 IVecI zvec)

    - #### box

          public static IBox box(IVecI pt1,
                                 IVecI pt2,
                                 IVecI pt3,
                                 IVecI pt4,
                                 IVecI pt5,
                                 IVecI pt6,
                                 IVecI pt7,
                                 IVecI pt8)

    - #### box

          public static IBox box(IVecI[][][] corners)

    - #### sphere

          public static ISphere sphere(double x,
                                       double y,
                                       double z,
                                       double radius)

      sphere

    - #### sphere

          public static ISphere sphere(IVecI center,
                                       double radius)

    - #### sphere

          public static ISphere sphere(IVecI center,
                                       IDoubleI radius)

    - #### cylinder

          public static ICylinder cylinder(IVecI pt1,
                                           IVecI pt2,
                                           double radius)

    - #### cylinder

          public static ICylinder cylinder(IVecI pt1,
                                           IVecI pt2,
                                           IDoubleI radius)

    - #### cylinder

          public static ICylinder cylinder(IVecI pt1,
                                           IVecI pt2,
                                           double radius1,
                                           double radius2)

    - #### cylinder

          public static ICylinder cylinder(IVecI pt1,
                                           IVecI pt2,
                                           IDoubleI radius1,
                                           IDoubleI radius2)

    - #### cone

          public static ICylinder cone(IVecI pt1,
                                       IVecI pt2,
                                       double radius)

    - #### cone

          public static ICylinder cone(IVecI pt1,
                                       IVecI pt2,
                                       IDoubleI radius)

    - #### plane

          public static ISurface plane(IVecI corner,
                                       double xwidth,
                                       double yheight)

    - #### plane

          public static ISurface plane(IVecI corner,
                                       IVecI widthVec,
                                       IVecI heightVec)

    - #### plane

          public static ISurface plane(double x,
                                       double y,
                                       double z,
                                       double xwidth,
                                       double yheight)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         double extrudeDepth)

      one directional extrusion

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         IDoubleI extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         double extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         IDoubleI extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         boolean closeProfile,
                                         double extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         boolean closeProfile,
                                         IDoubleI extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         IVecI extrudeDir)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         IVecI extrudeDir)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         boolean closeProfile,
                                         IVecI extrudeDir)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         double[] profileKnots,
                                         IVecI extrudeDir)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         ICurve rail)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         ICurve rail)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         boolean closeProfile,
                                         ICurve rail)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         double[] profileKnots,
                                         ICurve rail)

    - #### extrude

          public static ISurface extrude(ICurveI profile,
                                         IVecI extrudeDir)

    - #### extrude

          public static ISurface extrude(ICurveI profile,
                                         double extrudeDepth)

    - #### extrude

          public static ISurface extrude(ICurveI profile,
                                         IDoubleI extrudeDepth)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         IVecI[] rail)

      extrusion along path (profile control points are copied parallely)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         IVecI[] rail,
                                         int railDeg)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         boolean closeProfile,
                                         IVecI[] rail,
                                         int railDeg,
                                         boolean closeRail)

    - #### extrude

          public static ISurface extrude(IVecI[] profile,
                                         int profileDeg,
                                         double[] profileKnots,
                                         IVecI[] rail,
                                         int railDeg,
                                         double[] railKnots)

    - #### extrude

          public static ISurface extrude(ICurveI profile,
                                         ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       IVecI[] rail)

      sweep (profile is redirected perpendicular to rail and centered(actually just on bisector of control points))

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       IVecI profileCenter,
                                       IVecI[] rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       IVecI profileCenter,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       IVecI profileCenter,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       IVecI profileCenter,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       IVecI profileCenter,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       IVecI profileCenter,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       boolean closeProfile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI[] rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI[] rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail,
                                       int railDeg)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail,
                                       int railDeg,
                                       boolean closeRail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(ICurveI profile,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       ICurveI rail)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       double[] profileKnots,
                                       IVecI[] rail,
                                       int railDeg,
                                       double[] railKnots)

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       double[] profileKnots,
                                       IVecI profileCenter,
                                       IVecI[] rail,
                                       int railDeg,
                                       double[] railKnots)

      sweep.
      Parameters:
        `profileCenter` - point on profile to be located at the points of rail

    - #### sweep

          public static ISurface sweep(IVecI[] profile,
                                       int profileDeg,
                                       double[] profileKnots,
                                       IVecI profileCenter,
                                       IVecI profileDir,
                                       IVecI[] rail,
                                       int railDeg,
                                       double[] railKnots)

      sweep.
      Parameters:
        `profileCenter` - point on profile to be located at the points of rail
        `profileDir` - direction on profile to be aligned with the normal of rail

    - #### pipe

          public static ISurface pipe(IVecI pt1,
                                      IVecI pt2,
                                      double radius)

      pipe

    - #### pipe

          public static ISurface pipe(IVecI[] rail,
                                      double radius)

    - #### pipe

          public static ISurface pipe(IVecI[] rail,
                                      int railDeg,
                                      double radius)

    - #### pipe

          public static ISurface pipe(IVecI[] rail,
                                      int railDeg,
                                      boolean close,
                                      double radius)

    - #### pipe

          public static ISurface pipe(ICurveI rail,
                                      double radius)

    - #### pipe

          public static ISurface pipe(IVecI[] rail,
                                      int railDeg,
                                      double[] railKnots,
                                      double radius)

    - #### squarePipe

          public static ISurface squarePipe(IVecI pt1,
                                            IVecI pt2,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(IVecI pt1,
                                            IVecI pt2,
                                            IVecI widthDir,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(IVecI[] rail,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(IVecI[] rail,
                                            int deg,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(IVecI[] rail,
                                            int deg,
                                            boolean close,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(ICurveI rail,
                                            double size)

    - #### squarePipe

          public static ISurface squarePipe(IVecI[] rail,
                                            int deg,
                                            double[] knots,
                                            double size)

    - #### rectPipe

          public static ISurface rectPipe(IVecI pt1,
                                          IVecI pt2,
                                          double width,
                                          double height)

      Parameters:
        `width` - size in the direction of offset of rail
        `height` - size in the direction of normal of rail

    - #### rectPipe

          public static ISurface rectPipe(IVecI pt1,
                                          IVecI pt2,
                                          IVecI widthDir,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(IVecI pt1,
                                          IVecI pt2,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(IVecI pt1,
                                          IVecI pt2,
                                          IVecI widthDir,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          boolean close,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          boolean close,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(ICurveI rail,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(ICurveI rail,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          double[] knots,
                                          double width,
                                          double height)

    - #### rectPipe

          public static ISurface rectPipe(IVecI[] rail,
                                          int deg,
                                          double[] knots,
                                          double left,
                                          double right,
                                          double bottom,
                                          double top)

    - #### loft

          public static ISurface loft(ICurveI[] curves)

      loft

    - #### loft

          public static ISurface loft(ICurveI curve1,
                                      ICurveI curve2)

    - #### loft

          public static ISurface loft(ICurveI[] curves,
                                      int deg)

    - #### loft

          public static ISurface loft(ICurveI[] curves,
                                      int deg,
                                      boolean close)

    - #### loft

          public static ISurface loft(IVecI[][] pts)

    - #### loft

          public static ISurface loft(IVecI[][] pts,
                                      boolean closeLoft,
                                      boolean closePts)

    - #### loft

          public static ISurface loft(IVecI[][] pts,
                                      int loftDeg,
                                      int ptsDeg)

    - #### loft

          public static ISurface loft(IVecI[][] pts,
                                      int loftDeg,
                                      int ptsDeg,
                                      boolean closeLoft,
                                      boolean closePts)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      boolean closePts)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      int ptsDeg)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      int ptsDeg,
                                      boolean closePts)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      IVecI[] pts3)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      IVecI[] pts3,
                                      boolean closePts)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      IVecI[] pts3,
                                      int loftDeg,
                                      int ptsDeg)

    - #### loft

          public static ISurface loft(IVecI[] pts1,
                                      IVecI[] pts2,
                                      IVecI[] pts3,
                                      int loftDeg,
                                      int ptsDeg,
                                      boolean closePts)

    - #### loftX

          public static ISurface loftX(ICurveI[] curves)

      loft with sorted curves in x

    - #### loftX

          public static ISurface loftX(ICurveI[] curves,
                                       int deg)

    - #### loftX

          public static ISurface loftX(ICurveI[] curves,
                                       int deg,
                                       boolean close)

    - #### loftY

          public static ISurface loftY(ICurveI[] curves)

      loft with sorted curves in y

    - #### loftY

          public static ISurface loftY(ICurveI[] curves,
                                       int deg)

    - #### loftY

          public static ISurface loftY(ICurveI[] curves,
                                       int deg,
                                       boolean close)

    - #### loftZ

          public static ISurface loftZ(ICurveI[] curves)

      loft with sorted curves in z

    - #### loftZ

          public static ISurface loftZ(ICurveI[] curves,
                                       int deg)

    - #### loftZ

          public static ISurface loftZ(ICurveI[] curves,
                                       int deg,
                                       boolean close)

    - #### flatten

          public static ICurve flatten(ICurveI curve,
                                       IVecI planeDir,
                                       IVecI planePt)

      flattening

    - #### flatten

          public static ICurve flatten(ICurveI curve,
                                       IVecI planeDir)

    - #### flatten

          public static ICurve flatten(ICurveI curve)

    - #### flatten

          public static ISurface flatten(ISurfaceI surface,
                                         IVecI planeDir,
                                         IVecI planePt)

    - #### flatten

          public static ISurface flatten(ISurfaceI surface,
                                         IVecI planeDir)

    - #### flatten

          public static ISurface flatten(ISurfaceI surface)

    - #### cap

          public static IBrep cap(ISurfaceI surface)

      cap a surface which is cyclically closed in u or v direction.

    - #### profileSurface

          public static ISurface profileSurface(IVecI[] cps,
                                                int deg,
                                                double[] knots)

      surface defined by closed profile.if the profile is flat, planar surface is created. if not lofting profile into the center of the profile

    - #### profileSurface

          public static ISurface profileSurface(ICurveI profile)

      surface defined by closed profile.if the profile is flat, planar surface is created. if not lofting profile into the center of the profile

    - #### radialSurface

          public static ISurface radialSurface(IVecI[] cps,
                                               int deg,
                                               double[] knots)

      surface by lofting profile into the center of the profile

    - #### radialSurface

          public static ISurface radialSurface(ICurveI profile)

      surface by lofting profile into the center of the profile

    - #### pointLoft

          public static ISurface pointLoft(IVecI[] cps,
                                           int deg,
                                           double[] knots,
                                           IVecI center)

      surface by lofting profile into the specified point

    - #### pointLoft

          public static ISurface pointLoft(ICurveI profile,
                                           IVecI center)

      surface by lofting profile into the specified point

    - #### meshType

          public static void meshType(IMeshType type)

      set mesh type (class of vertex, edge, face)

    - #### meshType

          public static IMeshType meshType()

      get the current mesh type (class of vertex, edge, face)

    - #### mesh

          public static IMesh mesh()

    - #### mesh

          public static IMesh mesh(IMeshGeo m)

    - #### mesh

          public static IMesh mesh(IMesh m)

    - #### mesh

          public static IMesh mesh(java.util.ArrayList<ICurveI> lines)

    - #### mesh

          public static IMesh mesh(ICurveI[] lines)

    - #### mesh

          public static IMesh mesh(IVec[][] matrix)

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

          public static IMesh mesh(IVec[] vert)

    - #### mesh

          public static IMesh mesh(IVertex[] vert)

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

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

    - #### mesh

          public static IMesh mesh(IFace[] fcs)

    - #### meshFromTriangles

          public static IMesh meshFromTriangles(IVecI[][] trianglePts)

      create polygon mesh out of array of triangle points which is array of 3 IVec

    - #### meshBox

          public static IMesh meshBox(double x,
                                      double y,
                                      double z,
                                      double size)

      creating mesh box

    - #### meshBox

          public static IMesh meshBox(double x,
                                      double y,
                                      double z,
                                      double width,
                                      double height,
                                      double depth)

    - #### meshBox

          public static IMesh meshBox(IVecI origin,
                                      double size)

    - #### meshBox

          public static IMesh meshBox(IVecI origin,
                                      double width,
                                      double height,
                                      double depth)

    - #### meshBox

          public static IMesh meshBox(IVecI origin,
                                      IVecI xvec,
                                      IVecI yvec,
                                      IVecI zvec)

    - #### meshBox

          public static IMesh meshBox(IVecI pt1,
                                      IVecI pt2,
                                      IVecI pt3,
                                      IVecI pt4,
                                      IVecI pt5,
                                      IVecI pt6,
                                      IVecI pt7,
                                      IVecI pt8)

    - #### meshBox

          public static IMesh meshBox(IVecI[][][] corners)

    - #### meshBox

          public static IMesh meshBox(IVertex[][][] corners)

    - #### meshTetrahedron

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

    - #### meshTetrahedron

          public static IMesh meshTetrahedron(IVecI[] vtx)

    - #### meshTetrahedron

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

    - #### meshTetrahedron

          public static IMesh meshTetrahedron(IVertex[] vtx)

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         IVecI sideDir,
                                         int resolution)

      mesh sphere
      Parameters:
        `topDir` - length of vector is radius in vertical direction
        `sideDir` - length of vector is radius in holizontal direction. sideDir is re-orthogonalized to topDir

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         IVecI sideDir)

      mesh sphere
      Parameters:
        `topDir` - length of vector is radius in vertical direction
        `sideDir` - length of vector is radius in holizontal direction. sideDir is re-orthogonalized to topDir

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         int resolution)

      mesh sphere
      Parameters:
        `topDir` - length of vector is radius in vertical direction

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir)

      mesh sphere
      Parameters:
        `topDir` - length of vector is radius in vertical direction

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         double radius,
                                         int resolution)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         double topRadius,
                                         double sideRadius,
                                         int resolution)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         double radius)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         IVecI topDir,
                                         double topRadius,
                                         double sideRadius)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         double radius,
                                         int resolution)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         double radius)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         double zradius,
                                         double xyradius,
                                         int resolution)

      mesh sphere

    - #### meshSphere

          public static IMesh meshSphere(IVecI center,
                                         double zradius,
                                         double xyradius)

      mesh sphere

    - #### meshRectStick

          public static IMesh meshRectStick(IVecI pt1,
                                            IVecI pt2,
                                            IVecI udir,
                                            IVecI vdir)

    - #### meshRectStick

          public static IMesh meshRectStick(IVecI pt1,
                                            IVecI pt2,
                                            double width,
                                            double height,
                                            IVecI heightDir)

      creating closed mesh stick with 2 points and with and height
      Parameters:
        `heightDir` - it provides reference to the direction of height but actual direction is re-calculated to be perpendicular to pt1-pt2 direction.

    - #### meshRectStick

          public static IMesh meshRectStick(IVecI pt1,
                                            IVecI pt2,
                                            double width,
                                            double height)

      creating closed mesh stick. reference height direction is z axis

    - #### meshSquareStick

          public static IMesh meshSquareStick(IVecI pt1,
                                              IVecI pt2,
                                              double width,
                                              IVecI heightDir)

      creating closed mesh stick with square profile.
      Parameters:
        `heightDir` - it provides reference to the direction of height but actual direction is re-calculated to be perpendicular to pt1-pt2 direction.

    - #### meshSquareStick

          public static IMesh meshSquareStick(IVecI pt1,
                                              IVecI pt2,
                                              double width)

      creating closed mesh stick. height direction is z axis

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(IVecI pt1,
                                               IVecI pt2,
                                               double radius,
                                               int polygonVertexNum)

      creates closed mesh stick with polygon profile
      Parameters:
        `pt1` - center of one side of a stick
        `pt2` - center of another side of a stick
        `polygonVertexNum` - number of vertex of profile polygon

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(IVecI pt1,
                                               IVecI pt2,
                                               double radius,
                                               int polygonVertexNum,
                                               IVecI heightDir)

      creates closed mesh stick with polygon profile
      Parameters:
        `pt1` - center of one side of a stick
        `pt2` - center of another side of a stick
        `polygonVertexNum` - number of vertex of profile polygon
        `heightDir` - reference vector to locate one of vertex of polygon aligned with this direction

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(IVecI pt1,
                                               IVecI pt2,
                                               double radius1,
                                               double radius2,
                                               int polygonVertexNum)

      creates closed mesh stick with polygon profile
      Parameters:
        `pt1` - center of one side of a stick
        `pt2` - center of another side of a stick
        `polygonVertexNum` - number of vertex of profile polygon

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(IVecI pt1,
                                               IVecI pt2,
                                               double radius1,
                                               double radius2,
                                               int polygonVertexNum,
                                               IVecI heightDir)

      creates closed mesh stick with polygon profile
      Parameters:
        `pt1` - center of one side of a stick
        `pt2` - center of another side of a stick
        `polygonVertexNum` - number of vertex of profile polygon
        `heightDir` - reference vector to locate one of vertex of polygon aligned with this direction

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(ICurveI railCurve,
                                               double radius,
                                               int polygonVertexNum,
                                               int railSegmentNum)

    - #### meshPolygonStick

          public static IMesh meshPolygonStick(ICurveI railCurve,
                                               double radius,
                                               int polygonVertexNum)

    - #### meshStick

          public static IMesh meshStick(IVecI pt1,
                                        IVecI pt2,
                                        double radius)

      round stick

    - #### meshStick

          public static IMesh meshStick(IVecI pt1,
                                        IVecI pt2,
                                        double radius1,
                                        double radius2)

      round stick

    - #### meshStick

          public static IMesh meshStick(ICurveI railCurve,
                                        double radius,
                                        int railSegmentNum)

      round stick

    - #### meshStick

          public static IMesh meshStick(ICurveI railCurve,
                                        double radius)

      round stick

    - #### meshRoundStick

          public static IMesh meshRoundStick(IVecI pt1,
                                             IVecI pt2,
                                             double radius)

      round stick (alias of stick())

    - #### meshRoundStick

          public static IMesh meshRoundStick(IVecI pt1,
                                             IVecI pt2,
                                             double radius1,
                                             double radius2)

      round stick (alias of stick())

    - #### meshRoundStick

          public static IMesh meshRoundStick(ICurveI railCurve,
                                             double radius,
                                             int railSegmentNum)

      round stick

    - #### meshRoundStick

          public static IMesh meshRoundStick(ICurveI railCurve,
                                             double radius)

      round stick

    - #### meshSquareStick

          public static IMesh meshSquareStick(ICurveI railCurve,
                                              double radius,
                                              int railSegmentNum)

      square stick

    - #### meshSquareStick

          public static IMesh meshSquareStick(ICurveI railCurve,
                                              double radius)

      square stick

    - #### meshRectPipe

          public static IMesh meshRectPipe(IVecI pt1,
                                           IVecI pt2,
                                           IVecI udir,
                                           IVecI vdir)

      open pipe mesh

    - #### meshRectPipe

          public static IMesh meshRectPipe(IVecI pt1,
                                           IVecI pt2,
                                           double width,
                                           double height,
                                           IVecI heightDir)

      creating open mesh pipe with 2 points and with and height
      Parameters:
        `heightDir` - it provides reference to the direction of height but actual direction is re-calculated to be perpendicular to pt1-pt2 direction.

    - #### meshRectPipe

          public static IMesh meshRectPipe(IVecI pt1,
                                           IVecI pt2,
                                           double width,
                                           double height)

      creating open mesh pipe. reference height direction is z axis

    - #### meshSquarePipe

          public static IMesh meshSquarePipe(IVecI pt1,
                                             IVecI pt2,
                                             double width,
                                             IVecI heightDir)

      creating open mesh pipe with square profile.
      Parameters:
        `heightDir` - it provides reference to the direction of height but actual direction is re-calculated to be perpendicular to pt1-pt2 direction.

    - #### meshSquarePipe

          public static IMesh meshSquarePipe(IVecI pt1,
                                             IVecI pt2,
                                             double width)

      creating open mesh stick. height direction is z axis

    - #### vec

          public static IVec vec()

      creating vector

    - #### vec

          public static IVec vec(double x,
                                 double y,
                                 double z)

    - #### vec

          public static IVec vec(double x,
                                 double y)

    - #### vec

          public static IVec vec(IVec v)

    - #### vec

          public static IVec vec(IVecI v)

    - #### vec

          public static IVec vec(IDoubleI x,
                                 IDoubleI y,
                                 IDoubleI z)

    - #### vec

          public static IVec vec(IDoubleI x,
                                 IDoubleI y)

    - #### vec

          public static IVec vec(IVec2I v)

    - #### v

          public static IVec v()

      vector shorter name

    - #### v

          public static IVec v(double x,
                               double y,
                               double z)

    - #### v

          public static IVec v(double x,
                               double y)

    - #### v

          public static IVec v(IVec v)

    - #### v

          public static IVec v(IVecI v)

    - #### v

          public static IVec v(IDoubleI x,
                               IDoubleI y,
                               IDoubleI z)

    - #### v

          public static IVec v(IDoubleI x,
                               IDoubleI y)

    - #### v

          public static IVec v(IVec2I v)

    - #### vector

          public static IVec vector()

      vector longer name

    - #### vector

          public static IVec vector(double x,
                                    double y,
                                    double z)

    - #### vector

          public static IVec vector(double x,
                                    double y)

    - #### vector

          public static IVec vector(IVec v)

    - #### vector

          public static IVec vector(IVecI v)

    - #### vector

          public static IVec vector(IDoubleI x,
                                    IDoubleI y,
                                    IDoubleI z)

    - #### vector

          public static IVec vector(IDoubleI x,
                                    IDoubleI y)

    - #### vector

          public static IVec vector(IVec2I v)

    - #### vec4

          public static IVec4 vec4()

      creating 4 dimensional vector with weight

    - #### vec4

          public static IVec4 vec4(double x,
                                   double y,
                                   double z,
                                   double w)

    - #### vec4

          public static IVec4 vec4(IVec v,
                                   double w)

    - #### vec4

          public static IVec4 vec4(IVec4 v)

    - #### vec4

          public static IVec4 vec4(IVecI v)

    - #### vec4

          public static IVec4 vec4(IVecI v,
                                   double w)

    - #### vec4

          public static IVec4 vec4(IVecI v,
                                   IDoubleI w)

    - #### vec4

          public static IVec4 vec4(IDoubleI x,
                                   IDoubleI y,
                                   IDoubleI z,
                                   IDoubleI w)

    - #### v4

          public static IVec4 v4()

      4d vector shorter name

    - #### v4

          public static IVec4 v4(double x,
                                 double y,
                                 double z,
                                 double w)

    - #### v4

          public static IVec4 v4(IVec v,
                                 double w)

    - #### v4

          public static IVec4 v4(IVec4 v)

    - #### v4

          public static IVec4 v4(IVecI v)

    - #### v4

          public static IVec4 v4(IVecI v,
                                 double w)

    - #### v4

          public static IVec4 v4(IVecI v,
                                 IDoubleI w)

    - #### v4

          public static IVec4 v4(IDoubleI x,
                                 IDoubleI y,
                                 IDoubleI z,
                                 IDoubleI w)

    - #### vector4

          public static IVec4 vector4()

      4d vector longer name

    - #### vector4

          public static IVec4 vector4(double x,
                                      double y,
                                      double z,
                                      double w)

    - #### vector4

          public static IVec4 vector4(IVec v,
                                      double w)

    - #### vector4

          public static IVec4 vector4(IVec4 v)

    - #### vector4

          public static IVec4 vector4(IVecI v)

    - #### vector4

          public static IVec4 vector4(IVecI v,
                                      double w)

    - #### vector4

          public static IVec4 vector4(IVecI v,
                                      IDoubleI w)

    - #### vector4

          public static IVec4 vector4(IDoubleI x,
                                      IDoubleI y,
                                      IDoubleI z,
                                      IDoubleI w)

    - #### vec2

          public static IVec2 vec2()

      creating 2 dimensional vector

    - #### vec2

          public static IVec2 vec2(double x,
                                   double y)

    - #### vec2

          public static IVec2 vec2(IVec2 v)

    - #### vec2

          public static IVec2 vec2(IVecI v)

    - #### vec2

          public static IVec2 vec2(IDoubleI x,
                                   IDoubleI y)

    - #### v2

          public static IVec2 v2()

      2d vector shorter name

    - #### v2

          public static IVec2 v2(double x,
                                 double y)

    - #### v2

          public static IVec2 v2(IVec2 v)

    - #### v2

          public static IVec2 v2(IVecI v)

    - #### v2

          public static IVec2 v2(IDoubleI x,
                                 IDoubleI y)

    - #### vector2

          public static IVec2 vector2()

      2d vector longer name

    - #### vector2

          public static IVec2 vector2(double x,
                                      double y)

    - #### vector2

          public static IVec2 vector2(IVec2 v)

    - #### vector2

          public static IVec2 vector2(IVecI v)

    - #### vector2

          public static IVec2 vector2(IDoubleI x,
                                      IDoubleI y)

    - #### vec

          public static IVec[] vec(double x,
                                   double y,
                                   double z,
                                   double... xyzvals)

      vector array

    - #### vec

          public static IVec[] vec(IVec... v)

    - #### vec

          public static IVecI[] vec(IVecI... v)

    - #### vec

          public static IVec[] vec(IDoubleI x,
                                   IDoubleI y,
                                   IDoubleI z,
                                   IDoubleI... xyzvals)

    - #### vec

          public static IVec[] vec(IVec2I... v)

    - #### vec

          public static IVec[][] vec(IVec[]... v)

    - #### vec

          public static IVecI[][] vec(IVecI[]... v)

    - #### vec

          public static IVec[][][] vec(IVec[][]... v)

    - #### vec

          public static IVecI[][][] vec(IVecI[][]... v)

    - #### v

          public static IVec[] v(double x,
                                 double y,
                                 double z,
                                 double... xyzvals)

      vector array shorter name

    - #### v

          public static IVec[] v(IVec... v)

    - #### v

          public static IVecI[] v(IVecI... v)

    - #### v

          public static IVec[] v(IDoubleI x,
                                 IDoubleI y,
                                 IDoubleI z,
                                 IDoubleI... xyzvals)

    - #### v

          public static IVec[] v(IVec2I... v)

    - #### v

          public static IVec[][] v(IVec[]... v)

      IVec 2d array

    - #### v

          public static IVecI[][] v(IVecI[]... v)

    - #### v

          public static IVec[][][] v(IVec[][]... v)

      IVec 3d array

    - #### v

          public static IVecI[][][] v(IVecI[][]... v)

    - #### vector

          public static IVec[] vector(double x,
                                      double y,
                                      double z,
                                      double... xyzvals)

      vector array longer name

    - #### vector

          public static IVec[] vector(IVec... v)

    - #### vector

          public static IVecI[] vector(IVecI... v)

    - #### vector

          public static IVec[] vector(IDoubleI x,
                                      IDoubleI y,
                                      IDoubleI z,
                                      IDoubleI... xyzvals)

    - #### vector

          public static IVec[] vector(IVec2I... v)

    - #### vector

          public static IVec[][] vector(IVec[]... v)

    - #### vector

          public static IVecI[][] vector(IVecI[]... v)

    - #### vector

          public static IVec[][][] vector(IVec[][]... v)

    - #### vector

          public static IVecI[][][] vector(IVecI[][]... v)

    - #### vec4

          public static IVec4[] vec4(double x,
                                     double y,
                                     double z,
                                     double w,
                                     double... xyzwvals)

      vector (IVec4) array

    - #### vec4

          public static IVec4[] vec4(IVec4... v)

    - #### vec4

          public static IVec4I[] vec4(IVec4I... v)

    - #### vec4

          public static IVec4[] vec4(IDoubleI x,
                                     IDoubleI y,
                                     IDoubleI z,
                                     IDoubleI w,
                                     IDoubleI... xyzwvals)

    - #### vec4

          public static IVec4[][] vec4(IVec4[]... v)

      IVec4 2d array

    - #### vec4

          public static IVec4I[][] vec4(IVec4I[]... v)

    - #### vec4

          public static IVec4[][][] vec4(IVec4[][]... v)

      IVec4 3d array

    - #### vec4

          public static IVec4I[][][] vec4(IVec4I[][]... v)

    - #### v4

          public static IVec4[] v4(double x,
                                   double y,
                                   double z,
                                   double w,
                                   double... xyzwvals)

    - #### v4

          public static IVec4[] v4(IVec4... v)

    - #### v4

          public static IVec4I[] v4(IVec4I... v)

    - #### v4

          public static IVec4[] v4(IDoubleI x,
                                   IDoubleI y,
                                   IDoubleI z,
                                   IDoubleI w,
                                   IDoubleI... xyzwvals)

    - #### v4

          public static IVec4[][] v4(IVec4[]... v)

      IVec4 2d array

    - #### v4

          public static IVec4I[][] v4(IVec4I[]... v)

    - #### v4

          public static IVec4[][][] v4(IVec4[][]... v)

      IVec4 3d array

    - #### v4

          public static IVec4I[][][] v4(IVec4I[][]... v)

    - #### vector4

          public static IVec4[] vector4(double x,
                                        double y,
                                        double z,
                                        double w,
                                        double... xyzwvals)

    - #### vector4

          public static IVec4[] vector4(IVec4... v)

    - #### vector4

          public static IVec4I[] vector4(IVec4I... v)

    - #### vector4

          public static IVec4[] vector4(IDoubleI x,
                                        IDoubleI y,
                                        IDoubleI z,
                                        IDoubleI w,
                                        IDoubleI... xyzwvals)

    - #### vector4

          public static IVec4[][] vector4(IVec4[]... v)

      IVec4 2d array

    - #### vector4

          public static IVec4I[][] vector4(IVec4I[]... v)

    - #### vector4

          public static IVec4[][][] vector4(IVec4[][]... v)

      IVec4 3d array

    - #### vector4

          public static IVec4I[][][] vector4(IVec4I[][]... v)

    - #### vec2

          public static IVec2[] vec2(double x,
                                     double y,
                                     double... xyvals)

      vector (IVec2) array

    - #### vec2

          public static IVec2[] vec2(IVec2... v)

    - #### vec2

          public static IVec2I[] vec2(IVec2I... v)

    - #### vec2

          public static IVec2[] vec2(IDoubleI x,
                                     IDoubleI y,
                                     IDoubleI... xyvals)

    - #### vec2

          public static IVec2I[] vec2(IVecI... v)

      IVec2 2d array from IVecI

    - #### vec2

          public static IVec2[] vec2(IVec... v)

      IVec2 2d array from IVecI

    - #### vec2

          public static IVec2[][] vec2(IVec2[]... v)

      IVec2 2d array

    - #### vec2

          public static IVec2I[][] vec2(IVec2I[]... v)

    - #### vec2

          public static IVec2[][][] vec2(IVec2[][]... v)

      IVec2 3d array

    - #### vec2

          public static IVec2I[][][] vec2(IVec2I[][]... v)

    - #### v2

          public static IVec2[] v2(double x,
                                   double y,
                                   double... xyvals)

    - #### v2

          public static IVec2[] v2(IVec2... v)

    - #### v2

          public static IVec2I[] v2(IVec2I... v)

    - #### v2

          public static IVec2[] v2(IDoubleI x,
                                   IDoubleI y,
                                   IDoubleI... xyvals)

    - #### v2

          public static IVec2[] v2(IVec... v)

      IVec2 array from IVec (projection)

    - #### v2

          public static IVec2I[] v2(IVecI... v)

      IVec2I array from IVecI (projection)

    - #### v2

          public static IVec2[][] v2(IVec2[]... v)

      IVec4 2d array

    - #### v2

          public static IVec2I[][] v2(IVec2I[]... v)

    - #### v2

          public static IVec2[][][] v2(IVec2[][]... v)

      IVec4 3d array

    - #### v2

          public static IVec2I[][][] v2(IVec2I[][]... v)

    - #### vector2

          public static IVec2[] vector2(double x,
                                        double y,
                                        double... xyvals)

    - #### vector2

          public static IVec2[] vector2(IVec2... v)

    - #### vector2

          public static IVec2I[] vector2(IVec2I... v)

    - #### vector2

          public static IVec2[] vector2(IDoubleI x,
                                        IDoubleI y,
                                        IDoubleI... xyvals)

    - #### vector2

          public static IVec2[][] vector2(IVec2[]... v)

      IVec4 2d array

    - #### vector2

          public static IVec2I[][] vector2(IVec2I[]... v)

    - #### vector2

          public static IVec2[][][] vector2(IVec2[][]... v)

      IVec4 3d array

    - #### vector2

          public static IVec2I[][][] vector2(IVec2I[][]... v)

    - #### array

          public static <T> T[] array(T... vals)

      create array of any class.

    - #### array

          public static <T> T[] array(int length,
                                      T... vals)

      create array of any class.

    - #### array2

          public static <T> T[][] array2(int length1,
                                         int length2,
                                         T... vals)

      create 2D array of any class.

    - #### array2

          public static <T> T[][] array2(int length2,
                                         T... vals)

      create 2D array of any class.

    - #### array3

          public static <T> T[][][] array3(int length1,
                                           int length2,
                                           int length3,
                                           T... vals)

      create 3D array of any class.

    - #### array3

          public static <T> T[][][] array3(int length2,
                                           int length3,
                                           T... vals)

      create 3D array of any class.

    - #### arr

          public static <T> T[] arr(T... vals)

      create array of any class.

    - #### arr

          public static <T> T[] arr(int length,
                                    T... vals)

      create array of any class.

    - #### arr2

          public static <T> T[][] arr2(int length1,
                                       int length2,
                                       T... vals)

      create 2D array of any class.

    - #### arr2

          public static <T> T[][] arr2(int length2,
                                       T... vals)

      create 2D array of any class.

    - #### arr3

          public static <T> T[][][] arr3(int length1,
                                         int length2,
                                         int length3,
                                         T... vals)

      create 3D array of any class.

    - #### arr3

          public static <T> T[][][] arr3(int length2,
                                         int length3,
                                         T... vals)

      create 3D array of any class.

    - #### a

          public static <T> T[] a(T... vals)

      create array of any class.

    - #### a

          public static <T> T[] a(int length,
                                  T... vals)

      create array of any class.

    - #### a2

          public static <T> T[][] a2(int length1,
                                     int length2,
                                     T... vals)

      create 2D array of any class.

    - #### a2

          public static <T> T[][] a2(int length2,
                                     T... vals)

      create 2D array of any class.

    - #### a3

          public static <T> T[][][] a3(int length1,
                                       int length2,
                                       int length3,
                                       T... vals)

      create 3D array of any class.

    - #### a3

          public static <T> T[][][] a3(int length2,
                                       int length3,
                                       T... vals)

      create 3D array of any class.

    - #### cp

          public static IVecI[] cp(IVecI... vecarray)

      generic vector array copy

    - #### cp

          public static IVec[] cp(IVec... vecarray)

    - #### cp

          public static IVec2I[] cp(IVec2I... vecarray)

    - #### cp

          public static IVec2[] cp(IVec2... vecarray)

    - #### cp

          public static IVec4[] cp(IVec4... vecarray)

    - #### copy

          public static IVecI[] copy(IVecI... vecarray)

    - #### copy

          public static IVec[] copy(IVec... vecarray)

    - #### copy

          public static IVec2I[] copy(IVec2I... vecarray)

    - #### copy

          public static IVec2[] copy(IVec2... vecarray)

    - #### copy

          public static IVec4[] copy(IVec4... vecarray)

    - #### eq

          public static boolean eq(double v1,
                                   double v2)

      create 3D array of any class.

    - #### eq

          public static boolean eq(double v1,
                                   double v2,
                                   double tolerance)

    - #### initRand

          public static void initRand(int seed)

      random number

    - #### initRandByTime

          public static void initRandByTime()

    - #### initRand

          public static void initRand()

    - #### seed

          public static void seed(int seed)

    - #### seedByTime

          public static void seedByTime()

    - #### seedRand

          public static void seedRand()

    - #### rand

          public static double rand()

    - #### rand

          public static double rand(double max)

    - #### rand

          public static double rand(double min,
                                    double max)

    - #### rand

          public static float rand(float max)

    - #### rand

          public static float rand(float min,
                                   float max)

    - #### rand

          public static int rand(int max)

    - #### rand

          public static int rand(int min,
                                 int max)

    - #### randPt

          public static IVec randPt()

    - #### randPt

          public static IVec randPt(double max)

    - #### randPt

          public static IVec randPt(double min,
                                    double max)

    - #### randPt

          public static IVec randPt(double maxx,
                                    double maxy,
                                    double maxz)

    - #### randPt

          public static IVec randPt(double minx,
                                    double miny,
                                    double maxx,
                                    double maxy)

    - #### randPt

          public static IVec randPt(double minx,
                                    double miny,
                                    double minz,
                                    double maxx,
                                    double maxy,
                                    double maxz)

    - #### randDir

          public static IVec randDir()

    - #### randDir

          public static IVec randDir(double len)

    - #### randDir

          public static IVec randDir(IVecI perpendicularAxis)

    - #### randDir

          public static IVec randDir(IVecI perpendicularAxis,
                                     double length)

    - #### randClr

          public static IColor randClr()

    - #### randClr

          public static IColor randClr(float alpha)

    - #### randClr

          public static IColor randClr(int alpha)

    - #### randColor

          public static IColor randColor()

    - #### randColor

          public static IColor randColor(float alpha)

    - #### randColor

          public static IColor randColor(int alpha)

    - #### randGray

          public static IColor randGray()

    - #### randGray

          public static IColor randGray(float alpha)

    - #### randGray

          public static IColor randGray(int alpha)

    - #### rand

          public static <T> T rand(T[] array)

    - #### rand

          public static <T> T rand(java.util.List<T> array)

    - #### randPercent

          public static boolean randPercent(double percent)

    - #### randPct

          public static boolean randPct(double percent)

    - #### percent

          public static boolean percent(double percent)

    - #### pct

          public static boolean pct(double percent)

    - #### clr

          public static IObject clr(IObject obj,
                                    IColor c)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      IColor c)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         IColor c)

    - #### clr

          public static IObject clr(IObject obj,
                                    IColor c,
                                    int alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      IColor c,
                                      int alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         IColor c,
                                                         int alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    IColor c,
                                    float alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      IColor c,
                                      float alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         IColor c,
                                                         float alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    IColor c,
                                    double alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      IColor c,
                                      double alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         IColor c,
                                                         double alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    java.awt.Color c)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      java.awt.Color c)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         java.awt.Color c)

    - #### clr

          public static IObject clr(IObject obj,
                                    java.awt.Color c,
                                    int alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      java.awt.Color c,
                                      int alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         java.awt.Color c,
                                                         int alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    java.awt.Color c,
                                    float alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      java.awt.Color c,
                                      float alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         java.awt.Color c,
                                                         float alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    java.awt.Color c,
                                    double alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      java.awt.Color c,
                                      double alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         java.awt.Color c,
                                                         double alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    int gray)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      int gray)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         int gray)

    - #### clr

          public static IObject clr(IObject obj,
                                    float gray)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      float gray)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         float gray)

    - #### clr

          public static IObject clr(IObject obj,
                                    double gray)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      double gray)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         double gray)

    - #### clr

          public static IObject clr(IObject obj,
                                    int gray,
                                    int alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      int gray,
                                      int alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         int gray,
                                                         int alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    float gray,
                                    float alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      float gray,
                                      float alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         float gray,
                                                         float alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    double gray,
                                    double alpha)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      double gray,
                                      double alpha)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         double gray,
                                                         double alpha)

    - #### clr

          public static IObject clr(IObject obj,
                                    int r,
                                    int g,
                                    int b)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      int r,
                                      int g,
                                      int b)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         int r,
                                                         int g,
                                                         int b)

    - #### clr

          public static IObject clr(IObject obj,
                                    double r,
                                    double g,
                                    double b)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      double r,
                                      double g,
                                      double b)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         double r,
                                                         double g,
                                                         double b)

    - #### clr

          public static IObject clr(IObject obj,
                                    float r,
                                    float g,
                                    float b)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      float r,
                                      float g,
                                      float b)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         float r,
                                                         float g,
                                                         float b)

    - #### clr

          public static IObject clr(IObject obj,
                                    int r,
                                    int g,
                                    int b,
                                    int a)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      int r,
                                      int g,
                                      int b,
                                      int a)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         int r,
                                                         int g,
                                                         int b,
                                                         int a)

    - #### clr

          public static IObject clr(IObject obj,
                                    double r,
                                    double g,
                                    double b,
                                    double a)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      double r,
                                      double g,
                                      double b,
                                      double a)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         double r,
                                                         double g,
                                                         double b,
                                                         double a)

    - #### clr

          public static IObject clr(IObject obj,
                                    float r,
                                    float g,
                                    float b,
                                    float a)

    - #### clr

          public static IObject[] clr(IObject[] objs,
                                      float r,
                                      float g,
                                      float b,
                                      float a)

    - #### clr

          public static java.util.ArrayList<IObject> clr(java.util.ArrayList<IObject> objs,
                                                         float r,
                                                         float g,
                                                         float b,
                                                         float a)

    - #### hsb

          public static IObject hsb(IObject obj,
                                    float h,
                                    float s,
                                    float b,
                                    float a)

    - #### hsb

          public static IObject[] hsb(IObject[] objs,
                                      float h,
                                      float s,
                                      float b,
                                      float a)

    - #### hsb

          public static java.util.ArrayList<IObject> hsb(java.util.ArrayList<IObject> objs,
                                                         float h,
                                                         float s,
                                                         float b,
                                                         float a)

    - #### hsb

          public static IObject hsb(IObject obj,
                                    double h,
                                    double s,
                                    double b,
                                    double a)

    - #### hsb

          public static IObject[] hsb(IObject[] objs,
                                      double h,
                                      double s,
                                      double b,
                                      double a)

    - #### hsb

          public static java.util.ArrayList<IObject> hsb(java.util.ArrayList<IObject> objs,
                                                         double h,
                                                         double s,
                                                         double b,
                                                         double a)

    - #### hsb

          public static IObject hsb(IObject obj,
                                    float h,
                                    float s,
                                    float b)

    - #### hsb

          public static IObject[] hsb(IObject[] objs,
                                      float h,
                                      float s,
                                      float b)

    - #### hsb

          public static java.util.ArrayList<IObject> hsb(java.util.ArrayList<IObject> objs,
                                                         float h,
                                                         float s,
                                                         float b)

    - #### hsb

          public static IObject hsb(IObject obj,
                                    double h,
                                    double s,
                                    double b)

    - #### hsb

          public static IObject[] hsb(IObject[] objs,
                                      double h,
                                      double s,
                                      double b)

    - #### hsb

          public static java.util.ArrayList<IObject> hsb(java.util.ArrayList<IObject> objs,
                                                         double h,
                                                         double s,
                                                         double b)

    - #### weight

          public static IObject weight(IObject obj,
                                       double w)

    - #### weight

          public static IObject[] weight(IObject[] objs,
                                         double w)

    - #### weight

          public static java.util.ArrayList<IObject> weight(java.util.ArrayList<IObject> objs,
                                                            double w)

    - #### weight

          public static IObject weight(IObject obj,
                                       float w)

    - #### weight

          public static IObject[] weight(IObject[] objs,
                                         float w)

    - #### weight

          public static java.util.ArrayList<IObject> weight(java.util.ArrayList<IObject> objs,
                                                            float w)

    - #### hide

          public static IObject hide(IObject obj)

    - #### hide

          public static IObject[] hide(IObject[] objs)

    - #### hide

          public static java.util.ArrayList<IObject> hide(java.util.ArrayList<IObject> objs)

    - #### show

          public static IObject show(IObject obj)

    - #### show

          public static IObject[] show(IObject[] objs)

    - #### show

          public static java.util.ArrayList<IObject> show(java.util.ArrayList<IObject> objs)