#include <smallgicp/pcl/pclregistration.hpp>
pcl::PointCloud<pcl::PointXYZ>::Ptr raw_target = ...; pcl::PointCloud<pcl::PointXYZ>::Ptr raw_source = ...;
// smallgicp::voxelgriddownsampling can directly operate on pcl::PointCloud. pcl::PointCloud<pcl::PointXYZ>::Ptr target = voxelgridsamplingomp(*raw_target, 0.25); pcl::PointCloud<pcl::PointXYZ>::Ptr source = voxelgridsamplingomp(*raw_source, 0.25);
// RegistrationPCL is derived from pcl::Registration and has mostly the same interface as pcl::GeneralizedIterativeClosestPoint. RegistrationPCL<pcl::PointXYZ, pcl::PointXYZ> reg; reg.setNumThreads(4); reg.setCorrespondenceRandomness(20); reg.setMaxCorrespondenceDistance(1.0); reg.setVoxelResolution(1.0); reg.setRegistrationType("VGICP");  // or "GICP" (default = "GICP")
// Set input point clouds. reg.setInputTarget(target); reg.setInputSource(source);
// Align point clouds. auto aligned = pcl::make_shared<pcl::PointCloud<pcl::PointXYZ>>(); reg.align(*aligned);
// Swap source and target and align again. // This is useful when you want to re-use preprocessed point clouds for successive registrations (e.g., odometry estimation). reg.swapSourceAndTarget(); reg.align(*aligned);

It is also possible to directly feed pcl::PointCloud to small_gicp::Registration. Because all preprocessed data are exposed in this way, you can easily re-use them to obtain the best efficiency.

#include <smallgicp/pcl/pclpoint.hpp>
#include <smallgicp/pcl/pclpoint_traits.hpp>
pcl::PointCloud<pcl::PointXYZ>::Ptr raw_target = ...; pcl::PointCloud<pcl::PointXYZ>::Ptr raw_source = ...;
// Downsample points and convert them into pcl::PointCloud<pcl::PointCovariance>. pcl::PointCloud<pcl::PointCovariance>::Ptr target = voxelgridsamplingomp<pcl::PointCloud<pcl::PointXYZ>, pcl::PointCloud<pcl::PointCovariance>>(*raw_target, 0.25); pcl::PointCloud<pcl::PointCovariance>::Ptr source = voxelgridsamplingomp<pcl::PointCloud<pcl::PointXYZ>, pcl::PointCloud<pcl::PointCovariance>>(*raw_source, 0.25);
// Estimate covariances of points. const int num_threads = 4; const int num_neighbors = 20; estimatecovariancesomp(*target, numneighbors, numthreads); estimatecovariancesomp(*source, numneighbors, numthreads);
// Create KdTree for target and source. auto targettree = std::makeshared<KdTree<pcl::PointCloud<pcl::PointCovariance>>>(target, KdTreeBuilderOMP(num_threads)); auto sourcetree = std::makeshared<KdTree<pcl::PointCloud<pcl::PointCovariance>>>(source, KdTreeBuilderOMP(num_threads));
Registration<GICPFactor, ParallelReductionOMP> registration; registration.reduction.numthreads = numthreads; registration.rejector.maxdistsq = 1.0;
// Align point clouds. Note that the input point clouds are pcl::PointCloud<pcl::PointCovariance>. auto result = registration.align(target, source, *target_tree, Eigen::Isometry3d::Identity());

#include <smallgicp/ann/kdtreeomp.hpp>
#include <smallgicp/points/pointcloud.hpp>
#include <smallgicp/factors/gicpfactor.hpp>
#include <smallgicp/util/normalestimation_omp.hpp>
#include <smallgicp/registration/reductionomp.hpp>
#include <small_gicp/registration/registration.hpp>
std::vector<Eigen::Vector3d> target_points = ...;   // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...;   //
int num_threads = 4; double downsampling_resolution = 0.25; int num_neighbors = 10; double maxcorrespondencedistance = 1.0;
// Convert to small_gicp::PointCloud auto target = std::makeshared<PointCloud>(targetpoints); auto source = std::makeshared<PointCloud>(sourcepoints);
// Downsampling target = voxelgridsamplingomp(*target, downsamplingresolution, numthreads); source = voxelgridsamplingomp(*source, downsamplingresolution, numthreads);
// Create KdTree auto targettree = std::makeshared<KdTree<PointCloud>>(target, KdTreeBuilderOMP(num_threads)); auto sourcetree = std::makeshared<KdTree<PointCloud>>(source, KdTreeBuilderOMP(num_threads));
// Estimate point covariances estimatecovariancesomp(target, targettree, numneighbors, num_threads); estimatecovariancesomp(source, sourcetree, numneighbors, num_threads);
// GICP + OMP-based parallel reduction Registration<GICPFactor, ParallelReductionOMP> registration; registration.reduction.numthreads = numthreads; registration.rejector.maxdistsq = maxcorrespondencedistance * maxcorrespondencedistance;
// Align point clouds Eigen::Isometry3d initTtarget_source = Eigen::Isometry3d::Identity(); auto result = registration.align(target, source, *targettree, initTtargetsource);
Eigen::Isometry3d T = result.Ttargetsource;  // Estimated transformation sizet numinliers = result.num_inliers;       // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H;      // Final Hessian matrix (6x6)

