Affine3D

java.lang.Object
- com.sun.javafx.geom.transform.BaseTransform
- - com.sun.javafx.geom.transform.AffineBase
  - - com.sun.javafx.geom.transform.Affine3D

All Implemented Interfaces:

CanTransformVec3d
```
public class Affine3D
extends AffineBase
```

Nested Class Summary
- Nested classes/interfaces inherited from class com.sun.javafx.geom.transform.BaseTransform
  BaseTransform.Degree

Field Summary

Fields
Modifier and Type Field and Description

private double mxz

private double myz

private double mzt

private double mzx

private double mzy

private double mzz
- Fields inherited from class com.sun.javafx.geom.transform.AffineBase
  APPLY_2D_DELTA_MASK, APPLY_2D_MASK, APPLY_3D, APPLY_IDENTITY, APPLY_SCALE, APPLY_SHEAR, APPLY_TRANSLATE, HI_3D, HI_IDENTITY, HI_SCALE, HI_SHEAR, HI_SHIFT, HI_TRANSLATE, mxt, mxx, mxy, myt, myx, myy, state, type
- Fields inherited from class com.sun.javafx.geom.transform.BaseTransform
  EPSILON_ABSOLUTE, IDENTITY_TRANSFORM, TYPE_AFFINE_3D, TYPE_AFFINE2D_MASK, TYPE_FLIP, TYPE_GENERAL_ROTATION, TYPE_GENERAL_SCALE, TYPE_GENERAL_TRANSFORM, TYPE_IDENTITY, TYPE_MASK_ROTATION, TYPE_MASK_SCALE, TYPE_QUADRANT_ROTATION, TYPE_TRANSLATION, TYPE_UNIFORM_SCALE, TYPE_UNKNOWN

Fields
Modifier and Type	Field and Description
`private double`	`mxz`
`private double`	`myz`
`private double`	`mzt`
`private double`	`mzx`
`private double`	`mzy`
`private double`	`mzz`

Constructor Summary

