CFeatureExtraction.h

Go to the documentation of this file.

/* +---------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)               |
   |                          http://www.mrpt.org/                             |
   |                                                                           |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file        |
   | See: http://www.mrpt.org/Authors - All rights reserved.                   |
   | Released under BSD License. See details in http://www.mrpt.org/License    |
   +---------------------------------------------------------------------------+
   */
#ifndef CFeatureExtraction_H
#define CFeatureExtraction_H

#include <mrpt/img/CImage.h>
#include <mrpt/system/CTicTac.h>
#include <mrpt/vision/utils.h>
#include <mrpt/vision/CFeature.h>
#include <mrpt/vision/TSimpleFeature.h>

namespace mrpt::vision
{
/** The central class from which images can be analyzed in search of different
  *kinds of interest points and descriptors computed for them.
  *  To extract features from an image, create an instance of
  *CFeatureExtraction,
  *   fill out its CFeatureExtraction::options field, including the algorithm to
  *use (see
  *   CFeatureExtraction::TOptions::featsType), and call
  *CFeatureExtraction::detectFeatures.
  *  This will return a set of features of the class mrpt::vision::CFeature,
  *which include
  *   details for each interest point as well as the desired descriptors and/or
  *patches.
  *
  *  By default, a 21x21 patch is extracted for each detected feature. If the
  *patch is not needed,
  *   set patchSize to 0 in CFeatureExtraction::options
  *
  *  The implemented <b>detection</b> algorithms are (see
  *CFeatureExtraction::TOptions::featsType):
  *     - KLT (Kanade-Lucas-Tomasi): A detector (no descriptor vector).
  *     - Harris: A detector (no descriptor vector).
  *     - BCD (Binary Corner Detector): A detector (no descriptor vector) (Not
  *implemented yet).
  *     - SIFT: An implementation of the SIFT detector and descriptor. The
  *implemention may be selected with
  *CFeatureExtraction::TOptions::SIFTOptions::implementation.
  *     - SURF: OpenCV's implementation of SURF detector and descriptor.
  *     - The FAST feature detector (OpenCV's implementation)
  *     - The FASTER (9,10,12) detectors (Edward Rosten's libcvd implementation
  *optimized for SSE2).
  *
  *  Additionally, given a list of interest points onto an image, the following
  *   <b>descriptors</b> can be computed for each point by calling
  *CFeatureExtraction::computeDescriptors :
  *     - SIFT descriptor (Lowe's descriptors).
  *     - SURF descriptor (OpenCV's implementation - Requires OpenCV 1.1.0 from
  *SVN
  *or later).
  *     - Intensity-domain spin images (SpinImage): Creates a vector descriptor
  *with the 2D histogram as a single row.
  *     - A circular patch in polar coordinates (Polar images): The matrix
  *descriptor is a 2D polar image centered at the interest point.
  *     - A log-polar image patch (Log-polar images): The matrix descriptor is
  *the
  *2D log-polar image centered at the interest point.
  *
  *
  *  Apart from the normal entry point \a detectFeatures(), these other
  *low-level static methods are provided for convenience:
  *   - CFeatureExtraction::detectFeatures_SSE2_FASTER9()
  *   - CFeatureExtraction::detectFeatures_SSE2_FASTER10()
  *   - CFeatureExtraction::detectFeatures_SSE2_FASTER12()
  *
  * \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.
  * \sa mrpt::vision::CFeature
  * \ingroup mrptvision_features
  */
class CFeatureExtraction
{
   public:
    enum TSIFTImplementation
    {
        LoweBinary = 0,
        CSBinary,
        VedaldiBinary,
        Hess,
        OpenCV
    };

    /** The set of parameters for all the detectors & descriptor algorithms */
    struct TOptions : public mrpt::config::CLoadableOptions
    {
        /** Initalizer */
        TOptions(const TFeatureType featsType = featKLT);

        void loadFromConfigFile(
            const mrpt::config::CConfigFileBase& source,
            const std::string& section) override;  // See base docs
        void dumpToTextStream(
            std::ostream& out) const override;  // See base docs

