DeformationTransformer (Artisynth API documentation)

java.lang.Object
- maspack.geometry.GeometryTransformer
- - maspack.geometry.DeformationTransformer

Direct Known Subclasses:

FemGeometryTransformer
```
public abstract class DeformationTransformer
extends GeometryTransformer
```
Base class for GeometryTransformers that implement general deformation fields. Subclasses must implement a single abstract method that for a given reference point r returns its deformed position f(r) and the deformation gradient F at that location.

Author:

John E Lloyd

Nested Class Summary
- Nested classes/interfaces inherited from class maspack.geometry.GeometryTransformer
  GeometryTransformer.Constrainer, GeometryTransformer.UndoState, GeometryTransformer.UniformScalingConstrainer

Constructor Summary

Constructors
Constructor and Description

DeformationTransformer()

Constructors
Constructor and Description
`DeformationTransformer()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`computeLocalTransforms(Matrix3d PL, Vector3d Ndiag, RigidTransform3d T)` Computes the matrices `PL` and `N` that transform points `xl` local to a coordinate frame `T` after that frame is itself transformed.
`void`	`computeTransform(AffineTransform3d XR, AffineTransform3d X)` Transforms an affine transform `X` and returns the result in `XR`.
`void`	`computeTransform(Matrix3d MR, Matrix3d M, Vector3d r)` Transforms a general 3 X 3 matrix `M`, located at reference position `r`, and returns the result in `MR`.
`void`	`computeTransform(Plane pr, Plane p, Vector3d r)` Transforms a plane `p`, located at reference position `r`, and returns the result in `pr`.
`void`	`computeTransform(RotationMatrix3d RR, Vector3d Ndiag, RotationMatrix3d R, Vector3d r)` Transforms a rotation matrix `R`, located at reference position `r`, and returns the result in `RR`.
`void`	`computeTransformNormal(Vector3d nr, Vector3d n, Vector3d r)` Transforms a normal vector `n`, located at a reference position `r`, and returns the result in `nr`.
`void`	`computeTransformPnt(Point3d pr, Point3d p)` Transforms a point `p` and returns the result in `pr`.
`void`	`computeTransformVec(Vector3d vr, Vector3d v, Vector3d r)` Transforms a vector `v`, located at a reference position `r`, and returns the result in `vr`.
`abstract void`	`getDeformation(Vector3d p, Matrix3d F, Vector3d r)` Computes the deformed position `f(r)` and deformation gradient `F` for a given reference point `r` in undeformed coordinates.
`DeformationTransformer`	`getInverse()` Returns `null` by since this transformer is not by default invertible; subclasses my override this.
`boolean`	`isAffine()` Returns `false` since this transformer does not implement a linear affine transform.
`boolean`	`isInvertible()` Returns `false` since this transformer is not by default invertible; subclasses my override this.
`boolean`	`isRigid()` Returns `false` since this transformer does not implement a linear rigid transform.

Methods inherited from class maspack.geometry.GeometryTransformer
computeLinearizedTransform, computeLocalAffineTransform, computeTransform, create, getUndoDataSize, isReflecting, isRestoring, isSaving, popRestoreData, restoreObject, saveObject, setUndoState, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transformNormal, transformNormal, transformPnt, transformPnt, transformVec, transformVec, transformWorld, transformWorld

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DeformationTransformer
```
public DeformationTransformer()
```
- Method Detail
  - isRigid
```
public boolean isRigid()
```
    Returns false since this transformer does not implement a linear rigid transform.
    
    Specified by:
    
    isRigid in class GeometryTransformer
  - isAffine
```
public boolean isAffine()
```
    Returns false since this transformer does not implement a linear affine transform.
    
    Specified by:
    
    isAffine in class GeometryTransformer
  - isInvertible
```
public boolean isInvertible()
```
    Returns false since this transformer is not by default invertible; subclasses my override this.
    
    Specified by:
    
    isInvertible in class GeometryTransformer
  - getInverse
```
public DeformationTransformer getInverse()
```
    Returns null by since this transformer is not by default invertible; subclasses my override this.
    
    Specified by:
    
    getInverse in class GeometryTransformer
    
    Returns:
    
    inverse transformer
  - getDeformation
```
public abstract void getDeformation(Vector3d p,
                                    Matrix3d F,
                                    Vector3d r)
```
    Computes the deformed position f(r) and deformation gradient F for a given reference point r in undeformed coordinates.
    
    Parameters:
    
    p - if non-null, returns the deformed position
    
    F - if non-null, returns the deformation gradient
    
    r - reference point in undeformed coordinates
  - computeTransformPnt
```
public void computeTransformPnt(Point3d pr,
                                Point3d p)
```
    Transforms a point p and returns the result in pr. The transform is computed according to
```
 pr = f(p)
 
```
    This method provides the low level implementation for point transformations and does not do any saving or restoring of data.
    Specified by:
    
    computeTransformPnt in class GeometryTransformer
    
    Parameters:
    
    pr - transformed point
    
    p - point to be transformed
  - computeTransformVec
```
public void computeTransformVec(Vector3d vr,
                                Vector3d v,
                                Vector3d r)
```
    Transforms a vector v, located at a reference position r, and returns the result in vr. The transform is computed according to
```
 vr = F v
 
