ICPRegistration (Artisynth API documentation)

java.lang.Object
- maspack.geometry.ICPRegistration

```
public class ICPRegistration
extends java.lang.Object
```
Class to perform interative closest point (ICP) registration of one mesh onto another.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ICPRegistration.Prealign` Specifies whether to prealign the mesh using principal component analysis (PCA), and if so, which of the resulting PCA axes to try.

Field Summary

Fields
Modifier and Type Field and Description

static double myAdjustTime

static double myDistanceTime

static double myPCATime

static boolean myProfiling

Fields
Modifier and Type	Field and Description
`static double`	`myAdjustTime`
`static double`	`myDistanceTime`
`static double`	`myPCATime`
`static boolean`	`myProfiling`

Constructor Summary

Constructors
Constructor and Description

ICPRegistration()

Constructors
Constructor and Description
`ICPRegistration()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAxisFlips(java.util.LinkedList<RotationMatrix3d> flips, RotationMatrix3d R, Vector3d axis, int n)`
`void`	`computeAdjustment(AffineTransform3d dX, int ndists, int n)` Computes an adjustment `dX` to the current AffineTransform3d `X` such that `dX` moves all the points in such a way as to minimize their distance to the surface.
`RotationMatrix3d[]`	`computeFlips(Vector3d sig)`
`double`	`computeInertia(Matrix3d J, Vector3d c, PolygonalMesh mesh)`
`static void`	`computeOBBFromPCA(OBB obb, MeshBase mesh)` Use PCA to determine the OBB for a mesh.
`static double`	`computePCA(Matrix3d J, Vector3d c, MeshBase mesh)` Based on "Non-rigid Transformations for Musculoskeletal Model", by Petr Kellnhofer.
`boolean`	`isDualDistancingEnabled()`
`void`	`registerICP(AffineTransform3d X, PolygonalMesh mesh1, PolygonalMesh mesh2, ICPRegistration.Prealign align, int[] npar)` Computes an affine transform that tries to register `mesh2` onto `mesh1`, using an interative closest point (ICP) approach.
`void`	`registerICP(AffineTransform3d X, PolygonalMesh mesh1, PolygonalMesh mesh2, int... npar)` Computes an affine transform that tries to register mesh2 onto mesh1, using an interative closest point (ICP) approach.
`void`	`registerInertia(AffineTransform3d X, PolygonalMesh mesh1, PolygonalMesh mesh2)`
`void`	`registerPCA(AffineTransform3d X, PolygonalMesh mesh1, PolygonalMesh mesh2)`
`void`	`setDualDistancingEnabled(boolean enable)`

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

- Field Detail
  - myProfiling
```
public static boolean myProfiling
```
  - myDistanceTime
```
public static double myDistanceTime
```
  - myAdjustTime
```
public static double myAdjustTime
```
  - myPCATime
```
public static double myPCATime
```
- Constructor Detail
  - ICPRegistration
```
public ICPRegistration()
```
- Method Detail
  - isDualDistancingEnabled
```
public boolean isDualDistancingEnabled()
```
  - setDualDistancingEnabled
```
public void setDualDistancingEnabled(boolean enable)
```
  - computeAdjustment
```
public void computeAdjustment(AffineTransform3d dX,
                              int ndists,
                              int n)
```
    Computes an adjustment dX to the current AffineTransform3d X such that dX moves all the points in such a way as to minimize their distance to the surface. Specifically, we want to move each point by a displacement dp_i such that the projection of this displacement onto the normal n_i arising from the nearest surface point equals the negative of the offset o_i from the surface:
```
 n_i^T dp_i = -o_i
 
```
    Now, dp_i is determined by dX p_i, and dX is itself described by n independent coordinates y, where n is either 3, 6, 7, or 12:
    
    3
    
    corresponds to translation only, with y0:y2 describing the translation parameters;
    
    6
    
    corresponds to rotation and translation, with y3:y5 describing the incremental yaw, pitch and roll angles;
    
    7
    
    corresponds to rotation, translation and scaling, with y6 describing the incremental scaling;
    
    12
    
    corresponds to a full affine transform, with y0:y2 describing the translation parameters and y3:y11 the coefficients of the 3 x 3 affine matrix.
    
    For cases 3, 6, and 7, dX takes the general form
```
 
      [  y6  -y5   y4   y0  ]
 dX = [  y5   y6  -y3   y1  ]
      [ -y4   y3   y6   y2  ]
      [  0    0    0    1   ]
 
```
    where yi = 0 whenever i >= n.
    For each of the above cases, the relation n_i^T dp_i = -o_i can be expressed as
```
 a_i^T y = -o_i
 
```
    where a_i is a n-vector formed from n_i and p_i.
    Assembling these into a single matrix equation for all points, we end up with the linear least squares problem
```
 A y = -o
 