        /** Type of the extracted features
        */
        TFeatureType featsType;

        /** Size of the patch to extract, or 0 if no patch is desired
         * (default=21).
          */
        unsigned int patchSize;

        /** Whether to use a mask for determining the regions where not to look
         * for keypoints (default=false).
          */
        bool useMask;

        /** Whether to add the found features to the input feature list or clear
         * it before adding them (default=false).
          */
        bool addNewFeatures;

        /** Indicates if subpixel accuracy is desired for the extracted points
         * (only applicable to KLT and Harris features)
          */
        bool FIND_SUBPIXEL;

        /** KLT Options */
        struct TKLTOptions
        {
            int radius;  // size of the block of pixels used
            float threshold;  // (default=0.1) for rejecting weak local maxima
            // (with min_eig < threshold*max(eig_image))
            float min_distance;  // minimum distance between features
            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)
        } KLTOptions;

        /** Harris Options */
        struct THarrisOptions
        {
            float threshold;  // (default=0.005) for rejecting weak local maxima
            // (with min_eig < threshold*max(eig_image))
            float k;  // k factor for the Harris algorithm
            float sigma;  // standard deviation for the gaussian smoothing
            // function
            int radius;  // size of the block of pixels used
            float min_distance;  // minimum distance between features
            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)
        } harrisOptions;

        /** BCD Options */
        struct TBCDOptions
        {
        } BCDOptions;

        /** FAST and FASTER Options */
        struct TFASTOptions
        {
            int threshold;  //!< default= 20
            float min_distance;  //!< (default=5) minimum distance between
            //! features (in pixels)
            bool nonmax_suppression;  //!< Default = true
            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".
        } FASTOptions;

        /** ORB Options */
        struct TORBOptions
        {
            TORBOptions()
                : n_levels(8),
                  min_distance(0),
                  scale_factor(1.2f),
                  extract_patch(false)
            {
            }

            size_t n_levels;
            size_t min_distance;
            float scale_factor;
            bool extract_patch;
        } ORBOptions;

        /** SIFT Options  */
        struct TSIFTOptions
        {
            TSIFTOptions() : threshold(0.04), edgeThreshold(10) {}
            TSIFTImplementation implementation;  //!< Default: Hess (OpenCV
            //! should be preferred, but its
            //! nonfree module is not always
            //! available by default in all
            //! systems)
            double threshold;  //!< default= 0.04
            double edgeThreshold;  //!< default= 10
        } SIFTOptions;

        struct TSURFOptions
        {
            TSURFOptions()
                : rotation_invariant(true),
                  hessianThreshold(600),
                  nOctaves(2),
                  nLayersPerOctave(4)
            {
            }

            /** SURF Options
              */
            bool rotation_invariant;  //!< Compute the rotation invariant SURF
            //!(dim=128) if set to true (default), or
            //! the smaller uSURF otherwise (dim=64)
            int hessianThreshold;  //!< Default: 600
            int nOctaves;  //!< Default: 2
            int nLayersPerOctave;  //!< Default: 4
        } SURFOptions;

