AlcideSystem/Webcam
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init: 64 bits version of the webcam

Browse Source
This commit is contained in:
Nicolas RACOT
2026-07-13 16:31:52 +02:00
parent c0f3eeb00d
commit 07e526544d
381 changed files with 43996 additions and 9097 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/opencv2/flann/allocator.h
View File

@ -97,6 +97,7 @@ public:
blocksize = blockSize;
remaining = 0;
base = NULL;
loc = NULL;
usedMemory = 0;
wastedMemory = 0;
@ -181,6 +182,9 @@ public:
return mem;
}
private:
PooledAllocator(const PooledAllocator &); // copy disabled
PooledAllocator& operator=(const PooledAllocator &); // assign disabled
};
}

45
include/opencv2/flann/any.h
View File

@ -54,49 +54,50 @@ struct base_any_policy
template<typename T>
struct typed_base_any_policy : base_any_policy
{
virtual ::size_t get_size() { return sizeof(T); }
virtual const std::type_info& type() { return typeid(T); }
virtual ::size_t get_size() CV_OVERRIDE { return sizeof(T); }
virtual const std::type_info& type() CV_OVERRIDE { return typeid(T); }
};
template<typename T>
struct small_any_policy : typed_base_any_policy<T>
struct small_any_policy CV_FINAL : typed_base_any_policy<T>
{
virtual void static_delete(void**) { }
virtual void copy_from_value(void const* src, void** dest)
virtual void static_delete(void**) CV_OVERRIDE { }
virtual void copy_from_value(void const* src, void** dest) CV_OVERRIDE
{
new (dest) T(* reinterpret_cast<T const*>(src));
}
virtual void clone(void* const* src, void** dest) { *dest = *src; }
virtual void move(void* const* src, void** dest) { *dest = *src; }
virtual void* get_value(void** src) { return reinterpret_cast<void*>(src); }
virtual const void* get_value(void* const * src) { return reinterpret_cast<const void*>(src); }
virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(src); }
virtual void clone(void* const* src, void** dest) CV_OVERRIDE { *dest = *src; }
virtual void move(void* const* src, void** dest) CV_OVERRIDE { *dest = *src; }
virtual void* get_value(void** src) CV_OVERRIDE { return reinterpret_cast<void*>(src); }
virtual const void* get_value(void* const * src) CV_OVERRIDE { return reinterpret_cast<const void*>(src); }
virtual void print(std::ostream& out, void* const* src) CV_OVERRIDE { out << *reinterpret_cast<T const*>(src); }
};
template<typename T>
struct big_any_policy : typed_base_any_policy<T>
struct big_any_policy CV_FINAL : typed_base_any_policy<T>
{
virtual void static_delete(void** x)
virtual void static_delete(void** x) CV_OVERRIDE
{
if (* x) delete (* reinterpret_cast<T**>(x)); *x = NULL;
if (* x) delete (* reinterpret_cast<T**>(x));
*x = NULL;
}
virtual void copy_from_value(void const* src, void** dest)
virtual void copy_from_value(void const* src, void** dest) CV_OVERRIDE
{
*dest = new T(*reinterpret_cast<T const*>(src));
}
virtual void clone(void* const* src, void** dest)
virtual void clone(void* const* src, void** dest) CV_OVERRIDE
{
*dest = new T(**reinterpret_cast<T* const*>(src));
}
virtual void move(void* const* src, void** dest)
virtual void move(void* const* src, void** dest) CV_OVERRIDE
{
(*reinterpret_cast<T**>(dest))->~T();
**reinterpret_cast<T**>(dest) = **reinterpret_cast<T* const*>(src);
}
virtual void* get_value(void** src) { return *src; }
virtual const void* get_value(void* const * src) { return *src; }
virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(*src); }
virtual void* get_value(void** src) CV_OVERRIDE { return *src; }
virtual const void* get_value(void* const * src) CV_OVERRIDE { return *src; }
virtual void print(std::ostream& out, void* const* src) CV_OVERRIDE { out << *reinterpret_cast<T const*>(*src); }
};
template<> inline void big_any_policy<flann_centers_init_t>::print(std::ostream& out, void* const* src)
@ -245,6 +246,12 @@ public:
return assign(x);
}
/// Assignment operator. Template-based version above doesn't work as expected. We need regular assignment operator here.
any& operator=(const any& x)
{
return assign(x);
}
/// Assignment operator, specialed for literal strings.
/// They have types like const char [6] which don't work as expected.
any& operator=(const char* x)

22
include/opencv2/flann/autotuned_index.h
View File

