xfeatures2d.hpp

/*
By downloading, copying, installing or using the software you agree to this
license. If you do not agree to this license, do not download, install,
copy or use the software.
 
                          License Agreement
               For Open Source Computer Vision Library
                       (3-clause BSD License)
 
Copyright (C) 2013, OpenCV Foundation, all rights reserved.
Third party copyrights are property of their respective owners.
 
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
 
  * Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
 
  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
 
  * Neither the names of the copyright holders nor the names of the contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
This software is provided by the copyright holders and contributors "as is" and
any express or implied warranties, including, but not limited to, the implied
warranties of merchantability and fitness for a particular purpose are
disclaimed. In no event shall copyright holders or contributors be liable for
any direct, indirect, incidental, special, exemplary, or consequential damages
(including, but not limited to, procurement of substitute goods or services;
loss of use, data, or profits; or business interruption) however caused
and on any theory of liability, whether in contract, strict liability,
or tort (including negligence or otherwise) arising in any way out of
the use of this software, even if advised of the possibility of such damage.
*/
 
#ifndef __OPENCV_XFEATURES2D_HPP__
#define __OPENCV_XFEATURES2D_HPP__
 
#include "opencv2/features2d.hpp"
#include "opencv2/xfeatures2d/nonfree.hpp"
 
namespace cv
{
namespace xfeatures2d
{
 
 
class CV_EXPORTS_W FREAK : public Feature2D
{
public:
 
    static const int    NB_SCALES        = 64;
    static const int    NB_PAIRS         = 512;
    static const int    NB_ORIENPAIRS    = 45;
 
    CV_WRAP static Ptr<FREAK> create(bool orientationNormalized = true,
                             bool scaleNormalized = true,
                             float patternScale = 22.0f,
                             int nOctaves = 4,
                             const std::vector<int>& selectedPairs = std::vector<int>());
};
 
 
class CV_EXPORTS_W StarDetector : public Feature2D
{
public:
    CV_WRAP static Ptr<StarDetector> create(int maxSize=45, int responseThreshold=30,
                         int lineThresholdProjected=10,
                         int lineThresholdBinarized=8,
                         int suppressNonmaxSize=5);
};
 
/*
 * BRIEF Descriptor
 */
 
class CV_EXPORTS_W BriefDescriptorExtractor : public Feature2D
{
public:
    CV_WRAP static Ptr<BriefDescriptorExtractor> create( int bytes = 32, bool use_orientation = false );
};
 
class CV_EXPORTS_W LUCID : public Feature2D
{
public:
    CV_WRAP static Ptr<LUCID> create(const int lucid_kernel = 1, const int blur_kernel = 2);
};
 
 
/*
* LATCH Descriptor
*/
 
class CV_EXPORTS_W LATCH : public Feature2D
{
public:
    CV_WRAP static Ptr<LATCH> create(int bytes = 32, bool rotationInvariance = true, int half_ssd_size = 3, double sigma = 2.0);
};
 
class CV_EXPORTS_W BEBLID : public Feature2D
{
public:
    enum BeblidSize
    {
        SIZE_512_BITS = 100, SIZE_256_BITS = 101,
    };
    CV_WRAP static Ptr<BEBLID> create(float scale_factor, int n_bits = BEBLID::SIZE_512_BITS);
};
 
class CV_EXPORTS_W DAISY : public Feature2D
{
public:
    enum NormalizationType
    {
        NRM_NONE = 100, NRM_PARTIAL = 101, NRM_FULL = 102, NRM_SIFT = 103,
    };
    CV_WRAP static Ptr<DAISY> create( float radius = 15, int q_radius = 3, int q_theta = 8,
                int q_hist = 8, DAISY::NormalizationType norm = DAISY::NRM_NONE, InputArray H = noArray(),
                bool interpolation = true, bool use_orientation = false );
 
    virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE = 0;
 
    virtual void compute( InputArrayOfArrays images,
                          std::vector<std::vector<KeyPoint> >& keypoints,
                          OutputArrayOfArrays descriptors ) CV_OVERRIDE;
 
    virtual void compute( InputArray image, Rect roi, OutputArray descriptors ) = 0;
 
    virtual void compute( InputArray image, OutputArray descriptors ) = 0;
 
    virtual void GetDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
 
    virtual bool GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const = 0;
 
    virtual void GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
 
    virtual bool GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor , double *H ) const = 0;
 
};
 
class CV_EXPORTS_W MSDDetector : public Feature2D {
 
public:
 
    static Ptr<MSDDetector> create(int m_patch_radius = 3, int m_search_area_radius = 5,
            int m_nms_radius = 5, int m_nms_scale_radius = 0, float m_th_saliency = 250.0f, int m_kNN = 4,
            float m_scale_factor = 1.25f, int m_n_scales = -1, bool m_compute_orientation = false);
};
 
class CV_EXPORTS_W VGG : public Feature2D
{
public:
 
    CV_WRAP enum
    {
        VGG_120 = 100, VGG_80 = 101, VGG_64 = 102, VGG_48 = 103,
    };
 
