GeometryTransformer (Artisynth API documentation)

java.lang.Object
- maspack.geometry.GeometryTransformer

Direct Known Subclasses:

AffineTransformer, DeformationTransformer, RigidTransformer
```
public abstract class GeometryTransformer
extends java.lang.Object
```
Implements geometric transformations associated with a generalized deformation mapping, under which points p are mapped to deformed points p' using a function
```
 p' = f (p)
 
```
The mapping is assumed to be piece-wise differentiable, so that each point p is also associated with a deformation gradient F. The transformations can be applied to a variety of primitives, including points, vectors, planes, meshes, and transformation matrices. Sub-classes provide different types of transformations, include rigid, affine, and non-linear.
The transformations themselves are effected with a set of transform() methods, one for each primitive type. Primitives of type Point3d and Vector3d are transformed using primitives named transformVec() and transformPnt(), to help resolve ambiguities between point and vector transformations.
The transformer is able to save and restore the previous values associated with each transformation, so that its transform actions can later be "undone". Storing of save information is activated by calling setUndoState(UndoState.SAVING), after which each transform operation will save the original value of each primitive. Restoring of this information is then activated by calling setUndoState(UndoState.RESTORING), after which each transform operation will restore the original primitive value instead of performing the actual transformation. For example:
```
   GeometryTransformer gtr;
   Vector3d v1, v2;
   Plane plane;
   
   ... initialize variables ...
   
   // start saving undo information
   gtr.setUndoState (UndoState.SAVING); 
   gtr.transformVec (v1);  
   gtr.transformVec (v2);  // transform v1, v2, and plane
   gtr.transform (plane)

   // restore undo information
   gtr.setUndoState (UndoState.RESTORING); 
   gtr.transformVec (v1);                
   gtr.transformVec (v2);   // restore v1, v2, and plane to their
   gtr.transform (plane)    // original values
 
```
When restoring undo information, operations must be called on the same primitives in the same order as was used during the original transform. It is the responsibility of the calling application to ensure this. The caller may also save and restore additional application-specific information using the primitives saveObject(java.lang.Object) and restoreObject(T).
Author:

John E Lloyd

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`GeometryTransformer.Constrainer` Implements constraint operations on rigid or affine transform objects.
`static class`	`GeometryTransformer.UndoState` Describes the current undo state of this transformer.
`static class`	`GeometryTransformer.UniformScalingConstrainer` Constrains an affine transform so that it results in uniform scaling with no translation

Constructor Summary

Constructors
Constructor and Description

GeometryTransformer()