Constructors
Constructor and Description
`Affine3D()`
`Affine3D(Affine3D other)`
`Affine3D(BaseTransform transform)`
`Affine3D(double mxx, double mxy, double mxz, double mxt, double myx, double myy, double myz, double myt, double mzx, double mzy, double mzz, double mzt)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private static double`	`_matround(double matval)`
`(package private) static boolean`	`almostOne(double a)`
`void`	`concatenate(BaseTransform transform)` Concatenates a `BaseTransform` `Tx` to this `Affine2D` Cx in the most commonly useful way to provide a new user space that is mapped to the former user space by `Tx`.
`void`	`concatenate(double Txx, double Txy, double Txz, double Txt, double Tyx, double Tyy, double Tyz, double Tyt, double Tzx, double Tzy, double Tzz, double Tzt)`
`BaseTransform`	`copy()`
`BaseTransform`	`createInverse()` This function always returns a new object, unless the transform is an identity transform in which case it might return the `Identity` singleton.
`Vec3d`	`deltaTransform(Vec3d src, Vec3d dst)` Transforms the specified `src` vector and stores the result in `dst` vector, without applying the translation elements.
`Affine3D`	`deriveWithConcatenation(BaseTransform transform)`
`Affine3D`	`deriveWithConcatenation(double Txx, double Tyx, double Txy, double Tyy, double Txt, double Tyt)`
`BaseTransform`	`deriveWithConcatenation(double mxx, double mxy, double mxz, double mxt, double myx, double myy, double myz, double myt, double mzx, double mzy, double mzz, double mzt)`
`Affine3D`	`deriveWithNewTransform(BaseTransform tx)`
`Affine3D`	`deriveWithPreConcatenation(BaseTransform transform)`
`Affine3D`	`deriveWithPreTranslation(double mxt, double myt)`
`BaseTransform`	`deriveWithRotation(double theta, double axisX, double axisY, double axisZ)`
`BaseTransform`	`deriveWithScale(double mxx, double myy, double mzz)`
`Affine3D`	`deriveWithTranslation(double tx, double ty)`
`BaseTransform`	`deriveWithTranslation(double mxt, double myt, double mzt)`
`BaseTransform.Degree`	`getDegree()`
`double`	`getDeterminant()` Returns the determinant of the matrix representation of the transform.
`double`	`getMxz()`
`double`	`getMyz()`
`double`	`getMzt()`
`double`	`getMzx()`
`double`	`getMzy()`
`double`	`getMzz()`
`void`	`inverseDeltaTransform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)` Inverse transforms an array of single precision relative coordinates by this transform.
`Vec3d`	`inverseDeltaTransform(Vec3d src, Vec3d dst)` Inverse transforms the specified `src` vector and stores the result in `dst` vector (without applying the translation elements).
`BaseBounds`	`inverseTransform(BaseBounds bounds, BaseBounds result)`
`void`	`inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts)` Inverse transforms an array of double precision coordinates by this transform.
`void`	`inverseTransform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts)` Inverse transforms an array of single precision coordinates by this transform.
`Point2D`	`inverseTransform(Point2D src, Point2D dst)` Inverse transforms the specified `ptSrc` and stores the result in `ptDst`.
`void`	`inverseTransform(Rectangle bounds, Rectangle result)`
`Vec3d`	`inverseTransform(Vec3d src, Vec3d dst)` Inverse transforms the specified `src` and stores the result in `dst`.
`void`	`invert()` Sets this transform to the inverse of itself.
`Affine3D`	`lookAt(Vec3d eye, Vec3d center, Vec3d up)` Sets this transform to a viewing transform computed from the specified eye point, center point, and up vector.
`private double`	`minor(int row, int col)`
`void`	`preConcatenate(BaseTransform transform)`
`void`	`preTranslate(double mxt, double myt, double mzt)`
`protected void`	`reset3Delements()` Resets the 3D (Z) components of the matrix to identity settings (if they are present).
`void`	`restoreTransform(double mxx, double myx, double mxy, double myy, double mxt, double myt)` This function is only guaranteed to succeed if the transform is of degree AFFINE2D or less and the matrix parameters specified came from this same instance.
`void`	`restoreTransform(double mxx, double mxy, double mxz, double mxt, double myx, double myy, double myz, double myt, double mzx, double mzy, double mzz, double mzt)` This function is only guaranteed to succeed if the matrix parameters specified came from this same instance.
`void`	`rotate(double theta)` Concatenates this transform with a rotation transformation.
`void`	`rotate(double theta, double axisX, double axisY, double axisZ)`
`void`	`scale(double sx, double sy)` Concatenates this transform with a scaling transformation.
`void`	`scale(double sx, double sy, double sz)`
`void`	`setToRotation(double theta, double axisX, double axisY, double axisZ)`
`void`	`setToRotation(double theta, double axisX, double axisY, double axisZ, double pivotX, double pivotY, double pivotZ)`
`void`	`setToScale(double sx, double sy, double sz)`
`void`	`setToTranslation(double tx, double ty, double tz)`
`void`	`setTransform(BaseTransform transform)`
`void`	`setTransform(double mxx, double mxy, double mxz, double mxt, double myx, double myy, double myz, double myt, double mzx, double mzy, double mzz, double mzt)`
`void`	`shear(double shx, double shy)` Concatenates this transform with a shearing transformation.
`java.lang.String`	`toString()` Returns a `String` that represents the value of this `Object`.
`BaseBounds`	`transform(BaseBounds src, BaseBounds dst)`
`Vec3d`	`transform(Vec3d src, Vec3d dst)`
`void`	`translate(double tx, double ty)` Concatenates this transform with a translation transformation.
`void`	`translate(double tx, double ty, double tz)`
`protected void`	`updateState()` Manually recalculates the state of the transform when the matrix changes too much to predict the effects on the state.

