pyramidal_klt.h
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2014-, Open Perception.
*
* 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 Willow Garage, Inc. 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.
*
*/
#ifndef PCL_TRACKING_PYRAMIDAL_KLT_H
#define PCL_TRACKING_PYRAMIDAL_KLT_H
#include <pcl/point_types.h>
#include <pcl/tracking/tracker.h>
#include <pcl/common/intensity.h>
#include <pcl/common/transformation_from_correspondences.h>
namespace pcl
{
namespace tracking
{
/** Pyramidal Kanade Lucas Tomasi tracker.
* This is an implemntation of the Pyramidal Kanade Lucas Tomasi tracker that operates on
* organized 3D keypoints with color/intensity information (this is the default behaviour but you
* can alterate it by providing another operator as second template argument). It is an affine
* tracker that iteratively computes the optical flow to find the best guess for a point p at t
* given its location at t-1.
* User is advised to respect the Tomasi condition: the response computed is the maximum eigenvalue
* of the second moment matrix but no restrictin are applied to points to track so you can use a
* detector of your choice to indicate points to track.
*
* \author Nizar Sallem
*/
template<typename PointInT, typename IntensityT = pcl::common::IntensityFieldAccessor<PointInT> >
class PyramidalKLTTracker : public Tracker<PointInT, Eigen::Affine3f>
{
public:
typedef pcl::tracking::Tracker<PointInT, Eigen::Affine3f> TrackerBase;
typedef typename TrackerBase::PointCloudIn PointCloudIn;
typedef typename PointCloudIn::Ptr PointCloudInPtr;
typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
typedef pcl::PointCloud<float> FloatImage;
typedef FloatImage::Ptr FloatImagePtr;
typedef FloatImage::ConstPtr FloatImageConstPtr;
using TrackerBase::tracker_name_;
using TrackerBase::input_;
using TrackerBase::indices_;
/// Constructor
PyramidalKLTTracker (int nb_levels = 5, int tracking_window_width = 7, int tracking_window_height = 7)
: ref_ ()
, nb_levels_ (nb_levels)
, track_width_ (tracking_window_width)
, track_height_ (tracking_window_height)
, threads_ (0)
, initialized_ (false)
{
tracker_name_ = "PyramidalKLTTracker";
accuracy_ = 0.1;
epsilon_ = 1e-3;
max_iterations_ = 10;
keypoints_nbr_ = 100;
min_eigenvalue_threshold_ = 1e-4;
kernel_ << 1.f/16 ,1.f/4 ,3.f/8 ,1.f/4 ,1.f/16;
kernel_size_2_ = kernel_.size () / 2;
kernel_last_ = kernel_.size () -1;
}
/// Destructor
virtual ~PyramidalKLTTracker () {}
/** \brief Set the number of pyramid levels
* \param levels desired number of pyramid levels
*/
inline void
setNumberOfPyramidLevels (int levels) { nb_levels_ = levels; }
/// \brief \return the number of pyramid levels
inline int
getNumberOfPyramidLevels () const { return (nb_levels_); }
/** Set accuracy
* \param[in] accuracy desired accuracy.
*/
inline void
setAccuracy (float accuracy) { accuracy_ = accuracy; }
/// \return the accuracy
inline float
getAccuracy () const { return (accuracy_); }
/** Set epsilon
* \param[in] epsilon desired epsilon.
*/
inline void
setEpsilon (float epsilon) { epsilon_ = epsilon; }
/// \return the epsilon
inline float
getEpsilon () const { return (epsilon_); }
/** \brief Set the maximum number of points to track. Only the first keypoints_nbr_
* are used as points to track after sorting detected keypoints according to their
* response measure.
* \param[in] number the desired number of points to detect.
*/
inline void
setNumberOfKeypoints (std::size_t number) { keypoints_nbr_ = number; }
/// \return the maximum number of keypoints to keep
inline std::size_t
getNumberOfKeypoints () { return (keypoints_nbr_); }
/** \brief set the tracking window size
* \param[in] width the tracking window width
* \param[in] height the tracking window height
*/
inline void
setTrackingWindowSize (int width, int height);
/// \brief Set tracking window width
inline void
setTrackingWindowWidth (int width) {track_width_ = width; };
/// \brief \return the tracking window size
inline int
getTrackingWindowWidth () { return (track_width_); }
/// \brief Set tracking window height
inline void
setTrackingWindowHeight (int height) {track_height_ = height; };
/// \brief \return the tracking window size
inline int
getTrackingWindowHeight () { return (track_height_); }
/** \brief Initialize the scheduler and set the number of threads to use.
* \param nr_threads the number of hardware threads to use (0 sets the value back to
* automatic).
*/
inline void
setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
/** \brief Get a pointer of the cloud at t-1. */
inline PointCloudInConstPtr
getReferenceCloud () const { return (ref_); }
/** \brief Set the maximum number of iterations in the Lucas Kanade loop.
* \param[in] max the desired maximum number of iterations
*/
inline void
setMaxIterationsNumber (unsigned int max) { max_iterations_ = max; }
/// \brief \return the maximum iterations number
inline unsigned int
getMaxIterationsNumber () const { return (max_iterations_); }
/** \brief Provide a pointer to points to track.
* \param points the const boost shared pointer to a PointIndices message
*/
inline void
setPointsToTrack (const pcl::PointIndicesConstPtr& points);
/** \brief Provide a pointer to points to track.
* \param points the const boost shared pointer to a PointIndices message
*/
inline void
setPointsToTrack (const pcl::PointCloud<pcl::PointUV>::ConstPtr& points);
/// \brief \return a pointer to the points succesfully tracked.
inline pcl::PointCloud<pcl::PointUV>::ConstPtr
getTrackedPoints () const { return (keypoints_); };
/** \brief \return the status of points to track.
* Status == 0 --> points succesfully tracked;
* Status < 0 --> point is lost;
* Status == -1 --> point is out of bond;
* Status == -2 --> optical flow can not be computed for this point.
*/
inline pcl::PointIndicesConstPtr
getPointsToTrackStatus () const { return (keypoints_status_); }
/** \brief Return the computed transfromation from tracked points. */
Eigen::Affine3f
getResult () const { return (motion_); }
/// \brief \return initialization state
bool
getInitialized () const { return (initialized_); }
protected:
virtual bool
initCompute ();
/** \brief compute Scharr derivatives of a source cloud.
* \param[in] src the image for which gradients are to be computed
* \param[out] grad_x image gradient along X direction
* \param[out] grad_y image gradient along Y direction
*/
void
derivatives (const FloatImage& src, FloatImage& grad_x, FloatImage& grad_y) const;
/** \brief downsample input
* \param[in] input the image to downsample
* \param[out] output the downsampled image
*/
void
downsample (const FloatImageConstPtr& input, FloatImageConstPtr& output) const;
/** \brief downsample input and compute output gradients.
* \param[in] input the image to downsample
* \param[out] output the downsampled image
* \param[out] output_grad_x downsampled image gradient along X direction
* \param[out] output_grad_y downsampled image gradient along Y direction
*/
void
downsample (const FloatImageConstPtr& input, FloatImageConstPtr& output,
FloatImageConstPtr& output_grad_x, FloatImageConstPtr& output_grad_y) const;
/** \brief Separately convolve image with decomposable convolution kernel.
* \param[in] input input the image to convolve
* \param[out] output output the convolved image
*/
void
convolve (const FloatImageConstPtr& input, FloatImage& output) const;
/** \brief Convolve image columns.
* \param[in] input input the image to convolve
* \param[out] output output the convolved image
*/
void
convolveCols (const FloatImageConstPtr& input, FloatImage& output) const;
/** \brief Convolve image rows.
* \param[in] input input the image to convolve
* \param[out] output output the convolved image
*/
void
convolveRows (const FloatImageConstPtr& input, FloatImage& output) const;
/** \brief extract the patch from the previous image, previous image gradients surrounding
* pixel alocation while interpolating image and gradients data and compute covariation
* matrix of derivatives.
* \param[in] img original image
* \param[in] grad_x original image gradient along X direction
* \param[in] grad_y original image gradient along Y direction
* \param[in] location pixel at the center of the patch
* \param[in] weights bilinear interpolation weights at this location computed from subpixel
* location
* \param[out] win patch with interpolated intensity values
* \param[out] grad_x_win patch with interpolated gradient along X values
* \param[out] grad_y_win patch with interpolated gradient along Y values
* \param[out] covariance covariance matrix coefficents
*/
virtual void
spatialGradient (const FloatImage& img,
const FloatImage& grad_x,
const FloatImage& grad_y,
const Eigen::Array2i& location,
const Eigen::Array4f& weights,
Eigen::ArrayXXf& win,
Eigen::ArrayXXf& grad_x_win,
Eigen::ArrayXXf& grad_y_win,
Eigen::Array3f & covariance) const;
void
mismatchVector (const Eigen::ArrayXXf& prev,
const Eigen::ArrayXXf& prev_grad_x,
const Eigen::ArrayXXf& prev_grad_y,
const FloatImage& next,
const Eigen::Array2i& location,
const Eigen::Array4f& weights,
Eigen::Array2f &b) const;
/** \brief Compute the pyramidal representation of an image.
* \param[in] input the input cloud
* \param[out] pyramid computed pyramid levels along with their respective gradients
* \param[in] border_type
*/
virtual void
computePyramids (const PointCloudInConstPtr& input,
std::vector<FloatImageConstPtr>& pyramid,
pcl::InterpolationType border_type) const;
virtual void
track (const PointCloudInConstPtr& previous_input,
const PointCloudInConstPtr& current_input,
const std::vector<FloatImageConstPtr>& previous_pyramid,
const std::vector<FloatImageConstPtr>& current_pyramid,
const pcl::PointCloud<pcl::PointUV>::ConstPtr& previous_keypoints,
pcl::PointCloud<pcl::PointUV>::Ptr& current_keypoints,
std::vector<int>& status,
Eigen::Affine3f& motion) const;
virtual void
computeTracking ();
/// \brief input pyranid at t-1
std::vector<FloatImageConstPtr> ref_pyramid_;
/// \brief point cloud at t-1
PointCloudInConstPtr ref_;
/// \brief number of pyramid levels
int nb_levels_;
/// \brief detected keypoints 2D coordinates
pcl::PointCloud<pcl::PointUV>::ConstPtr keypoints_;
/// \brief status of keypoints of t-1 at t
pcl::PointIndicesPtr keypoints_status_;
/// \brief number of points to detect
std::size_t keypoints_nbr_;
/// \brief tracking width
int track_width_;
/// \brief half of tracking window width
int track_width_2_;
/// \brief tracking height
int track_height_;
/// \brief half of tracking window height
int track_height_2_;
/// \brief maximum number of iterations
unsigned int max_iterations_;
/// \brief accuracy criterion to stop iterating
float accuracy_;
float min_eigenvalue_threshold_;
/// \brief epsilon for subpixel computation
float epsilon_;
float max_residue_;
/// \brief number of hardware threads
unsigned int threads_;
/// \brief intensity accessor
IntensityT intensity_;
/// \brief is the tracker initialized ?
bool initialized_;
/// \brief compute transformation from successfully tracked points
pcl::TransformationFromCorrespondences transformation_computer_;
/// \brief computed transformation between tracked points
Eigen::Affine3f motion_;
/// \brief smoothing kernel
Eigen::Array<float, 5, 1> kernel_;
/// \brief smoothing kernel half size
int kernel_size_2_;
/// \brief index of last element in kernel
int kernel_last_;
public:
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
}
}
#include <pcl/tracking/impl/pyramidal_klt.hpp>
#endif
pcl::tracking::PyramidalKLTTracker::track_height_2_
int track_height_2_
half of tracking window height
Definition: pyramidal_klt.h:345
pcl::tracking::PyramidalKLTTracker::track_width_
int track_width_
tracking width
Definition: pyramidal_klt.h:339
pcl::tracking::PyramidalKLTTracker::setEpsilon
void setEpsilon(float epsilon)
Set epsilon.
Definition: pyramidal_klt.h:125
pcl::tracking::PyramidalKLTTracker::mismatchVector
void mismatchVector(const Eigen::ArrayXXf &prev, const Eigen::ArrayXXf &prev_grad_x, const Eigen::ArrayXXf &prev_grad_y, const FloatImage &next, const Eigen::Array2i &location, const Eigen::Array4f &weights, Eigen::Array2f &b) const
Definition: pyramidal_klt.hpp:447
pcl::tracking::PyramidalKLTTracker::setTrackingWindowHeight
void setTrackingWindowHeight(int height)
Set tracking window height.
Definition: pyramidal_klt.h:160
pcl::tracking::PyramidalKLTTracker::setNumberOfKeypoints
void setNumberOfKeypoints(std::size_t number)
Set the maximum number of points to track.
Definition: pyramidal_klt.h:137
pcl::tracking::PyramidalKLTTracker::convolveRows
void convolveRows(const FloatImageConstPtr &input, FloatImage &output) const
Convolve image rows.
Definition: pyramidal_klt.hpp:275
pcl::tracking::PyramidalKLTTracker::convolveCols
void convolveCols(const FloatImageConstPtr &input, FloatImage &output) const
Convolve image columns.
Definition: pyramidal_klt.hpp:306
pcl::tracking::PyramidalKLTTracker::setAccuracy
void setAccuracy(float accuracy)
Set accuracy.
Definition: pyramidal_klt.h:115
pcl::tracking::PyramidalKLTTracker::track_width_2_
int track_width_2_
half of tracking window width
Definition: pyramidal_klt.h:341
pcl::tracking::PyramidalKLTTracker::nb_levels_
int nb_levels_
number of pyramid levels
Definition: pyramidal_klt.h:331
pcl::tracking::PyramidalKLTTracker::spatialGradient
virtual void spatialGradient(const FloatImage &img, const FloatImage &grad_x, const FloatImage &grad_y, const Eigen::Array2i &location, const Eigen::Array4f &weights, Eigen::ArrayXXf &win, Eigen::ArrayXXf &grad_x_win, Eigen::ArrayXXf &grad_y_win, Eigen::Array3f &covariance) const
extract the patch from the previous image, previous image gradients surrounding pixel alocation while...
Definition: pyramidal_klt.hpp:406
pcl
Definition: cloud_iterator.h:46
pcl::tracking::PyramidalKLTTracker::getEpsilon
float getEpsilon() const
Definition: pyramidal_klt.h:129
pcl::PCLBase< PointInT >::indices_
IndicesPtr indices_
A pointer to the vector of point indices to use.
Definition: pcl_base.h:153
pcl::tracking::PyramidalKLTTracker::PyramidalKLTTracker
PyramidalKLTTracker(int nb_levels=5, int tracking_window_width=7, int tracking_window_height=7)
Constructor.
Definition: pyramidal_klt.h:79
pcl::tracking::PyramidalKLTTracker::downsample
void downsample(const FloatImageConstPtr &input, FloatImageConstPtr &output) const
downsample input
Definition: pyramidal_klt.hpp:221
pcl::tracking::PyramidalKLTTracker::ref_pyramid_
std::vector< FloatImageConstPtr > ref_pyramid_
input pyranid at t-1
Definition: pyramidal_klt.h:327
pcl::tracking::PyramidalKLTTracker::transformation_computer_
pcl::TransformationFromCorrespondences transformation_computer_
compute transformation from successfully tracked points
Definition: pyramidal_klt.h:361
pcl::tracking::PyramidalKLTTracker::max_residue_
float max_residue_
Definition: pyramidal_klt.h:353
pcl::tracking::PyramidalKLTTracker::getNumberOfKeypoints
std::size_t getNumberOfKeypoints()
Definition: pyramidal_klt.h:141
pcl::tracking::PyramidalKLTTracker::initialized_
bool initialized_
is the tracker initialized ?
Definition: pyramidal_klt.h:359
pcl::tracking::PyramidalKLTTracker::getReferenceCloud
PointCloudInConstPtr getReferenceCloud() const
Get a pointer of the cloud at t-1.
Definition: pyramidal_klt.h:175
pcl::tracking::PyramidalKLTTracker
Pyramidal Kanade Lucas Tomasi tracker.
Definition: pyramidal_klt.h:63
pcl::tracking::PyramidalKLTTracker::convolve
void convolve(const FloatImageConstPtr &input, FloatImage &output) const
Separately convolve image with decomposable convolution kernel.
Definition: pyramidal_klt.hpp:266
pcl::tracking::PyramidalKLTTracker::getPointsToTrackStatus
pcl::PointIndicesConstPtr getPointsToTrackStatus() const
Definition: pyramidal_klt.h:210
pcl::PointCloud< PointInT >::Ptr
boost::shared_ptr< PointCloud< PointInT > > Ptr
Definition: point_cloud.h:428
pcl::tracking::PyramidalKLTTracker::track
virtual void track(const PointCloudInConstPtr &previous_input, const PointCloudInConstPtr &current_input, const std::vector< FloatImageConstPtr > &previous_pyramid, const std::vector< FloatImageConstPtr > &current_pyramid, const pcl::PointCloud< pcl::PointUV >::ConstPtr &previous_keypoints, pcl::PointCloud< pcl::PointUV >::Ptr &current_keypoints, std::vector< int > &status, Eigen::Affine3f &motion) const
Definition: pyramidal_klt.hpp:476
pcl::tracking::PyramidalKLTTracker::kernel_last_
int kernel_last_
index of last element in kernel
Definition: pyramidal_klt.h:369
pcl::tracking::PyramidalKLTTracker::setTrackingWindowSize
void setTrackingWindowSize(int width, int height)
set the tracking window size
Definition: pyramidal_klt.hpp:49
pcl::tracking::PyramidalKLTTracker::setPointsToTrack
void setPointsToTrack(const pcl::PointIndicesConstPtr &points)
Provide a pointer to points to track.
Definition: pyramidal_klt.hpp:76
pcl::tracking::PyramidalKLTTracker::keypoints_nbr_
std::size_t keypoints_nbr_
number of points to detect
Definition: pyramidal_klt.h:337
pcl::tracking::PyramidalKLTTracker::motion_
Eigen::Affine3f motion_
computed transformation between tracked points
Definition: pyramidal_klt.h:363
pcl::tracking::PyramidalKLTTracker::FloatImage
pcl::PointCloud< float > FloatImage
Definition: pyramidal_klt.h:70
pcl::tracking::PyramidalKLTTracker::~PyramidalKLTTracker
virtual ~PyramidalKLTTracker()
Destructor.
Definition: pyramidal_klt.h:99
pcl::tracking::PyramidalKLTTracker::min_eigenvalue_threshold_
float min_eigenvalue_threshold_
Definition: pyramidal_klt.h:350
pcl::tracking::PyramidalKLTTracker::initCompute
virtual bool initCompute()
This method should get called before starting the actual computation.
Definition: pyramidal_klt.hpp:94
pcl::tracking::PyramidalKLTTracker::ref_
PointCloudInConstPtr ref_
point cloud at t-1
Definition: pyramidal_klt.h:329
pcl::tracking::PyramidalKLTTracker::setMaxIterationsNumber
void setMaxIterationsNumber(unsigned int max)
Set the maximum number of iterations in the Lucas Kanade loop.
Definition: pyramidal_klt.h:181
pcl::tracking::PyramidalKLTTracker::setNumberOfThreads
void setNumberOfThreads(unsigned int nr_threads=0)
Initialize the scheduler and set the number of threads to use.
Definition: pyramidal_klt.h:171
pcl::tracking::PyramidalKLTTracker::kernel_
Eigen::Array< float, 5, 1 > kernel_
smoothing kernel
Definition: pyramidal_klt.h:365
pcl::PointCloud< PointInT >::ConstPtr
boost::shared_ptr< const PointCloud< PointInT > > ConstPtr
Definition: point_cloud.h:429
pcl::tracking::PyramidalKLTTracker::computeTracking
virtual void computeTracking()
Abstract tracking method.
Definition: pyramidal_klt.hpp:627
pcl::PointIndicesConstPtr
boost::shared_ptr< ::pcl::PointIndices const > PointIndicesConstPtr
Definition: PointIndices.h:27
pcl::tracking::PyramidalKLTTracker::accuracy_
float accuracy_
accuracy criterion to stop iterating
Definition: pyramidal_klt.h:349
pcl::tracking::PyramidalKLTTracker::getResult
Eigen::Affine3f getResult() const
Return the computed transfromation from tracked points.
Definition: pyramidal_klt.h:214
pcl::tracking::PyramidalKLTTracker::intensity_
IntensityT intensity_
intensity accessor
Definition: pyramidal_klt.h:357
pcl::PointCloud< PointInT >
pcl::tracking::PyramidalKLTTracker::FloatImageConstPtr
FloatImage::ConstPtr FloatImageConstPtr
Definition: pyramidal_klt.h:72
pcl::InterpolationType
InterpolationType
Definition: io.h:227
pcl::tracking::PyramidalKLTTracker::epsilon_
float epsilon_
epsilon for subpixel computation
Definition: pyramidal_klt.h:352
pcl::tracking::PyramidalKLTTracker::derivatives
void derivatives(const FloatImage &src, FloatImage &grad_x, FloatImage &grad_y) const
compute Scharr derivatives of a source cloud.
Definition: pyramidal_klt.hpp:166
pcl::tracking::PyramidalKLTTracker::getInitialized
bool getInitialized() const
Definition: pyramidal_klt.h:218
pcl::tracking::PyramidalKLTTracker::keypoints_
pcl::PointCloud< pcl::PointUV >::ConstPtr keypoints_
detected keypoints 2D coordinates
Definition: pyramidal_klt.h:333
pcl::tracking::PyramidalKLTTracker::setTrackingWindowWidth
void setTrackingWindowWidth(int width)
Set tracking window width.
Definition: pyramidal_klt.h:152
pcl::PointIndicesPtr
boost::shared_ptr< ::pcl::PointIndices > PointIndicesPtr
Definition: PointIndices.h:26
pcl::tracking::PyramidalKLTTracker::FloatImagePtr
FloatImage::Ptr FloatImagePtr
Definition: pyramidal_klt.h:71
pcl::TransformationFromCorrespondences
Calculates a transformation based on corresponding 3D points.
Definition: transformation_from_correspondences.h:49
pcl::tracking::PyramidalKLTTracker::PointCloudInPtr
PointCloudIn::Ptr PointCloudInPtr
Definition: pyramidal_klt.h:68
pcl::tracking::PyramidalKLTTracker::setNumberOfPyramidLevels
void setNumberOfPyramidLevels(int levels)
Set the number of pyramid levels.
Definition: pyramidal_klt.h:105
pcl::tracking::PyramidalKLTTracker::getAccuracy
float getAccuracy() const
Definition: pyramidal_klt.h:119
pcl::tracking::PyramidalKLTTracker::computePyramids
virtual void computePyramids(const PointCloudInConstPtr &input, std::vector< FloatImageConstPtr > &pyramid, pcl::InterpolationType border_type) const
Compute the pyramidal representation of an image.
Definition: pyramidal_klt.hpp:338
pcl::tracking::PyramidalKLTTracker::getTrackingWindowHeight
int getTrackingWindowHeight()
Definition: pyramidal_klt.h:164
pcl::tracking::Tracker
Tracker represents the base tracker class.
Definition: tracker.h:56
pcl::tracking::PyramidalKLTTracker::getTrackingWindowWidth
int getTrackingWindowWidth()
Definition: pyramidal_klt.h:156
pcl::tracking::PyramidalKLTTracker::PointCloudInConstPtr
PointCloudIn::ConstPtr PointCloudInConstPtr
Definition: pyramidal_klt.h:69
pcl::PCLBase< PointInT >::input_
PointCloudConstPtr input_
The input point cloud dataset.
Definition: pcl_base.h:150
pcl::tracking::PyramidalKLTTracker::PointCloudIn
TrackerBase::PointCloudIn PointCloudIn
Definition: pyramidal_klt.h:67
pcl::tracking::PyramidalKLTTracker::TrackerBase
pcl::tracking::Tracker< PointInT, Eigen::Affine3f > TrackerBase
Definition: pyramidal_klt.h:66
pcl::tracking::PyramidalKLTTracker::getTrackedPoints
pcl::PointCloud< pcl::PointUV >::ConstPtr getTrackedPoints() const
Definition: pyramidal_klt.h:201
pcl::tracking::PyramidalKLTTracker::keypoints_status_
pcl::PointIndicesPtr keypoints_status_
status of keypoints of t-1 at t
Definition: pyramidal_klt.h:335
pcl::tracking::PyramidalKLTTracker::getNumberOfPyramidLevels
int getNumberOfPyramidLevels() const
Definition: pyramidal_klt.h:109
pcl::tracking::PyramidalKLTTracker::threads_
unsigned int threads_
number of hardware threads
Definition: pyramidal_klt.h:355
pcl::tracking::PyramidalKLTTracker::getMaxIterationsNumber
unsigned int getMaxIterationsNumber() const
Definition: pyramidal_klt.h:185
pcl::tracking::PyramidalKLTTracker::track_height_
int track_height_
tracking height
Definition: pyramidal_klt.h:343
pcl::tracking::PyramidalKLTTracker::kernel_size_2_
int kernel_size_2_
smoothing kernel half size
Definition: pyramidal_klt.h:367
pcl::tracking::Tracker< PointInT, Eigen::Affine3f >::tracker_name_
std::string tracker_name_
The tracker name.
Definition: tracker.h:92
pcl::tracking::PyramidalKLTTracker::max_iterations_
unsigned int max_iterations_
maximum number of iterations
Definition: pyramidal_klt.h:347