vision/include/mrpt/vision/types.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2020, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */
#pragma once

#include <mrpt/config/CLoadableOptions.h>
#include <mrpt/img/CImage.h>
#include <mrpt/math/TPoint3D.h>
#include <mrpt/tfest/TMatchingPair.h>
#include <mrpt/typemeta/TEnumType.h>
#include <map>
#include <vector>

namespace mrpt::vision
{
/** \addtogroup mrpt_vision_grp
 *  @{ */
/** Definition of a feature ID */
using TFeatureID = uint64_t;

/** Unique IDs for landmarks */
using TLandmarkID = uint64_t;
/** Unique IDs for camera frames (poses) */
using TCameraPoseID = uint64_t;

/** A list of camera frames (6D poses) indexed by unique IDs. */
using TFramePosesMap = std::map<TCameraPoseID, mrpt::poses::CPose3D>;
/** A list of camera frames (6D poses), which assumes indexes are unique,
 * consecutive IDs. */
using TFramePosesVec = std::vector<mrpt::poses::CPose3D>;

/** A list of landmarks (3D points) indexed by unique IDs. */
using TLandmarkLocationsMap = std::map<TLandmarkID, mrpt::math::TPoint3D>;
/** A list of landmarks (3D points), which assumes indexes are unique,
 * consecutive IDs. */
using TLandmarkLocationsVec = std::vector<mrpt::math::TPoint3D>;

/** Types of key point detectors */
enum TKeyPointMethod : int8_t
{
    /** Non-defined feature (also used for Occupancy features) */
    featNotDefined = -1,
    /** Kanade-Lucas-Tomasi feature [SHI'94] */
    featKLT = 0,
    /** Harris border and corner detector [HARRIS] */
    featHarris = 1,
    /* featBCD = 2, ==> deprecated in MRPT 2.0 */
    /** Scale Invariant Feature Transform [LOWE'04] */
    featSIFT = 3,
    /** Speeded Up Robust Feature [BAY'06] */
    featSURF = 4,
    /** A especial case: this is not an image feature, but a 2D/3D beacon (used
       for range-only SLAM from mrpt::maps::CLandmark) */
    featBeacon = 5,
    /** FAST feature detector, OpenCV's implementation ("Faster and better: A
       machine learning approach to corner detection", E. Rosten, R. Porter and
       T. Drummond, PAMI, 2009). */
    featFAST = 6,
    /** ORB detector and descriptor, OpenCV's implementation */
    featORB = 10,
    // #added by Raghavender Sahdev
    featAKAZE = 11,  //!< AKAZE detector, OpenCV's implementation
    featLSD = 12  //!< LSD detector, OpenCV's implementation
    // Remember: If new values are added, also update MRPT_FILL_ENUM below!
};

/** The bitwise OR combination of values of TDescriptorType are used in
 * CFeatureExtraction::computeDescriptors to indicate which descriptors are to
 * be computed for features.
 */
enum TDescriptorType : uint16_t
{
    /** Used in some methods to mean "any of the present descriptors" */
    descAny = 0,
    /** SIFT descriptors */
    descSIFT = 1,
    /** SURF descriptors */
    descSURF = 2,
    /** Intensity-domain spin image descriptors */
    descSpinImages = 4,
    /** Polar image descriptor */
    descPolarImages = 8,
    /** Log-Polar image descriptor */
    descLogPolarImages = 16,
    /** Bit-based feature descriptor */
    descORB = 32,
    descBLD = 64,  //!< BLD Line descriptor
    descLATCH = 128  //!< LATCH Line descriptor
    // Remember: If new values are added, also update MRPT_FILL_ENUM below!
};

enum TFeatureTrackStatus : uint8_t
{
    // Init value
    /** Inactive (right after detection, and before being tried to track) */
    status_IDLE = 0,

    // Ok:
    /** Feature correctly tracked */
    status_TRACKED = 5,

    // Bad:
    /** Feature fell Out Of Bounds (out of the image limits, too close to image
       borders) */
    status_OOB = 1,
    /** Unable to track this feature (mismatch is too high for the given
       tracking window: lack of texture? oclussion?) */
    status_LOST = 10
};

/** One feature observation entry, used within sequences with
 * TSequenceFeatureObservations */
struct TFeatureObservation
{
    inline TFeatureObservation() = default;
    inline TFeatureObservation(
        const TLandmarkID _id_feature, const TCameraPoseID _id_frame,
        const mrpt::img::TPixelCoordf& _px)
        : id_feature(_id_feature), id_frame(_id_frame), px(_px)
    {
    }

