58 | {
59 | public:
60 |
61 | /**
62 | * Constructor
63 | */
64 | BowVector(void);
65 |
66 | /**
67 | * Destructor
68 | */
69 | ~BowVector(void);
70 |
71 | /**
72 | * Adds a value to a word value existing in the vector, or creates a new
73 | * word with the given value
74 | * @param id word id to look for
75 | * @param v value to create the word with, or to add to existing word
76 | */
77 | void addWeight(WordId id, WordValue v);
78 |
79 | /**
80 | * Adds a word with a value to the vector only if this does not exist yet
81 | * @param id word id to look for
82 | * @param v value to give to the word if this does not exist
83 | */
84 | void addIfNotExist(WordId id, WordValue v);
85 |
86 | /**
87 | * L1-Normalizes the values in the vector
88 | * @param norm_type norm used
89 | */
90 | void normalize(LNorm norm_type);
91 |
92 | /**
93 | * Prints the content of the bow vector
94 | * @param out stream
95 | * @param v
96 | */
97 | friend std::ostream& operator<<(std::ostream &out, const BowVector &v);
98 |
99 | /**
100 | * Saves the bow vector as a vector in a matlab file
101 | * @param filename
102 | * @param W number of words in the vocabulary
103 | */
104 | void saveM(const std::string &filename, size_t W) const;
105 | };
106 |
107 | } // namespace DBoW2
108 |
109 | #endif
110 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/DBoW2.h:
--------------------------------------------------------------------------------
1 | /*
2 | * File: DBoW2.h
3 | * Date: November 2011
4 | * Author: Dorian Galvez-Lopez
5 | * Description: Generic include file for the DBoW2 classes and
6 | * the specialized vocabularies and databases
7 | * License: see the LICENSE.txt file
8 | *
9 | */
10 |
11 | /*! \mainpage DBoW2 Library
12 | *
13 | * DBoW2 library for C++:
14 | * Bag-of-word image database for image retrieval.
15 | *
16 | * Written by Dorian Galvez-Lopez,
17 | * University of Zaragoza
18 | *
19 | * Check my website to obtain updates: http://doriangalvez.com
20 | *
21 | * \section requirements Requirements
22 | * This library requires the DUtils, DUtilsCV, DVision and OpenCV libraries,
23 | * as well as the boost::dynamic_bitset class.
24 | *
25 | * \section citation Citation
26 | * If you use this software in academic works, please cite:
27 |
28 | @@ARTICLE{GalvezTRO12,
29 | author={Galvez-Lopez, Dorian and Tardos, J. D.},
30 | journal={IEEE Transactions on Robotics},
31 | title={Bags of Binary Words for Fast Place Recognition in Image Sequences},
32 | year={2012},
33 | month={October},
34 | volume={28},
35 | number={5},
36 | pages={1188--1197},
37 | doi={10.1109/TRO.2012.2197158},
38 | ISSN={1552-3098}
39 | }
40 |
41 | *
42 | * \section license License
43 | * This file is licensed under a Creative Commons
44 | * Attribution-NonCommercial-ShareAlike 3.0 license.
45 | * This file can be freely used and users can use, download and edit this file
46 | * provided that credit is attributed to the original author. No users are
47 | * permitted to use this file for commercial purposes unless explicit permission
48 | * is given by the original author. Derivative works must be licensed using the
49 | * same or similar license.
50 | * Check http://creativecommons.org/licenses/by-nc-sa/3.0/ to obtain further
51 | * details.
52 | *
53 | */
54 |
55 | #ifndef __D_T_DBOW2__
56 | #define __D_T_DBOW2__
57 |
58 | /// Includes all the data structures to manage vocabularies and image databases
59 | namespace DBoW2
60 | {
61 | }
62 |
63 | #include "TemplatedVocabulary.h"
64 | #include "TemplatedDatabase.h"
65 | #include "BowVector.h"
66 | #include "FeatureVector.h"
67 | #include "QueryResults.h"
68 | #include "FBrief.h"
69 | #include "FORB.h"
70 |
71 | /// BRIEF Vocabulary
72 | typedef DBoW2::TemplatedVocabulary
73 | BriefVocabulary;
74 |
75 | /// BRIEF Database
76 | typedef DBoW2::TemplatedDatabase
77 | BriefDatabase;
78 |
79 | #endif
80 |
81 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FBrief.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FBrief.cpp
3 | * Date: November 2011
4 | * Author: Dorian Galvez-Lopez
5 | * Description: functions for BRIEF descriptors
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #include
11 | #include
12 | #include
13 |
14 | #include "FBrief.h"
15 |
16 | using namespace std;
17 |
18 | namespace DBoW2 {
19 |
20 | // --------------------------------------------------------------------------
21 |
22 | void FBrief::meanValue(const std::vector &descriptors,
23 | FBrief::TDescriptor &mean)
24 | {
25 | mean.reset();
26 |
27 | if(descriptors.empty()) return;
28 |
29 | const int N2 = descriptors.size() / 2;
30 | const int L = descriptors[0]->size();
31 |
32 | vector counters(L, 0);
33 |
34 | vector::const_iterator it;
35 | for(it = descriptors.begin(); it != descriptors.end(); ++it)
36 | {
37 | const FBrief::TDescriptor &desc = **it;
38 | for(int i = 0; i < L; ++i)
39 | {
40 | if(desc[i]) counters[i]++;
41 | }
42 | }
43 |
44 | for(int i = 0; i < L; ++i)
45 | {
46 | if(counters[i] > N2) mean.set(i);
47 | }
48 |
49 | }
50 |
51 | // --------------------------------------------------------------------------
52 |
53 | double FBrief::distance(const FBrief::TDescriptor &a,
54 | const FBrief::TDescriptor &b)
55 | {
56 | return (double)DVision::BRIEF::distance(a, b);
57 | }
58 |
59 | // --------------------------------------------------------------------------
60 |
61 | std::string FBrief::toString(const FBrief::TDescriptor &a)
62 | {
63 | // from boost::bitset
64 | string s;
65 | to_string(a, s); // reversed
66 | return s;
67 | }
68 |
69 | // --------------------------------------------------------------------------
70 |
71 | void FBrief::fromString(FBrief::TDescriptor &a, const std::string &s)
72 | {
73 | // from boost::bitset
74 | stringstream ss(s);
75 | ss >> a;
76 | }
77 |
78 | // --------------------------------------------------------------------------
79 |
80 | void FBrief::toMat32F(const std::vector &descriptors,
81 | cv::Mat &mat)
82 | {
83 | if(descriptors.empty())
84 | {
85 | mat.release();
86 | return;
87 | }
88 |
89 | const int N = descriptors.size();
90 | const int L = descriptors[0].size();
91 |
92 | mat.create(N, L, CV_32F);
93 |
94 | for(int i = 0; i < N; ++i)
95 | {
96 | const TDescriptor& desc = descriptors[i];
97 | float *p = mat.ptr(i);
98 | for(int j = 0; j < L; ++j, ++p)
99 | {
100 | *p = (desc[j] ? 1 : 0);
101 | }
102 | }
103 | }
104 |
105 | // --------------------------------------------------------------------------
106 |
107 | } // namespace DBoW2
108 |
109 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FBrief.h:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FBrief.h
3 | * Date: November 2011
4 | * Author: Dorian Galvez-Lopez
5 | * Description: functions for BRIEF descriptors
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #ifndef __D_T_F_BRIEF__
11 | #define __D_T_F_BRIEF__
12 |
13 | #include
14 | #include
15 | #include
16 |
17 | #include "FClass.h"
18 | #include "../DVision/DVision.h"
19 |
20 | namespace DBoW2 {
21 |
22 | /// Functions to manipulate BRIEF descriptors
23 | class FBrief: protected FClass
24 | {
25 | public:
26 |
27 | typedef DVision::BRIEF::bitset TDescriptor;
28 | typedef const TDescriptor *pDescriptor;
29 |
30 | /**
31 | * Calculates the mean value of a set of descriptors
32 | * @param descriptors
33 | * @param mean mean descriptor
34 | */
35 | static void meanValue(const std::vector &descriptors,
36 | TDescriptor &mean);
37 |
38 | /**
39 | * Calculates the distance between two descriptors
40 | * @param a
41 | * @param b
42 | * @return distance
43 | */
44 | static double distance(const TDescriptor &a, const TDescriptor &b);
45 |
46 | /**
47 | * Returns a string version of the descriptor
48 | * @param a descriptor
49 | * @return string version
50 | */
51 | static std::string toString(const TDescriptor &a);
52 |
53 | /**
54 | * Returns a descriptor from a string
55 | * @param a descriptor
56 | * @param s string version
57 | */
58 | static void fromString(TDescriptor &a, const std::string &s);
59 |
60 | /**
61 | * Returns a mat with the descriptors in float format
62 | * @param descriptors
63 | * @param mat (out) NxL 32F matrix
64 | */
65 | static void toMat32F(const std::vector &descriptors,
66 | cv::Mat &mat);
67 |
68 | };
69 |
70 | } // namespace DBoW2
71 |
72 | #endif
73 |
74 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FClass.h:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FClass.h
3 | * Date: November 2011
4 | * Author: Dorian Galvez-Lopez
5 | * Description: generic FClass to instantiate templated classes
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #ifndef __D_T_FCLASS__
11 | #define __D_T_FCLASS__
12 |
13 | #include
14 | #include
15 | #include
16 |
17 | namespace DBoW2 {
18 |
19 | /// Generic class to encapsulate functions to manage descriptors.
20 | /**
21 | * This class must be inherited. Derived classes can be used as the
22 | * parameter F when creating Templated structures
23 | * (TemplatedVocabulary, TemplatedDatabase, ...)
24 | */
25 | class FClass
26 | {
27 | class TDescriptor;
28 | typedef const TDescriptor *pDescriptor;
29 |
30 | /**
31 | * Calculates the mean value of a set of descriptors
32 | * @param descriptors
33 | * @param mean mean descriptor
34 | */
35 | virtual void meanValue(const std::vector &descriptors,
36 | TDescriptor &mean) = 0;
37 |
38 | /**
39 | * Calculates the distance between two descriptors
40 | * @param a
41 | * @param b
42 | * @return distance
43 | */
44 | static double distance(const TDescriptor &a, const TDescriptor &b);
45 |
46 | /**
47 | * Returns a string version of the descriptor
48 | * @param a descriptor
49 | * @return string version
50 | */
51 | static std::string toString(const TDescriptor &a);
52 |
53 | /**
54 | * Returns a descriptor from a string
55 | * @param a descriptor
56 | * @param s string version
57 | */
58 | static void fromString(TDescriptor &a, const std::string &s);
59 |
60 | /**
61 | * Returns a mat with the descriptors in float format
62 | * @param descriptors
63 | * @param mat (out) NxL 32F matrix
64 | */
65 | static void toMat32F(const std::vector &descriptors,
66 | cv::Mat &mat);
67 | };
68 |
69 | } // namespace DBoW2
70 |
71 | #endif
72 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FORB.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FORB.cpp
3 | * Date: June 2012
4 | * Author: Dorian Galvez-Lopez
5 | * Description: functions for ORB descriptors
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #include
11 | #include
12 | #include
13 | #include
14 | #include
15 |
16 | #include "FORB.h"
17 |
18 | using namespace std;
19 |
20 | namespace DBoW2 {
21 |
22 | // --------------------------------------------------------------------------
23 |
24 | void FORB::meanValue(const std::vector &descriptors,
25 | FORB::TDescriptor &mean)
26 | {
27 | if(descriptors.empty())
28 | {
29 | mean.release();
30 | return;
31 | }
32 | else if(descriptors.size() == 1)
33 | {
34 | mean = descriptors[0]->clone();
35 | }
36 | else
37 | {
38 | vector sum(FORB::L * 8, 0);
39 |
40 | for(size_t i = 0; i < descriptors.size(); ++i)
41 | {
42 | const cv::Mat &d = *descriptors[i];
43 | const unsigned char *p = d.ptr();
44 |
45 | for(int j = 0; j < d.cols; ++j, ++p)
46 | {
47 | if(*p & (1 << 7)) ++sum[ j*8 ];
48 | if(*p & (1 << 6)) ++sum[ j*8 + 1 ];
49 | if(*p & (1 << 5)) ++sum[ j*8 + 2 ];
50 | if(*p & (1 << 4)) ++sum[ j*8 + 3 ];
51 | if(*p & (1 << 3)) ++sum[ j*8 + 4 ];
52 | if(*p & (1 << 2)) ++sum[ j*8 + 5 ];
53 | if(*p & (1 << 1)) ++sum[ j*8 + 6 ];
54 | if(*p & (1)) ++sum[ j*8 + 7 ];
55 | }
56 | }
57 |
58 | mean = cv::Mat::zeros(1, FORB::L, CV_8U);
59 | unsigned char *p = mean.ptr();
60 |
61 | const int N2 = (int)descriptors.size() / 2 + descriptors.size() % 2;
62 | for(size_t i = 0; i < sum.size(); ++i)
63 | {
64 | if(sum[i] >= N2)
65 | {
66 | // set bit
67 | *p |= 1 << (7 - (i % 8));
68 | }
69 |
70 | if(i % 8 == 7) ++p;
71 | }
72 | }
73 | }
74 |
75 | // --------------------------------------------------------------------------
76 |
77 | double FORB::distance(const FORB::TDescriptor &a,
78 | const FORB::TDescriptor &b)
79 | {
80 | // Bit count function got from:
81 | // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
82 | // This implementation assumes that a.cols (CV_8U) % sizeof(uint64_t) == 0
83 |
84 | const uint64_t *pa, *pb;
85 | pa = a.ptr(); // a & b are actually CV_8U
86 | pb = b.ptr();
87 |
88 | uint64_t v, ret = 0;
89 | for(size_t i = 0; i < a.cols / sizeof(uint64_t); ++i, ++pa, ++pb)
90 | {
91 | v = *pa ^ *pb;
92 | v = v - ((v >> 1) & (uint64_t)~(uint64_t)0/3);
93 | v = (v & (uint64_t)~(uint64_t)0/15*3) + ((v >> 2) &
94 | (uint64_t)~(uint64_t)0/15*3);
95 | v = (v + (v >> 4)) & (uint64_t)~(uint64_t)0/255*15;
96 | ret += (uint64_t)(v * ((uint64_t)~(uint64_t)0/255)) >>
97 | (sizeof(uint64_t) - 1) * CHAR_BIT;
98 | }
99 |
100 | return static_cast(ret);
101 |
102 | // // If uint64_t is not defined in your system, you can try this
103 | // // portable approach (requires DUtils from DLib)
104 | // const unsigned char *pa, *pb;
105 | // pa = a.ptr();
106 | // pb = b.ptr();
107 | //
108 | // int ret = 0;
109 | // for(int i = 0; i < a.cols; ++i, ++pa, ++pb)
110 | // {
111 | // ret += DUtils::LUT::ones8bits[ *pa ^ *pb ];
112 | // }
113 | //
114 | // return ret;
115 | }
116 |
117 | // --------------------------------------------------------------------------
118 |
119 | std::string FORB::toString(const FORB::TDescriptor &a)
120 | {
121 | stringstream ss;
122 | const unsigned char *p = a.ptr();
123 |
124 | for(int i = 0; i < a.cols; ++i, ++p)
125 | {
126 | ss << (int)*p << " ";
127 | }
128 |
129 | return ss.str();
130 | }
131 |
132 | // --------------------------------------------------------------------------
133 |
134 | void FORB::fromString(FORB::TDescriptor &a, const std::string &s)
135 | {
136 | a.create(1, FORB::L, CV_8U);
137 | unsigned char *p = a.ptr();
138 |
139 | stringstream ss(s);
140 | for(int i = 0; i < FORB::L; ++i, ++p)
141 | {
142 | int n;
143 | ss >> n;
144 |
145 | if(!ss.fail())
146 | *p = (unsigned char)n;
147 | }
148 |
149 | }
150 |
151 | // --------------------------------------------------------------------------
152 |
153 | void FORB::toMat32F(const std::vector &descriptors,
154 | cv::Mat &mat)
155 | {
156 | if(descriptors.empty())
157 | {
158 | mat.release();
159 | return;
160 | }
161 |
162 | const size_t N = descriptors.size();
163 |
164 | mat.create(N, FORB::L*8, CV_32F);
165 | float *p = mat.ptr();
166 |
167 | for(size_t i = 0; i < N; ++i)
168 | {
169 | const int C = descriptors[i].cols;
170 | const unsigned char *desc = descriptors[i].ptr();
171 |
172 | for(int j = 0; j < C; ++j, p += 8)
173 | {
174 | p[0] = (desc[j] & (1 << 7) ? 1.f : 0.f);
175 | p[1] = (desc[j] & (1 << 6) ? 1.f : 0.f);
176 | p[2] = (desc[j] & (1 << 5) ? 1.f : 0.f);
177 | p[3] = (desc[j] & (1 << 4) ? 1.f : 0.f);
178 | p[4] = (desc[j] & (1 << 3) ? 1.f : 0.f);
179 | p[5] = (desc[j] & (1 << 2) ? 1.f : 0.f);
180 | p[6] = (desc[j] & (1 << 1) ? 1.f : 0.f);
181 | p[7] = (desc[j] & (1) ? 1.f : 0.f);
182 | }
183 | }
184 | }
185 |
186 | // --------------------------------------------------------------------------
187 |
188 | void FORB::toMat32F(const cv::Mat &descriptors, cv::Mat &mat)
189 | {
190 | descriptors.convertTo(mat, CV_32F);
191 | }
192 |
193 | // --------------------------------------------------------------------------
194 |
195 | void FORB::toMat8U(const std::vector &descriptors,
196 | cv::Mat &mat)
197 | {
198 | mat.create(descriptors.size(), FORB::L, CV_8U);
199 |
200 | unsigned char *p = mat.ptr();
201 |
202 | for(size_t i = 0; i < descriptors.size(); ++i, p += FORB::L)
203 | {
204 | const unsigned char *d = descriptors[i].ptr();
205 | std::copy(d, d + FORB::L, p);
206 | }
207 |
208 | }
209 |
210 | // --------------------------------------------------------------------------
211 |
212 | } // namespace DBoW2
213 |
214 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FORB.h:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FORB.h
3 | * Date: June 2012
4 | * Author: Dorian Galvez-Lopez
5 | * Description: functions for ORB descriptors
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #ifndef __D_T_F_ORB__
11 | #define __D_T_F_ORB__
12 |
13 | #include
14 | #include
15 | #include
16 |
17 | #include "FClass.h"
18 |
19 | namespace DBoW2 {
20 |
21 | /// Functions to manipulate BRIEF descriptors
22 | class FORB: protected FClass
23 | {
24 | public:
25 |
26 | /// Descriptor type
27 | typedef cv::Mat TDescriptor; // CV_8U
28 | /// Pointer to a single descriptor
29 | typedef const TDescriptor *pDescriptor;
30 | /// Descriptor length (in bytes)
31 | static const int L = 32;
32 |
33 | /**
34 | * Calculates the mean value of a set of descriptors
35 | * @param descriptors
36 | * @param mean mean descriptor
37 | */
38 | static void meanValue(const std::vector &descriptors,
39 | TDescriptor &mean);
40 |
41 | /**
42 | * Calculates the distance between two descriptors
43 | * @param a
44 | * @param b
45 | * @return distance
46 | */
47 | static double distance(const TDescriptor &a, const TDescriptor &b);
48 |
49 | /**
50 | * Returns a string version of the descriptor
51 | * @param a descriptor
52 | * @return string version
53 | */
54 | static std::string toString(const TDescriptor &a);
55 |
56 | /**
57 | * Returns a descriptor from a string
58 | * @param a descriptor
59 | * @param s string version
60 | */
61 | static void fromString(TDescriptor &a, const std::string &s);
62 |
63 | /**
64 | * Returns a mat with the descriptors in float format
65 | * @param descriptors
66 | * @param mat (out) NxL 32F matrix
67 | */
68 | static void toMat32F(const std::vector &descriptors,
69 | cv::Mat &mat);
70 |
71 | /**
72 | * Returns a mat with the descriptors in float format
73 | * @param descriptors NxL CV_8U matrix
74 | * @param mat (out) NxL 32F matrix
75 | */
76 | static void toMat32F(const cv::Mat &descriptors, cv::Mat &mat);
77 |
78 | /**
79 | * Returns a matrix with the descriptor in OpenCV format
80 | * @param descriptors vector of N row descriptors
81 | * @param mat (out) NxL CV_8U matrix
82 | */
83 | static void toMat8U(const std::vector &descriptors,
84 | cv::Mat &mat);
85 |
86 | };
87 |
88 | } // namespace DBoW2
89 |
90 | #endif
91 |
92 |
--------------------------------------------------------------------------------
/loop_fusion/ThirdParty/DBoW/FeatureVector.cpp:
--------------------------------------------------------------------------------
1 | /**
2 | * File: FeatureVector.cpp
3 | * Date: November 2011
4 | * Author: Dorian Galvez-Lopez
5 | * Description: feature vector
6 | * License: see the LICENSE.txt file
7 | *
8 | */
9 |
10 | #include "FeatureVector.h"
11 | #include 