Constructors
Constructor and Description
`GeometryTransformer()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`AffineTransform3dBase`	`computeLinearizedTransform(Vector3d r)` Computes and returns the linearized affine transform at the specified reference position.
`AffineTransform3d`	`computeLocalAffineTransform(RigidTransform3d T, GeometryTransformer.Constrainer constrainer)` Computes the local affine transform `XL` that transforms points `xl` local to a coordinate frame `T` after that frame is itself transformed.
`abstract 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.
`abstract void`	`computeTransform(AffineTransform3d XR, AffineTransform3d X)` Transforms an affine transform `X` and returns the result in `XR`.
`void`	`computeTransform(AffineTransform3dBase X)`
`abstract 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`.
`abstract void`	`computeTransform(Plane pr, Plane p, Vector3d r)` Transforms a plane `p`, located at reference position `r`, and returns the result in `pr`.
`abstract 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`, according to
`abstract void`	`computeTransformNormal(Vector3d nr, Vector3d n, Vector3d r)` Transforms a normal vector `n`, located at reference position `r`, and returns the result in `nr`.
`abstract void`	`computeTransformPnt(Point3d pr, Point3d p)` Transforms a point `p` and returns the result in `pr`.
`abstract void`	`computeTransformVec(Vector3d vr, Vector3d v, Vector3d r)` Transforms a vector `v`, located at reference position `r`, and returns the result in `vr`.
`static GeometryTransformer`	`create(AffineTransform3dBase X)` Return an appropriate transformer for a given affine transform.
`abstract GeometryTransformer`	`getInverse()` Returns a transformer that implements the inverse operation of this transformer, if `isInvertible()` returns `true`.
`int`	`getUndoDataSize()` Return the current size of the undo data buffer, or -1 if the buffer is null.
`abstract boolean`	`isAffine()` Returns `true` if this transformer implements a linear affine transform.
`abstract boolean`	`isInvertible()` Returns `true` if this transformer is invertible.
`boolean`	`isReflecting()` Returns `true` if this transformer globally implements a reflection (i.e., the determinant of the deformation gradient at all transformation points is negative).
`boolean`	`isRestoring()` Returns `true` if the undo state of this transformer is set to restore primitive values.
`abstract boolean`	`isRigid()` Returns `true` if this transformer implements a linear rigid transform.
`boolean`	`isSaving()` Returns `true` if the undo state of this transformer is set to save primitive values.
`void`	`popRestoreData(int cnt)` Removes `cnt` items of restore data if the undo state of this transformer is set to `GeometryTransformer.UndoState.RESTORING`.
`<T> T`	`restoreObject(T obj)` Returns application-specific data (that was previously set using `saveObject(java.lang.Object)`) if the undo state of this transformer is set to `GeometryTransformer.UndoState.RESTORING`.
`void`	`saveObject(java.lang.Object obj)` Saves application-specific data if the undo state of this transformer is set to `GeometryTransformer.UndoState.SAVING`.
`void`	`setUndoState(GeometryTransformer.UndoState state)` Sets the undo state of this transformer so as to enable it save or restore the original data form transformation operations.
`void`	`transform(AffineTransform3d X)` Transforms an affine transform `X`, in place.
`void`	`transform(AffineTransform3d XR, AffineTransform3d X)` Transforms an affine transform `X` and returns the result in `XR`.
`void`	`transform(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`	`transform(Matrix3d M, Vector3d r)` Transforms a general 3 X 3 matrix `M`, located at reference position `r`, in place.
`void`	`transform(MeshBase mesh)` Applies a geometric transformation to the vertex positions of a mesh, in local mesh coordinates.
`void`	`transform(MeshBase mesh, GeometryTransformer.Constrainer constrainer)`
`void`	`transform(Plane pr, Plane p, Vector3d r)` Transforms a plane `p`, located at reference position `r`, and returns the result in `pr`.
`void`	`transform(Plane p, Vector3d r)` Transforms a plane `p`, located at reference position `r`, in place.
`void`	`transform(RigidTransform3d T)` Transforms a rigid transform `T`, in place.
`void`	`transform(RigidTransform3d TR, RigidTransform3d T)` Transforms a rigid transform `T` and returns the result in `TR`.
`void`	`transform(RotationMatrix3d RR, RotationMatrix3d R, Vector3d r)` Transforms a rotation matrix `R`, located at reference position `r`, and returns the result in `RR`.
`void`	`transform(RotationMatrix3d R, Vector3d r)` Transforms a rotation matrix `R`, located at reference position `r`, in place.
`void`	`transformNormal(Vector3d n, Vector3d r)` Transforms a normal vector `n`, located at reference position `r`, in place.
`void`	`transformNormal(Vector3d nr, Vector3d n, Vector3d r)` Transforms a normal vector `n`, located at reference position `r`, and returns the result in `nr`.
`void`	`transformPnt(Point3d p)` Transforms a point `p`, in place.
`void`	`transformPnt(Point3d pr, Point3d p)` Transforms a point `p` and returns the result in `pr`.
`void`	`transformVec(Vector3d v, Vector3d r)` Transforms a vector `v`, located at reference position `r`, in place.
`void`	`transformVec(Vector3d vr, Vector3d v, Vector3d r)` Transforms a vector `v`, located at reference position `r`, and returns the result in `vr`.
`void`	`transformWorld(MeshBase mesh)` Applies a geometric transformation to both the vertex positions of a mesh and its mesh-to-world transform TMW, in world coordinates.
`double`	`transformWorld(MeshBase mesh, GeometryTransformer.Constrainer constrainer)` Applies a geometric transformation to both the vertices of a mesh and its mesh-to-world transform TMW, in world coordinates.

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

- Constructor Detail
  - GeometryTransformer