    /** A unique ID of this feature */
    TLandmarkID id_feature;
    /** A unique ID of a "frame" (camera position) from where the feature was
     * observed. */
    TCameraPoseID id_frame;
    /** The pixel coordinates of the observed feature */
    mrpt::img::TPixelCoordf px;
};

/** One relative feature observation entry, used with some relative
 * bundle-adjustment functions.
 */
struct TRelativeFeaturePos
{
    inline TRelativeFeaturePos() = default;
    inline TRelativeFeaturePos(
        const mrpt::vision::TCameraPoseID _id_frame_base,
        const mrpt::math::TPoint3D& _pos)
        : id_frame_base(_id_frame_base), pos(_pos)
    {
    }

    /** The ID of the camera frame which is the coordinate reference of \a pos
     */
    mrpt::vision::TCameraPoseID id_frame_base;
    /** The (x,y,z) location of the feature, wrt to the camera frame \a
     * id_frame_base */
    mrpt::math::TPoint3D pos;
};

/** An index of feature IDs and their relative locations */
using TRelativeFeaturePosMap =
    std::map<mrpt::vision::TFeatureID, TRelativeFeaturePos>;

/** A complete sequence of observations of features from different camera frames
 * (poses).
 *  This structure is the input to some (Bundle-adjustment) methods in
 * mrpt::vision
 *  \note Pixel coordinates can be either "raw" or "undistorted". Read the doc
 * of functions handling this structure to see what they expect.
 *  \sa mrpt::vision::bundle_adj_full
 */
struct TSequenceFeatureObservations : public std::vector<TFeatureObservation>
{
    using BASE = std::vector<TFeatureObservation>;

    inline TSequenceFeatureObservations() = default;
    inline TSequenceFeatureObservations(size_t size) : BASE(size) {}
    inline TSequenceFeatureObservations(const TSequenceFeatureObservations& o)

        = default;

    /** Saves all entries to a text file, with each line having this format:
     * #FRAME_ID  #FEAT_ID  #PIXEL_X  #PIXEL_Y
     * The file is self-descripting, since the first line contains a comment
     * line (starting with '%') explaining the format.
     * Generated files can be loaded from MATLAB.
     * \sa loadFromTextFile \exception std::exception On I/O error  */
    void saveToTextFile(
        const std::string& filName, bool skipFirstCommentLine = false) const;

    /** Load from a text file, in the format described in \a saveToTextFile
     * \exception std::exception On I/O or format error */
    void loadFromTextFile(const std::string& filName);

    /** Save the list of observations + the point locations + the camera frame
     * poses to a pair of files in the format
     *  used by the Sparse Bundle Adjustment (SBA) C++ library.
     *
     *  Point file lines: X Y Z  nframes  frame0 x0 y0  frame1 x1 y1 ...
     *
     *  Camera file lines: qr qx qy qz x y z  (Pose as a quaternion)
     * \return false on any error
     */
    bool saveAsSBAFiles(
        const TLandmarkLocationsVec& pts, const std::string& pts_file,
        const TFramePosesVec& cams, const std::string& cams_file) const;

    /** Remove all those features that don't have a minimum number of
     * observations from different camera frame IDs.
     * \return the number of erased entries.
     * \sa After calling this you may want to call \a compressIDs */
    size_t removeFewObservedFeatures(size_t minNumObservations = 3);

    /** Remove all but one out of \a decimate_ratio camera frame IDs from the
     * list (eg: from N camera pose IDs at return there will be just
     * N/decimate_ratio)
     * The algorithm first builds a sorted list of frame IDs, then keep the
     * lowest ID, remove the next "decimate_ratio-1", and so on.
     * \sa After calling this you may want to call \a compressIDs */
    void decimateCameraFrames(const size_t decimate_ratio);