Methods inherited from class com.sun.javafx.geom.transform.AffineBase
calculateType, concatenate, createTransformedShape, deltaTransform, deltaTransform, getMxt, getMxx, getMxy, getMyt, getMyx, getMyy, getType, is2D, isIdentity, isTranslateOrIdentity, rotate180, rotate270, rotate90, setToIdentity, setToShear, setTransform, stateError, transform, transform, transform, transform, transform, transform, transform, updateState2D

Methods inherited from class com.sun.javafx.geom.transform.BaseTransform
almostZero, degreeError, equals, getInstance, getInstance, getInstance, getRotateInstance, getScaleInstance, getTranslateInstance, hashCode, makePoint

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - mxz
```
private double mxz
```
  - myz
```
private double myz
```
  - mzx
```
private double mzx
```
  - mzy
```
private double mzy
```
  - mzz
```
private double mzz
```
  - mzt
```
private double mzt
```
- Constructor Detail
  - Affine3D
```
public Affine3D()
```
  - Affine3D
```
public Affine3D(BaseTransform transform)
```
  - Affine3D
```
public Affine3D(double mxx,
                double mxy,
                double mxz,
                double mxt,
                double myx,
                double myy,
                double myz,
                double myt,
                double mzx,
                double mzy,
                double mzz,
                double mzt)
```
  - Affine3D
```
public Affine3D(Affine3D other)
```
- Method Detail
  - copy
```
public BaseTransform copy()
```
    Specified by:
    
    copy in class BaseTransform
  - getDegree
```
public BaseTransform.Degree getDegree()
```
    Specified by:
    
    getDegree in class BaseTransform
  - reset3Delements
```
protected void reset3Delements()
```
    Description copied from class: AffineBase
    
    Resets the 3D (Z) components of the matrix to identity settings (if they are present). This is a NOP unless the transform is Affine3D in which case it needs to reset its added fields.
    
    Specified by:
    
    reset3Delements in class AffineBase
  - updateState
```
protected void updateState()
```
    Description copied from class: AffineBase
    Manually recalculates the state of the transform when the matrix changes too much to predict the effects on the state. The following table specifies what the various settings of the state field say about the values of the corresponding matrix element fields. Note that the rules governing the SCALE fields are slightly different depending on whether the SHEAR flag is also set.
```
                     SCALE            SHEAR          TRANSLATE
                    m00/m11          m01/m10          m02/m12

 IDENTITY             1.0              0.0              0.0
 TRANSLATE (TR)       1.0              0.0          not both 0.0
 SCALE (SC)       not both 1.0         0.0              0.0
 TR | SC          not both 1.0         0.0          not both 0.0
 SHEAR (SH)           0.0          not both 0.0         0.0
 TR | SH              0.0          not both 0.0     not both 0.0
 SC | SH          not both 0.0     not both 0.0         0.0
 TR | SC | SH     not both 0.0     not both 0.0     not both 0.0
 
```
    Overrides:
    
    updateState in class AffineBase
  - getMxz
```
public double getMxz()
```
    Overrides:
    
    getMxz in class BaseTransform
  - getMyz
```
public double getMyz()
```
    Overrides:
    
    getMyz in class BaseTransform
  - getMzx
```
public double getMzx()
```
    Overrides:
    
    getMzx in class BaseTransform
  - getMzy
```
public double getMzy()
```
    Overrides:
    
    getMzy in class BaseTransform
  - getMzz
```
public double getMzz()
```
    Overrides:
    
    getMzz in class BaseTransform
  - getMzt
```
public double getMzt()
```
    Overrides:
    
    getMzt in class BaseTransform
  - getDeterminant