```
public GeometryTransformer()
```
- Method Detail
  - setUndoState
```
public void setUndoState(GeometryTransformer.UndoState state)
```
    Sets the undo state of this transformer so as to enable it save or restore the original data form transformation operations.
    
    Parameters:
    
    state - new undo state
  - isRestoring
```
public boolean isRestoring()
```
    Returns true if the undo state of this transformer is set to restore primitive values.
    
    Returns:
    
    true if this transformer is restoring values.
  - isSaving
```
public boolean isSaving()
```
    Returns true if the undo state of this transformer is set to save primitive values.
    
    Returns:
    
    true if this transformer is saving values.
  - restoreObject
```
public <T> T restoreObject(T obj)
```
    Returns application-specific data (that was previously set using saveObject(java.lang.Object)) if the undo state of this transformer is set to GeometryTransformer.UndoState.RESTORING. Otherwise, an exception is thrown.
    
    Parameters:
    
    obj - any object with the same data type as the object to be restored. Used only for compile-time type checking and will not be modified.
    
    Returns:
    
    original data value
  - saveObject
```
public void saveObject(java.lang.Object obj)
```
    Saves application-specific data if the undo state of this transformer is set to GeometryTransformer.UndoState.SAVING. Otherwise, an exception is thrown.
    
    Parameters:
    
    obj - object to be saved.
  - popRestoreData
```
public void popRestoreData(int cnt)
```
    Removes cnt items of restore data if the undo state of this transformer is set to GeometryTransformer.UndoState.RESTORING. Otherwise, an exception is thrown.
    
    Parameters:
    
    cnt - number of restore items to remove.
  - isRigid
```
public abstract boolean isRigid()
```
    Returns true if this transformer implements a linear rigid transform.
  - isAffine
```
public abstract boolean isAffine()
```
    Returns true if this transformer implements a linear affine transform.
  - isReflecting
```
public boolean isReflecting()
```
    Returns true if this transformer globally implements a reflection (i.e., the determinant of the deformation gradient at all transformation points is negative). The default declaration of this method returns false. Subclasses should override this if necessary.
  - isInvertible
```
public abstract boolean isInvertible()
```
    Returns true if this transformer is invertible. If it is, then an inverse transformer can be obtained using getInverse().
  - getInverse
```
public abstract GeometryTransformer getInverse()
```
    Returns a transformer that implements the inverse operation of this transformer, if isInvertible() returns true.
    
    Returns:
    
    inverse transformer
  - transformPnt
```
public void transformPnt(Point3d p)
```
    Transforms a point p, in place. This is equivalent to transformPnt(p,p).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then p is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    p - point to be transformed
  - transformPnt
```
public void transformPnt(Point3d pr,
                         Point3d p)
```
    Transforms a point p and returns the result in pr.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then pr is instead set to the value of p that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    pr - transformed point
    
    p - point to be transformed
  - computeTransformPnt
```
public abstract void computeTransformPnt(Point3d pr,
                                         Point3d p)
```
    Transforms a point p and returns the result in pr. This provides the low level implementation for point transformations and does not do any saving or restoring of data.
    
    Parameters:
    
    pr - transformed point
    
    p - point to be transformed
  - transformVec
```
public void transformVec(Vector3d v,
                         Vector3d r)
```
    Transforms a vector v, located at reference position r, in place. This is equivalent to transformVec(v,v,r).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then v is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    v - vector to be transformed
    
    r - reference position of the vector, in original coordinates
  - transformVec
```
public void transformVec(Vector3d vr,
                         Vector3d v,
                         Vector3d r)
```
    Transforms a vector v, located at reference position r, and returns the result in vr. Generally, this transformation will take the form
```
 vr = F v
 
```
    where F is the deformation gradient at the reference position.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then vr is instead set to the value of v that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    vr - transformed vector
    
    v - vector to be transformed
    
    r - reference position of the vector, in original coordinates
  - computeTransformVec