@ -30,6 +30,8 @@
#ifndef OPENCV_FLANN_AUTOTUNED_INDEX_H_
#define OPENCV_FLANN_AUTOTUNED_INDEX_H_
#include <sstream>
#include "general.h"
#include "nn_index.h"
#include "ground_truth.h"
@ -81,6 +83,7 @@ public:
memory_weight_ = get_param(params, "memory_weight", 0.0f);
sample_fraction_ = get_param(params,"sample_fraction", 0.1f);
bestIndex_ = NULL;
speedup_ = 0;
}
AutotunedIndex(const AutotunedIndex&);
@ -97,7 +100,7 @@ public:
/**
* Method responsible with building the index.
*/
virtual void buildIndex()
virtual void buildIndex() CV_OVERRIDE
{
std::ostringstream stream;
bestParams_ = estimateBuildParams();
@ -121,7 +124,7 @@ public:
/**
* Saves the index to a stream
*/
virtual void saveIndex(FILE* stream)
virtual void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream, (int)bestIndex_->getType());
bestIndex_->saveIndex(stream);
@ -131,7 +134,7 @@ public:
/**
* Loads the index from a stream
*/
virtual void loadIndex(FILE* stream)
virtual void loadIndex(FILE* stream) CV_OVERRIDE
{
int index_type;
@ -148,7 +151,7 @@ public:
/**
* Method that searches for nearest-neighbors
*/
virtual void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
virtual void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
int checks = get_param<int>(searchParams,"checks",FLANN_CHECKS_AUTOTUNED);
if (checks == FLANN_CHECKS_AUTOTUNED) {
@ -160,7 +163,7 @@ public:
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return bestIndex_->getParameters();
}
@ -179,7 +182,7 @@ public:
/**
* Number of features in this index.
*/
virtual size_t size() const
virtual size_t size() const CV_OVERRIDE
{
return bestIndex_->size();
}
@ -187,7 +190,7 @@ public:
/**
* The length of each vector in this index.
*/
virtual size_t veclen() const
virtual size_t veclen() const CV_OVERRIDE
{
return bestIndex_->veclen();
}
@ -195,7 +198,7 @@ public:
/**
* The amount of memory (in bytes) this index uses.
*/
virtual int usedMemory() const
virtual int usedMemory() const CV_OVERRIDE
{
return bestIndex_->usedMemory();
}
@ -203,7 +206,7 @@ public:
/**
* Algorithm name
*/
virtual flann_algorithm_t getType() const
virtual flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_AUTOTUNED;
}
@ -377,6 +380,7 @@ private:
// evaluate kdtree for all parameter combinations
for (size_t i = 0; i < FLANN_ARRAY_LEN(testTrees); ++i) {
CostData cost;
cost.params["algorithm"] = FLANN_INDEX_KDTREE;
cost.params["trees"] = testTrees[i];
evaluate_kdtree(cost);

18
include/opencv2/flann/composite_index.h
View File

@ -101,7 +101,7 @@ public:
/**
* @return The index type
*/
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_COMPOSITE;
}
@ -109,7 +109,7 @@ public:
/**
* @return Size of the index
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return kdtree_index_->size();
}
@ -117,7 +117,7 @@ public:
/**
* \returns The dimensionality of the features in this index.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return kdtree_index_->veclen();
}
@ -125,7 +125,7 @@ public:
/**
* \returns The amount of memory (in bytes) used by the index.
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return kmeans_index_->usedMemory() + kdtree_index_->usedMemory();
}
@ -133,7 +133,7 @@ public:
/**
* \brief Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
Logger::info("Building kmeans tree...\n");
kmeans_index_->buildIndex();
@ -145,7 +145,7 @@ public:
* \brief Saves the index to a stream
* \param stream The stream to save the index to
*/
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
kmeans_index_->saveIndex(stream);
kdtree_index_->saveIndex(stream);
@ -155,7 +155,7 @@ public:
* \brief Loads the index from a stream
* \param stream The stream from which the index is loaded
*/
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
kmeans_index_->loadIndex(stream);
kdtree_index_->loadIndex(stream);
@ -164,7 +164,7 @@ public:
/**
* \returns The index parameters
*/
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}
@ -172,7 +172,7 @@ public:
/**
* \brief Method that searches for nearest-neighbours
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
kmeans_index_->findNeighbors(result, vec, searchParams);
kdtree_index_->findNeighbors(result, vec, searchParams);

15
include/opencv2/flann/defines.h
View File

@ -35,7 +35,7 @@
#ifdef FLANN_EXPORT
#undef FLANN_EXPORT
#endif
#ifdef WIN32
#ifdef _WIN32
/* win32 dll export/import directives */
#ifdef FLANN_EXPORTS
#define FLANN_EXPORT __declspec(dllexport)
@ -50,19 +50,6 @@
#endif
#ifdef FLANN_DEPRECATED
#undef FLANN_DEPRECATED
#endif
#ifdef __GNUC__
#define FLANN_DEPRECATED __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define FLANN_DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: You need to implement FLANN_DEPRECATED for this compiler")
#define FLANN_DEPRECATED
#endif
#undef FLANN_PLATFORM_32_BIT
#undef FLANN_PLATFORM_64_BIT
#if defined __amd64__ || defined __x86_64__ || defined _WIN64 || defined _M_X64