```
public double getDeterminant()
```
    Description copied from class: AffineBase
    Returns the determinant of the matrix representation of the transform. The determinant is useful both to determine if the transform can be inverted and to get a single value representing the combined X and Y scaling of the transform.
    If the determinant is non-zero, then this transform is invertible and the various methods that depend on the inverse transform do not need to throw a NoninvertibleTransformException. If the determinant is zero then this transform can not be inverted since the transform maps all input coordinates onto a line or a point. If the determinant is near enough to zero then inverse transform operations might not carry enough precision to produce meaningful results.
    If this transform represents a uniform scale, as indicated by the getType method then the determinant also represents the square of the uniform scale factor by which all of the points are expanded from or contracted towards the origin. If this transform represents a non-uniform scale or more general transform then the determinant is not likely to represent a value useful for any purpose other than determining if inverse transforms are possible.
    Mathematically, the determinant is calculated using the formula:
```
      |  mxx  mxy  mxt  |
      |  myx  myy  myt  |  =  mxx * myy - mxy * myx
      |   0    0    1   |
 
```
    Overrides:
    
    getDeterminant in class AffineBase
    
    Returns:
    
    the determinant of the matrix used to transform the coordinates.
    
    See Also:
    
    AffineBase.getType(), BaseTransform.createInverse(), AffineBase.inverseTransform(com.sun.javafx.geom.Point2D, com.sun.javafx.geom.Point2D), BaseTransform.TYPE_UNIFORM_SCALE
  - setTransform
```
public void setTransform(BaseTransform transform)
```
    Specified by:
    
    setTransform in class BaseTransform
  - setTransform
```
public void setTransform(double mxx,
                         double mxy,
                         double mxz,
                         double mxt,
                         double myx,
                         double myy,
                         double myz,
                         double myt,
                         double mzx,
                         double mzy,
                         double mzz,
                         double mzt)
```
  - setToTranslation
```
public void setToTranslation(double tx,
                             double ty,
                             double tz)
```
  - setToScale
```
public void setToScale(double sx,
                       double sy,
                       double sz)
```
  - setToRotation
```
public void setToRotation(double theta,
                          double axisX,
                          double axisY,
                          double axisZ,
                          double pivotX,
                          double pivotY,
                          double pivotZ)
```
  - setToRotation
```
public void setToRotation(double theta,
                          double axisX,
                          double axisY,
                          double axisZ)
```
  - transform
```
public BaseBounds transform(BaseBounds src,
                            BaseBounds dst)
```
    Overrides:
    
    transform in class AffineBase
  - transform
```
public Vec3d transform(Vec3d src,
                       Vec3d dst)
```
    Specified by:
    
    transform in interface CanTransformVec3d
    
    Overrides:
    
    transform in class AffineBase
  - deltaTransform
```
public Vec3d deltaTransform(Vec3d src,
                            Vec3d dst)
```
    Description copied from class: AffineBase
    
    Transforms the specified src vector and stores the result in dst vector, without applying the translation elements. If dst is null, a new Vec3d object is allocated and then the result of the transformation is stored in this object. In either case, dst, which contains the transformed vector, is returned for convenience. If src and dst are the same object, the input vector is correctly overwritten with the transformed vector.
    
    Overrides:
    
    deltaTransform in class AffineBase
    
    Parameters:
    
    src - the specified Vec3d to be transformed
    
    dst - the specified Vec3d that stores the result of transforming src
    
    Returns:
    
    the dst vector after transforming src and storing the result in dst.
  - inverseTransform
