mirror of
https://github.com/opencv/opencv_contrib.git
synced 2025-10-22 16:08:41 +08:00
268 lines
10 KiB
C++
268 lines
10 KiB
C++
/*
|
|
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"
|
|
|
|
/** @defgroup xfeatures2d Extra 2D Features Framework
|
|
@{
|
|
@defgroup xfeatures2d_experiment Experimental 2D Features Algorithms
|
|
|
|
This section describes experimental algorithms for 2d feature detection.
|
|
|
|
@defgroup xfeatures2d_nonfree Non-free 2D Features Algorithms
|
|
|
|
This section describes two popular algorithms for 2d feature detection, SIFT and SURF, that are
|
|
known to be patented. Use them at your own risk.
|
|
|
|
@}
|
|
*/
|
|
|
|
namespace cv
|
|
{
|
|
namespace xfeatures2d
|
|
{
|
|
|
|
//! @addtogroup xfeatures2d_experiment
|
|
//! @{
|
|
|
|
/** @brief Class implementing the FREAK (*Fast Retina Keypoint*) keypoint descriptor, described in @cite AOV12 .
|
|
|
|
The algorithm propose a novel keypoint descriptor inspired by the human visual system and more
|
|
precisely the retina, coined Fast Retina Key- point (FREAK). A cascade of binary strings is
|
|
computed by efficiently comparing image intensities over a retinal sampling pattern. FREAKs are in
|
|
general faster to compute with lower memory load and also more robust than SIFT, SURF or BRISK.
|
|
They are competitive alternatives to existing keypoints in particular for embedded applications.
|
|
|
|
@note
|
|
- An example on how to use the FREAK descriptor can be found at
|
|
opencv_source_code/samples/cpp/freak_demo.cpp
|
|
*/
|
|
class CV_EXPORTS_W FREAK : public Feature2D
|
|
{
|
|
public:
|
|
|
|
enum
|
|
{
|
|
NB_SCALES = 64, NB_PAIRS = 512, NB_ORIENPAIRS = 45
|
|
};
|
|
|
|
/**
|
|
@param orientationNormalized Enable orientation normalization.
|
|
@param scaleNormalized Enable scale normalization.
|
|
@param patternScale Scaling of the description pattern.
|
|
@param nOctaves Number of octaves covered by the detected keypoints.
|
|
@param selectedPairs (Optional) user defined selected pairs indexes,
|
|
*/
|
|
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>());
|
|
};
|
|
|
|
|
|
/** @brief The class implements the keypoint detector introduced by @cite Agrawal08, synonym of StarDetector. :
|
|
*/
|
|
class CV_EXPORTS_W StarDetector : public Feature2D
|
|
{
|
|
public:
|
|
//! the full constructor
|
|
CV_WRAP static Ptr<StarDetector> create(int maxSize=45, int responseThreshold=30,
|
|
int lineThresholdProjected=10,
|
|
int lineThresholdBinarized=8,
|
|
int suppressNonmaxSize=5);
|
|
};
|
|
|
|
/*
|
|
* BRIEF Descriptor
|
|
*/
|
|
|
|
/** @brief Class for computing BRIEF descriptors described in @cite calon2010 .
|
|
|
|
@param bytes legth of the descriptor in bytes, valid values are: 16, 32 (default) or 64 .
|
|
@param use_orientation sample patterns using keypoints orientation, disabled by default.
|
|
|
|
*/
|
|
class CV_EXPORTS_W BriefDescriptorExtractor : public Feature2D
|
|
{
|
|
public:
|
|
static Ptr<BriefDescriptorExtractor> create( int bytes = 32, bool use_orientation = false );
|
|
};
|
|
|
|
/** @brief Class implementing the locally uniform comparison image descriptor, described in @cite LUCID
|
|
|
|
An image descriptor that can be computed very fast, while being
|
|
about as robust as, for example, SURF or BRIEF.
|
|
*/
|
|
class CV_EXPORTS_W LUCID : public Feature2D
|
|
{
|
|
public:
|
|
/**
|
|
* @param lucid_kernel kernel for descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
|
|
* @param blur_kernel kernel for blurring image prior to descriptor construction, where 1=3x3, 2=5x5, 3=7x7 and so forth
|
|
*/
|
|
CV_WRAP static Ptr<LUCID> create(const int lucid_kernel, const int blur_kernel);
|
|
};
|
|
|
|
|
|
/*
|
|
* LATCH Descriptor
|
|
*/
|
|
|
|
/** latch Class for computing the LATCH descriptor.
|
|
If you find this code useful, please add a reference to the following paper in your work:
|
|
Gil Levi and Tal Hassner, "LATCH: Learned Arrangements of Three Patch Codes", arXiv preprint arXiv:1501.03719, 15 Jan. 2015
|
|
|
|
LATCH is a binary descriptor based on learned comparisons of triplets of image patches.
|
|
|
|
* bytes is the size of the descriptor - can be 64, 32, 16, 8, 4, 2 or 1
|
|
* rotationInvariance - whether or not the descriptor should compansate for orientation changes.
|
|
* half_ssd_size - the size of half of the mini-patches size. For example, if we would like to compare triplets of patches of size 7x7x
|
|
then the half_ssd_size should be (7-1)/2 = 3.
|
|
|
|
Note: the descriptor can be coupled with any keypoint extractor. The only demand is that if you use set rotationInvariance = True then
|
|
you will have to use an extractor which estimates the patch orientation (in degrees). Examples for such extractors are ORB and SIFT.
|
|
|
|
Note: a complete example can be found under /samples/cpp/tutorial_code/xfeatures2D/latch_match.cpp
|
|
|
|
*/
|
|
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);
|
|
};
|
|
|
|
/** @brief Class implementing DAISY descriptor, described in @cite Tola10
|
|
|
|
@param radius radius of the descriptor at the initial scale
|
|
@param q_radius amount of radial range division quantity
|
|
@param q_theta amount of angular range division quantity
|
|
@param q_hist amount of gradient orientations range division quantity
|
|
@param norm choose descriptors normalization type, where
|
|
DAISY::NRM_NONE will not do any normalization (default),
|
|
DAISY::NRM_PARTIAL mean that histograms are normalized independently for L2 norm equal to 1.0,
|
|
DAISY::NRM_FULL mean that descriptors are normalized for L2 norm equal to 1.0,
|
|
DAISY::NRM_SIFT mean that descriptors are normalized for L2 norm equal to 1.0 but no individual one is bigger than 0.154 as in SIFT
|
|
@param H optional 3x3 homography matrix used to warp the grid of daisy but sampling keypoints remains unwarped on image
|
|
@param interpolation switch to disable interpolation for speed improvement at minor quality loss
|
|
@param use_orientation sample patterns using keypoints orientation, disabled by default.
|
|
|
|
*/
|
|
class CV_EXPORTS_W DAISY : public Feature2D
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
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, int norm = DAISY::NRM_NONE, InputArray H = noArray(),
|
|
bool interpolation = true, bool use_orientation = false );
|
|
|
|
/** @overload
|
|
* @param image image to extract descriptors
|
|
* @param keypoints of interest within image
|
|
* @param descriptors resulted descriptors array
|
|
*/
|
|
virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) = 0;
|
|
|
|
virtual void compute( InputArrayOfArrays images,
|
|
std::vector<std::vector<KeyPoint> >& keypoints,
|
|
OutputArrayOfArrays descriptors );
|
|
|
|
/** @overload
|
|
* @param image image to extract descriptors
|
|
* @param roi region of interest within image
|
|
* @param descriptors resulted descriptors array for roi image pixels
|
|
*/
|
|
virtual void compute( InputArray image, Rect roi, OutputArray descriptors ) = 0;
|
|
|
|
/**@overload
|
|
* @param image image to extract descriptors
|
|
* @param descriptors resulted descriptors array for all image pixels
|
|
*/
|
|
virtual void compute( InputArray image, OutputArray descriptors ) = 0;
|
|
|
|
/**
|
|
* @param y position y on image
|
|
* @param x position x on image
|
|
* @param orientation orientation on image (0->360)
|
|
* @param descriptor supplied array for descriptor storage
|
|
*/
|
|
virtual void GetDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
|
|
|
|
/**
|
|
* @param y position y on image
|
|
* @param x position x on image
|
|
* @param orientation orientation on image (0->360)
|
|
* @param descriptor supplied array for descriptor storage
|
|
* @param H homography matrix for warped grid
|
|
*/
|
|
virtual bool GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const = 0;
|
|
|
|
/**
|
|
* @param y position y on image
|
|
* @param x position x on image
|
|
* @param orientation orientation on image (0->360)
|
|
* @param descriptor supplied array for descriptor storage
|
|
*/
|
|
virtual void GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
|
|
|
|
/**
|
|
* @param y position y on image
|
|
* @param x position x on image
|
|
* @param orientation orientation on image (0->360)
|
|
* @param descriptor supplied array for descriptor storage
|
|
* @param H homography matrix for warped grid
|
|
*/
|
|
virtual bool GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor , double *H ) const = 0;
|
|
|
|
};
|
|
|
|
|
|
//! @}
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|