maspack.geometry

Class ICPRegistration

java.lang.Object

maspack.geometry.ICPRegistration

public class ICPRegistration
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ICPRegistration.Prealign

Field Summary

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

Method Summary

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)
void	registerICP(AffineTransform3d X, PolygonalMesh mesh1, PolygonalMesh mesh2, int... npar)
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)

registerICP

public void registerICP(AffineTransform3d X,
                        PolygonalMesh mesh1,
                        PolygonalMesh mesh2,
                        ICPRegistration.Prealign align,
                        int[] npar)