Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## igeo
Interface ISurfaceI

All Superinterfaces:
  IParameter, ISurfaceOp, ITransformable

All Known Implementing Classes:
  ICylinder, ISphere, ISurface, ISurfaceGeo, ISurfaceR

    public interface ISurfaceI

extends ISurfaceOp, ITransformable

Abstract interface of NURBS surface.

Method Summary
`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)`
`ISurfaceI` | `clearInnerTrim()`
`ISurfaceI` | `clearOuterTrim()`
`ISurfaceI` | `clearTrim()`
`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()`
`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
`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` | `isValid()`
`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 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)`
`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)

### 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 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

### 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)

### 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`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD