OpenCV 4.5.3(日本語機械翻訳)
xfeatures2d.hpp
1 /*
2 By downloading, copying, installing or using the software you agree to this
3 license. If you do not agree to this license, do not download, install,
4 copy or use the software.
5
6 License Agreement
7 For Open Source Computer Vision Library
8 (3-clause BSD License)
9
10 Copyright (C) 2013, OpenCV Foundation, all rights reserved.
11 Third party copyrights are property of their respective owners.
12
13 Redistribution and use in source and binary forms, with or without modification,
14 are permitted provided that the following conditions are met:
15
16 * Redistributions of source code must retain the above copyright notice,
17 this list of conditions and the following disclaimer.
18
19 * Redistributions in binary form must reproduce the above copyright notice,
20 this list of conditions and the following disclaimer in the documentation
21 and/or other materials provided with the distribution.
22
23 * Neither the names of the copyright holders nor the names of the contributors
24 may be used to endorse or promote products derived from this software
25 without specific prior written permission.
26
27 This software is provided by the copyright holders and contributors "as is" and
28 any express or implied warranties, including, but not limited to, the implied
29 warranties of merchantability and fitness for a particular purpose are
30 disclaimed. In no event shall copyright holders or contributors be liable for
31 any direct, indirect, incidental, special, exemplary, or consequential damages
32 (including, but not limited to, procurement of substitute goods or services;
33 loss of use, data, or profits; or business interruption) however caused
34 and on any theory of liability, whether in contract, strict liability,
35 or tort (including negligence or otherwise) arising in any way out of
36 the use of this software, even if advised of the possibility of such damage.
37 */
38
39 #ifndef __OPENCV_XFEATURES2D_HPP__
40 #define __OPENCV_XFEATURES2D_HPP__
41
42 #include "opencv2/features2d.hpp"
43 #include "opencv2/xfeatures2d/nonfree.hpp"
44
65 namespace cv
66{
67 namespace xfeatures2d
68{
69
72
85 class CV_EXPORTS_W FREAK : public Feature2D
86{
87 public:
88
89 static const int NB_SCALES = 64;
90 static const int NB_PAIRS = 512;
91 static const int NB_ORIENPAIRS = 45;
92
100 CV_WRAP static Ptr<FREAK> create(bool orientationNormalized = true,
101 bool scaleNormalized = true,
102 float patternScale = 22.0f,
103 int nOctaves = 4,
104 const std::vector<int>& selectedPairs = std::vector<int>());
105};
106
107
110 class CV_EXPORTS_W StarDetector : public Feature2D
111{
112 public:
114 CV_WRAP static Ptr<StarDetector> create(int maxSize=45, int responseThreshold=30,
115 int lineThresholdProjected=10,
116 int lineThresholdBinarized=8,
117 int suppressNonmaxSize=5);
118};
119
120 /*
121 * BRIEF Descriptor
122 */
123
130 class CV_EXPORTS_W BriefDescriptorExtractor : public Feature2D
131{
132 public:
133 CV_WRAP static Ptr<BriefDescriptorExtractor> create( int bytes = 32, bool use_orientation = false );
134};
135
143 class CV_EXPORTS_W LUCID : public Feature2D
144{
145 public:
150 CV_WRAP static Ptr<LUCID> create(const int lucid_kernel = 1, const int blur_kernel = 2);
151};
152
153
154 /*
155 * LATCH Descriptor
156 */
157
176 class CV_EXPORTS_W LATCH : public Feature2D
177{
178 public:
179 CV_WRAP static Ptr<LATCH> create(int bytes = 32, bool rotationInvariance = true, int half_ssd_size = 3, double sigma = 2.0);
180};
181
204 class CV_EXPORTS_W BEBLID : public Feature2D
205{
206 public:
211 enum BeblidSize
212 {
213 SIZE_512_BITS = 100, SIZE_256_BITS = 101,
214 };
224 CV_WRAP static Ptr<BEBLID> create(float scale_factor, int n_bits = BEBLID::SIZE_512_BITS);
225};
226
243 class CV_EXPORTS_W DAISY : public Feature2D
244{
245 public:
246 enum NormalizationType
247 {
248 NRM_NONE = 100, NRM_PARTIAL = 101, NRM_FULL = 102, NRM_SIFT = 103,
249 };
250 CV_WRAP static Ptr<DAISY> create( float radius = 15, int q_radius = 3, int q_theta = 8,
251 int q_hist = 8, DAISY::NormalizationType norm = DAISY::NRM_NONE, InputArray H = noArray(),
252 bool interpolation = true, bool use_orientation = false );
253
259 virtual void compute( InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors ) CV_OVERRIDE = 0;
260
261 virtual void compute( InputArrayOfArrays images,
262 std::vector<std::vector<KeyPoint> >& keypoints,
263 OutputArrayOfArrays descriptors ) CV_OVERRIDE;
264
270 virtual void compute( InputArray image, Rect roi, OutputArray descriptors ) = 0;
271
276 virtual void compute( InputArray image, OutputArray descriptors ) = 0;
277
284 virtual void GetDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
285
293 virtual bool GetDescriptor( double y, double x, int orientation, float* descriptor, double* H ) const = 0;
294
301 virtual void GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor ) const = 0;
302
310 virtual bool GetUnnormalizedDescriptor( double y, double x, int orientation, float* descriptor , double *H ) const = 0;
311
312};
313
327 class CV_EXPORTS_W MSDDetector : public Feature2D {
328
329 public:
330
331 static Ptr<MSDDetector> create(int m_patch_radius = 3, int m_search_area_radius = 5,
332 int m_nms_radius = 5, int m_nms_scale_radius = 0, float m_th_saliency = 250.0f, int m_kNN = 4,
333 float m_scale_factor = 1.25f, int m_n_scales = -1, bool m_compute_orientation = false);
334};
335
353 class CV_EXPORTS_W VGG : public Feature2D
354{
355 public:
356
357 CV_WRAP enum
358 {
359 VGG_120 = 100, VGG_80 = 101, VGG_64 = 102, VGG_48 = 103,
360 };
361
362 CV_WRAP static Ptr<VGG> create( int desc = VGG::VGG_120, float isigma = 1.4f,
363 bool img_normalize = true, bool use_scale_orientation = true,
364 float scale_factor = 6.25f, bool dsc_normalize = false );
365
366 CV_WRAP virtual void setSigma(const float isigma) = 0;
367 CV_WRAP virtual float getSigma() const = 0;
368
369 CV_WRAP virtual void setUseNormalizeImage(const bool img_normalize) = 0;
370 CV_WRAP virtual bool getUseNormalizeImage() const = 0;
371
372 CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
373 CV_WRAP virtual bool getUseScaleOrientation() const = 0;
374
375 CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
376 CV_WRAP virtual float getScaleFactor() const = 0;
377
378 CV_WRAP virtual void setUseNormalizeDescriptor(const bool dsc_normalize) = 0;
379 CV_WRAP virtual bool getUseNormalizeDescriptor() const = 0;
380};
381
409 class CV_EXPORTS_W BoostDesc : public Feature2D
410{
411 public:
412
413 CV_WRAP enum
414 {
415 BGM = 100, BGM_HARD = 101, BGM_BILINEAR = 102, LBGM = 200,
416 BINBOOST_64 = 300, BINBOOST_128 = 301, BINBOOST_256 = 302
417 };
418
419 CV_WRAP static Ptr<BoostDesc> create( int desc = BoostDesc::BINBOOST_256,
420 bool use_scale_orientation = true, float scale_factor = 6.25f );
421
422 CV_WRAP virtual void setUseScaleOrientation(const bool use_scale_orientation) = 0;
423 CV_WRAP virtual bool getUseScaleOrientation() const = 0;
424
425 CV_WRAP virtual void setScaleFactor(const float scale_factor) = 0;
426 CV_WRAP virtual float getScaleFactor() const = 0;
427};
428
429
430 /*
431 * Position-Color-Texture signatures
432 */
433
448 class CV_EXPORTS_W PCTSignatures : public Algorithm
449{
450 public:
454 enum DistanceFunction
455 {
456 L0_25, L0_5, L1, L2, L2SQUARED, L5, L_INFINITY
457 };
458
462 enum PointDistribution
463 {
464 UNIFORM,
465 REGULAR,
466 NORMAL
467 };
468
479 enum SimilarityFunction
480 {
481 MINUS,
482 GAUSSIAN,
483 HEURISTIC
484 };
485
486
497 CV_WRAP static Ptr<PCTSignatures> create(
498 const int initSampleCount = 2000,
499 const int initSeedCount = 400,
500 const int pointDistribution = 0);
501
511 CV_WRAP static Ptr<PCTSignatures> create(
512 const std::vector<Point2f>& initSamplingPoints,
513 const int initSeedCount);
514
523 CV_WRAP static Ptr<PCTSignatures> create(
524 const std::vector<Point2f>& initSamplingPoints,
525 const std::vector<int>& initClusterSeedIndexes);
526
527
528
534 CV_WRAP virtual void computeSignature(
535 InputArray image,
536 OutputArray signature) const = 0;
537
543 CV_WRAP virtual void computeSignatures(
544 const std::vector<Mat>& images,
545 std::vector<Mat>& signatures) const = 0;
546
559 CV_WRAP static void drawSignature(
560 InputArray source,
561 InputArray signature,
562 OutputArray result,
563 float radiusToShorterSideRatio = 1.0 / 8,
564 int borderThickness = 1);
565
574 CV_WRAP static void generateInitPoints(
575 std::vector<Point2f>& initPoints,
576 const int count,
577 int pointDistribution);
578
579
580 /**** sampler ****/
581
585 CV_WRAP virtual int getSampleCount() const = 0;
586
592 CV_WRAP virtual int getGrayscaleBits() const = 0;
598 CV_WRAP virtual void setGrayscaleBits(int grayscaleBits) = 0;
599
605 CV_WRAP virtual int getWindowRadius() const = 0;
611 CV_WRAP virtual void setWindowRadius(int radius) = 0;
612
613
618 CV_WRAP virtual float getWeightX() const = 0;
623 CV_WRAP virtual void setWeightX(float weight) = 0;
624
629 CV_WRAP virtual float getWeightY() const = 0;
634 CV_WRAP virtual void setWeightY(float weight) = 0;
635
640 CV_WRAP virtual float getWeightL() const = 0;
645 CV_WRAP virtual void setWeightL(float weight) = 0;
646
651 CV_WRAP virtual float getWeightA() const = 0;
656 CV_WRAP virtual void setWeightA(float weight) = 0;
657
662 CV_WRAP virtual float getWeightB() const = 0;
667 CV_WRAP virtual void setWeightB(float weight) = 0;
668
673 CV_WRAP virtual float getWeightContrast() const = 0;
678 CV_WRAP virtual void setWeightContrast(float weight) = 0;
679
684 CV_WRAP virtual float getWeightEntropy() const = 0;
689 CV_WRAP virtual void setWeightEntropy(float weight) = 0;
690
695 CV_WRAP virtual std::vector<Point2f> getSamplingPoints() const = 0;
696
697
698
713 CV_WRAP virtual void setWeight(int idx, float value) = 0;
727 CV_WRAP virtual void setWeights(const std::vector<float>& weights) = 0;
728
743 CV_WRAP virtual void setTranslation(int idx, float value) = 0;
757 CV_WRAP virtual void setTranslations(const std::vector<float>& translations) = 0;
758
764 CV_WRAP virtual void setSamplingPoints(std::vector<Point2f> samplingPoints) = 0;
765
766
767
768 /**** clusterizer ****/
772 CV_WRAP virtual std::vector<int> getInitSeedIndexes() const = 0;
776 CV_WRAP virtual void setInitSeedIndexes(std::vector<int> initSeedIndexes) = 0;
780 CV_WRAP virtual int getInitSeedCount() const = 0;
781
787 CV_WRAP virtual int getIterationCount() const = 0;
793 CV_WRAP virtual void setIterationCount(int iterationCount) = 0;
794
799 CV_WRAP virtual int getMaxClustersCount() const = 0;
804 CV_WRAP virtual void setMaxClustersCount(int maxClustersCount) = 0;
805
811 CV_WRAP virtual int getClusterMinSize() const = 0;
817 CV_WRAP virtual void setClusterMinSize(int clusterMinSize) = 0;
818
824 CV_WRAP virtual float getJoiningDistance() const = 0;
830 CV_WRAP virtual void setJoiningDistance(float joiningDistance) = 0;
831
835 CV_WRAP virtual float getDropThreshold() const = 0;
839 CV_WRAP virtual void setDropThreshold(float dropThreshold) = 0;
840
844 CV_WRAP virtual int getDistanceFunction() const = 0;
849 CV_WRAP virtual void setDistanceFunction(int distanceFunction) = 0;
850
851};
852
861 class CV_EXPORTS_W PCTSignaturesSQFD : public Algorithm
862{
863 public:
864
874 CV_WRAP static Ptr<PCTSignaturesSQFD> create(
875 const int distanceFunction = 3,
876 const int similarityFunction = 2,
877 const float similarityParameter = 1.0f);
878
884 CV_WRAP virtual float computeQuadraticFormDistance(
885 InputArray _signature0,
886 InputArray _signature1) const = 0;
887
895 CV_WRAP virtual void computeQuadraticFormDistances(
896 const Mat& sourceSignature,
897 const std::vector<Mat>& imageSignatures,
898 std::vector<float>& distances) const = 0;
899
900};
901
905 class CV_EXPORTS Elliptic_KeyPoint : public KeyPoint
906{
907 public:
908 Size_<float> axes;
909 float si;
910 Matx23f transf;
911 Elliptic_KeyPoint();
912 Elliptic_KeyPoint(Point2f pt, float angle, Size axes, float size, float si);
913 virtual ~Elliptic_KeyPoint();
914};
915
919 class CV_EXPORTS_W HarrisLaplaceFeatureDetector : public Feature2D
920{
921 public:
931 CV_WRAP static Ptr<HarrisLaplaceFeatureDetector> create(
932 int numOctaves=6,
933 float corn_thresh=0.01f,
934 float DOG_thresh=0.01f,
935 int maxCorners=5000,
936 int num_layers=4);
937};
938
949 class CV_EXPORTS_W AffineFeature2D : public Feature2D
950{
951 public:
956 static Ptr<AffineFeature2D> create(
957 Ptr<FeatureDetector> keypoint_detector,
958 Ptr<DescriptorExtractor> descriptor_extractor);
959
964 static Ptr<AffineFeature2D> create(
965 Ptr<FeatureDetector> keypoint_detector)
966 {
967 return create(keypoint_detector, keypoint_detector);
968 }
969
970 using Feature2D::detect; // overload, don't hide
975 virtual void detect(
976 InputArray image,
977 CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
978 InputArray mask=noArray() ) = 0;
979
980 using Feature2D::detectAndCompute; // overload, don't hide
985 virtual void detectAndCompute(
986 InputArray image,
987 InputArray mask,
988 CV_OUT std::vector<Elliptic_KeyPoint>& keypoints,
989 OutputArray descriptors,
990 bool useProvidedKeypoints=false ) = 0;
991};
992
1010 class CV_EXPORTS_W TBMR : public AffineFeature2D
1011{
1012 public:
1013 CV_WRAP static Ptr<TBMR> create(int min_area = 60,
1014 float max_area_relative = 0.01f,
1015 float scale_factor = 1.25f,
1016 int n_scales = -1);
1017
1018 CV_WRAP virtual void setMinArea(int minArea) = 0;
1019 CV_WRAP virtual int getMinArea() const = 0;
1020 CV_WRAP virtual void setMaxAreaRelative(float maxArea) = 0;
1021 CV_WRAP virtual float getMaxAreaRelative() const = 0;
1022 CV_WRAP virtual void setScaleFactor(float scale_factor) = 0;
1023 CV_WRAP virtual float getScaleFactor() const = 0;
1024 CV_WRAP virtual void setNScales(int n_scales) = 0;
1025 CV_WRAP virtual int getNScales() const = 0;
1026};
1027
1043 CV_EXPORTS void FASTForPointSet( InputArray image, CV_IN_OUT std::vector<KeyPoint>& keypoints,
1044 int threshold, bool nonmaxSuppression=true, cv::FastFeatureDetector::DetectorType type=FastFeatureDetector::TYPE_9_16);
1045
1046
1048
1049
1052
1068 CV_EXPORTS_W void matchGMS(const Size& size1, const Size& size2, const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
1069 const std::vector<DMatch>& matches1to2, CV_OUT std::vector<DMatch>& matchesGMS, const bool withRotation = false,
1070 const bool withScale = false, const double thresholdFactor = 6.0);
1071
1083 CV_EXPORTS_W void matchLOGOS(const std::vector<KeyPoint>& keypoints1, const std::vector<KeyPoint>& keypoints2,
1084 const std::vector<int>& nn1, const std::vector<int>& nn2,
1085 std::vector<DMatch>& matches1to2);
1086
1088
1089}
1090}
1091
1092 #endif
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::Feature2D
Abstract base class for 2D image feature detectors and descriptor extractors
Definition: features2d.hpp:135
cv::Feature2D::detect
virtual CV_WRAP void detect(InputArray image, CV_OUT std::vector< KeyPoint > &keypoints, InputArray mask=noArray())
Detects keypoints in an image (first variant) or image set (second variant).
cv::Feature2D::detectAndCompute
virtual CV_WRAP void detectAndCompute(InputArray image, InputArray mask, CV_OUT std::vector< KeyPoint > &keypoints, OutputArray descriptors, bool useProvidedKeypoints=false)
cv::KeyPoint
Data structure for salient point detectors.
Definition: core/types.hpp:712
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Point_< float >
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::Size_< float >
cv::xfeatures2d::AffineFeature2D
Class implementing affine adaptation for key points.
Definition: xfeatures2d.hpp:950
cv::xfeatures2d::AffineFeature2D::create
static Ptr< AffineFeature2D > create(Ptr< FeatureDetector > keypoint_detector)
Creates an instance where keypoint detector and descriptor extractor are identical.
Definition: xfeatures2d.hpp:964
cv::xfeatures2d::AffineFeature2D::create
static Ptr< AffineFeature2D > create(Ptr< FeatureDetector > keypoint_detector, Ptr< DescriptorExtractor > descriptor_extractor)
Creates an instance wrapping the given keypoint detector and descriptor extractor.
cv::xfeatures2d::AffineFeature2D::detectAndCompute
virtual void detectAndCompute(InputArray image, InputArray mask, CV_OUT std::vector< Elliptic_KeyPoint > &keypoints, OutputArray descriptors, bool useProvidedKeypoints=false)=0
Detects keypoints and computes descriptors for their surrounding regions, after warping them into cir...
cv::xfeatures2d::AffineFeature2D::detect
virtual void detect(InputArray image, CV_OUT std::vector< Elliptic_KeyPoint > &keypoints, InputArray mask=noArray())=0
Detects keypoints in the image using the wrapped detector and performs affine adaptation to augment t...
cv::xfeatures2d::BEBLID
Class implementing BEBLID (Boosted Efficient Binary Local Image Descriptor), described in .
Definition: xfeatures2d.hpp:205
cv::xfeatures2d::BEBLID::BeblidSize
BeblidSize
Descriptor number of bits, each bit is a boosting weak-learner. The user can choose between 512 or 25...
Definition: xfeatures2d.hpp:212
cv::xfeatures2d::BoostDesc
Class implementing BoostDesc (Learning Image Descriptors with Boosting), described in and .
Definition: xfeatures2d.hpp:410
cv::xfeatures2d::BriefDescriptorExtractor
Class for computing BRIEF descriptors described in .
Definition: xfeatures2d.hpp:131
cv::xfeatures2d::DAISY
Class implementing DAISY descriptor, described in
Definition: xfeatures2d.hpp:244
cv::xfeatures2d::DAISY::GetUnnormalizedDescriptor
virtual bool GetUnnormalizedDescriptor(double y, double x, int orientation, float *descriptor, double *H) const =0
cv::xfeatures2d::DAISY::GetDescriptor
virtual void GetDescriptor(double y, double x, int orientation, float *descriptor) const =0
cv::xfeatures2d::DAISY::compute
virtual void compute(InputArray image, std::vector< KeyPoint > &keypoints, OutputArray descriptors) CV_OVERRIDE=0
cv::xfeatures2d::DAISY::GetDescriptor
virtual bool GetDescriptor(double y, double x, int orientation, float *descriptor, double *H) const =0
cv::xfeatures2d::DAISY::compute
virtual void compute(InputArray image, OutputArray descriptors)=0
cv::xfeatures2d::DAISY::GetUnnormalizedDescriptor
virtual void GetUnnormalizedDescriptor(double y, double x, int orientation, float *descriptor) const =0
cv::xfeatures2d::DAISY::compute
virtual void compute(InputArray image, Rect roi, OutputArray descriptors)=0
cv::xfeatures2d::Elliptic_KeyPoint
Elliptic region around an interest point.
Definition: xfeatures2d.hpp:906
cv::xfeatures2d::Elliptic_KeyPoint::transf
Matx23f transf
the transformation between image space and local patch space
Definition: xfeatures2d.hpp:910
cv::xfeatures2d::Elliptic_KeyPoint::si
float si
the integration scale at which the parameters were estimated
Definition: xfeatures2d.hpp:909
cv::xfeatures2d::Elliptic_KeyPoint::axes
Size_< float > axes
the lengths of the major and minor ellipse axes
Definition: xfeatures2d.hpp:908
cv::xfeatures2d::FREAK
Class implementing the FREAK (Fast Retina Keypoint) keypoint descriptor, described in .
Definition: xfeatures2d.hpp:86
cv::xfeatures2d::HarrisLaplaceFeatureDetector
Class implementing the Harris-Laplace feature detector as described in .
Definition: xfeatures2d.hpp:920
cv::xfeatures2d::LATCH
Definition: xfeatures2d.hpp:177
cv::xfeatures2d::LUCID
Class implementing the locally uniform comparison image descriptor, described in
Definition: xfeatures2d.hpp:144
cv::xfeatures2d::MSDDetector
Class implementing the MSD (Maximal Self-Dissimilarity) keypoint detector, described in .
Definition: xfeatures2d.hpp:327
cv::xfeatures2d::PCTSignatures
Class implementing PCT (position-color-texture) signature extraction as described in ....
Definition: xfeatures2d.hpp:449
cv::xfeatures2d::PCTSignatures::PointDistribution
PointDistribution
Point distributions supported by random point generator.
Definition: xfeatures2d.hpp:463
cv::xfeatures2d::PCTSignatures::UNIFORM
@ UNIFORM
Generate numbers uniformly.
Definition: xfeatures2d.hpp:464
cv::xfeatures2d::PCTSignatures::REGULAR
@ REGULAR
Generate points in a regular grid.
Definition: xfeatures2d.hpp:465
cv::xfeatures2d::PCTSignatures::SimilarityFunction
SimilarityFunction
Similarity function selector.
Definition: xfeatures2d.hpp:480
cv::xfeatures2d::PCTSignatures::GAUSSIAN
@ GAUSSIAN
Definition: xfeatures2d.hpp:482
cv::xfeatures2d::PCTSignatures::MINUS
@ MINUS
Definition: xfeatures2d.hpp:481
cv::xfeatures2d::PCTSignatures::DistanceFunction
DistanceFunction
Lp distance function selector.
Definition: xfeatures2d.hpp:455
cv::xfeatures2d::PCTSignaturesSQFD
Class implementing Signature Quadratic Form Distance (SQFD).
Definition: xfeatures2d.hpp:862
cv::xfeatures2d::StarDetector
The class implements the keypoint detector introduced by , synonym of StarDetector....
Definition: xfeatures2d.hpp:111
cv::xfeatures2d::TBMR
Class implementing the Tree Based Morse Regions (TBMR) as described in extended with scaled extracti...
Definition: xfeatures2d.hpp:1011
cv::xfeatures2d::VGG
Class implementing VGG (Oxford Visual Geometry Group) descriptor trained end to end using "Descriptor...
Definition: xfeatures2d.hpp:354
cv::norm
CV_EXPORTS_W double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray())
Calculates the absolute norm of an array.
cv::threshold
CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)
Applies a fixed-level threshold to each array element.
cv::xfeatures2d::FASTForPointSet
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)
Estimates cornerness for prespecified KeyPoints using the FAST algorithm
cv::xfeatures2d::matchLOGOS
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)
LOGOS (Local geometric support for high-outlier spatial verification) feature matching strategy descr...
cv::xfeatures2d::matchGMS
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)
GMS (Grid-based Motion Statistics) feature matching strategy described in .
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::L1
Definition: features2d.hpp:910
cv::L2
Definition: features2d.hpp:894
cv::Ptr
Definition: cvstd_wrapper.hpp:74
構築: doxygen 1.9.2