```
    where F is the deformation gradient at the reference position. This method provides the low level implementation for vector transformations and does not do any saving or restoring of data.
    Specified by:
    
    computeTransformVec in class GeometryTransformer
    
    Parameters:
    
    vr - transformed vector
    
    v - vector to be transformed
    
    r - reference position of the vector, in original coordinates
  - computeLocalTransforms
```
public void computeLocalTransforms(Matrix3d PL,
                                   Vector3d Ndiag,
                                   RigidTransform3d T)
```
    Computes the matrices PL and N that transform points xl local to a coordinate frame T after that frame is itself transformed. The updated local coordinates are given by
```
 xl' = N PL xl
 
```
    where PL is symmetric positive definite and N is a diagonal matrix that is either the identity, or a reflection that flips a single axis. See the documentation for GeometryTransformer.computeLocalTransforms(maspack.matrix.Matrix3d, maspack.matrix.Vector3d, maspack.matrix.RigidTransform3d).
    Specified by:
    
    computeLocalTransforms in class GeometryTransformer
    
    Parameters:
    
    PL - primary transformation matrix
    
    Ndiag - if non-null, returns the diagonal components of N
    
    T - rigid transform for which the local transforms are computed
  - computeTransformNormal
```
public void computeTransformNormal(Vector3d nr,
                                   Vector3d n,
                                   Vector3d r)
```
    Transforms a normal vector n, located at a reference position r, and returns the result in nr. The transform is computed according to
```
       -1 T
 nr = F     n
 
```
    where F is the deformation gradient at the reference position. The result is not normalized since the unnormalized form could be useful in some contexts. This method provides the low level implementation for normal transformations and does not do any saving or restoring of data.
    Specified by:
    
    computeTransformNormal in class GeometryTransformer
    
    Parameters:
    
    nr - transformed normal
    
    n - normal to be transformed
    
    r - reference position of the normal, in original coordinates
  - computeTransform
```
public void computeTransform(AffineTransform3d XR,
                             AffineTransform3d X)
```
    Transforms an affine transform X and returns the result in XR. If
```
     [  A   p ]
 X = [        ]
     [  0   1 ]
 
```
    the transform is computed according to
```
      [  F A    f(p) ]
 XR = [              ]
      [   0      1   ]
 
```
    where f(p) and F are the deformation and deformation gradient at p. This method provides the low level implementation for the transformation of affine transforms and does not do any saving or restoring of data.
    Specified by:
    
    computeTransform in class GeometryTransformer
    
    Parameters:
    
    XR - transformed transform
    
    X - transform to be transformed
  - computeTransform
```
public void computeTransform(RotationMatrix3d RR,
                             Vector3d Ndiag,
                             RotationMatrix3d R,
                             Vector3d r)
```
    Transforms a rotation matrix R, located at reference position r, and returns the result in RR. The transform is computed according to
```
 RR = RF R
 
```
    where PF RF = F is the left polar decomposition of the deformation gradient at the reference position. This method provides the low level implementation for the transformation of rotation matrices and does not do any saving or restoring of data.
    Specified by:
    
    computeTransform in class GeometryTransformer
    
    Parameters:
    
    RR - transformed rotation
    
    R - rotation to be transformed
    
    r - reference position of the rotation, in original coordinates
    
    Ndiag - if non-null, returns the diagonal elements of the matrix N
  - computeTransform
```
public void computeTransform(Matrix3d MR,
                             Matrix3d M,
                             Vector3d r)
```
    Transforms a general 3 X 3 matrix M, located at reference position r, and returns the result in MR. The transform is computed according to
```
 MR = F M
 
```
    where F is the deformation gradient at the reference position. This method provides the low level implementation for the transformation of 3 X 3 matrices and does not do any saving or restoring of data.
    Specified by:
    
    computeTransform in class GeometryTransformer
    
    Parameters:
    
    MR - transformed matrix
    
    M - matrix to be transformed
    
    r - reference position of the matrix, in original coordinates
  - computeTransform
```
public void computeTransform(Plane pr,
                             Plane p,
                             Vector3d r)
```
    Transforms a plane p, located at reference position r, and returns the result in pr. Assume that p is defined by a normal n and offset o such that all planar points x satisfy
```
 n^T x = o
 
```
    Then the transformed normal nr and offset or are computed according to
```
 nr = inv(F)^T n
 nr = nr / ||nr||
 or = nr^T f(r)
 
```
    where F is the deformation gradient at the reference position. This method provides the low level implementation for the transformation of planes and does not do any saving or restoring of data.
    Specified by:
    
    computeTransform in class GeometryTransformer
    
    Parameters:
    
    pr - transformed plane
    
    p - plane to be transformed
    
    r - reference position of the plane, in original coordinates

Class DeformationTransformer

Nested Class Summary

Nested classes/interfaces inherited from class maspack.geometry.GeometryTransformer

Constructor Summary

Method Summary

Methods inherited from class maspack.geometry.GeometryTransformer

Methods inherited from class java.lang.Object

Constructor Detail

DeformationTransformer

Method Detail

isRigid

isAffine

isInvertible

getInverse

getDeformation

computeTransformPnt

computeTransformVec

computeLocalTransforms

computeTransformNormal

computeTransform

computeTransform

computeTransform

computeTransform