    CV_WRAP static Ptr<VGG> create( int desc = VGG::VGG_120, float isigma = 1.4f,
                                    bool img_normalize = true, bool use_scale_orientation = true,
                                    float scale_factor = 6.25f, bool dsc_normalize = false );
 
    CV_WRAP virtual void setSigma(const float isigma) = 0;
    CV_WRAP virtual float getSigma() const = 0;
 
    CV_WRAP virtual void setUseNormalizeImage(const bool img_normalize) = 0;
    CV_WRAP virtual bool getUseNormalizeImage() const = 0;
 
    CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
    CV_WRAP virtual bool getUseScaleOrientation() const = 0;
 
    CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
    CV_WRAP virtual float getScaleFactor() const = 0;
 
    CV_WRAP virtual void setUseNormalizeDescriptor(const bool dsc_normalize) = 0;
    CV_WRAP virtual bool getUseNormalizeDescriptor() const = 0;
};
 
class CV_EXPORTS_W BoostDesc : public Feature2D
{
public:
 
    CV_WRAP enum
    {
       BGM = 100, BGM_HARD = 101, BGM_BILINEAR = 102, LBGM = 200,
       BINBOOST_64 = 300, BINBOOST_128 = 301, BINBOOST_256 = 302
    };
 
    CV_WRAP static Ptr<BoostDesc> create( int desc = BoostDesc::BINBOOST_256,
                    bool use_scale_orientation = true, float scale_factor = 6.25f );
 
    CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
    CV_WRAP virtual bool getUseScaleOrientation() const = 0;
 
    CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
    CV_WRAP virtual float getScaleFactor() const = 0;
};
 
 
/*
* Position-Color-Texture signatures
*/
 
class CV_EXPORTS_W PCTSignatures : public Algorithm
{
public:
    enum DistanceFunction
    {
        L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY
    };
 
    enum PointDistribution
    {
        UNIFORM,    
        REGULAR,    
        NORMAL      
    };
 
    enum SimilarityFunction
    {
        MINUS,      
        GAUSSIAN,   
        HEURISTIC   
    };
 
 
    CV_WRAP static Ptr<PCTSignatures> create(
        const int initSampleCount = 2000,
        const int initSeedCount = 400,
        const int pointDistribution = 0);
 
    CV_WRAP static Ptr<PCTSignatures> create(
        const std::vector<Point2f>& initSamplingPoints,
        const int initSeedCount);
 
    CV_WRAP static Ptr<PCTSignatures> create(
        const std::vector<Point2f>& initSamplingPoints,
        const std::vector<int>& initClusterSeedIndexes);
 
 
 
    CV_WRAP virtual void computeSignature(
        InputArray image,
        OutputArray signature) const = 0;
 
    CV_WRAP virtual void computeSignatures(
        const std::vector<Mat>& images,
        std::vector<Mat>& signatures) const = 0;
 
    CV_WRAP static void drawSignature(
        InputArray source,
        InputArray signature,
        OutputArray result,
        float radiusToShorterSideRatio = 1.0 / 8,
        int borderThickness = 1);
 
    CV_WRAP static void generateInitPoints(
        std::vector<Point2f>& initPoints,
        const int count,
        int pointDistribution);
 
 
    /**** sampler ****/
 
    CV_WRAP virtual int getSampleCount() const = 0;
 
    CV_WRAP virtual int getGrayscaleBits() const = 0;
    CV_WRAP virtual void setGrayscaleBits(int grayscaleBits) = 0;
 
    CV_WRAP virtual int getWindowRadius() const = 0;
    CV_WRAP virtual void setWindowRadius(int radius) = 0;
 
 
    CV_WRAP virtual float getWeightX() const = 0;
    CV_WRAP virtual void setWeightX(float weight) = 0;
 
    CV_WRAP virtual float getWeightY() const = 0;
    CV_WRAP virtual void setWeightY(float weight) = 0;
 
    CV_WRAP virtual float getWeightL() const = 0;
    CV_WRAP virtual void setWeightL(float weight) = 0;
 
    CV_WRAP virtual float getWeightA() const = 0;
    CV_WRAP virtual void setWeightA(float weight) = 0;
 
    CV_WRAP virtual float getWeightB() const = 0;
    CV_WRAP virtual void setWeightB(float weight) = 0;
 
    CV_WRAP virtual float getWeightContrast() const = 0;
    CV_WRAP virtual void setWeightContrast(float weight) = 0;
 
    CV_WRAP virtual float getWeightEntropy() const = 0;
    CV_WRAP virtual void setWeightEntropy(float weight) = 0;
 
    CV_WRAP virtual std::vector<Point2f> getSamplingPoints() const = 0;
 
 
 
    CV_WRAP virtual void setWeight(int idx, float value) = 0;
    CV_WRAP virtual void setWeights(const std::vector<float>& weights) = 0;
 
    CV_WRAP virtual void setTranslation(int idx, float value) = 0;
    CV_WRAP virtual void setTranslations(const std::vector<float>& translations) = 0;
 