    /** Rearrange frame and feature IDs such as they start at 0 and there are no
     * gaps.
     * \param old2new_camIDs If provided, the mapping from old to new IDs is
     * stored here.
     * \param old2new_lmIDs If provided, the mapping from old to new IDs is
     * stored here. */
    void compressIDs(
        std::map<TCameraPoseID, TCameraPoseID>* old2new_camIDs = nullptr,
        std::map<TLandmarkID, TLandmarkID>* old2new_lmIDs = nullptr);
};

/** Parameters associated to a stereo system
 */
struct TStereoSystemParams : public mrpt::config::CLoadableOptions
{
    /** Initilization of default parameters */
    TStereoSystemParams();

    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

    /** Method for propagating the feature's image coordinate uncertainty into
     * 3D space. Default value: Prop_Linear
     */
    enum TUnc_Prop_Method
    {
        /** Linear propagation of the uncertainty
         */
        Prop_Linear = -1,
        /** Uncertainty propagation through the Unscented Transformation
         */
        Prop_UT,
        /** Uncertainty propagation through the Scaled Unscented Transformation
         */
        Prop_SUT
    };

    TUnc_Prop_Method uncPropagation{Prop_Linear};

    /** Stereo Fundamental matrix */
    mrpt::math::CMatrixDouble33 F;

    /** Intrinsic parameters
     */
    mrpt::math::CMatrixDouble33 K;
    /** Baseline. Default value: baseline = 0.119f; [Bumblebee]
     */
    float baseline{0.119f};
    /** Standard deviation of the error in feature detection. Default value:
     * stdPixel = 1
     */
    float stdPixel{1};
    /** Standard deviation of the error in disparity computation. Default value:
     * stdDisp = 1
     */
    float stdDisp{1};
    /** Maximum allowed distance. Default value: maxZ = 20.0f
     */
    float maxZ{20.0f};
    /** Maximum allowed distance. Default value: minZ = 0.5f
     */
    float minZ{0.5f};
    /** Maximum allowed height. Default value: maxY = 3.0f
     */
    float maxY{3.0f};
    /** K factor for the UT. Default value: k = 1.5f
     */
    float factor_k{1.5f};
    /** Alpha factor for SUT. Default value: a = 1e-3
     */
    float factor_a{1e-3f};
    /** Beta factor for the SUT. Default value: b = 2.0f
     */
    float factor_b{2.0f};

    /** Parameters initialization
     */
    // TStereoSystemParams();

};  // End struct TStereoSystemParams

/** A structure for storing a 3D ROI
 */
struct TROI
{
    // Constructors
    TROI() = default;
    TROI(float x1, float x2, float y1, float y2, float z1, float z2)
        : xMin(x1), xMax(x2), yMin(y1), yMax(y2), zMin(z1), zMax(z2)
    {
    }

    // Members
    float xMin{0};
    float xMax{0};
    float yMin{0};
    float yMax{0};
    float zMin{0};
    float zMax{0};
};  // end struct TROI

/** A structure for defining a ROI within an image
 */
struct TImageROI
{
    // Constructors
    TImageROI() = default;
    TImageROI(size_t x1, size_t x2, size_t y1, size_t y2)
        : xMin(x1), xMax(x2), yMin(y1), yMax(y2)
    {
    }

    /** X coordinate limits [0,imageWidth) */
    size_t xMin{0}, xMax{0};
    /** Y coordinate limits [0,imageHeight) */
    size_t yMin{0}, yMax{0};
};

/** A structure containing options for the matching
 */
struct TMatchingOptions : public mrpt::config::CLoadableOptions
{
    /** Method for propagating the feature's image coordinate uncertainty into
     * 3D space. Default value: Prop_Linear
     */
    enum TMatchingMethod
    {
        /** Matching by cross correlation of the image patches
         */
        mmCorrelation = 0,
        /** Matching by Euclidean distance between SIFT descriptors
         */
        mmDescriptorSIFT,
        /** Matching by Euclidean distance between SURF descriptors
         */
        mmDescriptorSURF,
        /** Matching by sum of absolute differences of the image patches
         */
        mmSAD,
        /** Matching by Hamming distance between ORB descriptors
         */
        mmDescriptorORB
    };