        struct TSpinImagesOptions
        {
            /** SpinImages Options
              */
            unsigned int hist_size_intensity;  //!< Number of bins in the
            //!"intensity" axis of the 2D
            //! histogram (default=10).
            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)
            float std_intensity;  //!< Standard deviation in "intensity", used
            //! for the "soft histogram" (default=20 units
            //![0,255])
            unsigned int radius;  //!< Maximum radius of the area of which the
            //! histogram is built, in pixel units
            //!(default=20 pixels)
        } SpinImagesOptions;

        /** PolarImagesOptions Options
          */
        struct TPolarImagesOptions
        {
            unsigned int bins_angle;  //!< Number of bins in the "angular" axis
            //! of the polar image (default=8).
            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)
        } PolarImagesOptions;

        /** LogPolarImagesOptions Options
          */
        struct TLogPolarImagesOptions
        {
            unsigned int radius;  //!< Maximum radius of the area of which the
            //! log polar image is built, in pixel units
            //!(default=30 pixels)
            unsigned int num_angles;  //!< (default=16) Log-Polar image patch
            //! will have dimensions WxH, with:
            //! W=num_angles,  H= rho_scale *
            //! log(radius)
            double rho_scale;  //!< (default=5) Log-Polar image patch will have
            //! dimensions WxH, with:  W=num_angles,  H=
            //! rho_scale * log(radius)
        } LogPolarImagesOptions;

        // # added by Raghavender Sahdev
        /** AKAZEOptions Options
         */
        struct TAKAZEOptions
        {
            int descriptor_type;
            int descriptor_size;
            int descriptor_channels;
            float threshold;
            int nOctaves;
            int nOctaveLayers;
            int diffusivity;
        } AKAZEOptions;

        /** LSDOptions Options
         */
        struct TLSDOptions
        {
            int scale;
            int nOctaves;
        } LSDOptions;

        /** BLDOptions Descriptor Options
         */
        struct TBLDOptions
        {
            int ksize_;
            int reductionRatio;
            int widthOfBand;
            int numOfOctave;

        } BLDOptions;

        /** LATCHOptions Descriptor
         */
        struct TLATCHOptions
        {
            int bytes;  // = 32,
            bool rotationInvariance;  // = true,
            int half_ssd_size;  // = 3
        } LATCHOptions;
    };

    TOptions options;  //!< Set all the parameters of the desired method here
    //! before calling "detectFeatures"

    /** Virtual destructor.
    */
    virtual ~CFeatureExtraction();

    /** Extract features from the image based on the method defined in TOptions.
    * \param img (input) The image from where to extract the images.
    * \param feats (output) A complete list of features (containing a patch for
    * each one of them if options.patchsize > 0).
    * \param nDesiredFeatures (op. input) Number of features to be extracted.
    * Default: all possible.
    *
    * \sa computeDescriptors
    */
    void detectFeatures(
        const mrpt::img::CImage& img, CFeatureList& feats,
        const unsigned int init_ID = 0, const unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    /** 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
    * \param in_img (input) The image from where to compute the descriptors.
    * \param inout_features (input/output) The list of features whose
    * descriptors are going to be computed.
    * \param in_descriptor_list (input) The bitwise OR of one or several
    * descriptors defined in TDescriptorType.
    *
    *  Each value in "in_descriptor_list" represents one descriptor to be
    * computed, for example:
    *  \code
    *    // This call will compute both, SIFT and Spin-Image descriptors for a
    * list of feature points lstFeats.
    *    fext.computeDescriptors(img, lstFeats, descSIFT | descSpinImages );
    *  \endcode
    *
    * \note The SIFT descriptors for already located features can only be
    * computed through the Hess and
    *        CSBinary implementations which may be specified in
    * CFeatureExtraction::TOptions::SIFTOptions.
    *
    * \note This call will also use additional parameters from \a options
    */
    void computeDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& inout_features,
        TDescriptorType in_descriptor_list) const;

#if 0  // Delete? see comments in .cpp
            /** Extract more features from the image (apart from the provided ones) based on the method defined in TOptions.
            * \param img (input) The image from where to extract the images.
            * \param inList (input) The actual features in the image.
            * \param outList (output) The list of new features (containing a patch for each one of them if options.patchsize > 0).
            * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
            *
            *  \sa The more powerful class: mrpt::vision::CGenericFeatureTracker
            */
            void  findMoreFeatures( const mrpt::img::CImage &img,
                                    const CFeatureList &inList,
                                    CFeatureList &outList,
                                    unsigned int nDesiredFeats = 0) const;