    CV_WRAP virtual void setSamplingPoints(std::vector<Point2f> samplingPoints) = 0;
 
 
 
    /**** clusterizer ****/
    CV_WRAP virtual std::vector<int> getInitSeedIndexes() const = 0;
    CV_WRAP virtual void setInitSeedIndexes(std::vector<int> initSeedIndexes) = 0;
    CV_WRAP virtual int getInitSeedCount() const = 0;
 
    CV_WRAP virtual int getIterationCount() const = 0;
    CV_WRAP virtual void setIterationCount(int iterationCount) = 0;
 
    CV_WRAP virtual int getMaxClustersCount() const = 0;
    CV_WRAP virtual void setMaxClustersCount(int maxClustersCount) = 0;
 
    CV_WRAP virtual int getClusterMinSize() const = 0;
    CV_WRAP virtual void setClusterMinSize(int clusterMinSize) = 0;
 
    CV_WRAP virtual float getJoiningDistance() const = 0;
    CV_WRAP virtual void setJoiningDistance(float joiningDistance) = 0;
 
    CV_WRAP virtual float getDropThreshold() const = 0;
    CV_WRAP virtual void setDropThreshold(float dropThreshold) = 0;
 
    CV_WRAP virtual int getDistanceFunction() const = 0;
    CV_WRAP virtual void setDistanceFunction(int distanceFunction) = 0;
 
};
 
class CV_EXPORTS_W PCTSignaturesSQFD : public Algorithm
{
public:
 
    CV_WRAP static Ptr<PCTSignaturesSQFD> create(
        const int distanceFunction = 3,
        const int similarityFunction = 2,
        const float similarityParameter = 1.0f);
 
    CV_WRAP virtual float computeQuadraticFormDistance(
        InputArray _signature0,
        InputArray _signature1) const = 0;
 
    CV_WRAP virtual void computeQuadraticFormDistances(
        const Mat& sourceSignature,
        const std::vector<Mat>& imageSignatures,
        std::vector<float>& distances) const = 0;
 
};
 
class CV_EXPORTS Elliptic_KeyPoint : public KeyPoint
{
public:
    Size_<float> axes; 
    float si;  
    Matx23f transf; 
    Elliptic_KeyPoint();
    Elliptic_KeyPoint(Point2f pt, float angle, Size axes, float size, float si);
    virtual ~Elliptic_KeyPoint();
};
 
class CV_EXPORTS_W HarrisLaplaceFeatureDetector : public Feature2D
{
public:
    CV_WRAP static Ptr<HarrisLaplaceFeatureDetector> create(
            int numOctaves=6,
            float corn_thresh=0.01f,
            float DOG_thresh=0.01f,
            int maxCorners=5000,
            int num_layers=4);
};
 
class CV_EXPORTS_W AffineFeature2D : public Feature2D
{
public:
    static Ptr<AffineFeature2D> create(
        Ptr<FeatureDetector> keypoint_detector,
        Ptr<DescriptorExtractor> descriptor_extractor);
 
    static Ptr<AffineFeature2D> create(
        Ptr<FeatureDetector> keypoint_detector)
    {
        return create(keypoint_detector, keypoint_detector);
    }
 
    using Feature2D::detect; // overload, don't hide
    virtual void detect(
        InputArray image,
        CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
        InputArray mask=noArray() ) = 0;
 
    using Feature2D::detectAndCompute; // overload, don't hide
    virtual void detectAndCompute(
        InputArray image,
        InputArray mask,
        CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
        OutputArray descriptors,
        bool useProvidedKeypoints=false ) = 0;
};
 
class CV_EXPORTS_W TBMR : public AffineFeature2D
{
public:
    CV_WRAP static Ptr<TBMR> create(int min_area = 60,
        float max_area_relative = 0.01f,
        float scale_factor = 1.25f,
        int n_scales = -1);
 
    CV_WRAP virtual void setMinArea(int minArea) = 0;
    CV_WRAP virtual int getMinArea() const = 0;
    CV_WRAP virtual void setMaxAreaRelative(float maxArea) = 0;
    CV_WRAP virtual float getMaxAreaRelative() const = 0;
    CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;
    CV_WRAP virtual float getScaleFactor() const = 0;
    CV_WRAP virtual void setNScales(int n_scales) = 0;
    CV_WRAP virtual int getNScales() const = 0;
};
 
CV_EXPORTS void FASTForPointSet( InputArray image, CV_IN_OUT std::vector<KeyPoint>& keypoints,
                      int threshold, bool nonmaxSuppression=true, cv::FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16);
 
 
 
 
 
CV_EXPORTS_W void matchGMS(const Size& size1, const Size& size2, const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
                           const std::vector<DMatch>& matches1to2, CV_OUT std::vector<DMatch>& matchesGMS, const bool withRotation = false,
                           const bool withScale = false, const double thresholdFactor = 6.0);
 
CV_EXPORTS_W void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
                             const std::vector<int>& nn1, const std::vector<int>& nn2,
                             std::vector<DMatch>& matches1to2);
 
 
}
}
 
#endif