9
include/opencv2/flann/dist.h
View File

@ -43,7 +43,7 @@ typedef unsigned __int64 uint64_t;
#include "defines.h"
#if (defined WIN32 || defined _WIN32) && defined(_M_ARM)
#if defined _WIN32 && defined(_M_ARM)
# include <Intrin.h>
#endif
@ -462,10 +462,9 @@ struct Hamming
}
}
#else // NO NEON and NOT GNUC
typedef unsigned long long pop_t;
HammingLUT lut;
result = lut(reinterpret_cast<const unsigned char*> (a),
reinterpret_cast<const unsigned char*> (b), size * sizeof(pop_t));
reinterpret_cast<const unsigned char*> (b), size);
#endif
return result;
}
@ -698,7 +697,7 @@ struct KL_Divergence
typedef typename Accumulator<T>::Type ResultType;
/**
* Compute the Kullback–Leibler divergence
* Compute the Kullback-Leibler divergence
*/
template <typename Iterator1, typename Iterator2>
ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const
@ -843,7 +842,7 @@ typename Distance::ResultType ensureSquareDistance( typename Distance::ResultTyp
/*
* ...and a template to ensure the user that he will process the normal distance,
* and not squared distance, without loosing processing time calling sqrt(ensureSquareDistance)
* and not squared distance, without losing processing time calling sqrt(ensureSquareDistance)
* that will result in doing actually sqrt(dist*dist) for L1 distance for instance.
*/
template <typename Distance, typename ElementType>

5
include/opencv2/flann/dummy.h
View File

@ -5,10 +5,7 @@
namespace cvflann
{
#if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
__declspec(dllexport)
#endif
void dummyfunc();
CV_DEPRECATED inline void dummyfunc() {}
}

2
include/opencv2/flann/dynamic_bitset.h
View File

@ -59,7 +59,7 @@ class DynamicBitset
public:
/** default constructor
*/
DynamicBitset()
DynamicBitset() : size_(0)
{
}

31
include/opencv2/flann/flann_base.hpp
View File

@ -80,9 +80,11 @@ NNIndex<Distance>* load_saved_index(const Matrix<typename Distance::ElementType>
}
IndexHeader header = load_header(fin);
if (header.data_type != Datatype<ElementType>::type()) {
fclose(fin);
throw FLANNException("Datatype of saved index is different than of the one to be created.");
}
if ((size_t(header.rows) != dataset.rows)||(size_t(header.cols) != dataset.cols)) {
fclose(fin);
throw FLANNException("The index saved belongs to a different dataset");
}
@ -126,7 +128,7 @@ public:
/**
* Builds the index.
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
if (!loaded_) {
nnIndex_->buildIndex();
@ -148,7 +150,7 @@ public:
* \brief Saves the index to a stream
* \param stream The stream to save the index to
*/
virtual void saveIndex(FILE* stream)
virtual void saveIndex(FILE* stream) CV_OVERRIDE
{
nnIndex_->saveIndex(stream);
}
@ -157,7 +159,7 @@ public:
* \brief Loads the index from a stream
* \param stream The stream from which the index is loaded
*/
virtual void loadIndex(FILE* stream)
virtual void loadIndex(FILE* stream) CV_OVERRIDE
{
nnIndex_->loadIndex(stream);
}
@ -165,7 +167,7 @@ public:
/**
* \returns number of features in this index.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return nnIndex_->veclen();
}
@ -173,7 +175,7 @@ public:
/**
* \returns The dimensionality of the features in this index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return nnIndex_->size();
}
@ -181,7 +183,7 @@ public:
/**
* \returns The index type (kdtree, kmeans,...)
*/
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return nnIndex_->getType();
}
@ -189,7 +191,7 @@ public:
/**
* \returns The amount of memory (in bytes) used by the index.
*/
virtual int usedMemory() const
virtual int usedMemory() const CV_OVERRIDE
{
return nnIndex_->usedMemory();
}
@ -198,7 +200,7 @@ public:
/**
* \returns The index parameters
*/
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return nnIndex_->getParameters();
}
@ -211,7 +213,7 @@ public:
* \param[in] knn Number of nearest neighbors to return
* \param[in] params Search parameters
*/
void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params) CV_OVERRIDE
{
nnIndex_->knnSearch(queries, indices, dists, knn, params);
}
@ -225,7 +227,7 @@ public:
* \param[in] params Search parameters
* \returns Number of neighbors found
*/
int radiusSearch(const Matrix<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& dists, float radius, const SearchParams& params)
int radiusSearch(const Matrix<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& dists, float radius, const SearchParams& params) CV_OVERRIDE
{
return nnIndex_->radiusSearch(query, indices, dists, radius, params);
}
@ -233,7 +235,7 @@ public:
/**
* \brief Method that searches for nearest-neighbours
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
nnIndex_->findNeighbors(result, vec, searchParams);
}
@ -241,7 +243,7 @@ public:
/**
* \brief Returns actual index
*/
FLANN_DEPRECATED NNIndex<Distance>* getIndex()
CV_DEPRECATED NNIndex<Distance>* getIndex()
{
return nnIndex_;
}
@ -250,7 +252,7 @@ public:
* \brief Returns index parameters.
* \deprecated use getParameters() instead.
*/
FLANN_DEPRECATED const IndexParams* getIndexParameters()
CV_DEPRECATED const IndexParams* getIndexParameters()
{
return &index_params_;
}
@ -262,6 +264,9 @@ private:
bool loaded_;
/** Parameters passed to the index */
IndexParams index_params_;
Index(const Index &); // copy disabled
Index& operator=(const Index &); // assign disabled
};
/**

18
include/opencv2/flann/hierarchical_clustering_index.h
View File

@ -435,7 +435,7 @@ public:
/**
* Returns size of index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return size_;
}
@ -443,7 +443,7 @@ public:
/**
* Returns the length of an index feature.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return veclen_;
}
@ -453,7 +453,7 @@ public:
* Computes the inde memory usage
* Returns: memory used by the index
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return pool.usedMemory+pool.wastedMemory+memoryCounter;
}
@ -461,7 +461,7 @@ public:
/**
* Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
if (branching_<2) {
throw FLANNException("Branching factor must be at least 2");
@ -480,13 +480,13 @@ public:
}
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_HIERARCHICAL;
}
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream, branching_);
save_value(stream, trees_);
@ -501,7 +501,7 @@ public:
}
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
free_elements();
@ -544,7 +544,7 @@ public:
* vec = the vector for which to search the nearest neighbors
* searchParams = parameters that influence the search algorithm (checks)
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
int maxChecks = get_param(searchParams,"checks",32);
@ -569,7 +569,7 @@ public:
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return params;
}

23
include/opencv2/flann/kdtree_index.h
View File

@ -120,24 +120,29 @@ public:
/**
* Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
/* Construct the randomized trees. */
for (int i = 0; i < trees_; i++) {
/* Randomize the order of vectors to allow for unbiased sampling. */
#ifndef OPENCV_FLANN_USE_STD_RAND
cv::randShuffle(vind_);
#else
std::random_shuffle(vind_.begin(), vind_.end());
#endif
tree_roots_[i] = divideTree(&vind_[0], int(size_) );
}
}
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_KDTREE;
}
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream, trees_);
for (int i=0; i<trees_; ++i) {
@ -147,7 +152,7 @@ public:
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
load_value(stream, trees_);
if (tree_roots_!=NULL) {
@ -165,7 +170,7 @@ public:
/**
* Returns size of index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return size_;
}
@ -173,7 +178,7 @@ public:
/**
* Returns the length of an index feature.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return veclen_;
}
@ -182,7 +187,7 @@ public:
* Computes the inde memory usage
* Returns: memory used by the index
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return int(pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int)); // pool memory and vind array memory
}
@ -196,7 +201,7 @@ public:
* vec = the vector for which to search the nearest neighbors
* maxCheck = the maximum number of restarts (in a best-bin-first manner)
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
int maxChecks = get_param(searchParams,"checks", 32);
float epsError = 1+get_param(searchParams,"eps",0.0f);
@ -209,7 +214,7 @@ public:
}
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}

21
include/opencv2/flann/kdtree_single_index.h
View File

@ -87,6 +87,7 @@ public:
{
size_ = dataset_.rows;
dim_ = dataset_.cols;
root_node_ = 0;
int dim_param = get_param(params,"dim",-1);
if (dim_param>0) dim_ = dim_param;
leaf_max_size_ = get_param(params,"leaf_max_size",10);
@ -113,7 +114,7 @@ public:
/**
* Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
computeBoundingBox(root_bbox_);
root_node_ = divideTree(0, (int)size_, root_bbox_ ); // construct the tree
@ -132,13 +133,13 @@ public:
}
}
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_KDTREE_SINGLE;
}
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream, size_);
save_value(stream, dim_);
@ -153,7 +154,7 @@ public:
}
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
load_value(stream, size_);
load_value(stream, dim_);
@ -178,7 +179,7 @@ public:
/**
* Returns size of index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return size_;
}
@ -186,7 +187,7 @@ public:
/**
* Returns the length of an index feature.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return dim_;
}
@ -195,7 +196,7 @@ public:
* Computes the inde memory usage
* Returns: memory used by the index
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return (int)(pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int)); // pool memory and vind array memory
}
@ -209,7 +210,7 @@ public:
* \param[in] knn Number of nearest neighbors to return
* \param[in] params Search parameters
*/
void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params) CV_OVERRIDE
{
assert(queries.cols == veclen());
assert(indices.rows >= queries.rows);
@ -224,7 +225,7 @@ public:
}
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}
@ -238,7 +239,7 @@ public:
* vec = the vector for which to search the nearest neighbors
* maxCheck = the maximum number of restarts (in a best-bin-first manner)
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
float epsError = 1+get_param(searchParams,"eps",0.0f);

