api/latest/util3d__filtering_8h_source.html

/*

Copyright (c) 2010-2016, Mathieu Labbe - IntRoLab - Universite de Sherbrooke

All rights reserved.


Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright

      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of the Universite de Sherbrooke nor the

      names of its contributors may be used to endorse or promote products

      derived from this software without specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY

DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


#ifndef UTIL3D_FILTERING_H_

#define UTIL3D_FILTERING_H_


#include <rtabmap/core/rtabmap_core_export.h>

#include <rtabmap/core/Transform.h>

#include <pcl/point_cloud.h>

#include <pcl/point_types.h>

#include <pcl/pcl_base.h>

#include <pcl/ModelCoefficients.h>

#include <rtabmap/core/LaserScan.h>


namespace rtabmap

{


namespace util3d

{


LaserScan RTABMAP_CORE_EXPORT commonFiltering(

    const LaserScan & scan,

    int downsamplingStep,

    float rangeMin = 0.0f,

    float rangeMax = 0.0f,

    float voxelSize = 0.0f,

    int normalK = 0,

    float normalRadius = 0.0f,

    float groundNormalsUp = 0.0f);

RTABMAP_DEPRECATED LaserScan RTABMAP_CORE_EXPORT commonFiltering(

    const LaserScan & scan,

    int downsamplingStep,

    float rangeMin,

    float rangeMax,

    float voxelSize,

    int normalK,

    float normalRadius,

    bool forceGroundNormalsUp);


LaserScan RTABMAP_CORE_EXPORT rangeFiltering(

    const LaserScan & scan,

    float rangeMin,

    float rangeMax);


pcl::IndicesPtr RTABMAP_CORE_EXPORT rangeFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float rangeMin,

    float rangeMax);

pcl::IndicesPtr RTABMAP_CORE_EXPORT rangeFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float rangeMin,

    float rangeMax);

pcl::IndicesPtr RTABMAP_CORE_EXPORT rangeFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float rangeMin,

    float rangeMax);

pcl::IndicesPtr RTABMAP_CORE_EXPORT rangeFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float rangeMin,

    float rangeMax);

void RTABMAP_CORE_EXPORT rangeSplitFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float range,

    pcl::IndicesPtr & closeIndices,

    pcl::IndicesPtr & farIndices);

void RTABMAP_CORE_EXPORT rangeSplitFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float range,

    pcl::IndicesPtr & closeIndices,

    pcl::IndicesPtr & farIndices);

void RTABMAP_CORE_EXPORT rangeSplitFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float range,

    pcl::IndicesPtr & closeIndices,

    pcl::IndicesPtr & farIndices);

void RTABMAP_CORE_EXPORT rangeSplitFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float range,

    pcl::IndicesPtr & closeIndices,

    pcl::IndicesPtr & farIndices);

LaserScan RTABMAP_CORE_EXPORT downsample(

  const LaserScan & cloud,

  int step);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT downsample(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    int step);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float voxelSize);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    float voxelSize);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT voxelize(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    float voxelSize);


inline pcl::PointCloud<pcl::PointXYZ>::Ptr uniformSampling(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float voxelSize)

{

  return voxelize(cloud, voxelSize);

}


inline pcl::PointCloud<pcl::PointXYZRGB>::Ptr uniformSampling(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    float voxelSize)

{

  return voxelize(cloud, voxelSize);

}


inline pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr uniformSampling(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    float voxelSize)

{

  return voxelize(cloud, voxelSize);

}


pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    int samples);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    int samples);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    int samples);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    int samples);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    int samples);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT randomSampling(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    int samples);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT passThrough(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const std::string & axis,

    float min,

    float max,

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PCLPointCloud2::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT cropBox(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const Eigen::Vector4f & min,

    const Eigen::Vector4f & max,

    const Transform & transform = Transform::getIdentity(),

    bool negative = false);

pcl::IndicesPtr RTABMAP_CORE_EXPORT frustumFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const Transform & cameraPose,

    float horizontalFOV,

    float verticalFOV,

    float nearClipPlaneDistance,

    float farClipPlaneDistance,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT frustumFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const Transform & cameraPose,

    float horizontalFOV,

    float verticalFOV,

    float nearClipPlaneDistance,

    float farClipPlaneDistance,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT frustumFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const Transform & cameraPose,

    float horizontalFOV,

    float verticalFOV,

    float nearClipPlaneDistance,

    float farClipPlaneDistance,

    bool negative = false);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT removeNaNFromPointCloud(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT removeNaNFromPointCloud(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT removeNaNFromPointCloud(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud);

pcl::PCLPointCloud2::Ptr RTABMAP_CORE_EXPORT removeNaNFromPointCloud(

    const pcl::PCLPointCloud2::Ptr & cloud);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT removeNaNNormalsFromPointCloud(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT removeNaNNormalsFromPointCloud(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT removeNaNNormalsFromPointCloud(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float radiusSearch,

    int minNeighborsInRadius);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);


pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const std::vector<int> & viewpointIndices,

    const std::map<int, Transform> & viewpoints,

    float factor=0.01f,

    float neighborScale=2.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(

  const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

  const pcl::IndicesPtr & indices,

  const pcl::PointCloud<pcl::PointXYZ>::Ptr & subtractCloud,

  const pcl::IndicesPtr & subtractIndices,

  float radiusSearch,

  int minNeighborsInRadius = 1);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & subtractCloud,

    const pcl::IndicesPtr & subtractIndices,

    float radiusSearch,

    int minNeighborsInRadius = 1);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const pcl::PointCloud<pcl::PointNormal>::Ptr & subtractCloud,

    const pcl::IndicesPtr & subtractIndices,

    float radiusSearch,

    float maxAngle = M_PI/4.0f,

    int minNeighborsInRadius = 1);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(

  const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

  const pcl::IndicesPtr & indices,

  const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & subtractCloud,

  const pcl::IndicesPtr & subtractIndices,

  float radiusSearch,

  float maxAngle = M_PI/4.0f,

  int minNeighborsInRadius = 1);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(

  const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

  const pcl::IndicesPtr & indices,

  const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & subtractCloud,

  const pcl::IndicesPtr & subtractIndices,

  float radiusSearch,

  float maxAngle = M_PI/4.0f,

  int minNeighborsInRadius = 1);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT subtractFiltering(

  const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

  const pcl::PointCloud<pcl::PointXYZ>::Ptr & subtractCloud,

  float radiusSearch,

  int minNeighborsInRadius = 1);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT subtractFiltering(

  const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

  const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & subtractCloud,

  float radiusSearch,

  int minNeighborsInRadius = 1);

pcl::PointCloud<pcl::PointNormal>::Ptr RTABMAP_CORE_EXPORT subtractFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::PointCloud<pcl::PointNormal>::Ptr & subtractCloud,

    float radiusSearch,

    float maxAngle = M_PI/4.0f,

    int minNeighborsInRadius = 1);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT subtractFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & subtractCloud,

    float radiusSearch,

    float maxAngle = M_PI/4.0f,

    int minNeighborsInRadius = 1);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT subtractFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & subtractCloud,

    float radiusSearch,

    float maxAngle = M_PI/4.0f,

    int minNeighborsInRadius = 1);

pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractAdaptiveFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & subtractCloud,

    const pcl::IndicesPtr & subtractIndices,

    float radiusSearchRatio = 0.01,

    int minNeighborsInRadius = 1,

    const Eigen::Vector3f & viewpoint = Eigen::Vector3f(0,0,0));


pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractAdaptiveFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & subtractCloud,

    const pcl::IndicesPtr & subtractIndices,

    float radiusSearchRatio = 0.01,

    float maxAngle = M_PI/4.0f,

    int minNeighborsInRadius = 1,

    const Eigen::Vector3f & viewpoint = Eigen::Vector3f(0,0,0));


pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float angleMax,

    const Eigen::Vector4f & normal,

    int normalKSearch,

    const Eigen::Vector4f & viewpoint,

    float groundNormalsUp = 0.0f);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

std::vector<pcl::IndicesPtr> RTABMAP_CORE_EXPORT extractClusters(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float clusterTolerance,

    int minClusterSize,

    int maxClusterSize = std::numeric_limits<int>::max(),

    int * biggestClusterIndex = 0);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative);

pcl::PointCloud<pcl::PointXYZ>::Ptr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative,

    bool keepOrganized);

pcl::PointCloud<pcl::PointXYZRGB>::Ptr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZRGB>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative,

    bool keepOrganized);

pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative,

    bool keepOrganized);

pcl::PointCloud<pcl::PointXYZI>::Ptr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZI>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative,

    bool keepOrganized);

pcl::PointCloud<pcl::PointXYZINormal>::Ptr RTABMAP_CORE_EXPORT extractIndices(

    const pcl::PointCloud<pcl::PointXYZINormal>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    bool negative,

    bool keepOrganized);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractPlane(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    const pcl::IndicesPtr & indices,

    float distanceThreshold,

    int maxIterations = 100,

    pcl::ModelCoefficients * coefficientsOut = 0);

pcl::IndicesPtr RTABMAP_CORE_EXPORT extractPlane(

    const pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud,

    float distanceThreshold,

    int maxIterations = 100,

    pcl::ModelCoefficients * coefficientsOut = 0);


} // namespace util3d

} // namespace rtabmap


#endif /* UTIL3D_FILTERING_H_ */

