Loading...
Searching...
No Matches
ground_based_people_detection_app.h
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2013-, Open Perception, Inc.
*
* 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 copyright holder(s) 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 OWNER 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.
*
* ground_based_people_detection_app.h
* Created on: Nov 30, 2012
* Author: Matteo Munaro
*/
#pragma once
#include <pcl/point_types.h>
#include <pcl/sample_consensus/sac_model_plane.h>
#include <pcl/sample_consensus/ransac.h>
#include <pcl/kdtree/kdtree.h>
#include <pcl/people/person_cluster.h>
#include <pcl/people/head_based_subcluster.h>
#include <pcl/people/person_classifier.h>
#include <pcl/common/transforms.h>
namespace pcl
{
namespace people
{
/** \brief GroundBasedPeopleDetectionApp performs people detection on RGB-D data having as input the ground plane coefficients.
* It implements the people detection algorithm described here:
* M. Munaro, F. Basso and E. Menegatti,
* Tracking people within groups with RGB-D data,
* In Proceedings of the International Conference on Intelligent Robots and Systems (IROS) 2012, Vilamoura (Portugal), 2012.
*
* \author Matteo Munaro
* \ingroup people
*/
template <typename PointT> class GroundBasedPeopleDetectionApp;
template <typename PointT>
class GroundBasedPeopleDetectionApp
{
public:
using PointCloud = pcl::PointCloud<PointT>;
using PointCloudPtr = typename PointCloud::Ptr;
using PointCloudConstPtr = typename PointCloud::ConstPtr;
/** \brief Constructor. */
GroundBasedPeopleDetectionApp ();
/** \brief Destructor. */
virtual ~GroundBasedPeopleDetectionApp ();
/**
* \brief Set the pointer to the input cloud.
*
* \param[in] cloud A pointer to the input cloud.
*/
void
setInputCloud (PointCloudPtr& cloud);
/**
* \brief Set the ground coefficients.
*
* \param[in] ground_coeffs Vector containing the four plane coefficients.
*/
void
setGround (Eigen::VectorXf& ground_coeffs);
/**
* \brief Set the transformation matrix, which is used in order to transform the given point cloud, the ground plane and the intrinsics matrix to the internal coordinate frame.
* \param[in] transformation
*/
void
setTransformation (const Eigen::Matrix3f& transformation);
/**
* \brief Set sampling factor.
*
* \param[in] sampling_factor Value of the downsampling factor (in each dimension) which is applied to the raw point cloud (default = 1.).
*/
void
setSamplingFactor (int sampling_factor);
/**
* \brief Set voxel size.
*
* \param[in] voxel_size Value of the voxel dimension (default = 0.06m.).
*/
void
setVoxelSize (float voxel_size);
/**
* \brief Set intrinsic parameters of the RGB camera.
*
* \param[in] intrinsics_matrix RGB camera intrinsic parameters matrix.
*/
void
setIntrinsics (Eigen::Matrix3f intrinsics_matrix);
/**
* \brief Set SVM-based person classifier.
*
* \param[in] person_classifier Needed for people detection on RGB data.
*/
void
setClassifier (pcl::people::PersonClassifier<pcl::RGB> person_classifier);
/**
* \brief Set the field of view of the point cloud in z direction.
*
* \param[in] min The beginning of the field of view in z-direction, should be usually set to zero.
* \param[in] max The end of the field of view in z-direction.
*/
void
setFOV (float min, float max);
/**
* \brief Set sensor orientation (vertical = true means portrait mode, vertical = false means landscape mode).
*
* \param[in] vertical Set landscape/portrait camera orientation (default = false).
*/
void
setSensorPortraitOrientation (bool vertical);
/**
* \brief Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole body centroid).
*
* \param[in] head_centroid Set the location of the person centroid (head or body center) (default = true).
*/
void
setHeadCentroid (bool head_centroid);
/**
* \brief Set minimum and maximum allowed height and width for a person cluster.
*
* \param[in] min_height Minimum allowed height for a person cluster (default = 1.3).
* \param[in] max_height Maximum allowed height for a person cluster (default = 2.3).
* \param[in] min_width Minimum width for a person cluster (default = 0.1).
* \param[in] max_width Maximum width for a person cluster (default = 8.0).
*/
void
setPersonClusterLimits (float min_height, float max_height, float min_width, float max_width);
/**
* \brief Set minimum distance between persons' heads.
*
* \param[in] heads_minimum_distance Minimum allowed distance between persons' heads (default = 0.3).
*/
void
setMinimumDistanceBetweenHeads (float heads_minimum_distance);
/**
* \brief Get the minimum and maximum allowed height and width for a person cluster.
*
* \param[out] min_height Minimum allowed height for a person cluster.
* \param[out] max_height Maximum allowed height for a person cluster.
* \param[out] min_width Minimum width for a person cluster.
* \param[out] max_width Maximum width for a person cluster.
*/
void
getPersonClusterLimits (float& min_height, float& max_height, float& min_width, float& max_width);
/**
* \brief Get minimum and maximum allowed number of points for a person cluster.
*
* \param[out] min_points Minimum allowed number of points for a person cluster.
* \param[out] max_points Maximum allowed number of points for a person cluster.
*/
void
getDimensionLimits (int& min_points, int& max_points);
/**
* \brief Get minimum distance between persons' heads.
*/
float
getMinimumDistanceBetweenHeads ();
/**
* \brief Get floor coefficients.
*/
Eigen::VectorXf
getGround ();
/**
* \brief Get the filtered point cloud.
*/
PointCloudPtr
getFilteredCloud ();
/**
* \brief Get pointcloud after voxel grid filtering and ground removal.
*/
PointCloudPtr
getNoGroundCloud ();
/**
* \brief Extract RGB information from a point cloud and output the corresponding RGB point cloud.
*
* \param[in] input_cloud A pointer to a point cloud containing also RGB information.
* \param[out] output_cloud A pointer to a RGB point cloud.
*/
void
extractRGBFromPointCloud (PointCloudPtr input_cloud, pcl::PointCloud<pcl::RGB>::Ptr& output_cloud);
/**
* \brief Swap rows/cols dimensions of a RGB point cloud (90 degrees counterclockwise rotation).
*
* \param[in,out] cloud A pointer to a RGB point cloud.
*/
void
swapDimensions (pcl::PointCloud<pcl::RGB>::Ptr& cloud);
/**
* \brief Estimates min_points_ and max_points_ based on the minimal and maximal cluster size and the voxel size.
*/
void
updateMinMaxPoints ();
/**
* \brief Applies the transformation to the input point cloud.
*/
void
applyTransformationPointCloud ();
/**
* \brief Applies the transformation to the ground plane.
*/
void
applyTransformationGround ();
/**
* \brief Applies the transformation to the intrinsics matrix.
*/
void
applyTransformationIntrinsics ();
/**
* \brief Reduces the input cloud to one point per voxel and limits the field of view.
*/
void
filter ();
/**
* \brief Perform people detection on the input data and return people clusters information.
*
* \param[out] clusters Vector of PersonCluster.
*
* \return true if the compute operation is successful, false otherwise.
*/
bool
compute (std::vector<pcl::people::PersonCluster<PointT> >& clusters);
protected:
/** \brief sampling factor used to downsample the point cloud */
int sampling_factor_;
/** \brief voxel size */
float voxel_size_;
/** \brief ground plane coefficients */
Eigen::VectorXf ground_coeffs_;
/** \brief flag stating whether the ground coefficients have been set or not */
bool ground_coeffs_set_;
/** \brief the transformed ground coefficients */
Eigen::VectorXf ground_coeffs_transformed_;
/** \brief ground plane normalization factor */
float sqrt_ground_coeffs_;
/** \brief rotation matrix which transforms input point cloud to internal people tracker coordinate frame */
Eigen::Matrix3f transformation_;
/** \brief flag stating whether the transformation matrix has been set or not */
bool transformation_set_;
/** \brief pointer to the input cloud */
PointCloudPtr cloud_;
/** \brief pointer to the filtered cloud */
PointCloudPtr cloud_filtered_;
/** \brief pointer to the cloud after voxel grid filtering and ground removal */
PointCloudPtr no_ground_cloud_;
/** \brief pointer to a RGB cloud corresponding to cloud_ */
pcl::PointCloud<pcl::RGB>::Ptr rgb_image_;
/** \brief person clusters maximum height from the ground plane */
float max_height_;
/** \brief person clusters minimum height from the ground plane */
float min_height_;
/** \brief person clusters maximum width, used to estimate how many points maximally represent a person cluster */
float max_width_;
/** \brief person clusters minimum width, used to estimate how many points minimally represent a person cluster */
float min_width_;
/** \brief the beginning of the field of view in z-direction, should be usually set to zero */
float min_fov_;
/** \brief the end of the field of view in z-direction */
float max_fov_;
/** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
bool vertical_;
/** \brief if true, the person centroid is computed as the centroid of the cluster points belonging to the head;
* if false, the person centroid is computed as the centroid of the whole cluster points (default = true) */
bool head_centroid_; // if true, the person centroid is computed as the centroid of the cluster points belonging to the head (default = true)
// if false, the person centroid is computed as the centroid of the whole cluster points
/** \brief maximum number of points for a person cluster */
int max_points_;
/** \brief minimum number of points for a person cluster */
int min_points_;
/** \brief minimum distance between persons' heads */
float heads_minimum_distance_;
/** \brief intrinsic parameters matrix of the RGB camera */
Eigen::Matrix3f intrinsics_matrix_;
/** \brief flag stating whether the intrinsics matrix has been set or not */
bool intrinsics_matrix_set_;
/** \brief the transformed intrinsics matrix */
Eigen::Matrix3f intrinsics_matrix_transformed_;
/** \brief SVM-based person classifier */
pcl::people::PersonClassifier<pcl::RGB> person_classifier_;
/** \brief flag stating if the classifier has been set or not */
bool person_classifier_set_flag_;
};
} /* namespace people */
} /* namespace pcl */
#include <pcl/people/impl/ground_based_people_detection_app.hpp>
pcl::PointCloud
PointCloud represents the base class in PCL for storing collections of 3D points.
Definition point_cloud.h:174
pcl::PointCloud::Ptr
shared_ptr< PointCloud< PointT > > Ptr
Definition point_cloud.h:414
pcl::PointCloud::ConstPtr
shared_ptr< const PointCloud< PointT > > ConstPtr
Definition point_cloud.h:415
pcl::people::GroundBasedPeopleDetectionApp
GroundBasedPeopleDetectionApp performs people detection on RGB-D data having as input the ground plan...
Definition ground_based_people_detection_app.h:69
pcl::people::GroundBasedPeopleDetectionApp::getDimensionLimits
void getDimensionLimits(int &min_points, int &max_points)
Get minimum and maximum allowed number of points for a person cluster.
Definition ground_based_people_detection_app.hpp:187
pcl::people::GroundBasedPeopleDetectionApp::getNoGroundCloud
PointCloudPtr getNoGroundCloud()
Get pointcloud after voxel grid filtering and ground removal.
Definition ground_based_people_detection_app.hpp:216
pcl::people::GroundBasedPeopleDetectionApp::filter
void filter()
Reduces the input cloud to one point per voxel and limits the field of view.
Definition ground_based_people_detection_app.hpp:299
pcl::people::GroundBasedPeopleDetectionApp::min_width_
float min_width_
person clusters minimum width, used to estimate how many points minimally represent a person cluster
Definition ground_based_people_detection_app.h:329
pcl::people::GroundBasedPeopleDetectionApp::applyTransformationIntrinsics
void applyTransformationIntrinsics()
Applies the transformation to the intrinsics matrix.
Definition ground_based_people_detection_app.hpp:286
pcl::people::GroundBasedPeopleDetectionApp::cloud_filtered_
PointCloudPtr cloud_filtered_
pointer to the filtered cloud
Definition ground_based_people_detection_app.h:311
pcl::people::GroundBasedPeopleDetectionApp::GroundBasedPeopleDetectionApp
GroundBasedPeopleDetectionApp()
Constructor.
Definition ground_based_people_detection_app.hpp:50
pcl::people::GroundBasedPeopleDetectionApp::setSamplingFactor
void setSamplingFactor(int sampling_factor)
Set sampling factor.
Definition ground_based_people_detection_app.hpp:108
pcl::people::GroundBasedPeopleDetectionApp::extractRGBFromPointCloud
void extractRGBFromPointCloud(PointCloudPtr input_cloud, pcl::PointCloud< pcl::RGB >::Ptr &output_cloud)
Extract RGB information from a point cloud and output the corresponding RGB point cloud.
Definition ground_based_people_detection_app.hpp:222
pcl::people::GroundBasedPeopleDetectionApp::PointCloudPtr
typename PointCloud::Ptr PointCloudPtr
Definition ground_based_people_detection_app.h:73
pcl::people::GroundBasedPeopleDetectionApp::person_classifier_
pcl::people::PersonClassifier< pcl::RGB > person_classifier_
SVM-based person classifier.
Definition ground_based_people_detection_app.h:363
pcl::people::GroundBasedPeopleDetectionApp::setMinimumDistanceBetweenHeads
void setMinimumDistanceBetweenHeads(float heads_minimum_distance)
Set minimum distance between persons' heads.
Definition ground_based_people_detection_app.hpp:166
pcl::people::GroundBasedPeopleDetectionApp::min_fov_
float min_fov_
the beginning of the field of view in z-direction, should be usually set to zero
Definition ground_based_people_detection_app.h:332
pcl::people::GroundBasedPeopleDetectionApp::setClassifier
void setClassifier(pcl::people::PersonClassifier< pcl::RGB > person_classifier)
Set SVM-based person classifier.
Definition ground_based_people_detection_app.hpp:129
pcl::people::GroundBasedPeopleDetectionApp::setHeadCentroid
void setHeadCentroid(bool head_centroid)
Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole bo...
Definition ground_based_people_detection_app.hpp:172
pcl::people::GroundBasedPeopleDetectionApp::transformation_set_
bool transformation_set_
flag stating whether the transformation matrix has been set or not
Definition ground_based_people_detection_app.h:305
pcl::people::GroundBasedPeopleDetectionApp::PointCloudConstPtr
typename PointCloud::ConstPtr PointCloudConstPtr
Definition ground_based_people_detection_app.h:74
pcl::people::GroundBasedPeopleDetectionApp::PointCloud
pcl::PointCloud< PointT > PointCloud
Definition ground_based_people_detection_app.h:72
pcl::people::GroundBasedPeopleDetectionApp::cloud_
PointCloudPtr cloud_
pointer to the input cloud
Definition ground_based_people_detection_app.h:308
pcl::people::GroundBasedPeopleDetectionApp::intrinsics_matrix_set_
bool intrinsics_matrix_set_
flag stating whether the intrinsics matrix has been set or not
Definition ground_based_people_detection_app.h:357
pcl::people::GroundBasedPeopleDetectionApp::setInputCloud
void setInputCloud(PointCloudPtr &cloud)
Set the pointer to the input cloud.
Definition ground_based_people_detection_app.hpp:79
pcl::people::GroundBasedPeopleDetectionApp::getFilteredCloud
PointCloudPtr getFilteredCloud()
Get the filtered point cloud.
Definition ground_based_people_detection_app.hpp:210
pcl::people::GroundBasedPeopleDetectionApp::max_fov_
float max_fov_
the end of the field of view in z-direction
Definition ground_based_people_detection_app.h:335
pcl::people::GroundBasedPeopleDetectionApp::setVoxelSize
void setVoxelSize(float voxel_size)
Set voxel size.
Definition ground_based_people_detection_app.hpp:114
pcl::people::GroundBasedPeopleDetectionApp::no_ground_cloud_
PointCloudPtr no_ground_cloud_
pointer to the cloud after voxel grid filtering and ground removal
Definition ground_based_people_detection_app.h:314
pcl::people::GroundBasedPeopleDetectionApp::max_width_
float max_width_
person clusters maximum width, used to estimate how many points maximally represent a person cluster
Definition ground_based_people_detection_app.h:326
pcl::people::GroundBasedPeopleDetectionApp::swapDimensions
void swapDimensions(pcl::PointCloud< pcl::RGB >::Ptr &cloud)
Swap rows/cols dimensions of a RGB point cloud (90 degrees counterclockwise rotation).
Definition ground_based_people_detection_app.hpp:243
pcl::people::GroundBasedPeopleDetectionApp::setGround
void setGround(Eigen::VectorXf &ground_coeffs)
Set the ground coefficients.
Definition ground_based_people_detection_app.hpp:99
pcl::people::GroundBasedPeopleDetectionApp::updateMinMaxPoints
void updateMinMaxPoints()
Estimates min_points_ and max_points_ based on the minimal and maximal cluster size and the voxel siz...
Definition ground_based_people_detection_app.hpp:149
pcl::people::GroundBasedPeopleDetectionApp::applyTransformationPointCloud
void applyTransformationPointCloud()
Applies the transformation to the input point cloud.
Definition ground_based_people_detection_app.hpp:260
pcl::people::GroundBasedPeopleDetectionApp::setIntrinsics
void setIntrinsics(Eigen::Matrix3f intrinsics_matrix)
Set intrinsic parameters of the RGB camera.
Definition ground_based_people_detection_app.hpp:121
pcl::people::GroundBasedPeopleDetectionApp::getPersonClusterLimits
void getPersonClusterLimits(float &min_height, float &max_height, float &min_width, float &max_width)
Get the minimum and maximum allowed height and width for a person cluster.
Definition ground_based_people_detection_app.hpp:178
pcl::people::GroundBasedPeopleDetectionApp::sqrt_ground_coeffs_
float sqrt_ground_coeffs_
ground plane normalization factor
Definition ground_based_people_detection_app.h:299
pcl::people::GroundBasedPeopleDetectionApp::voxel_size_
float voxel_size_
voxel size
Definition ground_based_people_detection_app.h:287
pcl::people::GroundBasedPeopleDetectionApp::getGround
Eigen::VectorXf getGround()
Get floor coefficients.
Definition ground_based_people_detection_app.hpp:200
pcl::people::GroundBasedPeopleDetectionApp::ground_coeffs_transformed_
Eigen::VectorXf ground_coeffs_transformed_
the transformed ground coefficients
Definition ground_based_people_detection_app.h:296
pcl::people::GroundBasedPeopleDetectionApp::ground_coeffs_
Eigen::VectorXf ground_coeffs_
ground plane coefficients
Definition ground_based_people_detection_app.h:290
pcl::people::GroundBasedPeopleDetectionApp::setFOV
void setFOV(float min, float max)
Set the field of view of the point cloud in z direction.
Definition ground_based_people_detection_app.hpp:136
pcl::people::GroundBasedPeopleDetectionApp::max_points_
int max_points_
maximum number of points for a person cluster
Definition ground_based_people_detection_app.h:345
pcl::people::GroundBasedPeopleDetectionApp::setPersonClusterLimits
void setPersonClusterLimits(float min_height, float max_height, float min_width, float max_width)
Set minimum and maximum allowed height and width for a person cluster.
Definition ground_based_people_detection_app.hpp:156
pcl::people::GroundBasedPeopleDetectionApp::intrinsics_matrix_transformed_
Eigen::Matrix3f intrinsics_matrix_transformed_
the transformed intrinsics matrix
Definition ground_based_people_detection_app.h:360
pcl::people::GroundBasedPeopleDetectionApp::intrinsics_matrix_
Eigen::Matrix3f intrinsics_matrix_
intrinsic parameters matrix of the RGB camera
Definition ground_based_people_detection_app.h:354
pcl::people::GroundBasedPeopleDetectionApp::setTransformation
void setTransformation(const Eigen::Matrix3f &transformation)
Set the transformation matrix, which is used in order to transform the given point cloud,...
Definition ground_based_people_detection_app.hpp:85
pcl::people::GroundBasedPeopleDetectionApp::person_classifier_set_flag_
bool person_classifier_set_flag_
flag stating if the classifier has been set or not
Definition ground_based_people_detection_app.h:366
pcl::people::GroundBasedPeopleDetectionApp::getMinimumDistanceBetweenHeads
float getMinimumDistanceBetweenHeads()
Get minimum distance between persons' heads.
Definition ground_based_people_detection_app.hpp:194
pcl::people::GroundBasedPeopleDetectionApp::min_height_
float min_height_
person clusters minimum height from the ground plane
Definition ground_based_people_detection_app.h:323
pcl::people::GroundBasedPeopleDetectionApp::transformation_
Eigen::Matrix3f transformation_
rotation matrix which transforms input point cloud to internal people tracker coordinate frame
Definition ground_based_people_detection_app.h:302
pcl::people::GroundBasedPeopleDetectionApp::applyTransformationGround
void applyTransformationGround()
Applies the transformation to the ground plane.
Definition ground_based_people_detection_app.hpp:271
pcl::people::GroundBasedPeopleDetectionApp::~GroundBasedPeopleDetectionApp
virtual ~GroundBasedPeopleDetectionApp()
Destructor.
pcl::people::GroundBasedPeopleDetectionApp::heads_minimum_distance_
float heads_minimum_distance_
minimum distance between persons' heads
Definition ground_based_people_detection_app.h:351
pcl::people::GroundBasedPeopleDetectionApp::compute
bool compute(std::vector< pcl::people::PersonCluster< PointT > > &clusters)
Perform people detection on the input data and return people clusters information.
Definition ground_based_people_detection_app.hpp:311
pcl::people::GroundBasedPeopleDetectionApp::rgb_image_
pcl::PointCloud< pcl::RGB >::Ptr rgb_image_
pointer to a RGB cloud corresponding to cloud_
Definition ground_based_people_detection_app.h:317
pcl::people::GroundBasedPeopleDetectionApp::max_height_
float max_height_
person clusters maximum height from the ground plane
Definition ground_based_people_detection_app.h:320
pcl::people::GroundBasedPeopleDetectionApp::ground_coeffs_set_
bool ground_coeffs_set_
flag stating whether the ground coefficients have been set or not
Definition ground_based_people_detection_app.h:293
pcl::people::GroundBasedPeopleDetectionApp::setSensorPortraitOrientation
void setSensorPortraitOrientation(bool vertical)
Set sensor orientation (vertical = true means portrait mode, vertical = false means landscape mode).
Definition ground_based_people_detection_app.hpp:143
pcl::people::GroundBasedPeopleDetectionApp::head_centroid_
bool head_centroid_
if true, the person centroid is computed as the centroid of the cluster points belonging to the head;...
Definition ground_based_people_detection_app.h:342
pcl::people::GroundBasedPeopleDetectionApp::min_points_
int min_points_
minimum number of points for a person cluster
Definition ground_based_people_detection_app.h:348
pcl::people::GroundBasedPeopleDetectionApp::sampling_factor_
int sampling_factor_
sampling factor used to downsample the point cloud
Definition ground_based_people_detection_app.h:284
pcl::people::GroundBasedPeopleDetectionApp::vertical_
bool vertical_
if true, the sensor is considered to be vertically placed (portrait mode)
Definition ground_based_people_detection_app.h:338
pcl::people::PersonClassifier
Definition person_classifier.h:54
pcl::people::PersonCluster
PersonCluster represents a class for representing information about a cluster containing a person.
Definition person_cluster.h:59
point_types.h
Defines all the PCL implemented PointT point type structures.
pcl::people
Definition ground_based_people_detection_app.h:55
pcl
Definition convolution.h:46