```
public abstract void computeTransformVec(Vector3d vr,
                                         Vector3d v,
                                         Vector3d r)
```
    Transforms a vector v, located at reference position r, and returns the result in vr. This provides the low level implementation for vector transformations and does not do any saving or restoring of data.
    
    Parameters:
    
    vr - transformed vector
    
    v - vector to be transformed
    
    r - reference position of the vector, in original coordinates
  - transformNormal
```
public void transformNormal(Vector3d n,
                            Vector3d r)
```
    Transforms a normal vector n, located at reference position r, in place. This is equivalent to transformNormal(n, n).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then n is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    n - normal to be transformed
    
    r - reference position of the normal, in original coordinates
  - transformNormal
```
public void transformNormal(Vector3d nr,
                            Vector3d n,
                            Vector3d r)
```
    Transforms a normal vector n, located at reference position r, and returns the result in nr. Generally, this transformation will take the form
```
       -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.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then nr is instead set to the value of n that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    nr - transformed normal
    
    n - normal to be transformed
    
    r - reference position of the normal, in original coordinates
  - computeTransformNormal
```
public abstract void computeTransformNormal(Vector3d nr,
                                            Vector3d n,
                                            Vector3d r)
```
    Transforms a normal vector n, located at reference position r, and returns the result in nr. This provides the low level implementation for normal transformations and does not do any saving or restoring of data.
    
    Parameters:
    
    nr - transformed normal
    
    n - normal to be transformed
    
    r - reference position of the normal, in original coordinates
  - transform
```
public void transform(RigidTransform3d T)
```
    Transforms a rigid transform T, in place. This is equivalent to transform(T,T).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then T is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    T - rigid transform to be transformed.
  - transform
```
public void transform(RigidTransform3d TR,
                      RigidTransform3d T)
```
    Transforms a rigid transform T and returns the result in TR. If
```
      [  R   p  ]
 T =  [         ]
      [  0   1  ]
 
```
    and f(p) and F are the deformed position and deformation gradient at p, then generally this transform takes the form
```
      [  Q R N   f(p) ]
 TR = [               ]
      [    0      1   ]
 
```
    where Q is the orthogonal matrix from the left polar decomposition F = P Q, and N is matrix that flips an axis to ensure that Q R N remains right-handed. If det(Q) = 1, then N is the identity, while if det(Q) = -1, then N is typically choosen to correspond to the axis least affected by Q, which is the one corresponding to the diagonal of Q nearest to 1.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then TR is instead set to the value of T that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    TR - transformed transform
    
    T - transform to be transformed
  - computeTransform
```
public void computeTransform(AffineTransform3dBase X)
```
  - transform
```
public void transform(AffineTransform3d X)
```
    Transforms an affine transform X, in place. This is equivalent to transform(X,X).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then X is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    X - affine transform to be transformed.
  - transform
```
public void transform(AffineTransform3d XR,
                      AffineTransform3d X)
```
    Transforms an affine transform X and returns the result in XR. If
```
     [  A   p  ]
 X = [         ]
     [  0   1  ]
 
```
    then generally, this transform takes the form
```
      [  F A   f(p) ]
 XR = [             ]
      [   0     1   ]
 
```
    where F is the deformation gradient at p, and f(p) is the deformed position of p.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then XR is instead set to the value of X that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    XR - transformed transform
    
    X - transform to be transformed
  - computeTransform
```
public abstract void computeTransform(AffineTransform3d XR,
                                      AffineTransform3d X)
```
    Transforms an affine transform X and returns the result in XR. This provides the low level implementation for the transformation of affine transforms and does not do any saving or restoring of data.
    
    Parameters:
    
    XR - transformed transform
    
    X - transform to be transformed
  - transform
```
public void transform(RotationMatrix3d R,
                      Vector3d r)
```
    Transforms a rotation matrix R, located at reference position r, in place. This is equivalent to transform(R,R,r).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then R is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    R - rotation to be transformed
    
    r - reference position of the rotation, in original coordinates
  - transform
```
public void transform(RotationMatrix3d RR,
                      RotationMatrix3d R,
                      Vector3d r)
```
    Transforms a rotation matrix R, located at reference position r, and returns the result in RR. If F is the deformation gradient at r, this transform takes the form
```
 RR = Q R N 
 