```
    where A is formed from individual rows a_i^T and o is formed from the aggregate of o_i. This least squares problem can be solved directly using the normal equations approach:
```
 A^T A y = -A^T o
 
```
    We use this instead of QR decomposition for reasons of speed.
    Parameters:
    
    dX - returns the computed adjustment transform
    
    ndists - number of points being adjusted
    
    n - number of independent coordinates in dX. 3 corrresponds to translation only, 6 to a rigid transform, 7 to a rigid transform plus scaling, and 9 to a general affine transform.
  - computePCA
```
public static double computePCA(Matrix3d J,
                                Vector3d c,
                                MeshBase mesh)
```
    Based on "Non-rigid Transformations for Musculoskeletal Model", by Petr Kellnhofer.
  - registerPCA
```
public void registerPCA(AffineTransform3d X,
                        PolygonalMesh mesh1,
                        PolygonalMesh mesh2)
```
  - addAxisFlips
```
public void addAxisFlips(java.util.LinkedList<RotationMatrix3d> flips,
                         RotationMatrix3d R,
                         Vector3d axis,
                         int n)
```
  - computeFlips
```
public RotationMatrix3d[] computeFlips(Vector3d sig)
```
  - computeOBBFromPCA
```
public static void computeOBBFromPCA(OBB obb,
                                     MeshBase mesh)
```
    Use PCA to determine the OBB for a mesh.
  - computeInertia
```
public double computeInertia(Matrix3d J,
                             Vector3d c,
                             PolygonalMesh mesh)
```
  - registerInertia
```
public void registerInertia(AffineTransform3d X,
                            PolygonalMesh mesh1,
                            PolygonalMesh mesh2)
```
  - registerICP
```
public void registerICP(AffineTransform3d X,
                        PolygonalMesh mesh1,
                        PolygonalMesh mesh2,
                        int... npar)
```
    Computes an affine transform that tries to register mesh2 onto mesh1, using an interative closest point (ICP) approach. This method has the same functionality as registerICP(AffineTransform3d,PolygonalMesh,PolygonalMesh,Prealign,int[]), only with align set to ICPRegistration.Prealign.PCA_ALL and npar specified as a variable argument list.
    The computed transform X is the transform that should be applied to the vertex positions of mesh2 in order to register them to mesh1.
    
    Parameters:
    
    X - returns the resulting transform
    
    mesh1 - target mesh
    
    mesh2 - mesh to register
    
    npar - DOFs to use in the final registration, as well as any preliminary registrations
  - registerICP
```
public void registerICP(AffineTransform3d X,
                        PolygonalMesh mesh1,
                        PolygonalMesh mesh2,
                        ICPRegistration.Prealign align,
                        int[] npar)
```
    Computes an affine transform that tries to register mesh2 onto mesh1, using an interative closest point (ICP) approach. The resulting transform is returned in X. The npar argument can be used to constrain the transform to rigid, rigid + scaling, or full affine (rigid + scaling + shearing), as described below.
    The computed transform X is the transform that should be applied to the vertex positions of mesh2 in order to register them to mesh1.
    The align argument can be used to specify whether or not to try prealigning the orientation using principal component analysis: ICPRegistration.Prealign.NONE specifies no prealignment, while ICPRegistration.Prealign.PCA_ALL specifies trying all possible PCA axis combinations for the best fit.
    The argument npar contains integers specifying the number of DOFs to be used in both the final registration transform, as well as any preliminary registrations that should be applied first. The last integer specifies the DOFs in the final transformation, while any previous integers specify the preliminary registrations (in order). The integers are restricted to the following values:
    - 3: translation only
    - 6: rigid transform
    - 7: rigid transform + scaling
    - 12: full affine transform (rigid + scaling + shearing)
    Preliminary registrations (usually with lower DOFs) can sometimes help improve the final result. For example, an npar containing the sequence
```
 3, 7
 
```
    would instruct the method to first perform a translational registration, and then finish with a final registration consisting of a rigid transform plus scaling. Likewise, an npar containing the sequence
```
 6, 12
 
```
    would instruct the method to first perform a rigid registration, and then finish with a final full affine registration. Repeating numbers in npar simply requests that the same registration be performed again.
    Parameters:
    
    X - returns the resulting transform
    
    mesh1 - target mesh
    
    mesh2 - mesh to register
    
    align - specifies whether or not to use PCA for prealignment
    
    npar - DOFs to use in the final registration, as well as any preliminary registrations

Class ICPRegistration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

myProfiling

myDistanceTime

myAdjustTime

myPCATime

Constructor Detail

ICPRegistration

Method Detail

isDualDistancingEnabled

setDualDistancingEnabled

computeAdjustment

computePCA

registerPCA

addAxisFlips

computeFlips

computeOBBFromPCA

computeInertia

registerInertia

registerICP

registerICP