ImageStitcherFAST/ORBExtractor.h at master · tharaka27/ImageStitcherFAST · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#pragma once


#include <vector>
#include <list>

namespace TORB {

	class ExtractorNode
	{
	public:
		ExtractorNode() :bNoMore(false) {}

		void DivideNode(ExtractorNode& n1, ExtractorNode& n2, ExtractorNode& n3, ExtractorNode& n4);

		std::vector<cv::KeyPoint> vKeys;
		cv::Point2i UL, UR, BL, BR;
		std::list<ExtractorNode>::iterator lit;
		bool bNoMore;
	};


	class ORBExtractor
	{

	public:
		enum { HARRIS_SCORE = 0, FAST_SCORE = 1 };

		ORBExtractor(int nfeatures, float scaleFactor, int nlevels,
			int iniThFAST, int minThFAST);

		~ORBExtractor() {}

		// Compute the ORB features and descriptors on an image.
		// ORB are dispersed on the image using an octree.
		// Mask is ignored in the current implementation.
		void operator()(cv::InputArray image, cv::InputArray mask,
			std::vector<cv::KeyPoint>& keypoints,
			cv::OutputArray descriptors);

		int inline GetLevels() {
			return nlevels;
		}

		float inline GetScaleFactor() {
			return scaleFactor;
		}

		std::vector<float> inline GetScaleFactors() {
			return mvScaleFactor;
		}

		std::vector<float> inline GetInverseScaleFactors() {
			return mvInvScaleFactor;
		}

		std::vector<float> inline GetScaleSigmaSquares() {
			return mvLevelSigma2;
		}

		std::vector<float> inline GetInverseScaleSigmaSquares() {
			return mvInvLevelSigma2;
		}

		std::vector<cv::Mat> mvImagePyramid;


	protected:

		void ComputePyramid(cv::Mat image);
		void ComputeKeyPointsOctTree(std::vector<std::vector<cv::KeyPoint> >& allKeypoints);
		std::vector<cv::KeyPoint> DistributeOctTree(const std::vector<cv::KeyPoint>& vToDistributeKeys, const int& minX,
			const int& maxX, const int& minY, const int& maxY, const int& nFeatures, const int& level);

		//void ComputeKeyPointsOld(std::vector<std::vector<cv::KeyPoint> >& allKeypoints);
		std::vector<cv::Point> pattern;

		int nfeatures;
		double scaleFactor;
		int nlevels;
		int iniThFAST;
		int minThFAST;

		std::vector<int> mnFeaturesPerLevel;

		std::vector<int> umax;

		std::vector<float> mvScaleFactor;
		std::vector<float> mvInvScaleFactor;
		std::vector<float> mvLevelSigma2;
		std::vector<float> mvInvLevelSigma2;
	};

}