ROS Index
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged small_gicp at Robotics Stack Exchange
|
|
small_gicp package from small_gicp reposmall_gicp |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.0.0 |
| License | MIT |
| Build type | CMAKE |
| Use | RECOMMENDED |
Repository Summary
| Description | Efficient and parallel algorithms for point cloud registration [C++, Python] |
| Checkout URI | https://github.com/koide3/small_gicp.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2025-06-10 |
| Dev Status | UNKNOWN |
| Released | UNRELEASED |
| Tags | python multi-threading cpp registration pcl icp pointcloud open3d scan-matching point-cloud-regstration |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Kenji Koide
Authors
small_gicp
small_gicp is a header-only C++ library providing efficient and parallelized algorithms for fine point cloud registration (ICP, Point-to-Plane ICP, GICP, VGICP, etc.). It is a refined and optimized version of its predecessor, fast_gicp, re-written from scratch with the following features.
- Highly Optimized : The core registration algorithm implementation has been further optimized from fast_gicp, achieving up to 2x speed gain.
- Fully parallerized : small_gicp offers parallel implementations of several preprocessing algorithms, making the entire registration process parallelized (e.g., Downsampling, KdTree construction, Normal/Covariance estimation). It supports OpenMP and Intel TBB as parallelism backends.
- Minimum dependencies : The library requires only Eigen along with the bundled nanoflann and Sophus. Optionally, it supports a PCL registration interface for use as a drop-in replacement
- Customizable : small_gicp allows the integration of any custom point cloud class into the registration algorithm via traits. Its template-based implementation enables customization of the registration process with original correspondence estimators and registration factors.
- Python bindings : By being isolated from PCL, small_gicp’s Python bindings are more portable and can be used seamlessly with other libraries such as Open3D.
Note that GPU-based implementations are NOT included in this package.
If you find this package useful for your project, please consider leaving a comment here. It would help the author receive recognition in his organization and keep working on this project. Please also cite the corresponding software paper if you use this software in an academic work.
Requirements
This library uses C++17 features. The PCL interface is not compatible with PCL older than 1.11 that uses boost::shared_ptr.
Dependencies
Installation
C++
small_gicp is a header-only library. You can just download and drop it in your project directory to use it.
If you need only basic point cloud registration functions, you can build and install the helper library as follows.
sudo apt-get install libeigen3-dev libomp-dev
cd small_gicp
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release && make -j
sudo make install
Python (Linux / Windows / MacOS)
Install from PyPI
pip install small_gicp
Install from source
cd small_gicp
pip install .
# [Optional (linux)] Install stubs for autocomplete (If you know a better way, let me know...)
pip install pybind11-stubgen
cd ~/.local/lib/python3.10/site-packages
pybind11-stubgen -o . --ignore-invalid=all small_gicp
Documentation
Usage (C++)
The following examples assume using namespace small_gicp is placed somewhere.
Using helper library (01_basic_registration.cpp)
The helper library (registration_helper.hpp) enables easily processing point clouds represented as std::vector<Eigen::Vector(3|4)(f|d)>.
Expand
`small_gicp::align` takes two point clouds (`std::vectors` of `Eigen::Vector(3|4)(f|d)`) and returns a registration result (estimated transformation and some information on the optimization result). This is the easiest way to use small_gicp but causes an overhead for duplicated preprocessing. ```cpp #include <small_gicp/registration/registration_helper.hpp> std::vector<Eigen::Vector3d> target_points = ...; // Any of Eigen::Vector(3|4)(f|d) can be used std::vector<Eigen::Vector3d> source_points = ...; // RegistrationSetting setting; setting.num_threads = 4; // Number of threads to be used setting.downsampling_resolution = 0.25; // Downsampling resolution setting.max_correspondence_distance = 1.0; // Maximum correspondence distance between points (e.g., triming threshold) Eigen::Isometry3d init_T_target_source = Eigen::Isometry3d::Identity(); RegistrationResult result = align(target_points, source_points, init_T_target_source, setting); Eigen::Isometry3d T = result.T_target_source; // Estimated transformation size_t num_inliers = result.num_inliers; // Number of inlier source points Eigen::Matrix<double, 6, 6> H = result.H; // Final Hessian matrix (6x6) ``` There is also a way to perform preprocessing and registration separately. This enables saving time for preprocessing in case registration is performed several times for the same point cloud (e.g., typical odometry estimation based on scan-to-scan matching). File truncated at 100 lines [see the full file](https://github.com/koide3/small_gicp/tree/master/./README.md)Package Dependencies
System Dependencies
| Name |
|---|
| cmake |
| eigen |
| libomp-dev |