igeo

## Interface ISurfaceI

- All Superinterfaces:
    IParameter, ISurfaceOp, ITransformable, IVal
  All Known Implementing Classes:
    ICylinder, ISphere, ISurface, ISurfaceGeo, ISurfaceR

      public interface ISurfaceI
      extends ISurfaceOp, ITransformable

  Abstract interface of NURBS surface.
  Author:
    Satoru Sugihara

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `ISurfaceI` | `add(double x, double y, double z)` transformation methods; API of ITransformable interface
    `ISurfaceI` | `add(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceI` | `add(IVecI v)`
    `ISurfaceI` | `add(IVecI v, double f)` scale add
    `ISurfaceI` | `add(IVecI v, IDoubleI f)` scale add
    `ISurfaceI` | `addInnerTrimLoop(ICurveI trim)` input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
    `ISurfaceI` | `addInnerTrimLoop(ICurveI[] trim)` input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR
    `ISurfaceI` | `addInnerTrimLoop(ICurveI[] trim, boolean deleteInput)`
    `ISurfaceI` | `addInnerTrimLoop(ICurveI trim, boolean deleteInput)`
    `ISurfaceI` | `addInnerTrimLoop(ITrimCurveI trim)`
    `ISurfaceI` | `addInnerTrimLoop(ITrimCurveI[] trim)`
    `ISurfaceI` | `addOuterTrimLoop(ICurveI trim)`
    `ISurfaceI` | `addOuterTrimLoop(ICurveI[] trim)`
    `ISurfaceI` | `addOuterTrimLoop(ICurveI[] trim, boolean deleteInput)`
    `ISurfaceI` | `addOuterTrimLoop(ICurveI trim, boolean deleteInput)`
    `ISurfaceI` | `addOuterTrimLoop(ITrimCurveI trim)`
    `ISurfaceI` | `addOuterTrimLoop(ITrimCurveI[] trim)`
    `IVecI` | `center()` returns center of geometry object
    `ISurfaceI` | `clearInnerTrim()`
    `ISurfaceI` | `clearOuterTrim()`
    `ISurfaceI` | `clearTrim()`
    `IVecI` | `closePt(IVec2I pt)` find approximately closest point on a surface on 2D
    `IVecI` | `closePt(IVecI pt)` find approximately closest point on a surface
    `IVecI` | `corner(IIntegerI u, IIntegerI v)`
    `IVecI` | `corner(int u, int v)`
    `IVecI` | `cornerCP(IIntegerI u, IIntegerI v)`
    `IVecI` | `cornerCP(int u, int v)`
    `ISurfaceI` | `cp()` cp() is alias of dup()
    `ISurfaceI` | `cp(double x, double y, double z)` cp() is alias of dup().add()
    `ISurfaceI` | `cp(IDoubleI x, IDoubleI y, IDoubleI z)`
    `IVecI` | `cp(IIntegerI i, IIntegerI j)`
    `IVecI` | `cp(int i, int j)`
    `ISurfaceI` | `cp(IVecI v)`
    `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
    `ISurfaceI` | `div(double v)`
    `ISurfaceI` | `div(IDoubleI v)`
    `ISurfaceI` | `dup()` duplicate the instance
    `IVecI` | `ep(IIntegerI i, IIntegerI j)`
    `IVecI` | `ep(int i, int j)`
    `ISurfaceI` | `flip()` same with neg
    `ISurfaceI` | `flipN()` alias of flipN()
    `ISurfaceI` | `flipU()` alias of revU()
    `ISurfaceI` | `flipUV()` alias of revUV()
    `ISurfaceI` | `flipV()` alias of revV()
    `ISurfaceGeo` | `get()`
    `boolean` | `hasDefaultTrim()` check if it has default rectangular outer trim
    `boolean` | `hasDefaultTrim(ISwitchE e)`
    `IBoolI` | `hasDefaultTrim(ISwitchR r)`
    `boolean` | `hasInnerTrim()`
    `boolean` | `hasInnerTrim(ISwitchE e)`
    `IBoolI` | `hasInnerTrim(ISwitchR r)`
    `boolean` | `hasOuterTrim()`
    `boolean` | `hasOuterTrim(ISwitchE e)`
    `IBoolI` | `hasOuterTrim(ISwitchR r)`
    `boolean` | `hasTrim()`
    `boolean` | `hasTrim(ISwitchE e)`
    `IBoolI` | `hasTrim(ISwitchR r)`
    `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)`
    `IIntegerI` | `innerTrimLoopNum(ISwitchR r)`
    `IIntegerI` | `innerTrimNum(IIntegerI i)`
    `int` | `innerTrimNum(int i)`
    `boolean` | `isFlat()`
    `boolean` | `isFlat(ISwitchE e)`
    `IBoolI` | `isFlat(ISwitchR r)`
    `boolean` | `isRational()`
    `boolean` | `isRational(ISwitchE e)`
    `IBoolI` | `isRational(ISwitchR r)`
    `boolean` | `isUClosed()`
    `boolean` | `isUClosed(ISwitchE e)`
    `IBoolI` | `isUClosed(ISwitchR r)`
    `boolean` | `isValid()`
    `boolean` | `isVClosed()`
    `boolean` | `isVClosed(ISwitchE e)`
    `IBoolI` | `isVClosed(ISwitchR r)`
    `IVecI` | `mid()` mid in UV parameter (u=0.5, v=0.5) point on a surface
    `ISurfaceI` | `mirror(IVecI planeDir)` mirror is alias of ref
    `ISurfaceI` | `mirror(IVecI center, IVecI planeDir)`
    `ISurfaceI` | `mul(double v)`
    `ISurfaceI` | `mul(IDoubleI v)`
    `ISurfaceI` | `mv(double x, double y, double z)` mv() is alias of add()
    `ISurfaceI` | `mv(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceI` | `mv(IVecI v)`
    `ISurfaceI` | `neg()`
    `IVecI` | `nml(double u, double v)` alias of normal
    `IVecI` | `nml(IDoubleI u, IDoubleI v)`
    `IVecI` | `nml(IVec2I uv)`
    `IVecI` | `normal(double u, double v)`
    `IVecI` | `normal(IDoubleI u, IDoubleI v)`
    `IVecI` | `normal(IVec2I uv)`
    `IVecI` | `nrml(double u, double v)`
    `IVecI` | `nrml(IDoubleI u, IDoubleI v)`
    `IVecI` | `nrml(IVec2I uv)`
    `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)`
    `IIntegerI` | `outerTrimLoopNum(ISwitchR r)`
    `IIntegerI` | `outerTrimNum(IIntegerI i)`
    `int` | `outerTrimNum(int i)`
    `IVecI` | `pt(double u, double v)`
    `IVecI` | `pt(double u, double v, double n)`
    `IVecI` | `pt(IDoubleI u, IDoubleI v)`
    `IVecI` | `pt(IDoubleI u, IDoubleI v, IDoubleI n)`
    `IVecI` | `pt(IVec2I uv)`
    `IVecI` | `pt(IVecI uvn)`
    `ISurfaceI` | `ref(IVecI planeDir)` reflect(mirror) 3 dimensionally to the other side of the plane
    `ISurfaceI` | `ref(IVecI center, IVecI planeDir)`
    `ISurfaceI` | `revN()` reverse normal direction by reversing V direction (UV and normal is dependent
    `ISurfaceI` | `revU()` reverse U parameter internally without creating a new instance
    `ISurfaceI` | `revUV()` reverse both U and V parameter internally without creating a new instance
    `ISurfaceI` | `revV()` reverse V parameter internally without creating a new instance
    `ISurfaceI` | `rot(IVecI axis, double angle)`
    `ISurfaceI` | `rot(IVecI axis, IDoubleI angle)` rotation around axis vector
    `ISurfaceI` | `rot(IVecI axis, IVecI destDir)` rotate to destination direction vector
    `ISurfaceI` | `rot(IVecI center, IVecI axis, double angle)`
    `ISurfaceI` | `rot(IVecI center, IVecI axis, IDoubleI angle)` rotation around axis vector and center
    `ISurfaceI` | `rot(IVecI center, IVecI axis, IVecI destPt)` rotate to destination point location
    `ISurfaceI` | `scale(double f)`
    `ISurfaceI` | `scale(IDoubleI f)` alias of mul
    `ISurfaceI` | `scale(IVecI center, double f)`
    `ISurfaceI` | `scale(IVecI center, IDoubleI f)`
    `ISurfaceI` | `scale1d(IVecI axis, double f)` scale only in 1 direction
    `ISurfaceI` | `scale1d(IVecI axis, IDoubleI f)`
    `ISurfaceI` | `scale1d(IVecI center, IVecI axis, double f)`
    `ISurfaceI` | `scale1d(IVecI center, IVecI axis, IDoubleI f)`
    `ISurfaceI` | `shear(double sxy, double syx, double syz, double szy, double szx, double sxz)` shear operation
    `ISurfaceI` | `shear(IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceI` | `shear(IVecI center, double sxy, double syx, double syz, double szy, double szx, double sxz)`
    `ISurfaceI` | `shear(IVecI center, IDoubleI sxy, IDoubleI syx, IDoubleI syz, IDoubleI szy, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceI` | `shearXY(double sxy, double syx)`
    `ISurfaceI` | `shearXY(IDoubleI sxy, IDoubleI syx)`
    `ISurfaceI` | `shearXY(IVecI center, double sxy, double syx)`
    `ISurfaceI` | `shearXY(IVecI center, IDoubleI sxy, IDoubleI syx)`
    `ISurfaceI` | `shearYZ(double syz, double szy)`
    `ISurfaceI` | `shearYZ(IDoubleI syz, IDoubleI szy)`
    `ISurfaceI` | `shearYZ(IVecI center, double syz, double szy)`
    `ISurfaceI` | `shearYZ(IVecI center, IDoubleI syz, IDoubleI szy)`
    `ISurfaceI` | `shearZX(double szx, double sxz)`
    `ISurfaceI` | `shearZX(IDoubleI szx, IDoubleI sxz)`
    `ISurfaceI` | `shearZX(IVecI center, double szx, double sxz)`
    `ISurfaceI` | `shearZX(IVecI center, IDoubleI szx, IDoubleI sxz)`
    `ISurfaceI` | `sub(double x, double y, double z)`
    `ISurfaceI` | `sub(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceI` | `sub(IVecI v)`
    `ISurfaceI` | `swapUV()` swap U and V parameter
    `ISurfaceI` | `transform(IMatrix3I mat)`
    `ISurfaceI` | `transform(IMatrix4I mat)`
    `ISurfaceI` | `transform(IVecI xvec, IVecI yvec, IVecI zvec)`
    `ISurfaceI` | `transform(IVecI xvec, IVecI yvec, IVecI zvec, IVecI translate)`
    `ISurfaceI` | `translate(double x, double y, double z)` translate() is alias of add()
    `ISurfaceI` | `translate(IDoubleI x, IDoubleI y, IDoubleI z)`
    `ISurfaceI` | `translate(IVecI v)`
    `IDoubleI` | `u(IIntegerI epIdx, IDoubleI epFraction)`
    `double` | `u(int epIdx, double epFraction)`
    `int` | `ucpNum()`
    `int` | `ucpNum(ISwitchE e)`
    `IIntegerI` | `ucpNum(ISwitchR r)`
    `int` | `udeg()`
    `int` | `udeg(ISwitchE e)`
    `IIntegerI` | `udeg(ISwitchR r)`
    `double` | `uend()`
    `double` | `uend(ISwitchE e)`
    `IDoubleI` | `uend(ISwitchR r)`
    `int` | `uepNum()`
    `int` | `uepNum(ISwitchE e)`
    `IIntegerI` | `uepNum(ISwitchR r)`
    `IDoubleI` | `uknot(IIntegerI i)`
    `double` | `uknot(int i)`
    `int` | `uknotNum()`
    `int` | `uknotNum(ISwitchE e)`
    `IIntegerI` | `uknotNum(ISwitchR r)`
    `double[]` | `uknots()`
    `double[]` | `uknots(ISwitchE e)`
    `IDoubleI[]` | `uknots(ISwitchR r)`
    `int` | `unum()`
    `int` | `unum(ISwitchE e)`
    `IIntegerI` | `unum(ISwitchR r)`
    `double` | `ustart()` original knots start value and end value
    `double` | `ustart(ISwitchE e)`
    `IDoubleI` | `ustart(ISwitchR r)`
    `IVecI` | `utan(double u, double v)`
    `IVecI` | `utan(IDoubleI u, IDoubleI v)`
    `IVecI` | `utan(IVec2I uv)`
    `IVec2I` | `uv(IVec2I pt)` approximate invert projection from 2D location to interanl UV parameter (closest point on surface)
    `IVec2I` | `uv(IVecI pt)` approximate invert projection from 3D location to interanl UV parameter (closest point on surface)
    `IDoubleI` | `v(IIntegerI epIdx, IDoubleI epFraction)`
    `double` | `v(int epIdx, double epFraction)`
    `int` | `vcpNum()`
    `int` | `vcpNum(ISwitchE e)`
    `IIntegerI` | `vcpNum(ISwitchR r)`
    `int` | `vdeg()`
    `int` | `vdeg(ISwitchE e)`
    `IIntegerI` | `vdeg(ISwitchR r)`
    `double` | `vend()`
    `double` | `vend(ISwitchE e)`
    `IDoubleI` | `vend(ISwitchR r)`
    `int` | `vepNum()`
    `int` | `vepNum(ISwitchE e)`
    `IIntegerI` | `vepNum(ISwitchR r)`
    `IDoubleI` | `vknot(IIntegerI i)`
    `double` | `vknot(int i)`
    `int` | `vknotNum()`
    `int` | `vknotNum(ISwitchE e)`
    `IIntegerI` | `vknotNum(ISwitchR r)`
    `double[]` | `vknots()`
    `double[]` | `vknots(ISwitchE e)`
    `IDoubleI[]` | `vknots(ISwitchR r)`
    `int` | `vnum()`
    `int` | `vnum(ISwitchE e)`
    `IIntegerI` | `vnum(ISwitchR r)`
    `double` | `vstart()`
    `double` | `vstart(ISwitchE e)`
    `IDoubleI` | `vstart(ISwitchR r)`
    `IVecI` | `vtan(double u, double v)`
    `IVecI` | `vtan(IDoubleI u, IDoubleI v)`
    `IVecI` | `vtan(IVec2I uv)`

    - ### Methods inherited from interface igeo.ITransformable

      `add, add, rot, rot, rot2, rot2, rot2, rot2, rot2, rot2`

- - ### Method Detail

    - #### get

          ISurfaceGeo get()

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

    - #### dup

          ISurfaceI dup()

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

    - #### isValid

          boolean isValid()

    - #### pt

          IVecI pt(double u,
                 double v)

    - #### pt

          IVecI pt(IDoubleI u,
                 IDoubleI v)

    - #### pt

          IVecI pt(IVec2I uv)

    - #### pt

          IVecI pt(double u,
                 double v,
                 double n)

    - #### pt

          IVecI pt(IDoubleI u,
                 IDoubleI v,
                 IDoubleI n)

    - #### pt

          IVecI pt(IVecI uvn)

    - #### utan

          IVecI utan(double u,
                   double v)

    - #### utan

          IVecI utan(IDoubleI u,
                   IDoubleI v)

    - #### utan

          IVecI utan(IVec2I uv)

    - #### vtan

          IVecI vtan(double u,
                   double v)

    - #### vtan

          IVecI vtan(IDoubleI u,
                   IDoubleI v)

    - #### vtan

          IVecI vtan(IVec2I uv)

    - #### normal

          IVecI normal(double u,
                     double v)

    - #### normal

          IVecI normal(IDoubleI u,
                     IDoubleI v)

    - #### normal

          IVecI normal(IVec2I uv)

    - #### nrml

          IVecI nrml(double u,
                   double v)

    - #### nrml

          IVecI nrml(IDoubleI u,
                   IDoubleI v)

    - #### nrml

          IVecI nrml(IVec2I uv)

    - #### nml

          IVecI nml(double u,
                  double v)

      alias of normal

    - #### nml

          IVecI nml(IDoubleI u,
                  IDoubleI v)

    - #### nml

          IVecI nml(IVec2I uv)

    - #### cp

          IVecI cp(int i,
                 int j)

    - #### cp

          IVecI cp(IIntegerI i,
                 IIntegerI j)

    - #### cps

          IVecI[][] cps()

    - #### corner

          IVecI corner(int u,
                     int v)

    - #### corner

          IVecI corner(IIntegerI u,
                     IIntegerI v)

    - #### cornerCP

          IVecI cornerCP(int u,
                       int v)

    - #### cornerCP

          IVecI cornerCP(IIntegerI u,
                       IIntegerI v)

    - #### ep

          IVecI ep(int i,
                 int j)

    - #### ep

          IVecI ep(IIntegerI i,
                 IIntegerI j)

    - #### mid

          IVecI mid()

      mid in UV parameter (u=0.5, v=0.5) point on a surface

    - #### center

          IVecI center()

      returns center of geometry object

    - #### uv

          IVec2I uv(IVecI pt)

      approximate invert projection from 3D location to interanl UV parameter (closest point on surface)

    - #### uv

          IVec2I uv(IVec2I pt)

      approximate invert projection from 2D location to interanl UV parameter (closest point on surface)

    - #### closePt

          IVecI closePt(IVecI pt)

      find approximately closest point on a surface

    - #### closePt

          IVecI closePt(IVec2I pt)

      find approximately closest point on a surface on 2D

    - #### dist

          double dist(IVecI pt)

      distance to the closest point on a surface

    - #### dist

          double dist(IVec2I pt)

      distance to the closest point on a surface on 2D

    - #### uknot

          double uknot(int i)

    - #### uknot

          IDoubleI uknot(IIntegerI i)

    - #### vknot

          double vknot(int i)

    - #### vknot

          IDoubleI vknot(IIntegerI i)

    - #### uknots

          double[] uknots()

    - #### uknots

          double[] uknots(ISwitchE e)

    - #### uknots

          IDoubleI[] uknots(ISwitchR r)

    - #### vknots

          double[] vknots()

    - #### vknots

          double[] vknots(ISwitchE e)

    - #### vknots

          IDoubleI[] vknots(ISwitchR r)

    - #### uknotNum

          int uknotNum()

    - #### vknotNum

          int vknotNum()

    - #### uknotNum

          int uknotNum(ISwitchE e)

    - #### vknotNum

          int vknotNum(ISwitchE e)

    - #### uknotNum

          IIntegerI uknotNum(ISwitchR r)

    - #### vknotNum

          IIntegerI vknotNum(ISwitchR r)

    - #### isRational

          boolean isRational()

      Returns:
        returns true if any of control point has non-default(1.0) weight otherwise false.

    - #### isRational

          boolean isRational(ISwitchE e)

    - #### isRational

          IBoolI isRational(ISwitchR r)

    - #### udeg

          int udeg()

    - #### vdeg

          int vdeg()

    - #### udeg

          int udeg(ISwitchE e)

    - #### vdeg

          int vdeg(ISwitchE e)

    - #### udeg

          IIntegerI udeg(ISwitchR r)

    - #### vdeg

          IIntegerI vdeg(ISwitchR r)

    - #### unum

          int unum()

    - #### vnum

          int vnum()

    - #### unum

          int unum(ISwitchE e)

    - #### vnum

          int vnum(ISwitchE e)

    - #### unum

          IIntegerI unum(ISwitchR r)

    - #### vnum

          IIntegerI vnum(ISwitchR r)

    - #### ucpNum

          int ucpNum()

    - #### vcpNum

          int vcpNum()

    - #### ucpNum

          int ucpNum(ISwitchE e)

    - #### vcpNum

          int vcpNum(ISwitchE e)

    - #### ucpNum

          IIntegerI ucpNum(ISwitchR r)

    - #### vcpNum

          IIntegerI vcpNum(ISwitchR r)

    - #### uepNum

          int uepNum()

    - #### vepNum

          int vepNum()

    - #### uepNum

          int uepNum(ISwitchE e)

    - #### vepNum

          int vepNum(ISwitchE e)

    - #### uepNum

          IIntegerI uepNum(ISwitchR r)

    - #### vepNum

          IIntegerI vepNum(ISwitchR r)

    - #### u

          double u(int epIdx,
                 double epFraction)

    - #### u

          IDoubleI u(IIntegerI epIdx,
                   IDoubleI epFraction)

    - #### v

          double v(int epIdx,
                 double epFraction)

    - #### v

          IDoubleI v(IIntegerI epIdx,
                   IDoubleI epFraction)

    - #### ustart

          double ustart()

      original knots start value and end value

    - #### uend

          double uend()

    - #### vstart

          double vstart()

    - #### vend

          double vend()

    - #### ustart

          double ustart(ISwitchE e)

    - #### uend

          double uend(ISwitchE e)

    - #### vstart

          double vstart(ISwitchE e)

    - #### vend

          double vend(ISwitchE e)

    - #### ustart

          IDoubleI ustart(ISwitchR r)

    - #### uend

          IDoubleI uend(ISwitchR r)

    - #### vstart

          IDoubleI vstart(ISwitchR r)

    - #### vend

          IDoubleI vend(ISwitchR r)

    - #### revU

          ISurfaceI revU()

      reverse U parameter internally without creating a new instance

    - #### revV

          ISurfaceI revV()

      reverse V parameter internally without creating a new instance

    - #### revUV

          ISurfaceI revUV()

      reverse both U and V parameter internally without creating a new instance

    - #### revN

          ISurfaceI revN()

      reverse normal direction by reversing V direction (UV and normal is dependent

    - #### flipU

          ISurfaceI flipU()

      alias of revU()

    - #### flipV

          ISurfaceI flipV()

      alias of revV()

    - #### flipUV

          ISurfaceI flipUV()

      alias of revUV()

    - #### flipN

          ISurfaceI flipN()

      alias of flipN()

    - #### swapUV

          ISurfaceI swapUV()

      swap U and V parameter

    - #### hasTrim

          boolean hasTrim()

    - #### hasTrim

          boolean hasTrim(ISwitchE e)

    - #### hasTrim

          IBoolI hasTrim(ISwitchR r)

    - #### hasInnerTrim

          boolean hasInnerTrim()

    - #### hasInnerTrim

          boolean hasInnerTrim(ISwitchE e)

    - #### hasInnerTrim

          IBoolI hasInnerTrim(ISwitchR r)

    - #### hasOuterTrim

          boolean hasOuterTrim()

    - #### hasOuterTrim

          boolean hasOuterTrim(ISwitchE e)

    - #### hasOuterTrim

          IBoolI hasOuterTrim(ISwitchR r)

    - #### innerTrimLoopNum

          int innerTrimLoopNum()

    - #### innerTrimLoopNum

          int innerTrimLoopNum(ISwitchE e)

    - #### innerTrimLoopNum

          IIntegerI innerTrimLoopNum(ISwitchR r)

    - #### innerTrimNum

          int innerTrimNum(int i)

    - #### innerTrimNum

          IIntegerI innerTrimNum(IIntegerI i)

    - #### innerTrimLoop

          ITrimCurveI[] innerTrimLoop(int i)

    - #### innerTrimLoop

          ITrimCurveI[] innerTrimLoop(IIntegerI i)

    - #### innerTrim

          ITrimCurveI innerTrim(int i,
                              int j)

    - #### innerTrim

          ITrimCurveI innerTrim(IIntegerI i,
                              IIntegerI j)

    - #### outerTrimLoopNum

          int outerTrimLoopNum()

    - #### outerTrimLoopNum

          int outerTrimLoopNum(ISwitchE e)

    - #### outerTrimLoopNum

          IIntegerI outerTrimLoopNum(ISwitchR r)

    - #### outerTrimNum

          int outerTrimNum(int i)

    - #### outerTrimNum

          IIntegerI outerTrimNum(IIntegerI i)

    - #### outerTrimLoop

          ITrimCurveI[] outerTrimLoop(int i)

    - #### outerTrimLoop

          ITrimCurveI[] outerTrimLoop(IIntegerI i)

    - #### outerTrim

          ITrimCurveI outerTrim(int i,
                              int j)

    - #### outerTrim

          ITrimCurveI outerTrim(IIntegerI i,
                              IIntegerI j)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ITrimCurveI trim)

      Parameters:
        `trim` - trim curve needs to be closed

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ITrimCurveI trim)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ICurveI trim)

      input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ICurveI trim)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ICurveI trim,
                                   boolean deleteInput)

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ICurveI trim,
                                   boolean deleteInput)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ITrimCurveI[] trim)

      Parameters:
        `trim` - array of trim curves need to form closed loop

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ITrimCurveI[] trim)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ICurveI[] trim)

      input trim curves is deleted as default if it inherits IObject like ICurve or ICurveR

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ICurveI[] trim)

    - #### addInnerTrimLoop

          ISurfaceI addInnerTrimLoop(ICurveI[] trim,
                                   boolean deleteInput)

    - #### addOuterTrimLoop

          ISurfaceI addOuterTrimLoop(ICurveI[] trim,
                                   boolean deleteInput)

    - #### clearInnerTrim

          ISurfaceI clearInnerTrim()

    - #### clearOuterTrim

          ISurfaceI clearOuterTrim()

    - #### clearTrim

          ISurfaceI clearTrim()

    - #### hasDefaultTrim

          boolean hasDefaultTrim()

      check if it has default rectangular outer trim

    - #### hasDefaultTrim

          boolean hasDefaultTrim(ISwitchE e)

    - #### hasDefaultTrim

          IBoolI hasDefaultTrim(ISwitchR r)

    - #### isFlat

          boolean isFlat()

    - #### isFlat

          boolean isFlat(ISwitchE e)

    - #### isFlat

          IBoolI isFlat(ISwitchR r)

    - #### isUClosed

          boolean isUClosed()

    - #### isUClosed

          boolean isUClosed(ISwitchE e)

    - #### isUClosed

          IBoolI isUClosed(ISwitchR r)

    - #### isVClosed

          boolean isVClosed()

    - #### isVClosed

          boolean isVClosed(ISwitchE e)

    - #### isVClosed

          IBoolI isVClosed(ISwitchR r)

    - #### add

          ISurfaceI add(double x,
                      double y,
                      double z)

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

    - #### add

          ISurfaceI add(IDoubleI x,
                      IDoubleI y,
                      IDoubleI z)

      Specified by:
        `add` in interface `ITransformable`

    - #### add

          ISurfaceI add(IVecI v)

      Specified by:
        `add` in interface `ITransformable`

    - #### sub

          ISurfaceI sub(double x,
                      double y,
                      double z)

      Specified by:
        `sub` in interface `ITransformable`

    - #### sub

          ISurfaceI sub(IDoubleI x,
                      IDoubleI y,
                      IDoubleI z)

      Specified by:
        `sub` in interface `ITransformable`

    - #### sub

          ISurfaceI sub(IVecI v)

      Specified by:
        `sub` in interface `ITransformable`

    - #### mul

          ISurfaceI mul(IDoubleI v)

      Specified by:
        `mul` in interface `ITransformable`

    - #### mul

          ISurfaceI mul(double v)

      Specified by:
        `mul` in interface `ITransformable`

    - #### div

          ISurfaceI div(IDoubleI v)

      Specified by:
        `div` in interface `ITransformable`

    - #### div

          ISurfaceI div(double v)

      Specified by:
        `div` in interface `ITransformable`

    - #### neg

          ISurfaceI neg()

      Specified by:
        `neg` in interface `ITransformable`

    - #### flip

          ISurfaceI flip()

      same with neg
      Specified by:
        `flip` in interface `ITransformable`

    - #### add

          ISurfaceI add(IVecI v,
                      double f)

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

    - #### add

          ISurfaceI add(IVecI v,
                      IDoubleI f)

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

    - #### rot

          ISurfaceI rot(IVecI axis,
                      IDoubleI angle)

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

    - #### rot

          ISurfaceI rot(IVecI axis,
                      double angle)

      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          ISurfaceI rot(IVecI center,
                      IVecI axis,
                      IDoubleI angle)

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

    - #### rot

          ISurfaceI rot(IVecI center,
                      IVecI axis,
                      double angle)

      Specified by:
        `rot` in interface `ITransformable`

    - #### rot

          ISurfaceI rot(IVecI axis,
                      IVecI destDir)

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

    - #### rot

          ISurfaceI rot(IVecI center,
                      IVecI axis,
                      IVecI destPt)

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

    - #### scale

          ISurfaceI scale(IDoubleI f)

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

    - #### scale

          ISurfaceI scale(double f)

      Specified by:
        `scale` in interface `ITransformable`

    - #### scale

          ISurfaceI scale(IVecI center,
                        IDoubleI f)

      Specified by:
        `scale` in interface `ITransformable`

    - #### scale

          ISurfaceI scale(IVecI center,
                        double f)

      Specified by:
        `scale` in interface `ITransformable`

    - #### scale1d

          ISurfaceI scale1d(IVecI axis,
                          double f)

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

    - #### scale1d

          ISurfaceI scale1d(IVecI axis,
                          IDoubleI f)

      Specified by:
        `scale1d` in interface `ITransformable`

    - #### scale1d

          ISurfaceI scale1d(IVecI center,
                          IVecI axis,
                          double f)

      Specified by:
        `scale1d` in interface `ITransformable`

    - #### scale1d

          ISurfaceI scale1d(IVecI center,
                          IVecI axis,
                          IDoubleI f)

      Specified by:
        `scale1d` in interface `ITransformable`

    - #### ref

          ISurfaceI ref(IVecI planeDir)

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

    - #### ref

          ISurfaceI ref(IVecI center,
                      IVecI planeDir)

      Specified by:
        `ref` in interface `ITransformable`

    - #### mirror

          ISurfaceI mirror(IVecI planeDir)

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

    - #### mirror

          ISurfaceI mirror(IVecI center,
                         IVecI planeDir)

      Specified by:
        `mirror` in interface `ITransformable`

    - #### shear

          ISurfaceI shear(double sxy,
                        double syx,
                        double syz,
                        double szy,
                        double szx,
                        double sxz)

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

    - #### shear

          ISurfaceI shear(IDoubleI sxy,
                        IDoubleI syx,
                        IDoubleI syz,
                        IDoubleI szy,
                        IDoubleI szx,
                        IDoubleI sxz)

      Specified by:
        `shear` in interface `ITransformable`

    - #### shear

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

      Specified by:
        `shear` in interface `ITransformable`

    - #### shear

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

      Specified by:
        `shear` in interface `ITransformable`

    - #### shearXY

          ISurfaceI shearXY(double sxy,
                          double syx)

      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

          ISurfaceI shearXY(IDoubleI sxy,
                          IDoubleI syx)

      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

          ISurfaceI shearXY(IVecI center,
                          double sxy,
                          double syx)

      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearXY

          ISurfaceI shearXY(IVecI center,
                          IDoubleI sxy,
                          IDoubleI syx)

      Specified by:
        `shearXY` in interface `ITransformable`

    - #### shearYZ

          ISurfaceI shearYZ(double syz,
                          double szy)

      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

          ISurfaceI shearYZ(IDoubleI syz,
                          IDoubleI szy)

      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

          ISurfaceI shearYZ(IVecI center,
                          double syz,
                          double szy)

      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearYZ

          ISurfaceI shearYZ(IVecI center,
                          IDoubleI syz,
                          IDoubleI szy)

      Specified by:
        `shearYZ` in interface `ITransformable`

    - #### shearZX

          ISurfaceI shearZX(double szx,
                          double sxz)

      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

          ISurfaceI shearZX(IDoubleI szx,
                          IDoubleI sxz)

      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

          ISurfaceI shearZX(IVecI center,
                          double szx,
                          double sxz)

      Specified by:
        `shearZX` in interface `ITransformable`

    - #### shearZX

          ISurfaceI shearZX(IVecI center,
                          IDoubleI szx,
                          IDoubleI sxz)

      Specified by:
        `shearZX` in interface `ITransformable`

    - #### mv

          ISurfaceI mv(double x,
                     double y,
                     double z)

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

    - #### mv

          ISurfaceI mv(IDoubleI x,
                     IDoubleI y,
                     IDoubleI z)

      Specified by:
        `mv` in interface `ITransformable`

    - #### mv

          ISurfaceI mv(IVecI v)

      Specified by:
        `mv` in interface `ITransformable`

    - #### cp

          ISurfaceI cp()

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

    - #### cp

          ISurfaceI cp(double x,
                     double y,
                     double z)

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

    - #### cp

          ISurfaceI cp(IDoubleI x,
                     IDoubleI y,
                     IDoubleI z)

      Specified by:
        `cp` in interface `ITransformable`

    - #### cp

          ISurfaceI cp(IVecI v)

      Specified by:
        `cp` in interface `ITransformable`

    - #### translate

          ISurfaceI translate(double x,
                            double y,
                            double z)

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

    - #### translate

          ISurfaceI translate(IDoubleI x,
                            IDoubleI y,
                            IDoubleI z)

      Specified by:
        `translate` in interface `ITransformable`

    - #### translate

          ISurfaceI translate(IVecI v)

      Specified by:
        `translate` in interface `ITransformable`

    - #### transform

          ISurfaceI transform(IMatrix3I mat)

      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

          ISurfaceI transform(IMatrix4I mat)

      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

          ISurfaceI transform(IVecI xvec,
                            IVecI yvec,
                            IVecI zvec)

      Specified by:
        `transform` in interface `ITransformable`

    - #### transform

          ISurfaceI transform(IVecI xvec,
                            IVecI yvec,
                            IVecI zvec,
                            IVecI translate)

      Specified by:
        `transform` in interface `ITransformable`