49
include/opencv2/flann/kmeans_index.h
View File

@ -266,7 +266,7 @@ public:
public:
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_KMEANS;
}
@ -276,7 +276,7 @@ public:
public:
KMeansDistanceComputer(Distance _distance, const Matrix<ElementType>& _dataset,
const int _branching, const int* _indices, const Matrix<double>& _dcenters, const size_t _veclen,
int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool& _converged, cv::Mutex& _mtx)
int* _count, int* _belongs_to, std::vector<DistanceType>& _radiuses, bool& _converged)
: distance(_distance)
, dataset(_dataset)
, branching(_branching)
@ -287,11 +287,10 @@ public:
, belongs_to(_belongs_to)
, radiuses(_radiuses)
, converged(_converged)
, mtx(_mtx)
{
}
void operator()(const cv::Range& range) const
void operator()(const cv::Range& range) const CV_OVERRIDE
{
const int begin = range.start;
const int end = range.end;
@ -311,12 +310,10 @@ public:
radiuses[new_centroid] = sq_dist;
}
if (new_centroid != belongs_to[i]) {
count[belongs_to[i]]--;
count[new_centroid]++;
CV_XADD(&count[belongs_to[i]], -1);
CV_XADD(&count[new_centroid], 1);
belongs_to[i] = new_centroid;
mtx.lock();
converged = false;
mtx.unlock();
}
}
}
@ -332,7 +329,6 @@ public:
int* belongs_to;
std::vector<DistanceType>& radiuses;
bool& converged;
cv::Mutex& mtx;
KMeansDistanceComputer& operator=( const KMeansDistanceComputer & ) { return *this; }
};
@ -398,7 +394,7 @@ public:
/**
* Returns size of index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return size_;
}
@ -406,7 +402,7 @@ public:
/**
* Returns the length of an index feature.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return veclen_;
}
@ -421,7 +417,7 @@ public:
* Computes the inde memory usage
* Returns: memory used by the index
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return pool_.usedMemory+pool_.wastedMemory+memoryCounter_;
}
@ -429,7 +425,7 @@ public:
/**
* Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
if (branching_<2) {
throw FLANNException("Branching factor must be at least 2");
@ -441,12 +437,14 @@ public:
}
root_ = pool_.allocate<KMeansNode>();
std::memset(root_, 0, sizeof(KMeansNode));
computeNodeStatistics(root_, indices_, (int)size_);
computeClustering(root_, indices_, (int)size_, branching_,0);
}
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream, branching_);
save_value(stream, iterations_);
@ -458,7 +456,7 @@ public:
}
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
load_value(stream, branching_);
load_value(stream, iterations_);
@ -493,7 +491,7 @@ public:
* vec = the vector for which to search the nearest neighbors
* searchParams = parameters that influence the search algorithm (checks, cb_index)
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams) CV_OVERRIDE
{
int maxChecks = get_param(searchParams,"checks",32);
@ -552,7 +550,7 @@ public:
return clusterCount;
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}
@ -724,7 +722,7 @@ private:
}
cv::AutoBuffer<int> centers_idx_buf(branching);
int* centers_idx = (int*)centers_idx_buf;
int* centers_idx = centers_idx_buf.data();
int centers_length;
(this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length);
@ -737,7 +735,7 @@ private:
cv::AutoBuffer<double> dcenters_buf(branching*veclen_);
Matrix<double> dcenters((double*)dcenters_buf,branching,veclen_);
Matrix<double> dcenters(dcenters_buf.data(), branching, veclen_);
for (int i=0; i<centers_length; ++i) {
ElementType* vec = dataset_[centers_idx[i]];
for (size_t k=0; k<veclen_; ++k) {
@ -747,7 +745,7 @@ private:
std::vector<DistanceType> radiuses(branching);
cv::AutoBuffer<int> count_buf(branching);
int* count = (int*)count_buf;
int* count = count_buf.data();
for (int i=0; i<branching; ++i) {
radiuses[i] = 0;
count[i] = 0;
@ -755,7 +753,7 @@ private:
// assign points to clusters
cv::AutoBuffer<int> belongs_to_buf(indices_length);
int* belongs_to = (int*)belongs_to_buf;
int* belongs_to = belongs_to_buf.data();
for (int i=0; i<indices_length; ++i) {
DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
@ -799,8 +797,7 @@ private:
}
// reassign points to clusters
cv::Mutex mtx;
KMeansDistanceComputer invoker(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, converged, mtx);
KMeansDistanceComputer invoker(distance_, dataset_, branching, indices, dcenters, veclen_, count, belongs_to, radiuses, converged);
parallel_for_(cv::Range(0, (int)indices_length), invoker);
for (int i=0; i<branching; ++i) {
@ -864,14 +861,16 @@ private:
variance -= distance_(centers[c], ZeroIterator<ElementType>(), veclen_);
node->childs[c] = pool_.allocate<KMeansNode>();
std::memset(node->childs[c], 0, sizeof(KMeansNode));
node->childs[c]->radius = radiuses[c];
node->childs[c]->pivot = centers[c];
node->childs[c]->variance = variance;
node->childs[c]->mean_radius = mean_radius;
node->childs[c]->indices = NULL;
computeClustering(node->childs[c],indices+start, end-start, branching, level+1);
start=end;
}
delete[] centers;
}
@ -1049,7 +1048,7 @@ private:
/**
* Helper function the descends in the hierarchical k-means tree by spliting those clusters that minimize
* Helper function the descends in the hierarchical k-means tree by splitting those clusters that minimize
* the overall variance of the clustering.
* Params:
* root = root node

18
include/opencv2/flann/linear_index.h
View File

@ -63,47 +63,47 @@ public:
LinearIndex(const LinearIndex&);
LinearIndex& operator=(const LinearIndex&);
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_LINEAR;
}
size_t size() const
size_t size() const CV_OVERRIDE
{
return dataset_.rows;
}
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return dataset_.cols;
}
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return 0;
}
void buildIndex()
void buildIndex() CV_OVERRIDE
{
/* nothing to do here for linear search */
}
void saveIndex(FILE*)
void saveIndex(FILE*) CV_OVERRIDE
{
/* nothing to do here for linear search */
}
void loadIndex(FILE*)
void loadIndex(FILE*) CV_OVERRIDE
{
/* nothing to do here for linear search */
index_params_["algorithm"] = getType();
}
void findNeighbors(ResultSet<DistanceType>& resultSet, const ElementType* vec, const SearchParams& /*searchParams*/)
void findNeighbors(ResultSet<DistanceType>& resultSet, const ElementType* vec, const SearchParams& /*searchParams*/) CV_OVERRIDE
{
ElementType* data = dataset_.data;
for (size_t i = 0; i < dataset_.rows; ++i, data += dataset_.cols) {
@ -112,7 +112,7 @@ public:
}
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}