rtabmap::LaserScan
Represents 2D or 3D laser scan data with support for multiple point data formats.
Definition LaserScan.h:46

rtabmap::Transform
Represents a 3D rigid body transformation (rotation + translation).
Definition Transform.h:53

rtabmap::Transform::getIdentity
static Transform getIdentity()
Returns identity transform.

rtabmap::util3d::cropBox
pcl::IndicesPtr RTABMAP_CORE_EXPORT cropBox(const pcl::PCLPointCloud2::Ptr &cloud, const pcl::IndicesPtr &indices, const Eigen::Vector4f &min, const Eigen::Vector4f &max, const Transform &transform=Transform::getIdentity(), bool negative=false)
Performs crop box filtering on a point cloud of type pcl::PCLPointCloud2 and returns filtered indices...

rtabmap::util3d::extractClusters
std::vector< pcl::IndicesPtr > RTABMAP_CORE_EXPORT extractClusters(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, float clusterTolerance, int minClusterSize, int maxClusterSize=std::numeric_limits< int >::max(), int *biggestClusterIndex=0)
Extract clusters from point cloud of type pcl::PointXYZ.

rtabmap::util3d::extractIndices
pcl::IndicesPtr RTABMAP_CORE_EXPORT extractIndices(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, bool negative)
Extract indices from point cloud of type pcl::PointXYZ.