See 03registrationtemplate.cpp for more detailed customization examples.

Example A : Perform registration with numpy arrays

# Align two point clouds using various ICP-like algorithms.
# 
Parameters
----------
target_points : NDArray[np.float64]
    Nx3 or Nx4 matrix representing the target point cloud.
source_points : NDArray[np.float64]
    Nx3 or Nx4 matrix representing the source point cloud.
initTtarget_source : np.ndarray[np.float64]
    4x4 matrix representing the initial transformation from target to source.
registration_type : str = 'GICP'
    Type of registration algorithm to use ('ICP', 'PLANE_ICP', 'GICP', 'VGICP').
voxel_resolution : float = 1.0
    Resolution of voxels used for correspondence search (used only in VGICP).
downsampling_resolution : float = 0.25
    Resolution for downsampling the point clouds.
maxcorrespondencedistance : float = 1.0
    Maximum distance for matching points between point clouds.
num_threads : int = 1
    Number of threads to use for parallel processing.
# 
Returns
-------
RegistrationResult
    Object containing the final transformation matrix and convergence status.
result = smallgicp.align(targetrawnumpy, sourcerawnumpy, downsamplingresolution=0.25)
result.Ttargetsource  # Estimated transformation (4x4 numpy array) result.converged        # If true, the optimization converged successfully result.iterations       # Number of iterations the optimization took result.num_inliers      # Number of inlier points result.H                # Final Hessian matrix (6x6 matrix) result.b                # Final information vector (6D vector) result.e                # Final error (float)

Example B : Perform preprocessing and registration separately

# Preprocess point cloud (downsampling, kdtree construction, and normal/covariance estimation)
#
Parameters
----------
points : NDArray[np.float64]
    Nx3 or Nx4 matrix representing the point cloud.
downsampling_resolution : float = 0.1
    Resolution for downsampling the point clouds.
num_neighbors : int = 20
    Number of neighbor points to usefor point normal/covariance estimation.
num_threads : int = 1
    Number of threads to use for parallel processing.
# 
Returns
-------
PointCloud
    Downsampled point cloud with estimated normals and covariances.
KdTree
    KdTree for the downsampled point cloud
target, targettree = smallgicp.preprocesspoints(targetrawnumpy, downsamplingresolution=0.25)
source, sourcetree = smallgicp.preprocesspoints(sourcerawnumpy, downsamplingresolution=0.25)
target and source are small_gicp.PointCloud with the following methods
target.size()           # Number of points
target.points()         # Nx4 numpy array   [x, y, z, 1] x N
target.normals()        # Nx4 numpy array   [nx, ny, nz, 0] x N
target.covs()           # Array of 4x4 covariance matrices
 Align two point clouds using specified ICP-like algorithms, utilizing point cloud and KD-tree inputs.
#
 Parameters
 ----------
 target : PointCloud::ConstPtr
     Pointer to the target point cloud.
 source : PointCloud::ConstPtr
     Pointer to the source point cloud.
 target_tree : KdTree<PointCloud>::ConstPtr, optional
     Pointer to the KD-tree of the target for nearest neighbor search. If nullptr, a new tree is built.
 initTtarget_source : NDArray[np.float64]
     4x4 matrix representing the initial transformation from target to source.
 registration_type : str = 'GICP'
     Type of registration algorithm to use ('ICP', 'PLANE_ICP', 'GICP').
 maxcorrespondencedistance : float = 1.0
     Maximum distance for corresponding point pairs.
 num_threads : int = 1
     Number of threads to use for computation.
# 
 Returns
 -------
 RegistrationResult
     Object containing the final transformation matrix and convergence status.
result = smallgicp.align(target, source, targettree)

Example C : Perform each of preprocessing steps one-by-one

# Convert numpy arrays (Nx3 or Nx4) to small_gicp.PointCloud
targetraw = smallgicp.PointCloud(targetrawnumpy)
sourceraw = smallgicp.PointCloud(sourcerawnumpy)
Downsampling
target = smallgicp.voxelgridsampling(target_raw, 0.25)
source = smallgicp.voxelgridsampling(source_raw, 0.25)
KdTree construction
targettree = smallgicp.KdTree(target)
sourcetree = smallgicp.KdTree(source)
Estimate covariances
smallgicp.estimatecovariances(target, target_tree)
smallgicp.estimatecovariances(source, source_tree)
Align point clouds
result = smallgicp.align(target, source, targettree)

Example D: Example with Open3D

targeto3d = open3d.io.readpointcloud('smallgicp/data/target.ply').paintuniformcolor([0, 1, 0])
sourceo3d = open3d.io.readpointcloud('smallgicp/data/source.ply').paintuniformcolor([0, 0, 1])
target, targettree = smallgicp.preprocesspoints(numpy.asarray(targeto3d.points), downsampling_resolution=0.25) source, sourcetree = smallgicp.preprocesspoints(numpy.asarray(sourceo3d.points), downsampling_resolution=0.25) result = smallgicp.align(target, source, targettree)
sourceo3d.transform(result.Ttarget_source) open3d.visualization.drawgeometries([targeto3d, source_o3d])