igeo

## Class ISurfaceGeo

- java.lang.Object
- - igeo.IParameterObject
  - - igeo.INurbsGeo
    - - igeo.ISurfaceGeo

- All Implemented Interfaces:
    IEntityParameter, IParameter, ISubobject, ISurfaceI, ISurfaceOp, ITransformable, IVal

      public class ISurfaceGeo
      extends INurbsGeo
      implements ISurfaceI, IEntityParameter

  Geometry of NURBS surface.
  Author:
    Satoru Sugihara

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `IBSplineBasisFunction` | `basisFunctionU`
    `IBSplineBasisFunction` | `basisFunctionV`
    `IVecI[][]` | `controlPoints`
    `boolean[][]` | `defaultWeights` flag to determine to use default weight value (1.0)
    `IBSplineBasisFunction` | `derivativeFunctionU`
    `IBSplineBasisFunction` | `derivativeFunctionV`
    `boolean` | `innerTrimClosed`
    `java.util.ArrayList<java.util.ArrayList<ITrimCurve>>` | `innerTrimLoop`
    `boolean` | `outerTrimClosed`
    `java.util.ArrayList<java.util.ArrayList<ITrimCurve>>` | `outerTrimLoop`
    `ITrimCache` | `trimCache`
    `int` | `udegree`
    `double` | `uend`
    `double[]` | `uknots` normalized knot vector (start value in knot vector is 0, end value is 1)
    `double` | `ustart`
    `ISurfaceCache` | `uvSearchCache` point cache for proximity search
    `int` | `vdegree`
    `double` | `vend`
    `double[]` | `vknots` normalized knot vector (start value in knot vector is 0, end value is 1)
    `double` | `vstart`

    - ### Fields inherited from class igeo.IParameterObject

      `parent`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ISurfaceGeo()`
    `ISurfaceGeo(double[][][] xyzValues)`
    `ISurfaceGeo(double[][][] xyzValues, boolean closeU, boolean closeV)`
    `ISurfaceGeo(double[][][] xyzValues, int udeg, int vdeg)`
    `ISurfaceGeo(double[][][] xyzValues, int udeg, int vdeg, boolean closeU, boolean closeV)`
    `ISurfaceGeo(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`
    `ISurfaceGeo(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4)`
    `ISurfaceGeo(ICurveI trimCurve)` create surface with outer trim curve
    `ISurfaceGeo(ICurveI[] trimCurves)`
    `ISurfaceGeo(ICurveI[] outerTrimCurves, ICurveI[][] innerTrimCurves)`
    `ISurfaceGeo(ICurveI trimCurve, ICurveI innerTrimCurve)`
    `ISurfaceGeo(ICurveI trimCurve, ICurveI[] innerTrimCurves)`
    `ISurfaceGeo(ISurfaceGeo srf)`
    `ISurfaceGeo(IVecI[] trimCrvPts)`
    `ISurfaceGeo(IVecI[][] cpts)`
    `ISurfaceGeo(IVecI[][] cpts, boolean closeU, boolean closeV)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, boolean closeV)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree, boolean closeU, double[] vk)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree, double[] uk, boolean closeV)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots)`
    `ISurfaceGeo(IVecI[][] cpts, int udegree, int vdegree, double[] uknots, double[] vknots, double ustart, double uend, double vstart, double vend)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg, double[] trimCrvKnots)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg, double[] trimCrvKnots, IVecI[][] innerTrimCrvPts, int[] innerTrimCrvDeg, double[][] innerTrimCrvKnots)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg, double[] trimCrvKnots, IVecI[] innerTrimCrvPts, int innerTrimCrvDeg, double[] innerTrimCrvKnots)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg, IVecI[][] innerTrimCrvPts, int[] innerTrimCrvDeg)`
    `ISurfaceGeo(IVecI[] trimCrvPts, int trimCrvDeg, IVecI[] innerTrimCrvPts, int innerTrimCrvDeg)`
    `ISurfaceGeo(IVecI[] trimCrvPts, IVecI[] innerTrimCrvPts)`
    `ISurfaceGeo(IVecI[] trimCrvPts, IVecI[][] innerTrimCrvPts)`
    `ISurfaceGeo(IVecI pt1, IVecI pt2, IVecI pt3)`
    `ISurfaceGeo(IVecI pt1, IVecI pt2, IVecI pt3, IVecI pt4)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ISurfaceGeo` | `add(double x, double y, double z)` transformation methods; API of ITransformable interface
    `ISurfaceGeo` | `add(double f, IVecI v)` scale add alias
    `ISurfaceGeo` | `add(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceGeo` | `add(IDoubleI f, IVecI v)` scale add alias
    `ISurfaceGeo` | `add(IVecI v)`
    `ISurfaceGeo` | `add(IVecI v, double f)` scale add
    `ISurfaceGeo` | `add(IVecI v, IDoubleI f)` scale add
    `ISurfaceGeo` | `addDefaultOuterTrimLoop()`
    `ISurfaceGeo` | `addInnerTrim(ITrimCurve trimCrv)`
    `ISurfaceGeo` | `addInnerTrimLoop(ICurveI trim)` input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
    `ISurfaceGeo` | `addInnerTrimLoop(ICurveI[] trim)` input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
    `ISurfaceGeo` | `addInnerTrimLoop(ICurveI[] trim, boolean deleteInput)`
    `ISurfaceGeo` | `addInnerTrimLoop(ICurveI trim, boolean deleteInput)`
    `ISurfaceGeo` | `addInnerTrimLoop(ITrimCurve loop)`
    `ISurfaceGeo` | `addInnerTrimLoop(ITrimCurve[] loop)`
    `ISurfaceGeo` | `addInnerTrimLoop(ITrimCurveI loop)`
    `ISurfaceGeo` | `addInnerTrimLoop(ITrimCurveI[] loop)`
    `ISurfaceGeo` | `addOuterTrim(ITrimCurve trimCrv)`
    `ISurfaceGeo` | `addOuterTrimLoop(ICurveI trim)`
    `ISurfaceGeo` | `addOuterTrimLoop(ICurveI[] trim)`
    `ISurfaceGeo` | `addOuterTrimLoop(ICurveI[] trim, boolean deleteInput)`
    `ISurfaceGeo` | `addOuterTrimLoop(ICurveI trim, boolean deleteInput)`
    `ISurfaceGeo` | `addOuterTrimLoop(ITrimCurve loop)`
    `ISurfaceGeo` | `addOuterTrimLoop(ITrimCurve[] loop)`
    `ISurfaceGeo` | `addOuterTrimLoop(ITrimCurveI loop)`
    `ISurfaceGeo` | `addOuterTrimLoop(ITrimCurveI[] loop)`
    `ISurfaceGeo` | `addUCP(IVecI[] pts)` add control point at the end and rebuild the surface note that a knots is rebuilt with default equal intervals and destroy original knot intervals if variable, like circle.
    `ISurfaceGeo` | `addVCP(IVecI[] pts)` add control point at the end and rebuild the surface note that a knots is rebuilt with default equal intervals and destroy original knot intervals if variable, like circle.
    `IVec` | `center()` returns center of geometry object
    `static void` | `checkDuplicatedCP(IVecI[][] cpts)`
    `static void` | `checkDuplicatedCP(IVecI[][] cpts, IVecI[] pts)`
    `static void` | `checkDuplicatedCPOnEdge(IVecI[][] cpts)`
    `boolean` | `checkTrim(ITrimCurve curve)`
    `boolean` | `checkTrimLoop(ITrimCurve loop)`
    `boolean` | `checkTrimLoop(ITrimCurve[] loop)`
    `ISurfaceGeo` | `clearInnerTrim()`
    `ISurfaceGeo` | `clearOuterTrim()`
    `ISurfaceGeo` | `clearTrim()`
    `ISurfaceGeo` | `closeInnerTrim()`
    `ISurfaceGeo` | `closeOuterTrim()`
    `IVec` | `closePt(IVec2I pt)` find approximately closest point on a surface on 2D
    `IVec` | `closePt(IVecI pt)` find approximately closest point on a surface
    `IVec` | `corner(IIntegerI u, IIntegerI v)`
    `IVec` | `corner(int u, int v)`
    `IVecI` | `cornerCP(IIntegerI u, IIntegerI v)`
    `IVec` | `cornerCP(int u, int v)`
    `ISurfaceGeo` | `cp()` cp() is alias of dup()
    `ISurfaceGeo` | `cp(double x, double y, double z)` cp() is alias of dup().add()
    `ISurfaceGeo` | `cp(IDoubleI x, IDoubleI y, IDoubleI z)` cp() is alias of dup().add()
    `IVecI` | `cp(IIntegerI i, IIntegerI j)` getting control point at i and j
    `IVecI` | `cp(int i, int j)` getting control point at i and j
    `ISurfaceGeo` | `cp(IVecI v)` cp() is alias of dup().add()
    `IVecI[][]` | `cps()`
    `double` | `dist(IVec2I pt)` distance to the closest point on a surface on 2D
    `double` | `dist(IVecI pt)` distance to the closest point on a surface
    `ISurfaceGeo` | `div(double v)`
    `ISurfaceGeo` | `div(IDoubleI v)`
    `ISurfaceGeo` | `dup()` duplicate the instance
    `IVec` | `ep(IIntegerI i, IIntegerI j)` getting edit point at i and j
    `IVec` | `ep(int i, int j)` getting edit point at i and j
    `ISurfaceGeo` | `flip()` alias of neg
    `ISurfaceGeo` | `flipN()` alias of flipN()
    `ISurfaceGeo` | `flipU()` alias of revU()
    `ISurfaceGeo` | `flipUV()` alias of revUV()
    `ISurfaceGeo` | `flipV()` alias of revV()
    `ISurfaceGeo` | `get()`
    `static IVec[][]` | `getPlanarUVPoints(IVecI[][] pts, IVecI origin, IVec uvec, IVec vvec)`
    `static IVec[]` | `getPlanarUVPoints(IVecI[] pts, IVecI origin, IVec uvec, IVec vvec)`
    `static double[][]` | `getPlanarUVRange(IVec[] uvpts)`
    `static double[][]` | `getPlanarUVRange(IVec[][] uvpts)`
    `static IVec[]` | `getPlanarUVVectors(IVecI[] pts)`
    `static IVec[][]` | `getPointsFromArray(double[][][] xyzvalues)`
    `boolean` | `hasDefaultTrim()` default trim is rectangular outer trim at the exact boundary of untrimmed surface
    `boolean` | `hasDefaultTrim(ISwitchE e)`
    `IBool` | `hasDefaultTrim(ISwitchR r)`
    `boolean` | `hasInnerTrim()`
    `boolean` | `hasInnerTrim(ISwitchE e)`
    `IBool` | `hasInnerTrim(ISwitchR r)`
    `boolean` | `hasOuterTrim()`
    `boolean` | `hasOuterTrim(ISwitchE e)`
    `IBool` | `hasOuterTrim(ISwitchR r)`
    `boolean` | `hasTrim()`
    `boolean` | `hasTrim(ISwitchE e)`
    `IBool` | `hasTrim(ISwitchR r)`
    `void` | `init(IVecI[][] cpts, int udeg, int vdeg, boolean closeU, boolean closeV)`
    `void` | `init(IVecI[][] cpts, int udeg, int vdeg, boolean closeU, double[] vk)`
    `void` | `init(IVecI[][] cpts, int udeg, int vdeg, double[] uk, boolean closeV)`
    `void` | `init(IVecI[][] cpts, int udeg, int vdeg, double[] uk, double[] vk)`
    `void` | `initWithPlanarTrim(IVecI[][] cpts, int[] trimDeg, double[][] trimKnots, boolean close)`
    `void` | `initWithPlanarTrim(IVecI[][] cpts, int[] trimDeg, double[][] trimKnots, boolean close, IVecI[][][] innerCpts, int[][] innerTrimDeg, double[][][] innerTrimKnots, boolean[] innerClose)`
    `void` | `initWithPlanarTrim(IVecI[] cpts, int trimDeg, double[] trimKnots, boolean close)`
    `void` | `initWithPlanarTrim(IVecI[] cpts, int trimDeg, double[] trimKnots, boolean close, IVecI[][] innerCpts, int[] innerTrimDeg, double[][] innerTrimKnots, boolean[] innerClose)`
    `void` | `initWithPlanarTrims(ICurveI[] curves)`
    `ITrimCurveI` | `innerTrim(IIntegerI i, IIntegerI j)`
    `ITrimCurveI` | `innerTrim(int i, int j)`
    `ITrimCurveI[]` | `innerTrimLoop(IIntegerI i)`
    `ITrimCurveI[]` | `innerTrimLoop(int i)`
    `int` | `innerTrimLoopNum()`
    `int` | `innerTrimLoopNum(ISwitchE e)`
    `IInteger` | `innerTrimLoopNum(ISwitchR r)`
    `IInteger` | `innerTrimNum(IIntegerI i)`
    `int` | `innerTrimNum(int i)`
    `boolean` | `isFlat()` is the surface planar and flat
    `boolean` | `isFlat(ISwitchE e)`
    `IBool` | `isFlat(ISwitchR r)`
    `boolean` | `isInsideTrim(double u, double v)`
    `boolean` | `isInsideTrim(IVec2 v)` check if a u-v point is inside trim curves.
    `boolean` | `isInsideTrim(IVec2I v)`
    `boolean` | `isRational()`
    `boolean` | `isRational(ISwitchE e)`
    `IBool` | `isRational(ISwitchR r)`
    `static boolean` | `isTrimCurveCPInsideBoundary(ITrimCurveI crv, double u1, double v1, double u2, double v2)`
    `static boolean` | `isTrimCurveInsideBoundary(ITrimCurveI crv, double u1, double v1, double u2, double v2)`
    `static boolean` | `isTrimLoopClosed(ITrimCurveI[] crv)`
    `static boolean` | `isTrimLoopInsideBoundary(ITrimCurveI[] crv, double u1, double v1, double u2, double v2)`
    `boolean` | `isUClosed()` is the surface closed in u direction
    `boolean` | `isUClosed(ISwitchE e)`
    `IBool` | `isUClosed(ISwitchR r)`
    `boolean` | `isValid()`
    `static boolean` | `isValidCP(IVecI[][] cpts)`
    `static boolean` | `isValidCP(IVecI[][] cpts, int udeg, int vdeg, double[] uknots, double[] vknots)`
    `boolean` | `isVClosed()` is the surface closed in v direction
    `boolean` | `isVClosed(ISwitchE e)`
    `IBool` | `isVClosed(ISwitchR r)`
    `IVec` | `mid()` mid in UV parameter (u=0.5, v=0.5) point on a surface
    `ISurfaceGeo` | `mirror(IVecI planeDir)` mirror is alias of ref
    `ISurfaceGeo` | `mirror(IVecI center, IVecI planeDir)`
    `ISurfaceGeo` | `mul(double v)`
    `ISurfaceGeo` | `mul(IDoubleI v)`
    `ISurfaceGeo` | `mv(double x, double y, double z)` mv() is alias of add()
    `ISurfaceGeo` | `mv(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceGeo` | `mv(IVecI v)`
    `ISurfaceGeo` | `neg()`
    `IVec` | `nml(double u, double v)` alias of normal
    `void` | `nml(double u, double v, IVec retval)`
    `IVec` | `nml(IDoubleI u, IDoubleI v)`
    `IVec` | `nml(IVec2I v)`
    `IVec` | `normal(double u, double v)`
    `void` | `normal(double u, double v, IVec retval)`
    `IVec` | `normal(IDoubleI u, IDoubleI v)`
    `IVec` | `normal(IVec2I v)`
    `IVec` | `nrml(double u, double v)`
    `void` | `nrml(double u, double v, IVec retval)`
    `IVec` | `nrml(IDoubleI u, IDoubleI v)`
    `IVec` | `nrml(IVec2I v)`
    `ITrimCurveI` | `outerTrim(IIntegerI i, IIntegerI j)`
    `ITrimCurveI` | `outerTrim(int i, int j)`
    `ITrimCurveI[]` | `outerTrimLoop(IIntegerI i)`
    `ITrimCurveI[]` | `outerTrimLoop(int i)`
    `int` | `outerTrimLoopNum()`
    `int` | `outerTrimLoopNum(ISwitchE e)`
    `IInteger` | `outerTrimLoopNum(ISwitchR r)`
    `IInteger` | `outerTrimNum(IIntegerI i)`
    `int` | `outerTrimNum(int i)`
    `IVec` | `pt(double u, double v)`
    `IVec` | `pt(double u, double v, double n)`
    `void` | `pt(double u, double v, IVec retval)`
    `IVec` | `pt(IDoubleI u, IDoubleI v)`
    `IVec` | `pt(IDoubleI u, IDoubleI v, IDoubleI n)`
    `IVec` | `pt(IVec v)`
    `IVec` | `pt(IVec2I v)`
    `IVec` | `pt(IVecI v)`
    `ISurfaceGeo` | `ref(IVecI planeDir)` reflect(mirror) 3 dimensionally to the other side of the plane
    `ISurfaceGeo` | `ref(IVecI center, IVecI planeDir)`
    `ISurfaceGeo` | `revN()` reverse normal direction.
    `ISurfaceGeo` | `revTrimU()`
    `ISurfaceGeo` | `revU()` reverse U parameter.
    `ISurfaceGeo` | `revUV()` reverse U and V parameter at the same time
    `ISurfaceGeo` | `revV()` reverse V parameter.
    `ISurfaceGeo` | `rot(double angle)`
    `ISurfaceGeo` | `rot(IDoubleI angle)` rotation around z-axis and origin
    `ISurfaceGeo` | `rot(IVecI axis, double angle)`
    `ISurfaceGeo` | `rot(IVecI axis, IDoubleI angle)` rotation around axis vector
    `ISurfaceGeo` | `rot(IVecI axis, IVecI destDir)` rotate to destination direction vector
    `ISurfaceGeo` | `rot(IVecI center, IVecI axis, double angle)`
    `ISurfaceGeo` | `rot(IVecI center, IVecI axis, IDoubleI angle)` rotation around axis vector and center
    `ISurfaceGeo` | `rot(IVecI center, IVecI axis, IVecI destPt)` rotate to destination point location
    `ISurfaceGeo` | `rot2(double angle)` rotation on xy-plane around origin; same with rot(double)
    `ISurfaceGeo` | `rot2(IDoubleI angle)` rotation on xy-plane around origin; same with rot(IDoubleI)
    `ISurfaceGeo` | `rot2(IVecI destDir)` rotation on xy-plane to destination direction vector
    `ISurfaceGeo` | `rot2(IVecI center, double angle)`
    `ISurfaceGeo` | `rot2(IVecI center, IDoubleI angle)` rotation on xy-plane around center
    `ISurfaceGeo` | `rot2(IVecI center, IVecI destPt)` rotation on xy-plane to destination point location
    `ISurfaceGeo` | `scale(double f)`
    `ISurfaceGeo` | `scale(IDoubleI f)` alias of mul
    `ISurfaceGeo` | `scale(IVecI center, double f)`
    `ISurfaceGeo` | `scale(IVecI center, IDoubleI f)`
    `ISurfaceGeo` | `scale1d(IVecI axis, double f)` scale only in 1 direction
    `ISurfaceGeo` | `scale1d(IVecI axis, IDoubleI f)`
    `ISurfaceGeo` | `scale1d(IVecI center, IVecI axis, double f)`
    `ISurfaceGeo` | `scale1d(IVecI center, IVecI axis, IDoubleI f)`
    `IVecI[]` | `serializeMatrix(IVecI[][] cpts)`
    `ISurfaceGeo` | `shear(double sxy, double syx, double syz, double szy, double szx, double sxz)` shear operation
    `ISurfaceGeo` | `shear(IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceGeo` | `shear(IVecI center, double sxy, double syx, double syz, double szy, double szx, double sxz)`
    `ISurfaceGeo` | `shear(IVecI center, IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceGeo` | `shearXY(double sxy, double syx)`
    `ISurfaceGeo` | `shearXY(IDoubleI sxy, IDoubleI syx)`
    `ISurfaceGeo` | `shearXY(IVecI center, double sxy, double syx)`
    `ISurfaceGeo` | `shearXY(IVecI center, IDoubleI sxy, IDoubleI syx)`
    `ISurfaceGeo` | `shearYZ(double syz, double szy)`
    `ISurfaceGeo` | `shearYZ(IDoubleI syz, IDoubleI szy)`
    `ISurfaceGeo` | `shearYZ(IVecI center, double syz, double szy)`
    `ISurfaceGeo` | `shearYZ(IVecI center, IDoubleI syz, IDoubleI szy)`
    `ISurfaceGeo` | `shearZX(double szx, double sxz)`
    `ISurfaceGeo` | `shearZX(IDoubleI szx, IDoubleI sxz)`
    `ISurfaceGeo` | `shearZX(IVecI center, double szx, double sxz)`
    `ISurfaceGeo` | `shearZX(IVecI center, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceGeo` | `sub(double x, double y, double z)`
    `ISurfaceGeo` | `sub(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceGeo` | `sub(IVecI v)`
    `ISurfaceGeo` | `swapUV()` swap U and V parameter
    `ISurfaceGeo` | `transform(IMatrix3I mat)`
    `ISurfaceGeo` | `transform(IMatrix4I mat)`
    `ISurfaceGeo` | `transform(IVecI xvec, IVecI yvec, IVecI zvec)`
    `ISurfaceGeo` | `transform(IVecI xvec, IVecI yvec, IVecI zvec, IVecI translate)`
    `ISurfaceGeo` | `translate(double x, double y, double z)` translate() is alias of add()
    `ISurfaceGeo` | `translate(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceGeo` | `translate(IVecI v)`
    `IDouble` | `u(IIntegerI epIdx, IDoubleI epFraction)`
    `double` | `u(int epIdx, double epFraction)`
    `int` | `ucpNum()`
    `int` | `ucpNum(ISwitchE e)`
    `IInteger` | `ucpNum(ISwitchR r)`
    `int` | `udeg()`
    `int` | `udeg(ISwitchE e)`
    `IInteger` | `udeg(ISwitchR r)`
    `double` | `uend()`
    `double` | `uend(ISwitchE e)`
    `IDouble` | `uend(ISwitchR r)`
    `int` | `uepNum()`
    `int` | `uepNum(ISwitchE e)`
    `IInteger` | `uepNum(ISwitchR r)`
    `IDouble` | `uknot(IIntegerI i)`
    `double` | `uknot(int i)`
    `int` | `uknotNum()`
    `int` | `uknotNum(ISwitchE e)`
    `IInteger` | `uknotNum(ISwitchR r)`
    `double[]` | `uknots()`
    `double[]` | `uknots(ISwitchE e)`
    `IDouble[]` | `uknots(ISwitchR r)`
    `int` | `unum()`
    `int` | `unum(ISwitchE e)`
    `IInteger` | `unum(ISwitchR r)`
    `ISurfaceGeo` | `updateCache()`
    `double` | `ustart()` original knots start value and end value
    `double` | `ustart(ISwitchE e)`
    `IDouble` | `ustart(ISwitchR r)`
    `IVec` | `utan(double u, double v)`
    `void` | `utan(double u, double v, IVec retval)`
    `IVec` | `utan(IDoubleI u, IDoubleI v)`
    `IVec` | `utan(IVec2I v)`
    `IVec2` | `uv(IVec2I pt)` approximate invert projection from 2D location to interanl UV parameter (closest point on surface)
    `IVec2` | `uv(IVecI pt)` approximate invert projection from 3D location to interanl UV parameter (closest point on surface)
    `IDouble` | `v(IIntegerI epIdx, IDoubleI epFraction)`
    `double` | `v(int epIdx, double epFraction)`
    `int` | `vcpNum()`
    `int` | `vcpNum(ISwitchE e)`
    `IInteger` | `vcpNum(ISwitchR r)`
    `int` | `vdeg()`
    `int` | `vdeg(ISwitchE e)`
    `IInteger` | `vdeg(ISwitchR r)`
    `double` | `vend()`
    `double` | `vend(ISwitchE e)`
    `IDouble` | `vend(ISwitchR r)`
    `int` | `vepNum()`
    `int` | `vepNum(ISwitchE e)`
    `IInteger` | `vepNum(ISwitchR r)`
    `IDouble` | `vknot(IIntegerI i)`
    `double` | `vknot(int i)`
    `int` | `vknotNum()`
    `int` | `vknotNum(ISwitchE e)`
    `IInteger` | `vknotNum(ISwitchR r)`
    `double[]` | `vknots()`
    `double[]` | `vknots(ISwitchE e)`
    `IDouble[]` | `vknots(ISwitchR r)`
    `int` | `vnum()`
    `int` | `vnum(ISwitchE e)`
    `IInteger` | `vnum(ISwitchR r)`
    `double` | `vstart()`
    `double` | `vstart(ISwitchE e)`
    `IDouble` | `vstart(ISwitchR r)`
    `IVec` | `vtan(double u, double v)`
    `void` | `vtan(double u, double v, IVec retval)`
    `IVec` | `vtan(IDoubleI u, IDoubleI v)`
    `IVec` | `vtan(IVec2I v)`

    - ### Methods inherited from class igeo.INurbsGeo

      `createClosedCP, createClosedCPInU, createClosedCPInU, createClosedCPInV, createClosedCPInV, createClosedCPInW, createClosedKnots, createKnots, createKnots, invertKnots, isUClosed, isValidKnots, isVClosed, isWClosed, normalizeKnots`

    - ### Methods inherited from class igeo.IParameterObject

      `createObject, parent, parent`

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

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

- - ### Field Detail

    - #### controlPoints

          public IVecI[][] controlPoints

    - #### udegree

          public int udegree

    - #### vdegree

          public int vdegree

    - #### uknots

          public double[] uknots

      normalized knot vector (start value in knot vector is 0, end value is 1)

    - #### vknots

          public double[] vknots

      normalized knot vector (start value in knot vector is 0, end value is 1)

    - #### ustart

          public double ustart

    - #### uend

          public double uend

    - #### vstart

          public double vstart

    - #### vend

          public double vend

    - #### defaultWeights

          public boolean[][] defaultWeights

      flag to determine to use default weight value (1.0)

    - #### basisFunctionU

          public IBSplineBasisFunction basisFunctionU

    - #### basisFunctionV

          public IBSplineBasisFunction basisFunctionV

    - #### derivativeFunctionU

          public IBSplineBasisFunction derivativeFunctionU

    - #### derivativeFunctionV

          public IBSplineBasisFunction derivativeFunctionV

    - #### innerTrimLoop

          public java.util.ArrayList<java.util.ArrayList<ITrimCurve>> innerTrimLoop

    - #### outerTrimLoop

          public java.util.ArrayList<java.util.ArrayList<ITrimCurve>> outerTrimLoop

    - #### innerTrimClosed

          public boolean innerTrimClosed

    - #### outerTrimClosed

          public boolean outerTrimClosed

    - #### uvSearchCache

          public ISurfaceCache uvSearchCache

      point cache for proximity search

    - #### trimCache

          public ITrimCache trimCache

  - ### Constructor Detail

    - #### ISurfaceGeo

          public ISurfaceGeo()

    - #### ISurfaceGeo

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

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             int udegree,
                             int vdegree,
                             double[] uknots,
                             double[] vknots)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             int udegree,
                             int vdegree)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             int udegree,
                             int vdegree,
                             boolean closeU,
                             boolean closeV)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             int udegree,
                             int vdegree,
                             boolean closeU,
                             double[] vk)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             int udegree,
                             int vdegree,
                             double[] uk,
                             boolean closeV)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[][] cpts,
                             boolean closeU,
                             boolean closeV)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI pt1,
                             IVecI pt2,
                             IVecI pt3,
                             IVecI pt4)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI pt1,
                             IVecI pt2,
                             IVecI pt3)

    - #### ISurfaceGeo

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

    - #### ISurfaceGeo

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

    - #### ISurfaceGeo

          public ISurfaceGeo(double[][][] xyzValues)

    - #### ISurfaceGeo

          public ISurfaceGeo(double[][][] xyzValues,
                             int udeg,
                             int vdeg)

    - #### ISurfaceGeo

          public ISurfaceGeo(double[][][] xyzValues,
                             boolean closeU,
                             boolean closeV)

    - #### ISurfaceGeo

          public ISurfaceGeo(double[][][] xyzValues,
                             int udeg,
                             int vdeg,
                             boolean closeU,
                             boolean closeV)

    - #### ISurfaceGeo

          public ISurfaceGeo(ICurveI trimCurve)

      create surface with outer trim curve

    - #### ISurfaceGeo

          public ISurfaceGeo(ICurveI trimCurve,
                             ICurveI[] innerTrimCurves)

    - #### ISurfaceGeo

          public ISurfaceGeo(ICurveI[] outerTrimCurves,
                             ICurveI[][] innerTrimCurves)

    - #### ISurfaceGeo

          public ISurfaceGeo(ICurveI trimCurve,
                             ICurveI innerTrimCurve)

    - #### ISurfaceGeo

          public ISurfaceGeo(ICurveI[] trimCurves)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg,
                             double[] trimCrvKnots)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             IVecI[] innerTrimCrvPts)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg,
                             IVecI[] innerTrimCrvPts,
                             int innerTrimCrvDeg)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg,
                             double[] trimCrvKnots,
                             IVecI[] innerTrimCrvPts,
                             int innerTrimCrvDeg,
                             double[] innerTrimCrvKnots)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             IVecI[][] innerTrimCrvPts)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg,
                             IVecI[][] innerTrimCrvPts,
                             int[] innerTrimCrvDeg)

    - #### ISurfaceGeo

          public ISurfaceGeo(IVecI[] trimCrvPts,
                             int trimCrvDeg,
                             double[] trimCrvKnots,
                             IVecI[][] innerTrimCrvPts,
                             int[] innerTrimCrvDeg,
                             double[][] innerTrimCrvKnots)

    - #### ISurfaceGeo

          public ISurfaceGeo(ISurfaceGeo srf)

  - ### Method Detail

    - #### init

          public void init(IVecI[][] cpts,
                           int udeg,
                           int vdeg,
                           boolean closeU,
                           boolean closeV)

    - #### init

          public void init(IVecI[][] cpts,
                           int udeg,
                           int vdeg,
                           double[] uk,
                           boolean closeV)

    - #### init

          public void init(IVecI[][] cpts,
                           int udeg,
                           int vdeg,
                           boolean closeU,
                           double[] vk)

    - #### init

          public void init(IVecI[][] cpts,
                           int udeg,
                           int vdeg,
                           double[] uk,
                           double[] vk)

    - #### initWithPlanarTrim

          public void initWithPlanarTrim(IVecI[] cpts,
                                         int trimDeg,
                                         double[] trimKnots,
                                         boolean close)

    - #### serializeMatrix

          public IVecI[] serializeMatrix(IVecI[][] cpts)

    - #### initWithPlanarTrim

          public void initWithPlanarTrim(IVecI[][] cpts,
                                         int[] trimDeg,
                                         double[][] trimKnots,
                                         boolean close)

    - #### initWithPlanarTrim

          public void initWithPlanarTrim(IVecI[] cpts,
                                         int trimDeg,
                                         double[] trimKnots,
                                         boolean close,
                                         IVecI[][] innerCpts,
                                         int[] innerTrimDeg,
                                         double[][] innerTrimKnots,
                                         boolean[] innerClose)

    - #### initWithPlanarTrim

          public void initWithPlanarTrim(IVecI[][] cpts,
                                         int[] trimDeg,
                                         double[][] trimKnots,
                                         boolean close,
                                         IVecI[][][] innerCpts,
                                         int[][] innerTrimDeg,
                                         double[][][] innerTrimKnots,
                                         boolean[] innerClose)

    - #### initWithPlanarTrims

          public void initWithPlanarTrims(ICurveI[] curves)

    - #### isValid

          public boolean isValid()

      Specified by:
        `isValid` in interface `ISurfaceI`

    - #### isValidCP

          public static boolean isValidCP(IVecI[][] cpts,
                                          int udeg,
                                          int vdeg,
                                          double[] uknots,
                                          double[] vknots)

    - #### isValidCP

          public static boolean isValidCP(IVecI[][] cpts)

    - #### checkDuplicatedCP

          public static void checkDuplicatedCP(IVecI[][] cpts)

    - #### checkDuplicatedCP

          public static void checkDuplicatedCP(IVecI[][] cpts,
                                               IVecI[] pts)

    - #### checkDuplicatedCPOnEdge

          public static void checkDuplicatedCPOnEdge(IVecI[][] cpts)

    - #### getPointsFromArray

          public static IVec[][] getPointsFromArray(double[][][] xyzvalues)

    - #### getPlanarUVVectors

          public static IVec[] getPlanarUVVectors(IVecI[] pts)

    - #### getPlanarUVPoints

          public static IVec[] getPlanarUVPoints(IVecI[] pts,
                                                 IVecI origin,
                                                 IVec uvec,
                                                 IVec vvec)

    - #### getPlanarUVPoints

          public static IVec[][] getPlanarUVPoints(IVecI[][] pts,
                                                   IVecI origin,
                                                   IVec uvec,
                                                   IVec vvec)

    - #### getPlanarUVRange

          public static double[][] getPlanarUVRange(IVec[] uvpts)

    - #### getPlanarUVRange

          public static double[][] getPlanarUVRange(IVec[][] uvpts)

    - #### get

          public ISurfaceGeo get()

      Specified by:
        `get` in interface `IParameter`
      Specified by:
        `get` in interface `ISurfaceI`
      Specified by:
        `get` in interface `ISurfaceOp`
      Returns:
        fixed value but in wrapper class

    - #### dup

          public ISurfaceGeo dup()

      Description copied from interface: `ITransformable`
      duplicate the instance
      Specified by:
        `dup` in interface `ISurfaceI`
      Specified by:
        `dup` in interface `ITransformable`
      Returns:
        duplicated instance

    - #### pt

          public IVec pt(IVec2I v)

      Specified by:
        `pt` in interface `ISurfaceI`

    - #### pt

          public IVec pt(IDoubleI u,
                         IDoubleI v)

      Specified by:
        `pt` in interface `ISurfaceI`

    - #### pt

          public IVec pt(double u,
                         double v)

      Specified by:
        `pt` in interface `ISurfaceI`

    - #### pt

          public void pt(double u,
                         double v,
                         IVec retval)

    - #### pt

          public IVec pt(double u,
                         double v,
                         double n)

      Specified by:
        `pt` in interface `ISurfaceI`
      Parameters:
        `u` - u coordinates in uv parameter space
        `v` - v coordinates in uv parameter space
        `n` - length in normal direction in 3D space

    - #### pt

          public IVec pt(IDoubleI u,
                         IDoubleI v,
                         IDoubleI n)

      Specified by:
        `pt` in interface `ISurfaceI`

    - #### pt

          public IVec pt(IVec v)

    - #### pt

          public IVec pt(IVecI v)

      Specified by:
        `pt` in interface `ISurfaceI`

    - #### utan

          public IVec utan(IVec2I v)

      Specified by:
        `utan` in interface `ISurfaceI`

    - #### utan

          public IVec utan(IDoubleI u,
                           IDoubleI v)

      Specified by:
        `utan` in interface `ISurfaceI`

    - #### utan

          public IVec utan(double u,
                           double v)

      Specified by:
        `utan` in interface `ISurfaceI`

    - #### utan

          public void utan(double u,
                           double v,
                           IVec retval)

    - #### vtan

          public IVec vtan(IVec2I v)

      Specified by:
        `vtan` in interface `ISurfaceI`

    - #### vtan

          public IVec vtan(IDoubleI u,
                           IDoubleI v)

      Specified by:
        `vtan` in interface `ISurfaceI`

    - #### vtan

          public IVec vtan(double u,
                           double v)

      Specified by:
        `vtan` in interface `ISurfaceI`

    - #### vtan

          public void vtan(double u,
                           double v,
                           IVec retval)

    - #### nml

          public IVec nml(IVec2I v)

      Specified by:
        `nml` in interface `ISurfaceI`

    - #### nml

          public IVec nml(IDoubleI u,
                          IDoubleI v)

      Specified by:
        `nml` in interface `ISurfaceI`

    - #### nml

          public IVec nml(double u,
                          double v)

      Description copied from interface: `ISurfaceI`
      alias of normal
      Specified by:
        `nml` in interface `ISurfaceI`

    - #### nml

          public void nml(double u,
                          double v,
                          IVec retval)

    - #### nrml

          public IVec nrml(IVec2I v)

      Specified by:
        `nrml` in interface `ISurfaceI`

    - #### nrml

          public IVec nrml(IDoubleI u,
                           IDoubleI v)

      Specified by:
        `nrml` in interface `ISurfaceI`

    - #### nrml

          public IVec nrml(double u,
                           double v)

      Specified by:
        `nrml` in interface `ISurfaceI`

    - #### nrml

          public void nrml(double u,
                           double v,
                           IVec retval)

    - #### normal

          public IVec normal(IVec2I v)

      Specified by:
        `normal` in interface `ISurfaceI`

    - #### normal

          public IVec normal(IDoubleI u,
                             IDoubleI v)

      Specified by:
        `normal` in interface `ISurfaceI`

    - #### normal

          public IVec normal(double u,
                             double v)

      Specified by:
        `normal` in interface `ISurfaceI`

    - #### normal

          public void normal(double u,
                             double v,
                             IVec retval)

    - #### cp

          public IVecI cp(int i,
                          int j)

      getting control point at i and j
      Specified by:
        `cp` in interface `ISurfaceI`

    - #### cp

          public IVecI cp(IIntegerI i,
                          IIntegerI j)

      getting control point at i and j
      Specified by:
        `cp` in interface `ISurfaceI`

    - #### cps

          public IVecI[][] cps()

      Specified by:
        `cps` in interface `ISurfaceI`

    - #### corner

          public IVec corner(int u,
                             int v)

      Specified by:
        `corner` in interface `ISurfaceI`

    - #### corner

          public IVec corner(IIntegerI u,
                             IIntegerI v)

      Specified by:
        `corner` in interface `ISurfaceI`

    - #### cornerCP

          public IVec cornerCP(int u,
                               int v)

      Specified by:
        `cornerCP` in interface `ISurfaceI`

    - #### cornerCP

          public IVecI cornerCP(IIntegerI u,
                                IIntegerI v)

      Specified by:
        `cornerCP` in interface `ISurfaceI`

    - #### addUCP

          public ISurfaceGeo addUCP(IVecI[] pts)

      add control point at the end and rebuild the surface note that a knots is rebuilt with default equal intervals and destroy original knot intervals if variable, like circle.

    - #### addVCP

          public ISurfaceGeo addVCP(IVecI[] pts)

      add control point at the end and rebuild the surface note that a knots is rebuilt with default equal intervals and destroy original knot intervals if variable, like circle.

    - #### ep

          public IVec ep(int i,
                         int j)

      getting edit point at i and j
      Specified by:
        `ep` in interface `ISurfaceI`

    - #### ep

          public IVec ep(IIntegerI i,
                         IIntegerI j)

      getting edit point at i and j
      Specified by:
        `ep` in interface `ISurfaceI`

    - #### mid

          public IVec mid()

      mid in UV parameter (u=0.5, v=0.5) point on a surface
      Specified by:
        `mid` in interface `ISurfaceI`

    - #### center

          public IVec center()

      returns center of geometry object
      Specified by:
        `center` in interface `ISurfaceI`

    - #### uv

          public IVec2 uv(IVecI pt)

      approximate invert projection from 3D location to interanl UV parameter (closest point on surface)
      Specified by:
        `uv` in interface `ISurfaceI`

    - #### uv

          public IVec2 uv(IVec2I pt)

      approximate invert projection from 2D location to interanl UV parameter (closest point on surface)
      Specified by:
        `uv` in interface `ISurfaceI`

    - #### closePt

          public IVec closePt(IVecI pt)

      find approximately closest point on a surface
      Specified by:
        `closePt` in interface `ISurfaceI`

    - #### closePt

          public IVec closePt(IVec2I pt)

      find approximately closest point on a surface on 2D
      Specified by:
        `closePt` in interface `ISurfaceI`

    - #### dist

          public double dist(IVecI pt)

      distance to the closest point on a surface
      Specified by:
        `dist` in interface `ISurfaceI`

    - #### dist

          public double dist(IVec2I pt)

      distance to the closest point on a surface on 2D
      Specified by:
        `dist` in interface `ISurfaceI`

    - #### uknot

          public double uknot(int i)

      Specified by:
        `uknot` in interface `ISurfaceI`

    - #### uknot

          public IDouble uknot(IIntegerI i)

      Specified by:
        `uknot` in interface `ISurfaceI`

    - #### vknot

          public double vknot(int i)

      Specified by:
        `vknot` in interface `ISurfaceI`

    - #### vknot

          public IDouble vknot(IIntegerI i)

      Specified by:
        `vknot` in interface `ISurfaceI`

    - #### uknots

          public double[] uknots()

      Specified by:
        `uknots` in interface `ISurfaceI`

    - #### uknots

          public double[] uknots(ISwitchE e)

      Specified by:
        `uknots` in interface `ISurfaceI`

    - #### uknots

          public IDouble[] uknots(ISwitchR r)

      Specified by:
        `uknots` in interface `ISurfaceI`

    - #### vknots

          public double[] vknots()

      Specified by:
        `vknots` in interface `ISurfaceI`

    - #### vknots

          public double[] vknots(ISwitchE e)

      Specified by:
        `vknots` in interface `ISurfaceI`

    - #### vknots

          public IDouble[] vknots(ISwitchR r)

      Specified by:
        `vknots` in interface `ISurfaceI`

    - #### uknotNum

          public int uknotNum()

      Specified by:
        `uknotNum` in interface `ISurfaceI`

    - #### vknotNum

          public int vknotNum()

      Specified by:
        `vknotNum` in interface `ISurfaceI`

    - #### uknotNum

          public int uknotNum(ISwitchE e)

      Specified by:
        `uknotNum` in interface `ISurfaceI`

    - #### vknotNum

          public int vknotNum(ISwitchE e)

      Specified by:
        `vknotNum` in interface `ISurfaceI`

    - #### uknotNum

          public IInteger uknotNum(ISwitchR r)

      Specified by:
        `uknotNum` in interface `ISurfaceI`

    - #### vknotNum

          public IInteger vknotNum(ISwitchR r)

      Specified by:
        `vknotNum` in interface `ISurfaceI`

    - #### isRational

          public boolean isRational()

      Specified by:
        `isRational` in interface `ISurfaceI`
      Returns:
        returns true if any of control point has non-default(1.0) weight otherwise false.

    - #### isRational

          public boolean isRational(ISwitchE e)

      Specified by:
        `isRational` in interface `ISurfaceI`

    - #### isRational

          public IBool isRational(ISwitchR r)

      Specified by:
        `isRational` in interface `ISurfaceI`

    - #### udeg

          public int udeg()

      Specified by:
        `udeg` in interface `ISurfaceI`

    - #### vdeg

          public int vdeg()

      Specified by:
        `vdeg` in interface `ISurfaceI`

    - #### udeg

          public int udeg(ISwitchE e)

      Specified by:
        `udeg` in interface `ISurfaceI`

    - #### vdeg

          public int vdeg(ISwitchE e)

      Specified by:
        `vdeg` in interface `ISurfaceI`

    - #### udeg

          public IInteger udeg(ISwitchR r)

      Specified by:
        `udeg` in interface `ISurfaceI`

    - #### vdeg

          public IInteger vdeg(ISwitchR r)

      Specified by:
        `vdeg` in interface `ISurfaceI`

    - #### unum

          public int unum()

      Specified by:
        `unum` in interface `ISurfaceI`

    - #### vnum

          public int vnum()

      Specified by:
        `vnum` in interface `ISurfaceI`

    - #### unum

          public int unum(ISwitchE e)

      Specified by:
        `unum` in interface `ISurfaceI`

    - #### vnum

          public int vnum(ISwitchE e)

      Specified by:
        `vnum` in interface `ISurfaceI`

    - #### unum

          public IInteger unum(ISwitchR r)

      Specified by:
        `unum` in interface `ISurfaceI`

    - #### vnum

          public IInteger vnum(ISwitchR r)

      Specified by:
        `vnum` in interface `ISurfaceI`

    - #### ucpNum

          public int ucpNum()

      Specified by:
        `ucpNum` in interface `ISurfaceI`

    - #### vcpNum

          public int vcpNum()

      Specified by:
        `vcpNum` in interface `ISurfaceI`

    - #### ucpNum

          public int ucpNum(ISwitchE e)

      Specified by:
        `ucpNum` in interface `ISurfaceI`

    - #### vcpNum

          public int vcpNum(ISwitchE e)

      Specified by:
        `vcpNum` in interface `ISurfaceI`

    - #### ucpNum

          public IInteger ucpNum(ISwitchR r)

      Specified by:
        `ucpNum` in interface `ISurfaceI`

    - #### vcpNum

          public IInteger vcpNum(ISwitchR r)

      Specified by:
        `vcpNum` in interface `ISurfaceI`

    - #### uepNum

          public int uepNum()

      Specified by:
        `uepNum` in interface `ISurfaceI`

    - #### vepNum

          public int vepNum()

      Specified by:
        `vepNum` in interface `ISurfaceI`

    - #### uepNum

          public int uepNum(ISwitchE e)

      Specified by:
        `uepNum` in interface `ISurfaceI`

    - #### vepNum

          public int vepNum(ISwitchE e)

      Specified by:
        `vepNum` in interface `ISurfaceI`

    - #### uepNum

          public IInteger uepNum(ISwitchR r)

      Specified by:
        `uepNum` in interface `ISurfaceI`

    - #### vepNum

          public IInteger vepNum(ISwitchR r)

      Specified by:
        `vepNum` in interface `ISurfaceI`

    - #### u

          public double u(int epIdx,
                          double epFraction)

      Specified by:
        `u` in interface `ISurfaceI`

    - #### u

          public IDouble u(IIntegerI epIdx,
                           IDoubleI epFraction)

      Specified by:
        `u` in interface `ISurfaceI`

    - #### v

          public double v(int epIdx,
                          double epFraction)

      Specified by:
        `v` in interface `ISurfaceI`

    - #### v

          public IDouble v(IIntegerI epIdx,
                           IDoubleI epFraction)

      Specified by:
        `v` in interface `ISurfaceI`

    - #### ustart

          public double ustart()

      Description copied from interface: `ISurfaceI`
      original knots start value and end value
      Specified by:
        `ustart` in interface `ISurfaceI`

    - #### uend

          public double uend()

      Specified by:
        `uend` in interface `ISurfaceI`

    - #### vstart

          public double vstart()

      Specified by:
        `vstart` in interface `ISurfaceI`

    - #### vend

          public double vend()

      Specified by:
        `vend` in interface `ISurfaceI`

    - #### ustart

          public double ustart(ISwitchE e)

      Specified by:
        `ustart` in interface `ISurfaceI`

    - #### uend

          public double uend(ISwitchE e)

      Specified by:
        `uend` in interface `ISurfaceI`

    - #### vstart

          public double vstart(ISwitchE e)

      Specified by:
        `vstart` in interface `ISurfaceI`

    - #### vend

          public double vend(ISwitchE e)

      Specified by:
        `vend` in interface `ISurfaceI`

    - #### ustart

          public IDouble ustart(ISwitchR r)

      Specified by:
        `ustart` in interface `ISurfaceI`

    - #### uend

          public IDouble uend(ISwitchR r)

      Specified by:
        `uend` in interface `ISurfaceI`

    - #### vstart

          public IDouble vstart(ISwitchR r)

      Specified by:
        `vstart` in interface `ISurfaceI`

    - #### vend

          public IDouble vend(ISwitchR r)

      Specified by:
        `vend` in interface `ISurfaceI`

    - #### revU

          public ISurfaceGeo revU()

      reverse U parameter. it changes internal parameter without creating a new instance.
      Specified by:
        `revU` in interface `ISurfaceI`

    - #### revTrimU

          public ISurfaceGeo revTrimU()

    - #### revV

          public ISurfaceGeo revV()

      reverse V parameter. it changes internal parameter without creating a new instance.
      Specified by:
        `revV` in interface `ISurfaceI`

    - #### revUV

          public ISurfaceGeo revUV()

      reverse U and V parameter at the same time
      Specified by:
        `revUV` in interface `ISurfaceI`

    - #### revN

          public ISurfaceGeo revN()

      reverse normal direction. just reversing V direction. the normal direction is not independent from U and V direction.
      Specified by:
        `revN` in interface `ISurfaceI`

    - #### flipU

          public ISurfaceGeo flipU()

      alias of revU()
      Specified by:
        `flipU` in interface `ISurfaceI`

    - #### flipV

          public ISurfaceGeo flipV()

      alias of revV()
      Specified by:
        `flipV` in interface `ISurfaceI`

    - #### flipUV

          public ISurfaceGeo flipUV()

      alias of revUV()
      Specified by:
        `flipUV` in interface `ISurfaceI`

    - #### flipN

          public ISurfaceGeo flipN()

      alias of flipN()
      Specified by:
        `flipN` in interface `ISurfaceI`

    - #### swapUV

          public ISurfaceGeo swapUV()

      swap U and V parameter
      Specified by:
        `swapUV` in interface `ISurfaceI`

    - #### clearInnerTrim

          public ISurfaceGeo clearInnerTrim()

      Specified by:
        `clearInnerTrim` in interface `ISurfaceI`

    - #### clearOuterTrim

          public ISurfaceGeo clearOuterTrim()

      Specified by:
        `clearOuterTrim` in interface `ISurfaceI`

    - #### clearTrim

          public ISurfaceGeo clearTrim()

      Specified by:
        `clearTrim` in interface `ISurfaceI`

    - #### isTrimLoopInsideBoundary

          public static boolean isTrimLoopInsideBoundary(ITrimCurveI[] crv,
                                                         double u1,
                                                         double v1,
                                                         double u2,
                                                         double v2)

    - #### isTrimCurveInsideBoundary

          public static boolean isTrimCurveInsideBoundary(ITrimCurveI crv,
                                                          double u1,
                                                          double v1,
                                                          double u2,
                                                          double v2)

    - #### isTrimCurveCPInsideBoundary

          public static boolean isTrimCurveCPInsideBoundary(ITrimCurveI crv,
                                                            double u1,
                                                            double v1,
                                                            double u2,
                                                            double v2)

    - #### isTrimLoopClosed

          public static boolean isTrimLoopClosed(ITrimCurveI[] crv)

    - #### checkTrimLoop

          public boolean checkTrimLoop(ITrimCurve[] loop)

    - #### checkTrimLoop

          public boolean checkTrimLoop(ITrimCurve loop)

    - #### checkTrim

          public boolean checkTrim(ITrimCurve curve)

    - #### addDefaultOuterTrimLoop

          public ISurfaceGeo addDefaultOuterTrimLoop()

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ITrimCurveI[] loop)

      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`
      Parameters:
        `loop` - array of trim curves need to form closed loop

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ITrimCurve[] loop)

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ITrimCurveI loop)

      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`
      Parameters:
        `loop` - trim curve needs to be closed

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ITrimCurve loop)

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ICurveI[] trim)

      Description copied from interface: `ISurfaceI`
      input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ICurveI[] trim,
                                              boolean deleteInput)

      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ICurveI trim)

      Description copied from interface: `ISurfaceI`
      input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`

    - #### addInnerTrimLoop

          public ISurfaceGeo addInnerTrimLoop(ICurveI trim,
                                              boolean deleteInput)

      Specified by:
        `addInnerTrimLoop` in interface `ISurfaceI`

    - #### addInnerTrim

          public ISurfaceGeo addInnerTrim(ITrimCurve trimCrv)

    - #### closeInnerTrim

          public ISurfaceGeo closeInnerTrim()

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ITrimCurveI[] loop)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ITrimCurve[] loop)

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ITrimCurveI loop)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ITrimCurve loop)

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ICurveI[] trim)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ICurveI[] trim,
                                              boolean deleteInput)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ICurveI trim)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrimLoop

          public ISurfaceGeo addOuterTrimLoop(ICurveI trim,
                                              boolean deleteInput)

      Specified by:
        `addOuterTrimLoop` in interface `ISurfaceI`

    - #### addOuterTrim

          public ISurfaceGeo addOuterTrim(ITrimCurve trimCrv)

    - #### closeOuterTrim

          public ISurfaceGeo closeOuterTrim()

    - #### hasTrim

          public boolean hasTrim()

      Specified by:
        `hasTrim` in interface `ISurfaceI`

    - #### hasInnerTrim

          public boolean hasInnerTrim()

      Specified by:
        `hasInnerTrim` in interface `ISurfaceI`

    - #### hasOuterTrim

          public boolean hasOuterTrim()

      Specified by:
        `hasOuterTrim` in interface `ISurfaceI`

    - #### hasTrim

          public boolean hasTrim(ISwitchE e)

      Specified by:
        `hasTrim` in interface `ISurfaceI`

    - #### hasInnerTrim

          public boolean hasInnerTrim(ISwitchE e)

      Specified by:
        `hasInnerTrim` in interface `ISurfaceI`

    - #### hasOuterTrim

          public boolean hasOuterTrim(ISwitchE e)

      Specified by:
        `hasOuterTrim` in interface `ISurfaceI`

    - #### hasTrim

          public IBool hasTrim(ISwitchR r)

      Specified by:
        `hasTrim` in interface `ISurfaceI`

    - #### hasInnerTrim

          public IBool hasInnerTrim(ISwitchR r)

      Specified by:
        `hasInnerTrim` in interface `ISurfaceI`

    - #### hasOuterTrim

          public IBool hasOuterTrim(ISwitchR r)

      Specified by:
        `hasOuterTrim` in interface `ISurfaceI`

    - #### innerTrimLoopNum

          public int innerTrimLoopNum()

      Specified by:
        `innerTrimLoopNum` in interface `ISurfaceI`

    - #### outerTrimLoopNum

          public int outerTrimLoopNum()

      Specified by:
        `outerTrimLoopNum` in interface `ISurfaceI`

    - #### innerTrimLoopNum

          public int innerTrimLoopNum(ISwitchE e)

      Specified by:
        `innerTrimLoopNum` in interface `ISurfaceI`

    - #### outerTrimLoopNum

          public int outerTrimLoopNum(ISwitchE e)

      Specified by:
        `outerTrimLoopNum` in interface `ISurfaceI`

    - #### innerTrimLoopNum

          public IInteger innerTrimLoopNum(ISwitchR r)

      Specified by:
        `innerTrimLoopNum` in interface `ISurfaceI`

    - #### outerTrimLoopNum

          public IInteger outerTrimLoopNum(ISwitchR r)

      Specified by:
        `outerTrimLoopNum` in interface `ISurfaceI`

    - #### innerTrimNum

          public int innerTrimNum(int i)

      Specified by:
        `innerTrimNum` in interface `ISurfaceI`

    - #### innerTrimNum

          public IInteger innerTrimNum(IIntegerI i)

      Specified by:
        `innerTrimNum` in interface `ISurfaceI`

    - #### outerTrimNum

          public int outerTrimNum(int i)

      Specified by:
        `outerTrimNum` in interface `ISurfaceI`

    - #### outerTrimNum

          public IInteger outerTrimNum(IIntegerI i)

      Specified by:
        `outerTrimNum` in interface `ISurfaceI`

    - #### innerTrimLoop

          public ITrimCurveI[] innerTrimLoop(int i)

      Specified by:
        `innerTrimLoop` in interface `ISurfaceI`

    - #### innerTrimLoop

          public ITrimCurveI[] innerTrimLoop(IIntegerI i)

      Specified by:
        `innerTrimLoop` in interface `ISurfaceI`

    - #### outerTrimLoop

          public ITrimCurveI[] outerTrimLoop(int i)

      Specified by:
        `outerTrimLoop` in interface `ISurfaceI`

    - #### outerTrimLoop

          public ITrimCurveI[] outerTrimLoop(IIntegerI i)

      Specified by:
        `outerTrimLoop` in interface `ISurfaceI`

    - #### innerTrim

          public ITrimCurveI innerTrim(int i,
                                       int j)

      Specified by:
        `innerTrim` in interface `ISurfaceI`

    - #### innerTrim

          public ITrimCurveI innerTrim(IIntegerI i,
                                       IIntegerI j)

      Specified by:
        `innerTrim` in interface `ISurfaceI`

    - #### outerTrim

          public ITrimCurveI outerTrim(int i,
                                       int j)

      Specified by:
        `outerTrim` in interface `ISurfaceI`

    - #### outerTrim

          public ITrimCurveI outerTrim(IIntegerI i,
                                       IIntegerI j)

      Specified by:
        `outerTrim` in interface `ISurfaceI`

    - #### hasDefaultTrim

          public boolean hasDefaultTrim()

      default trim is rectangular outer trim at the exact boundary of untrimmed surface
      Specified by:
        `hasDefaultTrim` in interface `ISurfaceI`

    - #### hasDefaultTrim

          public boolean hasDefaultTrim(ISwitchE e)

      Specified by:
        `hasDefaultTrim` in interface `ISurfaceI`

    - #### hasDefaultTrim

          public IBool hasDefaultTrim(ISwitchR r)

      Specified by:
        `hasDefaultTrim` in interface `ISurfaceI`

    - #### isFlat

          public boolean isFlat()

      is the surface planar and flat
      Specified by:
        `isFlat` in interface `ISurfaceI`

    - #### isFlat

          public boolean isFlat(ISwitchE e)

      Specified by:
        `isFlat` in interface `ISurfaceI`

    - #### isFlat

          public IBool isFlat(ISwitchR r)

      Specified by:
        `isFlat` in interface `ISurfaceI`

    - #### isUClosed

          public boolean isUClosed()

      is the surface closed in u direction
      Specified by:
        `isUClosed` in interface `ISurfaceI`

    - #### isUClosed

          public boolean isUClosed(ISwitchE e)

      Specified by:
        `isUClosed` in interface `ISurfaceI`

    - #### isUClosed

          public IBool isUClosed(ISwitchR r)

      Specified by:
        `isUClosed` in interface `ISurfaceI`

    - #### isVClosed

          public boolean isVClosed()

      is the surface closed in v direction
      Specified by:
        `isVClosed` in interface `ISurfaceI`

    - #### isVClosed

          public boolean isVClosed(ISwitchE e)

      Specified by:
        `isVClosed` in interface `ISurfaceI`

    - #### isVClosed

          public IBool isVClosed(ISwitchR r)

      Specified by:
        `isVClosed` in interface `ISurfaceI`

    - #### isInsideTrim

          public boolean isInsideTrim(IVec2I v)

    - #### isInsideTrim

          public boolean isInsideTrim(double u,
                                      double v)

    - #### isInsideTrim

          public boolean isInsideTrim(IVec2 v)

      check if a u-v point is inside trim curves. the condition where out-trim loop is inside in-trim loop is ignored and it'd be false.

    - #### updateCache

          public ISurfaceGeo updateCache()

    - #### add

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

      transformation methods; API of ITransformable interface
      Specified by:
        `add` in interface `ISurfaceI`
      Specified by:
        `add` in interface `ITransformable`

    - #### add

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

      Specified by:
        `add` in interface `ISurfaceI`
      Specified by:
        `add` in interface `ITransformable`

    - #### add

          public ISurfaceGeo add(IVecI v)

      Specified by:
        `add` in interface `ISurfaceI`
      Specified by:
        `add` in interface `ITransformable`

    - #### sub

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

      Specified by:
        `sub` in interface `ISurfaceI`
      Specified by:
        `sub` in interface `ITransformable`

    - #### sub

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

      Specified by:
        `sub` in interface `ISurfaceI`
      Specified by:
        `sub` in interface `ITransformable`

    - #### sub

          public ISurfaceGeo sub(IVecI v)

      Specified by:
        `sub` in interface `ISurfaceI`
      Specified by:
        `sub` in interface `ITransformable`

    - #### mul

          public ISurfaceGeo mul(IDoubleI v)

      Specified by:
        `mul` in interface `ISurfaceI`
      Specified by:
        `mul` in interface `ITransformable`

    - #### mul

          public ISurfaceGeo mul(double v)

      Specified by:
        `mul` in interface `ISurfaceI`
      Specified by:
        `mul` in interface `ITransformable`

    - #### div

          public ISurfaceGeo div(IDoubleI v)

      Specified by:
        `div` in interface `ISurfaceI`
      Specified by:
        `div` in interface `ITransformable`

    - #### div

          public ISurfaceGeo div(double v)

      Specified by:
        `div` in interface `ISurfaceI`
      Specified by:
        `div` in interface `ITransformable`

    - #### neg

          public ISurfaceGeo neg()

      Specified by:
        `neg` in interface `ISurfaceI`
      Specified by:
        `neg` in interface `ITransformable`

    - #### flip

          public ISurfaceGeo flip()

      alias of neg
      Specified by:
        `flip` in interface `ISurfaceI`
      Specified by:
        `flip` in interface `ITransformable`

    - #### add

          public ISurfaceGeo add(IVecI v,
                                 double f)

      scale add
      Specified by:
        `add` in interface `ISurfaceI`
      Specified by:
        `add` in interface `ITransformable`

    - #### add

          public ISurfaceGeo add(IVecI v,
                                 IDoubleI f)

      Description copied from interface: `ITransformable`
      scale add
      Specified by:
        `add` in interface `ISurfaceI`
      Specified by:
        `add` in interface `ITransformable`

    - #### add

          public ISurfaceGeo add(double f,
                                 IVecI v)

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

    - #### add

          public ISurfaceGeo add(IDoubleI f,
                                 IVecI v)

      Description copied from interface: `ITransformable`
      scale add alias
      Specified by:
        `add` in interface `ITransformable`

    - #### rot

          public ISurfaceGeo rot(IDoubleI angle)

      Description copied from interface: `ITransformable`
      rotation around z-axis and origin
      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          public ISurfaceGeo rot(double angle)

      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          public ISurfaceGeo rot(IVecI axis,
                                 IDoubleI angle)

      Description copied from interface: `ITransformable`
      rotation around axis vector
      Specified by:
        `rot` in interface `ISurfaceI`
      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          public ISurfaceGeo rot(IVecI axis,
                                 double angle)

      Specified by:
        `rot` in interface `ISurfaceI`
      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

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

      Description copied from interface: `ITransformable`
      rotation around axis vector and center
      Specified by:
        `rot` in interface `ISurfaceI`
      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

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

      Specified by:
        `rot` in interface `ISurfaceI`
      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          public ISurfaceGeo rot(IVecI axis,
                                 IVecI destDir)

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

    - #### rot

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

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

    - #### rot2

          public ISurfaceGeo rot2(IDoubleI angle)

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

    - #### rot2

          public ISurfaceGeo rot2(double angle)

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

    - #### rot2

          public ISurfaceGeo rot2(IVecI center,
                                  IDoubleI angle)

      Description copied from interface: `ITransformable`
      rotation on xy-plane around center
      Specified by:
        `rot2` in interface `ITransformable`

    - #### rot2

          public ISurfaceGeo rot2(IVecI center,
                                  double angle)

      Specified by:
        `rot2` in interface `ITransformable`

    - #### rot2

          public ISurfaceGeo rot2(IVecI destDir)

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

    - #### rot2

          public ISurfaceGeo rot2(IVecI center,
                                  IVecI destPt)

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

    - #### scale

          public ISurfaceGeo scale(IDoubleI f)

      alias of mul
      Specified by:
        `scale` in interface `ISurfaceI`
      Specified by:
        `scale` in interface `ITransformable`

    - #### scale

          public ISurfaceGeo scale(double f)

      Specified by:
        `scale` in interface `ISurfaceI`
      Specified by:
        `scale` in interface `ITransformable`

    - #### scale

          public ISurfaceGeo scale(IVecI center,
                                   IDoubleI f)

      Specified by:
        `scale` in interface `ISurfaceI`
      Specified by:
        `scale` in interface `ITransformable`

    - #### scale

          public ISurfaceGeo scale(IVecI center,
                                   double f)

      Specified by:
        `scale` in interface `ISurfaceI`
      Specified by:
        `scale` in interface `ITransformable`

    - #### scale1d

          public ISurfaceGeo scale1d(IVecI axis,
                                     double f)

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

    - #### scale1d

          public ISurfaceGeo scale1d(IVecI axis,
                                     IDoubleI f)

      Specified by:
        `scale1d` in interface `ISurfaceI`
      Specified by:
        `scale1d` in interface `ITransformable`

    - #### scale1d

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

      Specified by:
        `scale1d` in interface `ISurfaceI`
      Specified by:
        `scale1d` in interface `ITransformable`

    - #### scale1d

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

      Specified by:
        `scale1d` in interface `ISurfaceI`
      Specified by:
        `scale1d` in interface `ITransformable`

    - #### ref

          public ISurfaceGeo ref(IVecI planeDir)

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

    - #### ref

          public ISurfaceGeo ref(IVecI center,
                                 IVecI planeDir)

      Specified by:
        `ref` in interface `ISurfaceI`
      Specified by:
        `ref` in interface `ITransformable`

    - #### mirror

          public ISurfaceGeo mirror(IVecI planeDir)

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

    - #### mirror

          public ISurfaceGeo mirror(IVecI center,
                                    IVecI planeDir)

      Specified by:
        `mirror` in interface `ISurfaceI`
      Specified by:
        `mirror` in interface `ITransformable`

    - #### shear

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

      shear operation
      Specified by:
        `shear` in interface `ISurfaceI`
      Specified by:
        `shear` in interface `ITransformable`

    - #### shear

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

      Specified by:
        `shear` in interface `ISurfaceI`
      Specified by:
        `shear` in interface `ITransformable`

    - #### shear

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

      Specified by:
        `shear` in interface `ISurfaceI`
      Specified by:
        `shear` in interface `ITransformable`

    - #### shear

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

      Specified by:
        `shear` in interface `ISurfaceI`
      Specified by:
        `shear` in interface `ITransformable`

    - #### shearXY

          public ISurfaceGeo shearXY(double sxy,
                                     double syx)

      Specified by:
        `shearXY` in interface `ISurfaceI`
      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

          public ISurfaceGeo shearXY(IDoubleI sxy,
                                     IDoubleI syx)

      Specified by:
        `shearXY` in interface `ISurfaceI`
      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

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

      Specified by:
        `shearXY` in interface `ISurfaceI`
      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

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

      Specified by:
        `shearXY` in interface `ISurfaceI`
      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearYZ

          public ISurfaceGeo shearYZ(double syz,
                                     double szy)

      Specified by:
        `shearYZ` in interface `ISurfaceI`
      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

          public ISurfaceGeo shearYZ(IDoubleI syz,
                                     IDoubleI szy)

      Specified by:
        `shearYZ` in interface `ISurfaceI`
      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

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

      Specified by:
        `shearYZ` in interface `ISurfaceI`
      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

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

      Specified by:
        `shearYZ` in interface `ISurfaceI`
      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearZX

          public ISurfaceGeo shearZX(double szx,
                                     double sxz)

      Specified by:
        `shearZX` in interface `ISurfaceI`
      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

          public ISurfaceGeo shearZX(IDoubleI szx,
                                     IDoubleI sxz)

      Specified by:
        `shearZX` in interface `ISurfaceI`
      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

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

      Specified by:
        `shearZX` in interface `ISurfaceI`
      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

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

      Specified by:
        `shearZX` in interface `ISurfaceI`
      Specified by:
        `shearZX` in interface `ITransformable`

    - #### mv

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

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

    - #### mv

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

      Specified by:
        `mv` in interface `ISurfaceI`
      Specified by:
        `mv` in interface `ITransformable`

    - #### mv

          public ISurfaceGeo mv(IVecI v)

      Specified by:
        `mv` in interface `ISurfaceI`
      Specified by:
        `mv` in interface `ITransformable`

    - #### cp

          public ISurfaceGeo cp()

      cp() is alias of dup()
      Specified by:
        `cp` in interface `ISurfaceI`
      Specified by:
        `cp` in interface `ITransformable`

    - #### cp

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

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

    - #### cp

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

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

    - #### cp

          public ISurfaceGeo cp(IVecI v)

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

    - #### translate

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

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

    - #### translate

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

      Specified by:
        `translate` in interface `ISurfaceI`
      Specified by:
        `translate` in interface `ITransformable`

    - #### translate

          public ISurfaceGeo translate(IVecI v)

      Specified by:
        `translate` in interface `ISurfaceI`
      Specified by:
        `translate` in interface `ITransformable`

    - #### transform

          public ISurfaceGeo transform(IMatrix3I mat)

      Specified by:
        `transform` in interface `ISurfaceI`
      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

          public ISurfaceGeo transform(IMatrix4I mat)

      Specified by:
        `transform` in interface `ISurfaceI`
      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

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

      Specified by:
        `transform` in interface `ISurfaceI`
      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

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

      Specified by:
        `transform` in interface `ISurfaceI`
      Specified by:
        `transform` in interface `ITransformable`