```
public void inverseTransform(float[] srcPts,
                             int srcOff,
                             float[] dstPts,
                             int dstOff,
                             int numPts)
                      throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms an array of single precision coordinates by this transform. The two coordinate array sections can be exactly the same or can be overlapping sections of the same array without affecting the validity of the results. This method ensures that no source coordinates are overwritten by a previous operation before they can be transformed. The coordinates are stored in the arrays starting at the specified offset in the order [x0, y0, x1, y1, ..., xn, yn].
    
    Overrides:
    
    inverseTransform in class AffineBase
    
    Parameters:
    
    srcPts - the array containing the source point coordinates. Each point is stored as a pair of x, y coordinates.
    
    srcOff - the offset to the first point to be transformed in the source array
    
    dstPts - the array into which the transformed point coordinates are returned. Each point is stored as a pair of x, y coordinates.
    
    dstOff - the offset to the location of the first transformed point that is stored in the destination array
    
    numPts - the number of point objects to be transformed
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseDeltaTransform
```
public void inverseDeltaTransform(float[] srcPts,
                                  int srcOff,
                                  float[] dstPts,
                                  int dstOff,
                                  int numPts)
                           throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms an array of single precision relative coordinates by this transform. The two coordinate array sections can be exactly the same or can be overlapping sections of the same array without affecting the validity of the results. This method ensures that no source coordinates are overwritten by a previous operation before they can be transformed. The coordinates are stored in the arrays starting at the specified offset in the order [x0, y0, x1, y1, ..., xn, yn].
    
    Overrides:
    
    inverseDeltaTransform in class AffineBase
    
    Parameters:
    
    srcPts - the array containing the relative source coordinates. Each point is stored as a pair of x, y coordinates.
    
    srcOff - the offset to the first point to be transformed in the source array
    
    dstPts - the array into which the relative transformed point coordinates are returned. Each point is stored as a pair of x, y coordinates.
    
    dstOff - the offset to the location of the first transformed point that is stored in the destination array
    
    numPts - the number of point objects to be transformed
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseTransform
```
public void inverseTransform(double[] srcPts,
                             int srcOff,
                             double[] dstPts,
                             int dstOff,
                             int numPts)
                      throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms an array of double precision coordinates by this transform. The two coordinate array sections can be exactly the same or can be overlapping sections of the same array without affecting the validity of the results. This method ensures that no source coordinates are overwritten by a previous operation before they can be transformed. The coordinates are stored in the arrays starting at the specified offset in the order [x0, y0, x1, y1, ..., xn, yn].
    
    Overrides:
    
    inverseTransform in class AffineBase
    
    Parameters:
    
    srcPts - the array containing the source point coordinates. Each point is stored as a pair of x, y coordinates.
    
    srcOff - the offset to the first point to be transformed in the source array
    
    dstPts - the array into which the transformed point coordinates are returned. Each point is stored as a pair of x, y coordinates.
    
    dstOff - the offset to the location of the first transformed point that is stored in the destination array
    
    numPts - the number of point objects to be transformed
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseTransform
```
public Point2D inverseTransform(Point2D src,
                                Point2D dst)
                         throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms the specified ptSrc and stores the result in ptDst. If ptDst is null, a new Point2D object is allocated and then the result of the transform is stored in this object. In either case, ptDst, which contains the transformed point, is returned for convenience. If ptSrc and ptDst are the same object, the input point is correctly overwritten with the transformed point.
    
    Overrides:
    
    inverseTransform in class AffineBase
    
    Parameters:
    
    src - the point to be inverse transformed
    
    dst - the resulting transformed point
    
    Returns:
    
    ptDst, which contains the result of the inverse transform.
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseTransform
```
public Vec3d inverseTransform(Vec3d src,
                              Vec3d dst)
                       throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms the specified src and stores the result in dst. If dst is null, a new Vec3d object is allocated and then the result of the transform is stored in this object. In either case, dst, which contains the transformed point, is returned for convenience. If src and dst are the same object, the input point is correctly overwritten with the transformed point.
    
    Overrides:
    
    inverseTransform in class AffineBase
    
    Parameters:
    
    src - the point to be inverse transformed
    
    dst - the resulting transformed point
    
    Returns:
    
    dst, which contains the result of the inverse transform.
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseDeltaTransform
```
public Vec3d inverseDeltaTransform(Vec3d src,
                                   Vec3d dst)
                            throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Inverse transforms the specified src vector and stores the result in dst vector (without applying the translation elements). If dst is null, a new Vec3d object is allocated and then the result of the transform is stored in this object. In either case, dst, which contains the transformed vector, is returned for convenience. If src and dst are the same object, the input vector is correctly overwritten with the transformed vector.
    
    Overrides:
    
    inverseDeltaTransform in class AffineBase
    
    Parameters:
    
    src - the vector to be inverse transformed
    
    dst - the resulting transformed vector
    
    Returns:
    
    dst, which contains the result of the inverse transform.
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
  - inverseTransform
