Main MRPT website > C++ reference for MRPT 1.4.0
CFeatureExtraction.h
Go to the documentation of this file.
1/* +---------------------------------------------------------------------------+
2 | Mobile Robot Programming Toolkit (MRPT) |
3 | http://www.mrpt.org/ |
4 | |
5 | Copyright (c) 2005-2016, Individual contributors, see AUTHORS file |
6 | See: http://www.mrpt.org/Authors - All rights reserved. |
7 | Released under BSD License. See details in http://www.mrpt.org/License |
8 +---------------------------------------------------------------------------+ */
9#ifndef CFeatureExtraction_H
10#define CFeatureExtraction_H
11
12#include <mrpt/utils/CImage.h>
13#include <mrpt/utils/CTicTac.h>
14#include <mrpt/vision/utils.h>
17
18namespace mrpt
19{
20 namespace vision
21 {
22 /** The central class from which images can be analyzed in search of different kinds of interest points and descriptors computed for them.
23 * To extract features from an image, create an instance of CFeatureExtraction,
24 * fill out its CFeatureExtraction::options field, including the algorithm to use (see
25 * CFeatureExtraction::TOptions::featsType), and call CFeatureExtraction::detectFeatures.
26 * This will return a set of features of the class mrpt::vision::CFeature, which include
27 * details for each interest point as well as the desired descriptors and/or patches.
28 *
29 * By default, a 21x21 patch is extracted for each detected feature. If the patch is not needed,
30 * set patchSize to 0 in CFeatureExtraction::options
31 *
32 * The implemented <b>detection</b> algorithms are (see CFeatureExtraction::TOptions::featsType):
33 * - KLT (Kanade-Lucas-Tomasi): A detector (no descriptor vector).
34 * - Harris: A detector (no descriptor vector).
35 * - BCD (Binary Corner Detector): A detector (no descriptor vector) (Not implemented yet).
36 * - SIFT: An implementation of the SIFT detector and descriptor. The implemention may be selected with CFeatureExtraction::TOptions::SIFTOptions::implementation.
37 * - SURF: OpenCV's implementation of SURF detector and descriptor.
38 * - The FAST feature detector (OpenCV's implementation)
39 * - The FASTER (9,10,12) detectors (Edward Rosten's libcvd implementation optimized for SSE2).
40 *
41 * Additionally, given a list of interest points onto an image, the following
42 * <b>descriptors</b> can be computed for each point by calling CFeatureExtraction::computeDescriptors :
43 * - SIFT descriptor (Lowe's descriptors).
44 * - SURF descriptor (OpenCV's implementation - Requires OpenCV 1.1.0 from SVN or later).
45 * - Intensity-domain spin images (SpinImage): Creates a vector descriptor with the 2D histogram as a single row.
46 * - A circular patch in polar coordinates (Polar images): The matrix descriptor is a 2D polar image centered at the interest point.
47 * - A log-polar image patch (Log-polar images): The matrix descriptor is the 2D log-polar image centered at the interest point.
48 *
49 *
50 * Apart from the normal entry point \a detectFeatures(), these other low-level static methods are provided for convenience:
51 * - CFeatureExtraction::detectFeatures_SSE2_FASTER9()
52 * - CFeatureExtraction::detectFeatures_SSE2_FASTER10()
53 * - CFeatureExtraction::detectFeatures_SSE2_FASTER12()
54 *
55 * \note The descriptor "Intensity-domain spin images" is described in "A sparse texture representation using affine-invariant regions", S Lazebnik, C Schmid, J Ponce, 2003 IEEE Computer Society Conference on Computer Vision.
56 * \sa mrpt::vision::CFeature
57 * \ingroup mrptvision_features
58 */
60 {
61 public:
63 {
64 LoweBinary = 0,
68 OpenCV
69 };
70
71 /** The set of parameters for all the detectors & descriptor algorithms */
73 {
74 /** Initalizer */
75 TOptions(const TFeatureType featsType = featKLT);
76
77 void loadFromConfigFile(const mrpt::utils::CConfigFileBase &source,const std::string &section) MRPT_OVERRIDE; // See base docs
78 void dumpToTextStream(mrpt::utils::CStream &out) const MRPT_OVERRIDE; // See base docs
79
80 /** Type of the extracted features
81 */
83
84 /** Size of the patch to extract, or 0 if no patch is desired (default=21).
85 */
86 unsigned int patchSize;
87
88 /** Whether to use a mask for determining the regions where not to look for keypoints (default=false).
89 */
90 bool useMask;
91
92 /** Whether to add the found features to the input feature list or clear it before adding them (default=false).
93 */
95
96 /** Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris features)
97 */
99
100 /** KLT Options */
102 {
103 int radius; // size of the block of pixels used
104 float threshold; // (default=0.1) for rejecting weak local maxima (with min_eig < threshold*max(eig_image))
105 float min_distance; // minimum distance between features
106 bool tile_image; // splits the image into 8 tiles and search for the best points in all of them (distribute the features over all the image)
107 } KLTOptions;
108
109 /** Harris Options */
111 {
112 float threshold; // (default=0.005) for rejecting weak local maxima (with min_eig < threshold*max(eig_image))
113 float k; // k factor for the Harris algorithm
114 float sigma; // standard deviation for the gaussian smoothing function
115 int radius; // size of the block of pixels used
116 float min_distance; // minimum distance between features
117 bool tile_image; // splits the image into 8 tiles and search for the best points in all of them (distribute the features over all the image)
118 } harrisOptions;
119
120 /** BCD Options */
122 {
123 } BCDOptions;
124
125 /** FAST and FASTER Options */
127 {
128 int threshold; //!< default= 20
129 float min_distance; //!< (default=5) minimum distance between features (in pixels)
130 bool nonmax_suppression; //!< Default = true
131 bool use_KLT_response; //!< (default=false) If true, use CImage::KLT_response to compute the response at each point instead of the FAST "standard response".
132 } FASTOptions;
133
134 /** ORB Options */
136 {
137 TORBOptions() : n_levels(8), min_distance(0), scale_factor(1.2f),extract_patch(false) {}
138
139 size_t n_levels;
143 } ORBOptions;
144
145 /** SIFT Options */
147 {
148 TSIFTOptions() : threshold(0.04), edgeThreshold(10) { }
149
150 TSIFTImplementation implementation; //!< Default: Hess (OpenCV should be preferred, but its nonfree module is not always available by default in all systems)
151 double threshold; //!< default= 0.04
152 double edgeThreshold; //!< default= 10
153 } SIFTOptions;
154
156 {
157 TSURFOptions() : rotation_invariant(true),hessianThreshold(600), nOctaves(2), nLayersPerOctave(4) { }
158
159 /** SURF Options
160 */
161 bool rotation_invariant; //!< Compute the rotation invariant SURF (dim=128) if set to true (default), or the smaller uSURF otherwise (dim=64)
162 int hessianThreshold; //!< Default: 600
163 int nOctaves; //!< Default: 2
164 int nLayersPerOctave; //!< Default: 4
165 } SURFOptions;
166
168 {
169 /** SpinImages Options
170 */
171 unsigned int hist_size_intensity; //!< Number of bins in the "intensity" axis of the 2D histogram (default=10).
172 unsigned int hist_size_distance; //!< Number of bins in the "distance" axis of the 2D histogram (default=10).
173 float std_dist; //!< Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels)
174 float std_intensity; //!< Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0,255])
175 unsigned int radius; //!< Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels)
176 } SpinImagesOptions;
177
178 /** PolarImagesOptions Options
179 */
181 {
182 unsigned int bins_angle; //!< Number of bins in the "angular" axis of the polar image (default=8).
183 unsigned int bins_distance; //!< Number of bins in the "distance" axis of the polar image (default=6).
184 unsigned int radius; //!< Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels)
185 } PolarImagesOptions;
186
187 /** LogPolarImagesOptions Options
188 */
190 {
191 unsigned int radius; //!< Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels)
192 unsigned int num_angles; //!< (default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
193 double rho_scale; //!< (default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(radius)
194 } LogPolarImagesOptions;
195
196 };
197
198 TOptions options; //!< Set all the parameters of the desired method here before calling "detectFeatures"
199
200 /** Constructor
201 */
203
204 /** Virtual destructor.
205 */
207
208 /** Extract features from the image based on the method defined in TOptions.
209 * \param img (input) The image from where to extract the images.
210 * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
211 * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
212 *
213 * \sa computeDescriptors
214 */
216 const mrpt::utils::CImage & img,
217 CFeatureList & feats,
218 const unsigned int init_ID = 0,
219 const unsigned int nDesiredFeatures = 0,
220 const TImageROI &ROI = TImageROI()) const;
221
222 /** Compute one (or more) descriptors for the given set of interest points onto the image, which may have been filled out manually or from \a detectFeatures
223 * \param in_img (input) The image from where to compute the descriptors.
224 * \param inout_features (input/output) The list of features whose descriptors are going to be computed.
225 * \param in_descriptor_list (input) The bitwise OR of one or several descriptors defined in TDescriptorType.
226 *
227 * Each value in "in_descriptor_list" represents one descriptor to be computed, for example:
228 * \code
229 * // This call will compute both, SIFT and Spin-Image descriptors for a list of feature points lstFeats.
230 * fext.computeDescriptors(img, lstFeats, descSIFT | descSpinImages );
231 * \endcode
232 *
233 * \note The SIFT descriptors for already located features can only be computed through the Hess and
234 * CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
235 *
236 * \note This call will also use additional parameters from \a options
237 */
239 const mrpt::utils::CImage &in_img,
240 CFeatureList &inout_features,
241 TDescriptorType in_descriptor_list) const;
242
243#if 0 // Delete? see comments in .cpp
244 /** Extract more features from the image (apart from the provided ones) based on the method defined in TOptions.
245 * \param img (input) The image from where to extract the images.
246 * \param inList (input) The actual features in the image.
247 * \param outList (output) The list of new features (containing a patch for each one of them if options.patchsize > 0).
248 * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
249 *
250 * \sa The more powerful class: mrpt::vision::CGenericFeatureTracker
251 */
252 void findMoreFeatures( const mrpt::utils::CImage &img,
253 const CFeatureList &inList,
254 CFeatureList &outList,
255 unsigned int nDesiredFeats = 0) const;
256#endif
257
258 /** @name Static methods with low-level detector functionality
259 @{ */
260
261 /** A SSE2-optimized implementation of FASTER-9 (requires img to be grayscale). If SSE2 is not available, it gratefully falls back to a non-optimized version.
262 *
263 * Only the pt.{x,y} fields are filled out for each feature: the rest of fields are left <b>uninitialized</b> and their content is <b>undefined</b>.
264 * Note that (x,y) are already scaled to the 0-level image coordinates if octave>0, by means of:
265 *
266 * \code
267 * pt.x = detected.x << octave;
268 * pt.y = detected.y << octave;
269 * \endcode
270 *
271 * If \a append_to_list is true, the \a corners list is not cleared before adding the newly detected feats.
272 *
273 * If a valid pointer is provided for \a out_feats_index_by_row, upon return you will find a vector with
274 * as many entries as rows in the image (the real number of rows, disregarding the value of \a octave).
275 * The number in each entry is the 0-based index (in \a corners) of
276 * the first feature that falls in that line of the image. This index can be used to fasten looking for correspondences.
277 *
278 * \ingroup mrptvision_features
279 */
281 const mrpt::utils::CImage &img,
282 TSimpleFeatureList & corners,
283 const int threshold = 20,
284 bool append_to_list = false,
285 uint8_t octave = 0,
286 std::vector<size_t> * out_feats_index_by_row = NULL );
287
288 /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
289 * \ingroup mrptvision_features */
291 const mrpt::utils::CImage &img,
292 TSimpleFeatureList & corners,
293 const int threshold = 20,
294 bool append_to_list = false,
295 uint8_t octave = 0,
296 std::vector<size_t> * out_feats_index_by_row = NULL );
297
298 /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the detector.
299 * \ingroup mrptvision_features */
301 const mrpt::utils::CImage &img,
302 TSimpleFeatureList & corners,
303 const int threshold = 20,
304 bool append_to_list = false,
305 uint8_t octave = 0,
306 std::vector<size_t> * out_feats_index_by_row = NULL );
307
308 /** @} */
309
310 private:
311 /** Compute the SIFT descriptor of the provided features into the input image
312 * \param in_img (input) The image from where to compute the descriptors.
313 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
314 *
315 * \note The SIFT descriptors for already located features can only be computed through the Hess and
316 CSBinary implementations which may be specified in CFeatureExtraction::TOptions::SIFTOptions.
317 */
319 CFeatureList &in_features) const;
320
321
322 /** Compute the SURF descriptor of the provided features into the input image
323 * \param in_img (input) The image from where to compute the descriptors.
324 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
325 */
327 CFeatureList &in_features) const;
328
329 /** Compute the ORB descriptor of the provided features into the input image
330 * \param in_img (input) The image from where to compute the descriptors.
331 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
332 */
334 CFeatureList &in_features) const;
335
336 /** Compute the intensity-domain spin images descriptor of the provided features into the input image
337 * \param in_img (input) The image from where to compute the descriptors.
338 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
339 *
340 * \note Additional parameters from CFeatureExtraction::TOptions::SpinImagesOptions are used in this method.
341 */
343 CFeatureList &in_features) const;
344
345 /** Compute a polar-image descriptor of the provided features into the input image
346 * \param in_img (input) The image from where to compute the descriptors.
347 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
348 *
349 * \note Additional parameters from CFeatureExtraction::TOptions::PolarImagesOptions are used in this method.
350 */
352 CFeatureList &in_features) const;
353
354 /** Compute a log-polar image descriptor of the provided features into the input image
355 * \param in_img (input) The image from where to compute the descriptors.
356 * \param in_features (input/output) The list of features whose descriptors are going to be computed.
357 *
358 * \note Additional parameters from CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this method.
359 */
361 CFeatureList &in_features) const;
362
363#if 0 // Delete? see comments in .cpp
364 /** Select good features using the openCV implementation of the KLT method.
365 * \param img (input) The image from where to select extract the images.
366 * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
367 * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
368 */
369 void selectGoodFeaturesKLT(
370 const mrpt::utils::CImage &inImg,
371 CFeatureList &feats,
372 unsigned int init_ID = 0,
373 unsigned int nDesiredFeatures = 0) const;
374#endif
375
376 /** Extract features from the image based on the KLT method.
377 * \param img The image from where to extract the images.
378 * \param feats The list of extracted features.
379 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
380 */
382 const mrpt::utils::CImage &img,
383 CFeatureList &feats,
384 unsigned int init_ID = 0,
385 unsigned int nDesiredFeatures = 0,
386 const TImageROI &ROI = TImageROI()) const;
387
388 // ------------------------------------------------------------------------------------
389 // BCD
390 // ------------------------------------------------------------------------------------
391 /** Extract features from the image based on the BCD method.
392 * \param img The image from where to extract the images.
393 * \param feats The list of extracted features.
394 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
395 * \param ROI (op. input) Region of Interest. Default: All the image.
396 */
398 const mrpt::utils::CImage &img,
399 CFeatureList &feats,
400 unsigned int init_ID = 0,
401 unsigned int nDesiredFeatures = 0,
402 const TImageROI &ROI = TImageROI()) const;
403
404 // ------------------------------------------------------------------------------------
405 // SIFT
406 // ------------------------------------------------------------------------------------
407 /** Extract features from the image based on the SIFT method.
408 * \param img The image from where to extract the images.
409 * \param feats The list of extracted features.
410 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
411 * \param ROI (op. input) Region of Interest. Default: All the image.
412 */
414 const mrpt::utils::CImage &img,
415 CFeatureList &feats,
416 unsigned int init_ID = 0,
417 unsigned int nDesiredFeatures = 0,
418 const TImageROI &ROI = TImageROI()) const;
419
420 // ------------------------------------------------------------------------------------
421 // ORB
422 // ------------------------------------------------------------------------------------
423 /** Extract features from the image based on the ORB method.
424 * \param img The image from where to extract the images.
425 * \param feats The list of extracted features.
426 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
427 */
429 const mrpt::utils::CImage &img,
430 CFeatureList &feats,
431 const unsigned int init_ID = 0,
432 const unsigned int nDesiredFeatures = 0,
433 const TImageROI & ROI = TImageROI()) const;
434
435
436 // ------------------------------------------------------------------------------------
437 // SURF
438 // ------------------------------------------------------------------------------------
439 /** Extract features from the image based on the SURF method.
440 * \param img The image from where to extract the images.
441 * \param feats The list of extracted features.
442 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
443 */
445 const mrpt::utils::CImage &img,
446 CFeatureList &feats,
447 unsigned int init_ID = 0,
448 unsigned int nDesiredFeatures = 0,
449 const TImageROI &ROI = TImageROI()) const;
450
451 // ------------------------------------------------------------------------------------
452 // FAST
453 // ------------------------------------------------------------------------------------
454 /** Extract features from the image based on the FAST method.
455 * \param img The image from where to extract the images.
456 * \param feats The list of extracted features.
457 * \param nDesiredFeatures Number of features to be extracted. Default: authomatic.
458 */
460 const mrpt::utils::CImage &img,
461 CFeatureList &feats,
462 unsigned int init_ID = 0,
463 unsigned int nDesiredFeatures = 0,
464 const TImageROI & ROI = TImageROI(),
465 const mrpt::math::CMatrixBool * mask= NULL) const;
466
467 /** Edward's "FASTER & Better" detector, N=9,10,12 */
469 const int N,
470 const mrpt::utils::CImage &img,
471 CFeatureList &feats,
472 unsigned int init_ID = 0,
473 unsigned int nDesiredFeatures = 0,
474 const TImageROI & ROI = TImageROI()) const;
475
476
477 // ------------------------------------------------------------------------------------
478 // my_scale_space_extrema
479 // ------------------------------------------------------------------------------------
480 /** Computes extrema in the scale space.
481 * \param dog_pyr Pyramid of images.
482 * \param octvs Number of considered octaves.
483 * \param intvls Number of intervales in octaves.
484 */
486 CFeatureList &featList, void* dog_pyr,
487 int octvs, int intvls, double contr_thr, int curv_thr,
488 void* storage ) const;
489
490 /** Adjust scale if the image was initially doubled.
491 * \param features The sequence of features.
492 */
493 void my_adjust_for_img_dbl( void* features ) const;
494
495 /** Gets the number of times that a point in the image is higher or lower than the surroundings in the image-scale space
496 * \param dog_pyr Pyramid of images.
497 * \param octvs Number of considered octaves.
498 * \param intvls Number of intervales in octaves.
499 * \param row The row of the feature in the original image.
500 * \param col The column of the feature in the original image.
501 * \param nMin [out]: Times that the feature is lower than the surroundings.
502 * \param nMax [out]: Times that the feature is higher than the surroundings.
503 */
504 void getTimesExtrema( void* dog_pyr, int octvs, int intvls, float row, float col, unsigned int &nMin, unsigned int &nMax ) const;
505
506 /** Computes the Laplacian value of the feature in the corresponing image in the pyramid.
507 * \param dog_pyr Pyramid of images.
508 * \param octvs Number of considered octaves.
509 * \param intvls Number of intervales in octaves.
510 * \param row The row of the feature in the original image.
511 * \param col The column of the feature in the original image.
512 */
513 double getLaplacianValue( void* dog_pyr, int octvs, int intvls, float row, float col ) const;
514
515 /** Append a sequence of openCV features into an MRPT feature list.
516 * \param features The sequence of features.
517 * \param list [in-out] The list of MRPT features.
518 * \param init_ID [in] The initial ID for the new features.
519 */
520 void insertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0 ) const;
521
522 /** Converts a sequence of openCV features into an MRPT feature list.
523 * \param features The sequence of features.
524 * \param list [in-out] The list of MRPT features.
525 * \param init_ID [in][optional] The initial ID for the features (default = 0).
526 * \param ROI [in][optional] The initial ID for the features (default = empty ROI -> not used).
527 */
528 void convertCvSeqInCFeatureList( void* features, CFeatureList &list, unsigned int init_ID = 0, const TImageROI &ROI = TImageROI() ) const;
529
530 }; // end of class
531 } // end of namespace
532} // end of namespace
533#endif
Declares a matrix of booleans (non serializable).
This class allows loading and storing values and vectors of different types from a configuration text...
A class for storing images as grayscale or RGB bitmaps.
Definition CImage.h:102
This is a virtual base class for sets of options than can be loaded from and/or saved to configuratio...
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition CStream.h:39
The central class from which images can be analyzed in search of different kinds of interest points a...
void extractFeaturesFAST(const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI(), const mrpt::math::CMatrixBool *mask=NULL) const
Extract features from the image based on the FAST method.
void extractFeaturesFASTER_N(const int N, const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Edward's "FASTER & Better" detector, N=9,10,12.
void internal_computeSiftDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute the SIFT descriptor of the provided features into the input image.
void computeDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &inout_features, TDescriptorType in_descriptor_list) const
Compute one (or more) descriptors for the given set of interest points onto the image,...
double getLaplacianValue(void *dog_pyr, int octvs, int intvls, float row, float col) const
Computes the Laplacian value of the feature in the corresponing image in the pyramid.
void internal_computeORBDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute the ORB descriptor of the provided features into the input image.
virtual ~CFeatureExtraction()
Virtual destructor.
void extractFeaturesORB(const mrpt::utils::CImage &img, CFeatureList &feats, const unsigned int init_ID=0, const unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the ORB method.
void extractFeaturesSIFT(const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the SIFT method.
void detectFeatures(const mrpt::utils::CImage &img, CFeatureList &feats, const unsigned int init_ID=0, const unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the method defined in TOptions.
void insertCvSeqInCFeatureList(void *features, CFeatureList &list, unsigned int init_ID=0) const
Append a sequence of openCV features into an MRPT feature list.
void getTimesExtrema(void *dog_pyr, int octvs, int intvls, float row, float col, unsigned int &nMin, unsigned int &nMax) const
Gets the number of times that a point in the image is higher or lower than the surroundings in the im...
void internal_computeLogPolarImageDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute a log-polar image descriptor of the provided features into the input image.
void extractFeaturesSURF(const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the SURF method.
void internal_computeSurfDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute the SURF descriptor of the provided features into the input image.
void * my_scale_space_extrema(CFeatureList &featList, void *dog_pyr, int octvs, int intvls, double contr_thr, int curv_thr, void *storage) const
Computes extrema in the scale space.
void my_adjust_for_img_dbl(void *features) const
Adjust scale if the image was initially doubled.
void convertCvSeqInCFeatureList(void *features, CFeatureList &list, unsigned int init_ID=0, const TImageROI &ROI=TImageROI()) const
Converts a sequence of openCV features into an MRPT feature list.
TOptions options
Set all the parameters of the desired method here before calling "detectFeatures".
void extractFeaturesKLT(const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the KLT method.
void internal_computePolarImageDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute a polar-image descriptor of the provided features into the input image.
void internal_computeSpinImageDescriptors(const mrpt::utils::CImage &in_img, CFeatureList &in_features) const
Compute the intensity-domain spin images descriptor of the provided features into the input image.
void extractFeaturesBCD(const mrpt::utils::CImage &img, CFeatureList &feats, unsigned int init_ID=0, unsigned int nDesiredFeatures=0, const TImageROI &ROI=TImageROI()) const
Extract features from the image based on the BCD method.
A list of visual features, to be used as output by detectors, as input/output by trackers,...
Definition CFeature.h:212
TDescriptorType
The bitwise OR combination of values of TDescriptorType are used in CFeatureExtraction::computeDescri...
TFeatureType
Types of features - This means that the point has been detected with this algorithm,...
static void detectFeatures_SSE2_FASTER9(const mrpt::utils::CImage &img, TSimpleFeatureList &corners, const int threshold=20, bool append_to_list=false, uint8_t octave=0, std::vector< size_t > *out_feats_index_by_row=NULL)
A SSE2-optimized implementation of FASTER-9 (requires img to be grayscale).
static void detectFeatures_SSE2_FASTER12(const mrpt::utils::CImage &img, TSimpleFeatureList &corners, const int threshold=20, bool append_to_list=false, uint8_t octave=0, std::vector< size_t > *out_feats_index_by_row=NULL)
Just like detectFeatures_SSE2_FASTER9() for another version of the detector.
static void detectFeatures_SSE2_FASTER10(const mrpt::utils::CImage &img, TSimpleFeatureList &corners, const int threshold=20, bool append_to_list=false, uint8_t octave=0, std::vector< size_t > *out_feats_index_by_row=NULL)
Just like detectFeatures_SSE2_FASTER9() for another version of the detector.
#define MRPT_OVERRIDE
C++11 "override" for virtuals:
Definition mrpt_macros.h:28
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
unsigned char uint8_t
Definition pstdint.h:143
float min_distance
(default=5) minimum distance between features (in pixels)
bool use_KLT_response
(default=false) If true, use CImage::KLT_response to compute the response at each point instead of th...
unsigned int num_angles
(default=16) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(r...
double rho_scale
(default=5) Log-Polar image patch will have dimensions WxH, with: W=num_angles, H= rho_scale * log(ra...
unsigned int radius
Maximum radius of the area of which the log polar image is built, in pixel units (default=30 pixels)
unsigned int bins_distance
Number of bins in the "distance" axis of the polar image (default=6).
unsigned int radius
Maximum radius of the area of which the polar image is built, in pixel units (default=20 pixels)
unsigned int bins_angle
Number of bins in the "angular" axis of the polar image (default=8).
TSIFTImplementation implementation
Default: Hess (OpenCV should be preferred, but its nonfree module is not always available by default ...
float std_intensity
Standard deviation in "intensity", used for the "soft histogram" (default=20 units [0,...
unsigned int radius
Maximum radius of the area of which the histogram is built, in pixel units (default=20 pixels)
unsigned int hist_size_distance
Number of bins in the "distance" axis of the 2D histogram (default=10).
float std_dist
Standard deviation in "distance", used for the "soft histogram" (default=0.4 pixels)
The set of parameters for all the detectors & descriptor algorithms.
void dumpToTextStream(mrpt::utils::CStream &out) const MRPT_OVERRIDE
This method should clearly display all the contents of the structure in textual form,...
TOptions(const TFeatureType featsType=featKLT)
Initalizer.
unsigned int patchSize
Size of the patch to extract, or 0 if no patch is desired (default=21).
void loadFromConfigFile(const mrpt::utils::CConfigFileBase &source, const std::string &section) MRPT_OVERRIDE
This method load the options from a ".ini"-like file or memory-stored string list.
bool addNewFeatures
Whether to add the found features to the input feature list or clear it before adding them (default=f...
bool useMask
Whether to use a mask for determining the regions where not to look for keypoints (default=false).
TFeatureType featsType
Type of the extracted features.
bool FIND_SUBPIXEL
Indicates if subpixel accuracy is desired for the extracted points (only applicable to KLT and Harris...
A structure for defining a ROI within an image.



Page generated by Doxygen 1.9.8 for MRPT 1.4.0 SVN: at Thu Dec 14 16:41:50 UTC 2023