    // For determining
    /** Whether or not take into account the epipolar restriction for finding
     * correspondences */
    bool useEpipolarRestriction{true};
    /** Whether or not there is a fundamental matrix */
    bool hasFundamentalMatrix{false};
    /** Whether or not the stereo rig has the optical axes parallel */
    bool parallelOpticalAxis{true};
    /** Whether or not employ the x-coord restriction for finding
     * correspondences (bumblebee camera, for example) */
    bool useXRestriction{true};
    /** Whether or not to add the matches found into the input matched list (if
     * false the input list will be cleared before being filled with the new
     * matches) */
    bool addMatches{false};
    /** Whether or not use limits (min,max) for the disparity, see also
     * 'min_disp, max_disp' */
    bool useDisparityLimits{false};
    /** Whether or not only permit matches that are consistent from left->right
     * and right->left */
    bool enable_robust_1to1_match;

    /** Disparity limits, see also 'useDisparityLimits' */
    float min_disp{1.0f}, max_disp{1e4f};

    mrpt::math::CMatrixDouble33 F;

    // General
    /** Matching method */
    TMatchingMethod matching_method{mmCorrelation};
    /** Epipolar constraint (rows of pixels) */
    float epipolar_TH{1.5f};

    // SIFT
    /** Maximum Euclidean Distance Between SIFT Descriptors */
    float maxEDD_TH{90.0f};
    /** Boundary Ratio between the two lowest EDD */
    float EDD_RATIO{0.6f};

    // KLT
    /** Minimum Value of the Cross Correlation */
    float minCC_TH{0.95f};
    /** Minimum Difference Between the Maximum Cross Correlation Values */
    float minDCC_TH{0.025f};
    /** Maximum Ratio Between the two highest CC values */
    float rCC_TH{0.92f};

    // SURF
    /** Maximum Euclidean Distance Between SURF Descriptors */
    float maxEDSD_TH{0.15f};
    /** Boundary Ratio between the two lowest SURF EDSD */
    float EDSD_RATIO{0.6f};

    // SAD
    /** Minimum Euclidean Distance Between Sum of Absolute Differences */
    double maxSAD_TH{0.4};
    /** Boundary Ratio between the two highest SAD */
    double SAD_RATIO{0.5};

    // ORB
    /** Maximun distance between ORB descriptors */
    double maxORB_dist;

    //          // To estimate depth
    /** Whether or not estimate the 3D position of the real features for the
     * matches (only with parallelOpticalAxis by now). */
    bool estimateDepth{false};
    /** The maximum allowed depth for the matching. If its computed depth is
     * larger than this, the match won't be considered. */
    double maxDepthThreshold{15.0};
    /** Intrinsic parameters of the stereo rig */
    //            double  fx,cx,cy,baseline;

    /** Constructor */
    TMatchingOptions();

    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

#define COPY_MEMBER(_m) this->_m = o._m;
#define CHECK_MEMBER(_m) this->_m == o._m

    bool operator==(const TMatchingOptions& o) const
    {
        return CHECK_MEMBER(useXRestriction) &&
               CHECK_MEMBER(useDisparityLimits) &&
               CHECK_MEMBER(useEpipolarRestriction) &&
               CHECK_MEMBER(addMatches) && CHECK_MEMBER(EDD_RATIO) &&
               CHECK_MEMBER(EDSD_RATIO) &&
               CHECK_MEMBER(enable_robust_1to1_match) &&
               CHECK_MEMBER(epipolar_TH) && CHECK_MEMBER(estimateDepth) &&
               CHECK_MEMBER(F) && CHECK_MEMBER(hasFundamentalMatrix) &&
               CHECK_MEMBER(matching_method) &&
               CHECK_MEMBER(maxDepthThreshold) && CHECK_MEMBER(maxEDD_TH) &&
               CHECK_MEMBER(maxEDSD_TH) && CHECK_MEMBER(maxORB_dist) &&
               CHECK_MEMBER(maxSAD_TH) && CHECK_MEMBER(max_disp) &&
               CHECK_MEMBER(minCC_TH) && CHECK_MEMBER(minDCC_TH) &&
               CHECK_MEMBER(min_disp) && CHECK_MEMBER(parallelOpticalAxis) &&
               CHECK_MEMBER(rCC_TH) && CHECK_MEMBER(SAD_RATIO);
    }