rtabmap::util3d::frustumFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT frustumFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, const Transform &cameraPose, float horizontalFOV, float verticalFOV, float nearClipPlaneDistance, float farClipPlaneDistance, bool negative=false)
Performs frustum filtering on a point cloud of type pcl::PointXYZ and returns filtered indices.

rtabmap::util3d::passThrough
pcl::IndicesPtr RTABMAP_CORE_EXPORT passThrough(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, const std::string &axis, float min, float max, bool negative=false)
Performs pass-through filtering on a point cloud of type pcl::PointXYZ and returns filtered indices.

rtabmap::util3d::downsample
LaserScan RTABMAP_CORE_EXPORT downsample(const LaserScan &cloud, int step)
Downsamples a LaserScan.

rtabmap::util3d::rangeSplitFiltering
void RTABMAP_CORE_EXPORT rangeSplitFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, float range, pcl::IndicesPtr &closeIndices, pcl::IndicesPtr &farIndices)
Splits a point cloud of type pcl::PointXYZ.

rtabmap::util3d::normalFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT normalFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, float angleMax, const Eigen::Vector4f &normal, int normalKSearch, const Eigen::Vector4f &viewpoint, float groundNormalsUp=0.0f)
Point normal filtering for point cloud of type pcl::PointXYZ.

