40#include <pcl/recognition/quantizable_modality.h>
41#include <pcl/recognition/distance_map.h>
43#include <pcl/pcl_base.h>
44#include <pcl/point_cloud.h>
46#include <pcl/recognition/point_types.h>
58 template <
typename Po
intInT>
91 return (filtered_quantized_colors_);
97 return (spreaded_filtered_quantized_colors_);
102 std::vector<QuantizedMultiModFeature> & features)
const;
133 float feature_distance_threshold_;
144template <
typename Po
intInT>
146 : feature_distance_threshold_ (1.0f), quantized_colors_ (), filtered_quantized_colors_ (), spreaded_filtered_quantized_colors_ ()
151template <
typename Po
intInT>
157template <
typename Po
intInT>
165 filterQuantizedColors ();
175template <
typename Po
intInT>
177 const std::size_t nr_features,
178 const std::size_t modality_index,
179 std::vector<QuantizedMultiModFeature> & features)
const
181 const std::size_t width =
mask.getWidth ();
182 const std::size_t height =
mask.getHeight ();
188 unsigned char map[255];
210 const unsigned char quantized_value = filtered_quantized_colors_ (
col_index,
row_index);
212 if (quantized_value == 0)
227 std::list<Candidate>
list1;
228 std::list<Candidate>
list2;
230 float weights[8] = {0,0,0,0,0,0,0,0};
232 const std::size_t off = 4;
240 const unsigned char quantized_value = filtered_quantized_colors_ (
col_index,
row_index);
246 if (quantized_value != 0)
253 if (distance >= feature_distance_threshold_)
271 for (
typename std::list<Candidate>::iterator iter =
list1.begin (); iter !=
list1.end (); ++iter)
272 iter->distance *= 1.0f / weights[iter->bin_index];
279 for (
typename std::list<Candidate>::iterator iter =
list1.begin (); iter !=
list1.end (); ++iter)
283 feature.
x =
static_cast<int> (iter->x);
284 feature.
y =
static_cast<int> (iter->y);
286 feature.
quantized_value = filtered_quantized_colors_ (iter->x, iter->y);
288 features.push_back (feature);
294 int distance =
static_cast<int> (
list1.
size () / nr_features + 1);
304 const int dx =
static_cast<int> (
iter1->x) -
static_cast<int> (
iter2->x);
305 const int dy =
static_cast<int> (
iter1->y) -
static_cast<int> (
iter2->y);
327 feature.
x =
static_cast<int> (
iter2->x);
328 feature.
y =
static_cast<int> (
iter2->y);
332 features.push_back (feature);
337template <
typename Po
intInT>
341 const std::size_t width = input_->width;
342 const std::size_t height = input_->height;
344 quantized_colors_.resize (width, height);
360template <
typename Po
intInT>
364 const std::size_t width = input_->width;
365 const std::size_t height = input_->height;
367 filtered_quantized_colors_.resize (width, height);
374 unsigned char histogram[8] = {0,0,0,0,0,0,0,0};
435template <
typename Po
intInT>
441 const float r_inv = 255.0f-r;
442 const float g_inv = 255.0f-g;
443 const float b_inv = 255.0f-b;
445 const float dist_0 = (r*r + g*g + b*b)*2.0f;
488template <
typename Po
intInT>
void
492 const std::size_t width =
input.getWidth ();
493 const std::size_t height =
input.getHeight ();
495 output.resize (width, height);
501 for (std::size_t index = 0; index < width*height; ++index)
506 distance_map[index] =
static_cast<float> (width + height);
512 for (std::size_t
ri = 1;
ri < height; ++
ri)
514 for (std::size_t
ci = 1;
ci < width; ++
ci)
534 for (
int ri =
static_cast<int> (height)-2;
ri >= 0; --
ri)
536 for (
int ci =
static_cast<int> (width)-2;
ci >= 0; --
ci)
void computeDistanceMap(const MaskMap &input, DistanceMap &output) const
QuantizedMap & getSpreadedQuantizedMap()
Returns a reference to the internally computed spread quantized map.
virtual void setInputCloud(const typename PointCloudIn::ConstPtr &cloud)
Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
void filterQuantizedColors()
static int quantizeColorOnRGBExtrema(const float r, const float g, const float b)
virtual void processInputData()
void extractFeatures(const MaskMap &mask, std::size_t nr_features, std::size_t modalityIndex, std::vector< QuantizedMultiModFeature > &features) const
Extracts features from this modality within the specified mask.
QuantizedMap & getQuantizedMap()
Returns a reference to the internally computed quantized map.
Iterator class for point clouds with or without given indices.
std::size_t size() const
Size of the range the iterator is going through.
Represents a distance map obtained from a distance transformation.
PointCloudConstPtr input_
The input point cloud dataset.
shared_ptr< const PointCloud< PointInT > > ConstPtr
Interface for a quantizable modality.
static void spreadQuantizedMap(const QuantizedMap &input_map, QuantizedMap &output_map, std::size_t spreading_size)
Defines all the PCL implemented PointT point type structures.
bool operator<(const Candidate &rhs)
Feature that defines a position and quantized value in a specific modality.
std::size_t modality_index
the index of the corresponding modality.
unsigned char quantized_value
the quantized value attached to the feature.