5
include/opencv2/flann/logger.h
View File

@ -63,7 +63,12 @@ class Logger
stream = stdout;
}
else {
#ifdef _MSC_VER
if (fopen_s(&stream, name, "w") != 0)
stream = NULL;
#else
stream = fopen(name,"w");
#endif
if (stream == NULL) {
stream = stdout;
}

20
include/opencv2/flann/lsh_index.h
View File

@ -107,7 +107,7 @@ public:
/**
* Builds the index
*/
void buildIndex()
void buildIndex() CV_OVERRIDE
{
tables_.resize(table_number_);
for (unsigned int i = 0; i < table_number_; ++i) {
@ -119,13 +119,13 @@ public:
}
}
flann_algorithm_t getType() const
flann_algorithm_t getType() const CV_OVERRIDE
{
return FLANN_INDEX_LSH;
}
void saveIndex(FILE* stream)
void saveIndex(FILE* stream) CV_OVERRIDE
{
save_value(stream,table_number_);
save_value(stream,key_size_);
@ -133,7 +133,7 @@ public:
save_value(stream, dataset_);
}
void loadIndex(FILE* stream)
void loadIndex(FILE* stream) CV_OVERRIDE
{
load_value(stream, table_number_);
load_value(stream, key_size_);
@ -151,7 +151,7 @@ public:
/**
* Returns size of index.
*/
size_t size() const
size_t size() const CV_OVERRIDE
{
return dataset_.rows;
}
@ -159,7 +159,7 @@ public:
/**
* Returns the length of an index feature.
*/
size_t veclen() const
size_t veclen() const CV_OVERRIDE
{
return feature_size_;
}
@ -168,13 +168,13 @@ public:
* Computes the index memory usage
* Returns: memory used by the index
*/
int usedMemory() const
int usedMemory() const CV_OVERRIDE
{
return (int)(dataset_.rows * sizeof(int));
}
IndexParams getParameters() const
IndexParams getParameters() const CV_OVERRIDE
{
return index_params_;
}
@ -187,7 +187,7 @@ public:
* \param[in] knn Number of nearest neighbors to return
* \param[in] params Search parameters
*/
virtual void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
virtual void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params) CV_OVERRIDE
{
assert(queries.cols == veclen());
assert(indices.rows >= queries.rows);
@ -217,7 +217,7 @@ public:
* vec = the vector for which to search the nearest neighbors
* maxCheck = the maximum number of restarts (in a best-bin-first manner)
*/
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& /*searchParams*/)
void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& /*searchParams*/) CV_OVERRIDE
{
getNeighbors(vec, result);
}