#endif

    /** @name Static methods with low-level detector functionality
        @{ */

    /** 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.
      *
      *  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>.
      *  Note that (x,y) are already scaled to the 0-level image coordinates if
     * octave>0, by means of:
      *
      *  \code
      *    pt.x = detected.x << octave;
      *    pt.y = detected.y << octave;
      *  \endcode
      *
      * If \a append_to_list is true, the \a corners list is not cleared before
     * adding the newly detected feats.
      *
      * If a valid pointer is provided for \a out_feats_index_by_row, upon
     * return you will find a vector with
      *  as many entries as rows in the image (the real number of rows,
     * disregarding the value of \a octave).
      * The number in each entry is the 0-based index (in \a corners) of
      *  the first feature that falls in that line of the image. This index can
     * be used to fasten looking for correspondences.
      *
      * \ingroup mrptvision_features
      */
    static void detectFeatures_SSE2_FASTER9(
        const mrpt::img::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 = nullptr);

    /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the
     * detector.
      * \ingroup mrptvision_features */
    static void detectFeatures_SSE2_FASTER10(
        const mrpt::img::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 = nullptr);

    /** Just like \a detectFeatures_SSE2_FASTER9() for another version of the
     * detector.
      * \ingroup mrptvision_features */
    static void detectFeatures_SSE2_FASTER12(
        const mrpt::img::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 = nullptr);

    /** @} */

   private:
    /** Compute the SIFT descriptor of the provided features into the input
    image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    are going to be computed.
    *
    * \note The SIFT descriptors for already located features can only be
    computed through the Hess and
            CSBinary implementations which may be specified in
    CFeatureExtraction::TOptions::SIFTOptions.
    */
    void internal_computeSiftDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

    /** Compute the SURF descriptor of the provided features into the input
    * image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    */
    void internal_computeSurfDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

    /** Compute the ORB descriptor of the provided features into the input image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    */
    void internal_computeORBDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

    /** Compute the intensity-domain spin images descriptor of the provided
    * features into the input image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    *
    * \note Additional parameters from
    * CFeatureExtraction::TOptions::SpinImagesOptions are used in this method.
    */
    void internal_computeSpinImageDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

    /** Compute a polar-image descriptor of the provided features into the input
    * image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    *
    * \note Additional parameters from
    * CFeatureExtraction::TOptions::PolarImagesOptions are used in this method.
    */
    void internal_computePolarImageDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

    /** Compute a log-polar image descriptor of the provided features into the
    * input image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    *
    * \note Additional parameters from
    * CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this
    * method.
    */
    void internal_computeLogPolarImageDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;
    /** Compute a BLD descriptor of the provided features into the input image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    *
    * \note Additional parameters from
    * CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this
    * method.
    */
    void internal_computeBLDLineDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;
    /** Compute a LATCH descriptor of the provided features into the input image
    * \param in_img (input) The image from where to compute the descriptors.
    * \param in_features (input/output) The list of features whose descriptors
    * are going to be computed.
    *
    * \note Additional parameters from
    * CFeatureExtraction::TOptions::LogPolarImagesOptions are used in this
    * method.
    */
    void internal_computeLATCHDescriptors(
        const mrpt::img::CImage& in_img, CFeatureList& in_features) const;

#if 0  // Delete? see comments in .cpp
            /** Select good features using the openCV implementation of the KLT method.
            * \param img (input) The image from where to select extract the images.
            * \param feats (output) A complete list of features (containing a patch for each one of them if options.patchsize > 0).
            * \param nDesiredFeatures (op. input) Number of features to be extracted. Default: all possible.
            */
            void  selectGoodFeaturesKLT(
                const mrpt::img::CImage &inImg,
                CFeatureList        &feats,
                unsigned int        init_ID = 0,
                unsigned int        nDesiredFeatures = 0) const;
