Vision and Mobile Robotics Laboratory | Software
Home | Members | Projects | Publications | Software | Videos Internal

ICP2

Description

ICP2 is an improved version of the previous MeshToolbox ICP program. Like the original ICP, it is an implementation of the Iterative Closest Point algorithm for registering two 3-D point clouds when the clouds are roughly aligned. It is based on algorithms of Besl and McKay (PAMI, February 1992) and Zhang (IJCV 1994). ICP2 is used as a final "polishing" step in the model-building process.

Improvements over ICP include:

The Lorentzian weighting function is designed to reduce the influence of outliers on the algorithm. The original ICP algorithm performs least squares minimization, which is equivalent to the maximum liklihood solution under the assumption that errors are Gaussian distributed. Assuming errors are distributed according to the Lorentzian leads to a weighed least squares minimization where the weights are the Lorentzian of the error.

The sigmoid weighting function has a similar shape to the Lorentzian but has the advantage that its parameters can be adjusted to approximate a step-edge threshold as well. The sigmoid provides thresholding similar to the dynamic thresholding approach but does not suffer from discontinuities in the error surface due to points crossing the threshold.

Weighting points by the area reduces the resolution dependence of the algorithm. Without area weighting, densely sampled regions have more influence on the transformation.

Filtering non-overlapping points corrects an important limitation of the ICP algorithm. ICP assumes that one data set is a subset of the other. If this is not the case, non-overlapping points can influence the transformation.

A stopping criterion based on the maximum motion of any point in the dataset in one iteration captures the notion that the algorithm should stop when the data stops moving. Using the angleT (change in angles) criterion does not take into account the size of the data.

Files

icp2_main.c contains the command-line interface for ICP. It reads in command line options and writes out the resulting registration.

icp2.c contains the implementation of the icp algorithm.

icp2.h class definition for the icp class.

3dtree.c contains the functions for creation and use of a 3-D closest point search tree.

3dtree.h contains the class definition for a 3-dimensional kDtree.

Usage

By typing ICP2 - the following options (format description default) are printed:

Usage: ICP2 - registers model to scene (see ICP2.html for details)

In more detail the options are:

%S scene faceset filename [required]

%S model faceset filename [required]

-output %S transformed model

-translate %F %F %F initial translation [0, 0, 0]

-rotate %F %F %F initial rotation [0, 0, 0]

-readTrans %S read initial transformation from file [off]

-writeTrans %S write final transformation from file [off]

Weighting methods:

-weightMethod %d point weighting method [0]:
0 = sigmoid function, 1 = Lorentzian function,
2 = dynamic threshold, 3 = static threshold

-sigmoid %F %F midpoint offset (dmid) [500] and slope (k) [1] parameters in sigmoid function

-lorentz %F sigma parameter in Lorentzian function [100]

-dynamic %F D parameter in dynamic thresholding [100]

-static %F threshold distance for static thresholding [1000]

Stopping criteria:

-errT %F stop when avg point distance falls below this [0] (sensor units)

-maxIter %d stop when number of iterations reaches this [20]

-distT %F stop when max point movement falls below this [10] (sensor units)

-angleT %F stop when max rotation change falls below this [0] (degrees)

-transT %F stop when translation distance falls below this [0] (sensor units)

-overlap %d filter non-overlapping points (0=off) [1]

-normalT %F angle threshold (in degrees) for compatible normals [20]

-area %d weight points by area of neighbor faces (0=off) [1]

-nPer %d number of perturbations about minimum [0]

Examples

An example of usage where no options are set thus providing a quick execution is:

An example which sets the algorithm to run for a longer time, but probably provide a better answer is:

up

The VMR Lab is part of the Vision and Autonomous Systems Center within the Robotics Institute in the School of Computer Science, Carnegie Mellon University.