39
include/opencv2/flann/lsh_table.h
View File

@ -146,6 +146,9 @@ public:
*/
LshTable()
{
key_size_ = 0;
feature_size_ = 0;
speed_level_ = kArray;
}
/** Default constructor
@ -155,8 +158,8 @@ public:
*/
LshTable(unsigned int feature_size, unsigned int key_size)
{
(void)feature_size;
(void)key_size;
feature_size_ = feature_size;
CV_UNUSED(key_size);
std::cerr << "LSH is not implemented for that type" << std::endl;
assert(0);
}
@ -265,7 +268,7 @@ private:
{
const size_t key_size_lower_bound = 1;
//a value (size_t(1) << key_size) must fit the size_t type so key_size has to be strictly less than size of size_t
const size_t key_size_upper_bound = std::min(sizeof(BucketKey) * CHAR_BIT + 1, sizeof(size_t) * CHAR_BIT);
const size_t key_size_upper_bound = (std::min)(sizeof(BucketKey) * CHAR_BIT + 1, sizeof(size_t) * CHAR_BIT);
if (key_size < key_size_lower_bound || key_size >= key_size_upper_bound)
{
CV_Error(cv::Error::StsBadArg, cv::format("Invalid key_size (=%d). Valid values for your system are %d <= key_size < %d.", (int)key_size, (int)key_size_lower_bound, (int)key_size_upper_bound));
@ -330,6 +333,8 @@ private:
*/
unsigned int key_size_;
unsigned int feature_size_;
// Members only used for the unsigned char specialization
/** The mask to apply to a feature to get the hash key
* Only used in the unsigned char case
@ -343,14 +348,19 @@ private:
template<>
inline LshTable<unsigned char>::LshTable(unsigned int feature_size, unsigned int subsignature_size)
{
feature_size_ = feature_size;
initialize(subsignature_size);
// Allocate the mask
mask_ = std::vector<size_t>((size_t)ceil((float)(feature_size * sizeof(char)) / (float)sizeof(size_t)), 0);
mask_ = std::vector<size_t>((feature_size * sizeof(char) + sizeof(size_t) - 1) / sizeof(size_t), 0);
// A bit brutal but fast to code
std::vector<size_t> indices(feature_size * CHAR_BIT);
for (size_t i = 0; i < feature_size * CHAR_BIT; ++i) indices[i] = i;
std::vector<int> indices(feature_size * CHAR_BIT);
for (size_t i = 0; i < feature_size * CHAR_BIT; ++i) indices[i] = (int)i;
#ifndef OPENCV_FLANN_USE_STD_RAND
cv::randShuffle(indices);
#else
std::random_shuffle(indices.begin(), indices.end());
#endif
// Generate a random set of order of subsignature_size_ bits
for (unsigned int i = 0; i < key_size_; ++i) {
@ -386,6 +396,7 @@ inline size_t LshTable<unsigned char>::getKey(const unsigned char* feature) cons
{
// no need to check if T is dividable by sizeof(size_t) like in the Hamming
// distance computation as we have a mask
// FIXIT: This is bad assumption, because we reading tail bytes after of the allocated features buffer
const size_t* feature_block_ptr = reinterpret_cast<const size_t*> ((const void*)feature);
// Figure out the subsignature of the feature
@ -394,10 +405,20 @@ inline size_t LshTable<unsigned char>::getKey(const unsigned char* feature) cons
size_t subsignature = 0;
size_t bit_index = 1;
for (std::vector<size_t>::const_iterator pmask_block = mask_.begin(); pmask_block != mask_.end(); ++pmask_block) {
for (unsigned i = 0; i < feature_size_; i += sizeof(size_t)) {
// get the mask and signature blocks
size_t feature_block = *feature_block_ptr;
size_t mask_block = *pmask_block;
size_t feature_block;
if (i <= feature_size_ - sizeof(size_t))
{
feature_block = *feature_block_ptr;
}
else
{
size_t tmp = 0;
memcpy(&tmp, feature_block_ptr, feature_size_ - i); // preserve bytes order
feature_block = tmp;
}
size_t mask_block = mask_[i / sizeof(size_t)];
while (mask_block) {
// Get the lowest set bit in the mask block
size_t lowest_bit = mask_block & (-(ptrdiff_t)mask_block);

2
include/opencv2/flann/matrix.h
View File

@ -66,7 +66,7 @@ public:
/**
* Convenience function for deallocating the storage data.
*/
FLANN_DEPRECATED void free()
CV_DEPRECATED void free()
{
fprintf(stderr, "The cvflann::Matrix<T>::free() method is deprecated "
"and it does not do any memory deallocation any more. You are"

8
include/opencv2/flann/miniflann.hpp
View File

@ -40,8 +40,8 @@
//
//M*/
#ifndef _OPENCV_MINIFLANN_HPP_
#define _OPENCV_MINIFLANN_HPP_
#ifndef OPENCV_MINIFLANN_HPP
#define OPENCV_MINIFLANN_HPP
#include "opencv2/core.hpp"
#include "opencv2/flann/defines.h"
@ -74,6 +74,10 @@ struct CV_EXPORTS IndexParams
std::vector<double>& numValues) const;
void* params;
private:
IndexParams(const IndexParams &); // copy disabled
IndexParams& operator=(const IndexParams &); // assign disabled
};
struct CV_EXPORTS KDTreeIndexParams : public IndexParams

28
include/opencv2/flann/random.h
View File

@ -40,13 +40,31 @@
namespace cvflann
{
inline int rand()
{
#ifndef OPENCV_FLANN_USE_STD_RAND
# if INT_MAX == RAND_MAX
int v = cv::theRNG().next() & INT_MAX;
# else
int v = cv::theRNG().uniform(0, RAND_MAX + 1);
# endif
#else
int v = std::rand();
#endif // OPENCV_FLANN_USE_STD_RAND
return v;
}
/**
* Seeds the random number generator
* @param seed Random seed
*/
inline void seed_random(unsigned int seed)
{
srand(seed);
#ifndef OPENCV_FLANN_USE_STD_RAND
cv::theRNG() = cv::RNG(seed);
#else
std::srand(seed);
#endif
}
/*
@ -60,7 +78,7 @@ inline void seed_random(unsigned int seed)
*/
inline double rand_double(double high = 1.0, double low = 0)
{
return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0)));
return low + ((high-low) * (rand() / (RAND_MAX + 1.0)));
}
/**
@ -71,7 +89,7 @@ inline double rand_double(double high = 1.0, double low = 0)
*/
inline int rand_int(int high = RAND_MAX, int low = 0)
{
return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0)));
return low + (int) ( double(high-low) * (rand() / (RAND_MAX + 1.0)));
}
/**
@ -107,7 +125,11 @@ public:
for (int i = 0; i < size_; ++i) vals_[i] = i;
// shuffle the elements in the array
#ifndef OPENCV_FLANN_USE_STD_RAND
cv::randShuffle(vals_);
#else
std::random_shuffle(vals_.begin(), vals_.end());
#endif
counter_ = 0;
}

30
include/opencv2/flann/result_set.h
View File

@ -109,13 +109,13 @@ public:
return count;
}
bool full() const
bool full() const CV_OVERRIDE
{
return count == capacity;
}
void addPoint(DistanceType dist, int index)
void addPoint(DistanceType dist, int index) CV_OVERRIDE
{
if (dist >= worst_distance_) return;
int i;
@ -139,7 +139,7 @@ public:
worst_distance_ = dists[capacity-1];
}
DistanceType worstDist() const
DistanceType worstDist() const CV_OVERRIDE
{
return worst_distance_;
}
@ -176,13 +176,13 @@ public:
return count;
}
bool full() const
bool full() const CV_OVERRIDE
{
return count == capacity;
}
void addPoint(DistanceType dist, int index)
void addPoint(DistanceType dist, int index) CV_OVERRIDE
{
if (dist >= worst_distance_) return;
int i;
@ -215,7 +215,7 @@ public:
worst_distance_ = dists[capacity-1];
}
DistanceType worstDist() const
DistanceType worstDist() const CV_OVERRIDE
{
return worst_distance_;
}
@ -303,14 +303,14 @@ public:
/** Default cosntructor */
UniqueResultSet() :
worst_distance_(std::numeric_limits<DistanceType>::max())
is_full_(false), worst_distance_(std::numeric_limits<DistanceType>::max())
{
}
/** Check the status of the set
* @return true if we have k NN
*/
inline bool full() const
inline bool full() const CV_OVERRIDE
{
return is_full_;
}
@ -365,7 +365,7 @@ public:
* If we don't have enough neighbors, it returns the max possible value
* @return
*/
inline DistanceType worstDist() const
inline DistanceType worstDist() const CV_OVERRIDE
{
return worst_distance_;
}
@ -402,7 +402,7 @@ public:
* @param dist distance for that neighbor
* @param index index of that neighbor
*/
inline void addPoint(DistanceType dist, int index)
inline void addPoint(DistanceType dist, int index) CV_OVERRIDE
{
// Don't do anything if we are worse than the worst
if (dist >= worst_distance_) return;
@ -422,7 +422,7 @@ public:
/** Remove all elements in the set
*/
void clear()
void clear() CV_OVERRIDE
{
dist_indices_.clear();
worst_distance_ = std::numeric_limits<DistanceType>::max();
@ -461,14 +461,14 @@ public:
* @param dist distance for that neighbor
* @param index index of that neighbor
*/
void addPoint(DistanceType dist, int index)
void addPoint(DistanceType dist, int index) CV_OVERRIDE
{
if (dist <= radius_) dist_indices_.insert(DistIndex(dist, index));
}
/** Remove all elements in the set
*/
inline void clear()
inline void clear() CV_OVERRIDE
{
dist_indices_.clear();
}
@ -477,7 +477,7 @@ public:
/** Check the status of the set
* @return alwys false
*/
inline bool full() const
inline bool full() const CV_OVERRIDE
{
return true;
}
@ -486,7 +486,7 @@ public:
* If we don't have enough neighbors, it returns the max possible value
* @return
*/
inline DistanceType worstDist() const
inline DistanceType worstDist() const CV_OVERRIDE
{
return radius_;
}