    void operator=(const TMatchingOptions& o)
    {
        COPY_MEMBER(useXRestriction)
        COPY_MEMBER(useDisparityLimits)
        COPY_MEMBER(useEpipolarRestriction)
        COPY_MEMBER(addMatches)
        COPY_MEMBER(EDD_RATIO)
        COPY_MEMBER(EDSD_RATIO)
        COPY_MEMBER(enable_robust_1to1_match)
        COPY_MEMBER(epipolar_TH)
        COPY_MEMBER(estimateDepth)
        COPY_MEMBER(F)
        COPY_MEMBER(hasFundamentalMatrix)
        COPY_MEMBER(matching_method)
        COPY_MEMBER(maxDepthThreshold)
        COPY_MEMBER(maxEDD_TH)
        COPY_MEMBER(maxEDSD_TH)
        COPY_MEMBER(maxORB_dist)
        COPY_MEMBER(maxSAD_TH)
        COPY_MEMBER(max_disp)
        COPY_MEMBER(minCC_TH)
        COPY_MEMBER(minDCC_TH)
        COPY_MEMBER(min_disp)
        COPY_MEMBER(parallelOpticalAxis)
        COPY_MEMBER(rCC_TH)
        COPY_MEMBER(SAD_RATIO)
    }

};  // end struct TMatchingOptions

/** Struct containing the output after matching multi-resolution SIFT-like
 * descriptors
 */
struct TMultiResMatchingOutput
{
    int nMatches{0};

    /** Contains the indexes within the second list corresponding to the first
     * one. */
    std::vector<int> firstListCorrespondences;
    /** Contains the indexes within the first list corresponding to the second
     * one. */
    std::vector<int> secondListCorrespondences;
    /** Contains the scales of the first list where the correspondence was
     * found. */
    std::vector<int> firstListFoundScales;
    /** Contains the distances between the descriptors. */
    std::vector<double> firstListDistance;

    TMultiResMatchingOutput() = default;

};  // end struct TMultiResMatchingOutput

/** Struct containing the options when matching multi-resolution SIFT-like
 * descriptors
 */
struct TMultiResDescMatchOptions : public mrpt::config::CLoadableOptions
{
    /** Whether or not use the filter based on orientation test */
    bool useOriFilter{true};
    /** The threshold for the orientation test */
    double oriThreshold{0.2};

    /** Whether or not use the filter based on the depth test */
    bool useDepthFilter{true};

    /** The absolute threshold in descriptor distance for considering a match */
    double matchingThreshold{1e4};
    /** The ratio between the two lowest distances threshold for considering a
     * match */
    double matchingRatioThreshold{0.5};
    /** The lowest scales in the two features to be taken into account in the
     * matching process */
    uint32_t lowScl1{0}, lowScl2{0};
    /** The highest scales in the two features to be taken into account in the
     * matching process */
    uint32_t highScl1{6}, highScl2{6};

    /** Size of the squared area where to search for a match. */
    uint32_t searchAreaSize{20};
    /** The allowed number of frames since a certain feature was seen for the
     * last time. */
    uint32_t lastSeenThreshold{10};
    /** The minimum number of frames for a certain feature to be considered
     * stable. */
    uint32_t timesSeenThreshold{5};

    /** The minimum number of features allowed in the system. If current number
     * is below this value, more features will be found. */
    uint32_t minFeaturesToFind{30};
    /** The minimum number of features allowed in the system to not be
     * considered to be lost. */
    uint32_t minFeaturesToBeLost{5};

    /** Default constructor
     */
    TMultiResDescMatchOptions() = default;

    TMultiResDescMatchOptions(
        bool _useOriFilter, double _oriThreshold, bool _useDepthFilter,
        double _th, double _th2, const unsigned int& _lwscl1,
        const unsigned int& _lwscl2, const unsigned int& _hwscl1,
        const unsigned int& _hwscl2, int _searchAreaSize, int _lsth, int _tsth,
        int _minFeaturesToFind, int _minFeaturesToBeLost)
        : useOriFilter(_useOriFilter),
          oriThreshold(_oriThreshold),
          useDepthFilter(_useDepthFilter),
          matchingThreshold(_th),
          matchingRatioThreshold(_th2),
          lowScl1(_lwscl1),
          lowScl2(_lwscl2),
          highScl1(_hwscl1),
          highScl2(_hwscl2),
          searchAreaSize(_searchAreaSize),
          lastSeenThreshold(_lsth),
          timesSeenThreshold(_tsth),
          minFeaturesToFind(_minFeaturesToFind),
          minFeaturesToBeLost(_minFeaturesToBeLost)
    {
    }