```
    where Q is the orthogonal matrix from the left polar decomposition F = P Q, and N is matrix that flips an axis to ensure that Q R N remains right-handed. If det(Q) = 1, then N is the identity, while if det(Q) = -1, then N is typically choosen to correspond to the axis least affected by Q, which is the one corresponding to the diagonal of Q nearest to 1.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then RR is instead set to the value of R that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    RR - transformed rotation
    
    R - rotation to be transformed
    
    r - reference position of the rotation, in original coordinates
  - computeTransform
```
public abstract 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, according to
```
 RR = Q R N
 
```
    where P, Q and N are described in the documentation for transform(RotationMatrix3d,RotationMatrix3d,Vector3d).
    This provides the low level implementation for the transformation of rotation matrices and does not do any saving or restoring of data.
    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
  - transform
```
public void transform(Matrix3d M,
                      Vector3d r)
```
    Transforms a general 3 X 3 matrix M, located at reference position r, in place. This is equivalent to transform(M,M,r).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then M is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    M - matrix to be transformed
    
    r - reference position of the matrix, in original coordinates
  - transform
```
public void transform(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. Generally, this transform takes the form
```
 MR = F M
 
```
    where F is the deformation gradient at the reference position.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then MR is instead set to the value of M that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    MR - transformed matrix
    
    M - matrix to be transformed
    
    r - reference position of the matrix, in original coordinates
  - computeTransform
```
public abstract 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. This provides the low level implementation for the transformation of 3 X 3 matrices and does not do any saving or restoring of data.
    
    Parameters:
    
    MR - transformed matrix
    
    M - matrix to be transformed
    
    r - reference position of the matrix, in original coordinates
  - transform
```
public void transform(Plane p,
                      Vector3d r)
```
    Transforms a plane p, located at reference position r, in place. This is equivalent to transform(p,p,r).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then p is instead set to its original value that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    p - plane to be transformed
    
    r - reference position of the plane, in original coordinates
  - transform
```
public void transform(Plane pr,
                      Plane p,
                      Vector3d r)
```
    Transforms a plane p, located at reference position r, and returns the result in pr.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then pr is instead set to the value of p that was previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    pr - transformed plane
    
    p - plane to be transformed
    
    r - reference position of the plane, in original coordinates
  - computeTransform
```
public abstract void computeTransform(Plane pr,
                                      Plane p,
                                      Vector3d r)
```
    Transforms a plane p, located at reference position r, and returns the result in pr. This provides the low level implementation for the transformation of planes and does not do any saving or restoring of data.
    
    Parameters:
    
    pr - transformed plane
    
    p - plane to be transformed
    
    r - reference position of the plane, in original coordinates
  - transform
```
public void transform(MeshBase mesh)
```
    Applies a geometric transformation to the vertex positions of a mesh, in local mesh coordinates. The topology of the mesh remains unchanged.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then the vertex positions are instead set to their original values that were previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    mesh - Mesh to be transformed
  - transform
```
public void transform(MeshBase mesh,
                      GeometryTransformer.Constrainer constrainer)
```
  - transformWorld
```
public void transformWorld(MeshBase mesh)
```
    Applies a geometric transformation to both the vertex positions of a mesh and its mesh-to-world transform TMW, in world coordinates. The local vertex positions p are modified to accommodate that of part of the transformation not provided by the change to TMW. Specifically,
```
 p' = TMWnew X (TMW p) 
```
    where X( ) indicates the transform applied by this transformer and TMWnew is the transformed value of TMW.
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then the vertex positions and TMW are instead set to their original values that were previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    Parameters:
    
    mesh - Mesh to be transformed
  - transformWorld
```
public double transformWorld(MeshBase mesh,
                             GeometryTransformer.Constrainer constrainer)
```
    Applies a geometric transformation to both the vertices of a mesh and its mesh-to-world transform TMW, in world coordinates. The local vertex positions p are modified to accommodate that part of the transformation not provided by the change to TMW. If a constrainer is supplied, then this change is constrained to that obtained by applying the constrainer to the local affine transform obtained at the origin of the mesh coordinate system. Otherwise, this method behaves identically to transformWorld(MeshBase).
    If this transformer's undo state is set to GeometryTransformer.UndoState.RESTORING, then the vertex positions and TMW are instead set to their original values that were previously saved when the undo state was set to GeometryTransformer.UndoState.SAVING.
    
    Parameters:
    
    mesh - Mesh to be transformed
  - computeLocalTransforms