rtabmap::util3d::proportionalRadiusFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT proportionalRadiusFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const std::vector< int > &viewpointIndices, const std::map< int, Transform > &viewpoints, float factor=0.01f, float neighborScale=2.0f)
Proportional radius filtering for point cloud of type pcl::PointXYZ.

rtabmap::util3d::radiusFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT radiusFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, float radiusSearch, int minNeighborsInRadius)
Radius filtering for point cloud of type pcl::PointXYZ.

rtabmap::util3d::randomSampling
pcl::PointCloud< pcl::PointXYZ >::Ptr RTABMAP_CORE_EXPORT randomSampling(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, int samples)
Performs random sampling on a point cloud of type pcl::PointXYZ.

rtabmap::util3d::removeNaNFromPointCloud
pcl::PointCloud< pcl::PointXYZ >::Ptr RTABMAP_CORE_EXPORT removeNaNFromPointCloud(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud)
Remove NaN points from a point cloud of type pcl::PointXYZ.

rtabmap::util3d::removeNaNNormalsFromPointCloud
pcl::PointCloud< pcl::PointNormal >::Ptr RTABMAP_CORE_EXPORT removeNaNNormalsFromPointCloud(const pcl::PointCloud< pcl::PointNormal >::Ptr &cloud)
Removes points with NaN normal values from a point cloud of type pcl::PointNormal.

rtabmap::util3d::subtractFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractFiltering(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, const pcl::PointCloud< pcl::PointXYZ >::Ptr &subtractCloud, const pcl::IndicesPtr &subtractIndices, float radiusSearch, int minNeighborsInRadius=1)
Subtract filtering for point cloud of type pcl::PointXYZ, returning filtered indices.

rtabmap::util3d::voxelize
pcl::PointCloud< pcl::PointXYZ >::Ptr RTABMAP_CORE_EXPORT voxelize(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, float voxelSize)
Performs voxel grid downsampling on a point cloud of type pcl::PointXYZ on provided indices.

rtabmap::util3d::subtractAdaptiveFiltering
pcl::IndicesPtr RTABMAP_CORE_EXPORT subtractAdaptiveFiltering(const pcl::PointCloud< pcl::PointXYZRGB >::Ptr &cloud, const pcl::IndicesPtr &indices, const pcl::PointCloud< pcl::PointXYZRGB >::Ptr &subtractCloud, const pcl::IndicesPtr &subtractIndices, float radiusSearchRatio=0.01, int minNeighborsInRadius=1, const Eigen::Vector3f &viewpoint=Eigen::Vector3f(0, 0, 0))
Performs adaptive radius-based subtraction filtering on a point cloud.

rtabmap::util3d::commonFiltering
LaserScan RTABMAP_CORE_EXPORT commonFiltering(const LaserScan &scan, int downsamplingStep, float rangeMin=0.0f, float rangeMax=0.0f, float voxelSize=0.0f, int normalK=0, float normalRadius=0.0f, float groundNormalsUp=0.0f)
Applies a common set of filters to a LaserScan, including downsampling, range limits,...

rtabmap::util3d::uniformSampling
pcl::PointCloud< pcl::PointXYZ >::Ptr uniformSampling(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, float voxelSize)
DEPRECATED: Use voxelize() instead.
Definition util3d_filtering.h:359

rtabmap::util3d::extractPlane
pcl::IndicesPtr RTABMAP_CORE_EXPORT extractPlane(const pcl::PointCloud< pcl::PointXYZ >::Ptr &cloud, const pcl::IndicesPtr &indices, float distanceThreshold, int maxIterations=100, pcl::ModelCoefficients *coefficientsOut=0)
Extracts the indices of the inliers that belong to a plane using RANSAC.

rtabmap::util3d::rangeFiltering
LaserScan RTABMAP_CORE_EXPORT rangeFiltering(const LaserScan &scan, float rangeMin, float rangeMax)
Filters a LaserScan data on a minimum and maximum Euclidean range.

rtabmap
Definition BayesFilter.h:39