    void loadFromConfigFile(
        const mrpt::config::CConfigFileBase& cfg,
        const std::string& section) override;
    void saveToConfigFile(
        mrpt::config::CConfigFileBase& cfg,
        const std::string& section) const override;
    void dumpToTextStream(std::ostream& out) const override;

};  // end TMultiResDescMatchOptions

/** Struct containing the options when computing the multi-resolution SIFT-like
 * descriptors
 */
struct TMultiResDescOptions : public mrpt::config::CLoadableOptions
{
    /** The size of the base patch */
    uint32_t basePSize{23};
    /** The set of scales relatives to the base patch */
    std::vector<double> scales;
    /** The subset of scales for which to compute the descriptors */
    uint32_t comLScl, comHScl;
    /** The sigmas for the Gaussian kernels */
    double sg1{0.5}, sg2{7.5}, sg3{8.0};
    /** Whether or not to compute the depth of the feature */
    bool computeDepth{true};
    /** Whether or not to blur the image previously to compute the descriptors
     */
    bool blurImage{true};
    /** Intrinsic stereo pair parameters for computing the depth of the feature
     */
    double fx{0.0}, cx{0.0}, cy{0.0}, baseline{0.0};
    /** Whether or not compute the coefficients for mantaining a HASH table of
     * descriptors (for relocalization) */
    bool computeHashCoeffs{false};

    /** The SIFT-like descriptor is cropped at this value during normalization
     */
    double cropValue{0.2};

    /** Default constructor
     */
    TMultiResDescOptions()
    {
        scales.resize(7);
        scales[0] = 0.5;
        scales[1] = 0.8;
        scales[2] = 1.0;
        scales[3] = 1.2;
        scales[4] = 1.5;
        scales[5] = 1.8;
        scales[6] = 2.0;
        comLScl = 0;
        comHScl = 6;
    }

    TMultiResDescOptions(
        const unsigned int& _basePSize, const std::vector<double>& _scales,
        const unsigned int& _comLScl, const unsigned int& _comHScl, double _sg1,
        double _sg2, double _sg3, bool _computeDepth, const bool _blurImage,
        double _fx, double _cx, double _cy, double _baseline,
        bool _computeHashCoeffs, double _cropValue)
        : basePSize(_basePSize),
          comLScl(_comLScl),
          comHScl(_comHScl),
          sg1(_sg1),
          sg2(_sg2),
          sg3(_sg3),
          computeDepth(_computeDepth),
          blurImage(_blurImage),
          fx(_fx),
          cx(_cx),
          cy(_cy),
          baseline(_baseline),
          computeHashCoeffs(_computeHashCoeffs),
          cropValue(_cropValue)
    {
        scales.resize(_scales.size());
        for (unsigned int k = 0; k < _scales.size(); ++k)
            scales[k] = _scales[k];
    }

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

};  // end TMultiResDescOptions

/** @} */  // end of grouping
}  // namespace mrpt::vision
MRPT_ENUM_TYPE_BEGIN(mrpt::vision::TKeyPointMethod)
using namespace mrpt::vision;
MRPT_FILL_ENUM(featNotDefined);
MRPT_FILL_ENUM(featKLT);
MRPT_FILL_ENUM(featHarris);
MRPT_FILL_ENUM(featSIFT);
MRPT_FILL_ENUM(featSURF);
MRPT_FILL_ENUM(featBeacon);
MRPT_FILL_ENUM(featFAST);
MRPT_FILL_ENUM(featORB);
MRPT_FILL_ENUM(featAKAZE);
MRPT_FILL_ENUM(featLSD);
MRPT_ENUM_TYPE_END()

MRPT_ENUM_TYPE_BEGIN(mrpt::vision::TDescriptorType)
using namespace mrpt::vision;
MRPT_FILL_ENUM(descAny);
MRPT_FILL_ENUM(descSIFT);
MRPT_FILL_ENUM(descSURF);
MRPT_FILL_ENUM(descSpinImages);
MRPT_FILL_ENUM(descPolarImages);
MRPT_FILL_ENUM(descLogPolarImages);
MRPT_FILL_ENUM(descORB);
MRPT_FILL_ENUM(descBLD);
MRPT_FILL_ENUM(descLATCH);
MRPT_ENUM_TYPE_END()