#endif

    /** Extract features from the image based on the KLT method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesKLT(
        const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                                          BCD
    // ------------------------------------------------------------------------------------
    /** Extract features from the image based on the BCD method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    * \param ROI (op. input) Region of Interest. Default: All the image.
    */
    void extractFeaturesBCD(
        const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                                          SIFT
    // ------------------------------------------------------------------------------------
    /** Extract features from the image based on the SIFT method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    * \param ROI (op. input) Region of Interest. Default: All the image.
    */
    void extractFeaturesSIFT(
        const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                                          ORB
    // ------------------------------------------------------------------------------------
    /** Extract features from the image based on the ORB method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesORB(
        const mrpt::img::CImage& img, CFeatureList& feats,
        const unsigned int init_ID = 0, const unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                                          SURF
    // ------------------------------------------------------------------------------------
    /** Extract features from the image based on the SURF method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesSURF(
        const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                                          FAST
    // ------------------------------------------------------------------------------------
    /** Extract features from the image based on the FAST method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesFAST(
        const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI(),
        const mrpt::math::CMatrixBool* mask = nullptr) const;

    /** Edward's "FASTER & Better" detector, N=9,10,12 */
    void extractFeaturesFASTER_N(
        const int N, const mrpt::img::CImage& img, CFeatureList& feats,
        unsigned int init_ID = 0, unsigned int nDesiredFeatures = 0,
        const TImageROI& ROI = TImageROI()) const;

    // # added by Raghavender Sahdev
    //-------------------------------------------------------------------------------------
    //                               AKAZE
    //-------------------------------------------------------------------------------------
    /** Extract features from the image based on the AKAZE method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesAKAZE(
        const mrpt::img::CImage& inImg, CFeatureList& feats,
        unsigned int init_ID, unsigned int nDesiredFeatures,
        const TImageROI& ROI = TImageROI()) const;

    //-------------------------------------------------------------------------------------
    //                               LSD
    //-------------------------------------------------------------------------------------
    /** Extract features from the image based on the LSD method.
    * \param img The image from where to extract the images.
    * \param feats The list of extracted features.
    * \param nDesiredFeatures Number of features to be extracted. Default:
    * authomatic.
    */
    void extractFeaturesLSD(
        const mrpt::img::CImage& inImg, CFeatureList& feats,
        unsigned int init_ID, unsigned int nDesiredFeatures,
        const TImageROI& ROI = TImageROI()) const;

    // ------------------------------------------------------------------------------------
    //                              my_scale_space_extrema
    // ------------------------------------------------------------------------------------
    /** Computes extrema in the scale space.
    * \param dog_pyr Pyramid of images.
    * \param octvs Number of considered octaves.
    * \param intvls Number of intervales in octaves.
    */
    void* my_scale_space_extrema(
        CFeatureList& featList, void* dog_pyr, int octvs, int intvls,
        double contr_thr, int curv_thr, void* storage) const;

    /** Adjust scale if the image was initially doubled.
    * \param features The sequence of features.
    */
    void my_adjust_for_img_dbl(void* features) const;

    /** Gets the number of times that a point in the image is higher or lower
    * than the surroundings in the image-scale space
    * \param dog_pyr Pyramid of images.
    * \param octvs Number of considered octaves.
    * \param intvls Number of intervales in octaves.
    * \param row The row of the feature in the original image.
    * \param col The column of the feature in the original image.
    * \param nMin [out]: Times that the feature is lower than the surroundings.
    * \param nMax [out]: Times that the feature is higher than the surroundings.
    */
    void getTimesExtrema(
        void* dog_pyr, int octvs, int intvls, float row, float col,
        unsigned int& nMin, unsigned int& nMax) const;

    /** Computes the Laplacian value of the feature in the corresponing image in
    * the pyramid.
    * \param dog_pyr Pyramid of images.
    * \param octvs Number of considered octaves.
    * \param intvls Number of intervales in octaves.
    * \param row The row of the feature in the original image.
    * \param col The column of the feature in the original image.
    */
    double getLaplacianValue(
        void* dog_pyr, int octvs, int intvls, float row, float col) const;

    /** Append a sequence of openCV features into an MRPT feature list.
    * \param features The sequence of features.
    * \param list [in-out] The list of MRPT features.
    * \param init_ID [in] The initial ID for the new features.
    */
    void insertCvSeqInCFeatureList(
        void* features, CFeatureList& list, unsigned int init_ID = 0) const;

    /** Converts a sequence of openCV features into an MRPT feature list.
    * \param features The sequence of features.
    * \param list [in-out] The list of MRPT features.
    * \param init_ID [in][optional] The initial ID for the features (default =
    * 0).
    * \param ROI [in][optional] The initial ID for the features (default = empty
    * ROI -> not used).
    */
    void convertCvSeqInCFeatureList(
        void* features, CFeatureList& list, unsigned int init_ID = 0,
        const TImageROI& ROI = TImageROI()) const;

};  // end of class
}
#endif