```
public BaseBounds inverseTransform(BaseBounds bounds,
                                   BaseBounds result)
                            throws NoninvertibleTransformException
```
    Overrides:
    
    inverseTransform in class AffineBase
    
    Throws:
    
    NoninvertibleTransformException
  - inverseTransform
```
public void inverseTransform(Rectangle bounds,
                             Rectangle result)
                      throws NoninvertibleTransformException
```
    Overrides:
    
    inverseTransform in class AffineBase
    
    Throws:
    
    NoninvertibleTransformException
  - createInverse
```
public BaseTransform createInverse()
                            throws NoninvertibleTransformException
```
    Description copied from class: BaseTransform
    
    This function always returns a new object, unless the transform is an identity transform in which case it might return the Identity singleton.
    
    Specified by:
    
    createInverse in class BaseTransform
    
    Returns:
    
    a new transform representing the inverse of this transform.
    
    Throws:
    
    NoninvertibleTransformException
  - invert
```
public void invert()
            throws NoninvertibleTransformException
```
    Description copied from class: AffineBase
    
    Sets this transform to the inverse of itself. The inverse transform Tx' of this transform Tx maps coordinates transformed by Tx back to their original coordinates. In other words, Tx'(Tx(p)) = p = Tx(Tx'(p)).
    If this transform maps all coordinates onto a point or a line then it will not have an inverse, since coordinates that do not lie on the destination point or line will not have an inverse mapping. The getDeterminant method can be used to determine if this transform has no inverse, in which case an exception will be thrown if the invert method is called.
    
    Overrides:
    
    invert in class AffineBase
    
    Throws:
    
    NoninvertibleTransformException - if the matrix cannot be inverted.
    
    See Also:
    
    AffineBase.getDeterminant()
  - minor
```
private double minor(int row,
                     int col)
```
  - deriveWithNewTransform
```
public Affine3D deriveWithNewTransform(BaseTransform tx)
```
    Specified by:
    
    deriveWithNewTransform in class BaseTransform
  - deriveWithTranslation
```
public Affine3D deriveWithTranslation(double tx,
                                      double ty)
```
    Specified by:
    
    deriveWithTranslation in class BaseTransform
  - translate
```
public void translate(double tx,
                      double ty)
```
    Description copied from class: AffineBase
    Concatenates this transform with a translation transformation. This is equivalent to calling concatenate(T), where T is an Affine2D represented by the following matrix:
```
      [   1    0    tx  ]
      [   0    1    ty  ]
      [   0    0    1   ]
 
```
    Overrides:
    
    translate in class AffineBase
    
    Parameters:
    
    tx - the distance by which coordinates are translated in the X axis direction
    
    ty - the distance by which coordinates are translated in the Y axis direction
  - translate
```
public void translate(double tx,
                      double ty,
                      double tz)
```
  - deriveWithPreTranslation
```
public Affine3D deriveWithPreTranslation(double mxt,
                                         double myt)
```
    Specified by:
    
    deriveWithPreTranslation in class BaseTransform
  - deriveWithTranslation
```
public BaseTransform deriveWithTranslation(double mxt,
                                           double myt,
                                           double mzt)
```
    Specified by:
    
    deriveWithTranslation in class BaseTransform
  - deriveWithScale
```
public BaseTransform deriveWithScale(double mxx,
                                     double myy,
                                     double mzz)
```
    Specified by:
    
    deriveWithScale in class BaseTransform
  - deriveWithRotation
```
public BaseTransform deriveWithRotation(double theta,
                                        double axisX,
                                        double axisY,
                                        double axisZ)
```
    Specified by:
    
    deriveWithRotation in class BaseTransform
  - preTranslate
```
public void preTranslate(double mxt,
                         double myt,
                         double mzt)
```
  - scale
```
public void scale(double sx,
                  double sy)
```
    Description copied from class: AffineBase
    Concatenates this transform with a scaling transformation. This is equivalent to calling concatenate(S), where S is an Affine2D represented by the following matrix:
```
      [   sx   0    0   ]
      [   0    sy   0   ]
      [   0    0    1   ]
 
```
    Overrides:
    
    scale in class AffineBase
    
    Parameters:
    
    sx - the factor by which coordinates are scaled along the X axis direction
    
    sy - the factor by which coordinates are scaled along the Y axis direction
  - scale
```
public void scale(double sx,
                  double sy,
                  double sz)
```
  - rotate
```
public void rotate(double theta)
```
    Description copied from class: AffineBase
    Concatenates this transform with a rotation transformation. This is equivalent to calling concatenate(R), where R is an Affine2D represented by the following matrix:
```
      [   cos(theta)    -sin(theta)    0   ]
      [   sin(theta)     cos(theta)    0   ]
      [       0              0         1   ]
 
```
    Rotating by a positive angle theta rotates points on the positive X axis toward the positive Y axis. Note also the discussion of Handling 90-Degree Rotations above.
    Overrides:
    
    rotate in class AffineBase
    
    Parameters:
    
    theta - the angle of rotation measured in radians
  - rotate
```
public void rotate(double theta,
                   double axisX,
                   double axisY,
                   double axisZ)
```
  - shear
```
public void shear(double shx,
                  double shy)
```
    Description copied from class: AffineBase
    Concatenates this transform with a shearing transformation. This is equivalent to calling concatenate(SH), where SH is an Affine2D represented by the following matrix:
```
      [   1   shx   0   ]
      [  shy   1    0   ]
      [   0    0    1   ]
 
```
    Overrides:
    
    shear in class AffineBase
    
    Parameters:
    
    shx - the multiplier by which coordinates are shifted in the direction of the positive X axis as a factor of their Y coordinate
    
    shy - the multiplier by which coordinates are shifted in the direction of the positive Y axis as a factor of their X coordinate
  - deriveWithConcatenation
```
public Affine3D deriveWithConcatenation(BaseTransform transform)
```
    Specified by:
    
    deriveWithConcatenation in class BaseTransform
  - deriveWithPreConcatenation
```
public Affine3D deriveWithPreConcatenation(BaseTransform transform)
```
    Specified by:
    
    deriveWithPreConcatenation in class BaseTransform
  - concatenate
```
public void concatenate(BaseTransform transform)
```
    Description copied from class: AffineBase
    Concatenates a BaseTransform Tx to this Affine2D Cx in the most commonly useful way to provide a new user space that is mapped to the former user space by Tx. Cx is updated to perform the combined transformation. Transforming a point p by the updated transform Cx' is equivalent to first transforming p by Tx and then transforming the result by the original transform Cx like this: Cx'(p) = Cx(Tx(p)) In matrix notation, if this transform Cx is represented by the matrix [this] and Tx is represented by the matrix [Tx] then this method does the following:
```
      [this] = [this] x [Tx]
 
```
    Overrides:
    
    concatenate in class AffineBase
    
    Parameters:
    
    transform - the BaseTransform object to be concatenated with this Affine2D object.
    
    See Also:
    
    #preConcatenate
  - concatenate
```
public void concatenate(double Txx,
                        double Txy,
                        double Txz,
                        double Txt,
                        double Tyx,
                        double Tyy,
                        double Tyz,
                        double Tyt,
                        double Tzx,
                        double Tzy,
                        double Tzz,
                        double Tzt)
```
  - deriveWithConcatenation
```
public Affine3D deriveWithConcatenation(double Txx,
                                        double Tyx,
                                        double Txy,
                                        double Tyy,
                                        double Txt,
                                        double Tyt)
```
    Specified by:
    
    deriveWithConcatenation in class BaseTransform
  - deriveWithConcatenation
```
public BaseTransform deriveWithConcatenation(double mxx,
                                             double mxy,
                                             double mxz,
                                             double mxt,
                                             double myx,
                                             double myy,
                                             double myz,
                                             double myt,
                                             double mzx,
                                             double mzy,
                                             double mzz,
                                             double mzt)
```
    Specified by:
    
    deriveWithConcatenation in class BaseTransform
  - preConcatenate
```
public void preConcatenate(BaseTransform transform)
```
  - restoreTransform
```
public void restoreTransform(double mxx,
                             double myx,
                             double mxy,
                             double myy,
                             double mxt,
                             double myt)
```
    Description copied from class: BaseTransform
    
    This function is only guaranteed to succeed if the transform is of degree AFFINE2D or less and the matrix parameters specified came from this same instance. In practice, they will also tend to succeed if they specify a transform of Degree less than or equal to the Degree of this instance as well, but the intent of this method is to restore the transform that had been read out of this transform into local variables.
    
    Specified by:
    
    restoreTransform in class BaseTransform
  - restoreTransform
```
public void restoreTransform(double mxx,
                             double mxy,
                             double mxz,
                             double mxt,
                             double myx,
                             double myy,
                             double myz,
                             double myt,
                             double mzx,
                             double mzy,
                             double mzz,
                             double mzt)
```
    Description copied from class: BaseTransform
    
    This function is only guaranteed to succeed if the matrix parameters specified came from this same instance. In practice, they will also tend to succeed if they specify a transform of Degree less than or equal to the Degree of this instance as well, but the intent of this method is to restore the transform that had been read out of this transform into local variables.
    
    Specified by:
    
    restoreTransform in class BaseTransform
  - lookAt
```
public Affine3D lookAt(Vec3d eye,
                       Vec3d center,
                       Vec3d up)
```
    Sets this transform to a viewing transform computed from the specified eye point, center point, and up vector. The resulting transform can be used as the view transform in a 3D camera.
    
    Parameters:
    
    eye - the eye point
    
    center - the center point
    
    up - the up vector
    
    Returns:
    
    this transform
  - almostOne
```
static boolean almostOne(double a)
```
  - _matround
```
private static double _matround(double matval)
```
  - toString
```
public java.lang.String toString()
```
    Returns a String that represents the value of this Object.
    
    Overrides:
    
    toString in class BaseTransform
    
    Returns:
    
    a String representing the value of this Object.

Class Affine3D

Nested Class Summary

Nested classes/interfaces inherited from class com.sun.javafx.geom.transform.BaseTransform

Field Summary

Fields inherited from class com.sun.javafx.geom.transform.AffineBase

Fields inherited from class com.sun.javafx.geom.transform.BaseTransform

Constructor Summary

Method Summary

Methods inherited from class com.sun.javafx.geom.transform.AffineBase

Methods inherited from class com.sun.javafx.geom.transform.BaseTransform

Methods inherited from class java.lang.Object

Field Detail

mxz

myz

mzx

mzy

mzz

mzt

Constructor Detail

Affine3D

Affine3D

Affine3D

Affine3D

Method Detail

copy

getDegree

reset3Delements

updateState

getMxz

getMyz

getMzx

getMzy

getMzz

getMzt

getDeterminant

setTransform

setTransform

setToTranslation

setToScale

setToRotation

setToRotation

transform

transform

deltaTransform

inverseTransform

inverseDeltaTransform

inverseTransform

inverseTransform

inverseTransform

inverseDeltaTransform

inverseTransform

inverseTransform

createInverse

invert

minor

deriveWithNewTransform

deriveWithTranslation

translate

translate

deriveWithPreTranslation

deriveWithTranslation

deriveWithScale

deriveWithRotation

preTranslate

scale

scale

rotate

rotate

shear

deriveWithConcatenation

deriveWithPreConcatenation

concatenate

concatenate

deriveWithConcatenation

deriveWithConcatenation

preConcatenate

restoreTransform

restoreTransform

lookAt

almostOne