```
public abstract 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. This accounts for the non-rigid aspects of the transformation that cannot be absorbed into T.
    See the documentation for transform(RigidTransform3d,RigidTransform3d). If
```
      [  R   p  ]
 T =  [         ]
      [  0   1  ]
 
```
    then
```
      [  Q R N   f(p) ]
 TR = [               ].
      [    0      1   ]
 
```
    Meanwhile, the linearization of f(p) about p is given by the affine transform
```
     [  F    -F p + f(p) ]
 X = [                   ].
     [  0         1      ]
 
```
    If xw and xl describe points with respect to world and T, respectively, we have
```
 xw' = X xw = X T xl
 
```
    and so the updated value of xl is given by
```
 xl' = inv(TR) xw' = inv(TR) X T xl
 
```
    which can be expressed as
```
                       T  T
 xl' = N PL xl,  PL = R  Q  P Q R
 
```
    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.
  - computeLocalAffineTransform
```
public AffineTransform3d computeLocalAffineTransform(RigidTransform3d T,
                                                     GeometryTransformer.Constrainer constrainer)
```
    Computes the local affine transform XL that transforms points xl local to a coordinate frame T after that frame is itself transformed. The updated local coordinates are given by
```
 [ xl' ]      [ xl ]
 [     ] = XL [    ]
 [  1  ]      [ 0  ]
 
```
    and XL is computed from the PL and N matrices returned by computeLocalTransform(PL,Ndiag,T), according to
```
      [  N PL  0 ]
 XL = [          ].
      [  0     1 ]
 
```
    An optional constrainer can be provided to further constrain the resulting value of XL.
    Parameters:
    
    T - rigid transform for which the local affine transform is computed
    
    constrainer - if non-null, specifies a constrainer that should be applied to constrain the value of the transform
    
    Returns:
    
    local affine transform
  - computeLinearizedTransform
```
public AffineTransform3dBase computeLinearizedTransform(Vector3d r)
```
    Computes and returns the linearized affine transform at the specified reference position. In the general case, this is the local linearization of the deformation field f(p) around r, given by
```
     [  F   f(dp) ]
 X = [            ]
     [  0     1   ]
 
```
    so that for a small change in position dp, we have
```
             [ dp ]
 f(p+dp) = X [    ]
             [ 1  ]
 
```
    In the case where f(p) is itself an affine or rigid transform given by
```
     [  F     px  ]
 A = [            ]
     [  0     1   ]
 
```
    the local transform becomes
```
     [  F     F p + px  ]
 X = [                  ]
     [  0         1     ]
 
```
    and if p = 0, then X is the simply the transform itself.
    Parameters:
    
    r - reference position at which the transformation is calculated
    
    Returns:
    
    local affine transform
  - create
```
public static GeometryTransformer create(AffineTransform3dBase X)
```
    Return an appropriate transformer for a given affine transform.
    
    Parameters:
    
    X - Affine transform (either rigid or strictly affine) for which the transformer should be created
    
    Returns:
    
    transformer for the indicated affine transform
  - getUndoDataSize
```
public int getUndoDataSize()
```
    Return the current size of the undo data buffer, or -1 if the buffer is null. Used for debugging only.

Class GeometryTransformer

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GeometryTransformer

Method Detail

setUndoState

isRestoring

isSaving

restoreObject

saveObject

popRestoreData

isRigid

isAffine

isReflecting

isInvertible

getInverse

transformPnt

transformPnt

computeTransformPnt

transformVec

transformVec

computeTransformVec

transformNormal

transformNormal

computeTransformNormal

transform

transform

computeTransform

transform

transform

computeTransform

transform

transform

computeTransform

transform

transform

computeTransform

transform

transform

computeTransform

transform

transform

transformWorld

transformWorld

computeLocalTransforms

computeLocalAffineTransform

computeLinearizedTransform

create

getUndoDataSize