From 848be8dfe14c1eccd87440a33b59edef55f08d47 Mon Sep 17 00:00:00 2001 From: Vadim Pisarevsky Date: Mon, 20 Jun 2011 09:20:17 +0000 Subject: [PATCH] temporarily reverted to FLANN 1.5 (FLANN 1.6 is put to a separate branch FLANN_1.6 until it's stabilized) --- modules/flann/include/opencv2/flann/all_indices.h | 155 +- modules/flann/include/opencv2/flann/allocator.h | 215 ++- modules/flann/include/opencv2/flann/any.h | 277 ---- .../flann/include/opencv2/flann/autotuned_index.h | 776 +++++----- .../flann/include/opencv2/flann/composite_index.h | 220 ++- modules/flann/include/opencv2/flann/config.h | 35 - modules/flann/include/opencv2/flann/defines.h | 160 --- modules/flann/include/opencv2/flann/dist.h | 1017 ++++--------- .../flann/include/opencv2/flann/dynamic_bitset.h | 152 -- modules/flann/include/opencv2/flann/flann.hpp | 339 +---- modules/flann/include/opencv2/flann/flann_base.hpp | 388 +++-- modules/flann/include/opencv2/flann/general.h | 115 +- modules/flann/include/opencv2/flann/ground_truth.h | 47 +- modules/flann/include/opencv2/flann/hdf5.h | 284 ++-- modules/flann/include/opencv2/flann/heap.h | 265 ++-- .../opencv2/flann/hierarchical_clustering_index.h | 717 --------- .../flann/include/opencv2/flann/index_testing.h | 182 +-- modules/flann/include/opencv2/flann/kdtree_index.h | 990 ++++++------- .../include/opencv2/flann/kdtree_single_index.h | 642 --------- modules/flann/include/opencv2/flann/kmeans_index.h | 1516 ++++++++++---------- modules/flann/include/opencv2/flann/linear_index.h | 119 +- modules/flann/include/opencv2/flann/logger.h | 102 +- modules/flann/include/opencv2/flann/lsh_index.h | 388 ----- modules/flann/include/opencv2/flann/lsh_table.h | 477 ------ modules/flann/include/opencv2/flann/matrix.h | 60 +- modules/flann/include/opencv2/flann/nn_index.h | 195 +-- .../flann/include/opencv2/flann/object_factory.h | 91 +- modules/flann/include/opencv2/flann/params.h | 97 -- modules/flann/include/opencv2/flann/random.h | 150 +- modules/flann/include/opencv2/flann/result_set.h | 659 +++------ modules/flann/include/opencv2/flann/sampling.h | 55 +- modules/flann/include/opencv2/flann/saving.h | 161 +-- .../flann/include/opencv2/flann/simplex_downhill.h | 48 +- modules/flann/include/opencv2/flann/timer.h | 19 +- modules/flann/src/flann.cpp | 196 ++- modules/flann/src/precomp.hpp | 1 - 36 files changed, 3676 insertions(+), 7634 deletions(-) delete mode 100644 modules/flann/include/opencv2/flann/any.h delete mode 100644 modules/flann/include/opencv2/flann/config.h delete mode 100644 modules/flann/include/opencv2/flann/defines.h delete mode 100644 modules/flann/include/opencv2/flann/dynamic_bitset.h delete mode 100644 modules/flann/include/opencv2/flann/hierarchical_clustering_index.h delete mode 100644 modules/flann/include/opencv2/flann/kdtree_single_index.h delete mode 100644 modules/flann/include/opencv2/flann/lsh_index.h delete mode 100644 modules/flann/include/opencv2/flann/lsh_table.h delete mode 100644 modules/flann/include/opencv2/flann/params.h diff --git a/modules/flann/include/opencv2/flann/all_indices.h b/modules/flann/include/opencv2/flann/all_indices.h index ff53fd8..898ac09 100644 --- a/modules/flann/include/opencv2/flann/all_indices.h +++ b/modules/flann/include/opencv2/flann/all_indices.h @@ -27,129 +27,50 @@ *************************************************************************/ -#ifndef OPENCV_FLANN_ALL_INDICES_H_ -#define OPENCV_FLANN_ALL_INDICES_H_ +#ifndef _OPENCV_ALL_INDICES_H_ +#define _OPENCV_ALL_INDICES_H_ -#include "general.h" +#include "opencv2/flann/general.h" -#include "nn_index.h" -#include "kdtree_index.h" -#include "kdtree_single_index.h" -#include "kmeans_index.h" -#include "composite_index.h" -#include "linear_index.h" -#include "hierarchical_clustering_index.h" -#include "lsh_index.h" -#include "autotuned_index.h" +#include "opencv2/flann/nn_index.h" +#include "opencv2/flann/kdtree_index.h" +#include "opencv2/flann/kmeans_index.h" +#include "opencv2/flann/composite_index.h" +#include "opencv2/flann/linear_index.h" +#include "opencv2/flann/autotuned_index.h" - -namespace cvflann -{ - -template -struct index_creator -{ - static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) - { - flann_algorithm_t index_type = get_param(params, "algorithm"); - - NNIndex* nnIndex; - switch (index_type) { - case FLANN_INDEX_LINEAR: - nnIndex = new LinearIndex(dataset, params, distance); - break; - case FLANN_INDEX_KDTREE_SINGLE: - nnIndex = new KDTreeSingleIndex(dataset, params, distance); - break; - case FLANN_INDEX_KDTREE: - nnIndex = new KDTreeIndex(dataset, params, distance); - break; - case FLANN_INDEX_KMEANS: - nnIndex = new KMeansIndex(dataset, params, distance); - break; - case FLANN_INDEX_COMPOSITE: - nnIndex = new CompositeIndex(dataset, params, distance); - break; - case FLANN_INDEX_AUTOTUNED: - nnIndex = new AutotunedIndex(dataset, params, distance); - break; - case FLANN_INDEX_HIERARCHICAL: - nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); - break; - case FLANN_INDEX_LSH: - nnIndex = new LshIndex(dataset, params, distance); - break; - default: - throw FLANNException("Unknown index type"); - } - - return nnIndex; - } -}; - -template -struct index_creator +namespace cvflann { - static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) - { - flann_algorithm_t index_type = get_param(params, "algorithm"); - NNIndex* nnIndex; - switch (index_type) { - case FLANN_INDEX_LINEAR: - nnIndex = new LinearIndex(dataset, params, distance); - break; - case FLANN_INDEX_KMEANS: - nnIndex = new KMeansIndex(dataset, params, distance); - break; - case FLANN_INDEX_HIERARCHICAL: - nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); - break; - case FLANN_INDEX_LSH: - nnIndex = new LshIndex(dataset, params, distance); - break; - default: - throw FLANNException("Unknown index type"); - } - - return nnIndex; - } -}; - -template -struct index_creator +template +NNIndex* create_index_by_type(const Matrix& dataset, const IndexParams& params) { - static NNIndex* create(const Matrix& dataset, const IndexParams& params, const Distance& distance) - { - flann_algorithm_t index_type = get_param(params, "algorithm"); - - NNIndex* nnIndex; - switch (index_type) { - case FLANN_INDEX_LINEAR: - nnIndex = new LinearIndex(dataset, params, distance); - break; - case FLANN_INDEX_HIERARCHICAL: - nnIndex = new HierarchicalClusteringIndex(dataset, params, distance); - break; - case FLANN_INDEX_LSH: - nnIndex = new LshIndex(dataset, params, distance); - break; - default: - throw FLANNException("Unknown index type"); - } - - return nnIndex; - } -}; - -template -NNIndex* create_index_by_type(const Matrix& dataset, const IndexParams& params, const Distance& distance) -{ - return index_creator::create(dataset, params,distance); + flann_algorithm_t index_type = params.getIndexType(); + + NNIndex* nnIndex; + switch (index_type) { + case FLANN_INDEX_LINEAR: + nnIndex = new LinearIndex(dataset, (const LinearIndexParams&)params); + break; + case FLANN_INDEX_KDTREE: + nnIndex = new KDTreeIndex(dataset, (const KDTreeIndexParams&)params); + break; + case FLANN_INDEX_KMEANS: + nnIndex = new KMeansIndex(dataset, (const KMeansIndexParams&)params); + break; + case FLANN_INDEX_COMPOSITE: + nnIndex = new CompositeIndex(dataset, (const CompositeIndexParams&) params); + break; + case FLANN_INDEX_AUTOTUNED: + nnIndex = new AutotunedIndex(dataset, (const AutotunedIndexParams&) params); + break; + default: + throw FLANNException("Unknown index type"); + } + + return nnIndex; } -} +} //namespace cvflann -#endif /* OPENCV_FLANN_ALL_INDICES_H_ */ +#endif /* _OPENCV_ALL_INDICES_H_ */ diff --git a/modules/flann/include/opencv2/flann/allocator.h b/modules/flann/include/opencv2/flann/allocator.h index 6ca44fc..0215ac6 100644 --- a/modules/flann/include/opencv2/flann/allocator.h +++ b/modules/flann/include/opencv2/flann/allocator.h @@ -28,13 +28,12 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_ALLOCATOR_H_ -#define OPENCV_FLANN_ALLOCATOR_H_ +#ifndef _OPENCV_ALLOCATOR_H_ +#define _OPENCV_ALLOCATOR_H_ #include #include - namespace cvflann { @@ -48,8 +47,8 @@ namespace cvflann template T* allocate(size_t count = 1) { - T* mem = (T*) ::malloc(sizeof(T)*count); - return mem; + T* mem = (T*) ::malloc(sizeof(T)*count); + return mem; } @@ -71,118 +70,118 @@ T* allocate(size_t count = 1) const size_t WORDSIZE=16; const size_t BLOCKSIZE=8192; -class PooledAllocator +class CV_EXPORTS PooledAllocator { - /* We maintain memory alignment to word boundaries by requiring that all - allocations be in multiples of the machine wordsize. */ - /* Size of machine word in bytes. Must be power of 2. */ - /* Minimum number of bytes requested at a time from the system. Must be multiple of WORDSIZE. */ + /* We maintain memory alignment to word boundaries by requiring that all + allocations be in multiples of the machine wordsize. */ + /* Size of machine word in bytes. Must be power of 2. */ + /* Minimum number of bytes requested at a time from the system. Must be multiple of WORDSIZE. */ - int remaining; /* Number of bytes left in current block of storage. */ - void* base; /* Pointer to base of current block of storage. */ - void* loc; /* Current location in block to next allocate memory. */ - int blocksize; + int remaining; /* Number of bytes left in current block of storage. */ + void* base; /* Pointer to base of current block of storage. */ + void* loc; /* Current location in block to next allocate memory. */ + int blocksize; public: - int usedMemory; - int wastedMemory; - - /** - Default constructor. Initializes a new pool. - */ - PooledAllocator(int blocksize = BLOCKSIZE) - { - this->blocksize = blocksize; - remaining = 0; - base = NULL; - - usedMemory = 0; - wastedMemory = 0; - } - - /** - * Destructor. Frees all the memory allocated in this pool. - */ - ~PooledAllocator() - { - void* prev; - - while (base != NULL) { - prev = *((void**) base); /* Get pointer to prev block. */ - ::free(base); - base = prev; - } - } - - /** - * Returns a pointer to a piece of new memory of the given size in bytes - * allocated from the pool. - */ - void* allocateMemory(int size) - { - int blocksize; - - /* Round size up to a multiple of wordsize. The following expression - only works for WORDSIZE that is a power of 2, by masking last bits of - incremented size to zero. - */ - size = (size + (WORDSIZE - 1)) & ~(WORDSIZE - 1); - - /* Check whether a new block must be allocated. Note that the first word - of a block is reserved for a pointer to the previous block. - */ - if (size > remaining) { - - wastedMemory += remaining; - - /* Allocate new storage. */ - blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ? - size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE; - - // use the standard C malloc to allocate memory - void* m = ::malloc(blocksize); - if (!m) { + int usedMemory; + int wastedMemory; + + /** + Default constructor. Initializes a new pool. + */ + PooledAllocator(int blocksize = BLOCKSIZE) + { + this->blocksize = blocksize; + remaining = 0; + base = NULL; + + usedMemory = 0; + wastedMemory = 0; + } + + /** + * Destructor. Frees all the memory allocated in this pool. + */ + ~PooledAllocator() + { + void *prev; + + while (base != NULL) { + prev = *((void **) base); /* Get pointer to prev block. */ + ::free(base); + base = prev; + } + } + + /** + * Returns a pointer to a piece of new memory of the given size in bytes + * allocated from the pool. + */ + void* allocateBytes(int size) + { + int blocksize; + + /* Round size up to a multiple of wordsize. The following expression + only works for WORDSIZE that is a power of 2, by masking last bits of + incremented size to zero. + */ + size = (size + (WORDSIZE - 1)) & ~(WORDSIZE - 1); + + /* Check whether a new block must be allocated. Note that the first word + of a block is reserved for a pointer to the previous block. + */ + if (size > remaining) { + + wastedMemory += remaining; + + /* Allocate new storage. */ + blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ? + size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE; + + // use the standard C malloc to allocate memory + void* m = ::malloc(blocksize); + if (!m) { fprintf(stderr,"Failed to allocate memory.\n"); - return NULL; - } - - /* Fill first word of new block with pointer to previous block. */ - ((void**) m)[0] = base; - base = m; - - int shift = 0; - //int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1); - - remaining = blocksize - sizeof(void*) - shift; - loc = ((char*)m + sizeof(void*) + shift); - } - void* rloc = loc; - loc = (char*)loc + size; - remaining -= size; - - usedMemory += size; - - return rloc; - } - - /** - * Allocates (using this pool) a generic type T. - * - * Params: - * count = number of instances to allocate. - * Returns: pointer (of type T*) to memory buffer - */ + exit(1); + } + + /* Fill first word of new block with pointer to previous block. */ + ((void **) m)[0] = base; + base = m; + + int shift = 0; + //int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1); + + remaining = blocksize - sizeof(void*) - shift; + loc = ((char*)m + sizeof(void*) + shift); + } + void* rloc = loc; + loc = (char*)loc + size; + remaining -= size; + + usedMemory += size; + + return rloc; + } + + /** + * Allocates (using this pool) a generic type T. + * + * Params: + * count = number of instances to allocate. + * Returns: pointer (of type T*) to memory buffer + */ template - T* allocate(size_t count = 1) - { - T* mem = (T*) this->allocateMemory((int)(sizeof(T)*count)); - return mem; - } + T* allocate(size_t count = 1) + { + T* mem = (T*) this->allocateBytes((int)(sizeof(T)*count)); + return mem; + } }; -} +} // namespace cvflann -#endif //OPENCV_FLANN_ALLOCATOR_H_ +#endif //_OPENCV_ALLOCATOR_H_ diff --git a/modules/flann/include/opencv2/flann/any.h b/modules/flann/include/opencv2/flann/any.h deleted file mode 100644 index aaa87df..0000000 --- a/modules/flann/include/opencv2/flann/any.h +++ /dev/null @@ -1,277 +0,0 @@ -#ifndef OPENCV_FLANN_ANY_H_ -#define OPENCV_FLANN_ANY_H_ -/* - * (C) Copyright Christopher Diggins 2005-2011 - * (C) Copyright Pablo Aguilar 2005 - * (C) Copyright Kevlin Henney 2001 - * - * Distributed under the Boost Software License, Version 1.0. (See - * accompanying file LICENSE_1_0.txt or copy at - * http://www.boost.org/LICENSE_1_0.txt - * - * Adapted for FLANN by Marius Muja - */ - - - -#include -#include - -namespace cdiggins -{ - -namespace anyimpl -{ - -struct bad_any_cast -{ -}; - -struct empty_any -{ -}; - -struct base_any_policy -{ - virtual void static_delete(void** x) = 0; - virtual void copy_from_value(void const* src, void** dest) = 0; - virtual void clone(void* const* src, void** dest) = 0; - virtual void move(void* const* src, void** dest) = 0; - virtual void* get_value(void** src) = 0; - virtual size_t get_size() = 0; - virtual void print(std::ostream& out, void* const* src) = 0; -}; - -template -struct typed_base_any_policy : base_any_policy -{ - virtual size_t get_size() { return sizeof(T); } - -}; - -template -struct small_any_policy : typed_base_any_policy -{ - virtual void static_delete(void**) { } - virtual void copy_from_value(void const* src, void** dest) - { - new (dest) T(* reinterpret_cast(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(src); } - virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast(src); } -}; - -template -struct big_any_policy : typed_base_any_policy -{ - virtual void static_delete(void** x) - { - if (* x) delete (* reinterpret_cast(x)); *x = NULL; - } - virtual void copy_from_value(void const* src, void** dest) - { - *dest = new T(*reinterpret_cast(src)); - } - virtual void clone(void* const* src, void** dest) - { - *dest = new T(**reinterpret_cast(src)); - } - virtual void move(void* const* src, void** dest) - { - (*reinterpret_cast(dest))->~T(); - **reinterpret_cast(dest) = **reinterpret_cast(src); - } - virtual void* get_value(void** src) { return *src; } - virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast(*src); } -}; - -template -struct choose_policy -{ - typedef big_any_policy type; -}; - -template -struct choose_policy -{ - typedef small_any_policy type; -}; - -struct any; - -/// Choosing the policy for an any type is illegal, but should never happen. -/// This is designed to throw a compiler error. -template<> -struct choose_policy -{ - typedef void type; -}; - -/// Specializations for small types. -#define SMALL_POLICY(TYPE) \ - template<> \ - struct choose_policy { typedef small_any_policy type; \ - }; - -SMALL_POLICY(signed char); -SMALL_POLICY(unsigned char); -SMALL_POLICY(signed short); -SMALL_POLICY(unsigned short); -SMALL_POLICY(signed int); -SMALL_POLICY(unsigned int); -SMALL_POLICY(signed long); -SMALL_POLICY(unsigned long); -SMALL_POLICY(float); -SMALL_POLICY(bool); - -#undef SMALL_POLICY - -/// This function will return a different policy for each type. -template -base_any_policy* get_policy() -{ - static typename choose_policy::type policy; - return &policy; -} -} // namespace anyimpl - -struct any -{ -private: - // fields - anyimpl::base_any_policy* policy; - void* object; - -public: - /// Initializing constructor. - template - any(const T& x) - : policy(anyimpl::get_policy()), object(NULL) - { - assign(x); - } - - /// Empty constructor. - any() - : policy(anyimpl::get_policy()), object(NULL) - { } - - /// Special initializing constructor for string literals. - any(const char* x) - : policy(anyimpl::get_policy()), object(NULL) - { - assign(x); - } - - /// Copy constructor. - any(const any& x) - : policy(anyimpl::get_policy()), object(NULL) - { - assign(x); - } - - /// Destructor. - ~any() - { - policy->static_delete(&object); - } - - /// Assignment function from another any. - any& assign(const any& x) - { - reset(); - policy = x.policy; - policy->clone(&x.object, &object); - return *this; - } - - /// Assignment function. - template - any& assign(const T& x) - { - reset(); - policy = anyimpl::get_policy(); - policy->copy_from_value(&x, &object); - return *this; - } - - /// Assignment operator. - template - any& operator=(const T& 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) - { - return assign(x); - } - - /// Utility functions - any& swap(any& x) - { - std::swap(policy, x.policy); - std::swap(object, x.object); - return *this; - } - - /// Cast operator. You can only cast to the original type. - template - T& cast() - { - if (policy != anyimpl::get_policy()) throw anyimpl::bad_any_cast(); - T* r = reinterpret_cast(policy->get_value(&object)); - return *r; - } - - /// Cast operator. You can only cast to the original type. - template - const T& cast() const - { - if (policy != anyimpl::get_policy()) throw anyimpl::bad_any_cast(); - T* r = reinterpret_cast(policy->get_value((void**)&object)); - return *r; - } - - /// Returns true if the any contains no value. - bool empty() const - { - return policy == anyimpl::get_policy(); - } - - /// Frees any allocated memory, and sets the value to NULL. - void reset() - { - policy->static_delete(&object); - policy = anyimpl::get_policy(); - } - - /// Returns true if the two types are the same. - bool compatible(const any& x) const - { - return policy == x.policy; - } - - /// Returns if the type is compatible with the policy - template - bool has_type() - { - return policy == anyimpl::get_policy(); - } - - friend std::ostream& operator <<(std::ostream& out, const any& any_val); -}; - -inline std::ostream& operator <<(std::ostream& out, const any& any_val) -{ - any_val.policy->print(out,&any_val.object); - return out; -} - -} - -#endif // OPENCV_FLANN_ANY_H_ diff --git a/modules/flann/include/opencv2/flann/autotuned_index.h b/modules/flann/include/opencv2/flann/autotuned_index.h index 6be0fd2..0e19f1d 100644 --- a/modules/flann/include/opencv2/flann/autotuned_index.h +++ b/modules/flann/include/opencv2/flann/autotuned_index.h @@ -27,204 +27,216 @@ * (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_FLANN_AUTOTUNED_INDEX_H_ -#define OPENCV_FLANN_AUTOTUNED_INDEX_H_ - -#include "general.h" -#include "nn_index.h" -#include "ground_truth.h" -#include "index_testing.h" -#include "sampling.h" -#include "kdtree_index.h" -#include "kdtree_single_index.h" -#include "kmeans_index.h" -#include "composite_index.h" -#include "linear_index.h" -#include "logger.h" -namespace cvflann -{ +#ifndef _OPENCV_AUTOTUNEDINDEX_H_ +#define _OPENCV_AUTOTUNEDINDEX_H_ -template -NNIndex* create_index_by_type(const Matrix& dataset, const IndexParams& params, const Distance& distance); +#include "opencv2/flann/general.h" +#include "opencv2/flann/nn_index.h" +#include "opencv2/flann/ground_truth.h" +#include "opencv2/flann/index_testing.h" +#include "opencv2/flann/sampling.h" +#include "opencv2/flann/all_indices.h" - -struct AutotunedIndexParams : public IndexParams +namespace cvflann { - AutotunedIndexParams(float target_precision = 0.8, float build_weight = 0.01, float memory_weight = 0, float sample_fraction = 0.1) - { - (*this)["algorithm"] = FLANN_INDEX_AUTOTUNED; - // precision desired (used for autotuning, -1 otherwise) - (*this)["target_precision"] = target_precision; - // build tree time weighting factor - (*this)["build_weight"] = build_weight; - // index memory weighting factor - (*this)["memory_weight"] = memory_weight; - // what fraction of the dataset to use for autotuning - (*this)["sample_fraction"] = sample_fraction; - } + +struct AutotunedIndexParams : public IndexParams { + AutotunedIndexParams( float target_precision_ = 0.8, float build_weight_ = 0.01, + float memory_weight_ = 0, float sample_fraction_ = 0.1) : + IndexParams(FLANN_INDEX_AUTOTUNED), + target_precision(target_precision_), + build_weight(build_weight_), + memory_weight(memory_weight_), + sample_fraction(sample_fraction_) {}; + + float target_precision; // precision desired (used for autotuning, -1 otherwise) + float build_weight; // build tree time weighting factor + float memory_weight; // index memory weighting factor + float sample_fraction; // what fraction of the dataset to use for autotuning + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + logger().info("logger(). precision: %g\n", target_precision); + logger().info("Build weight: %g\n", build_weight); + logger().info("Memory weight: %g\n", memory_weight); + logger().info("Sample fraction: %g\n", sample_fraction); + } }; -template -class AutotunedIndex : public NNIndex +template ::type > +class AutotunedIndex : public NNIndex { -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - AutotunedIndex(const Matrix& inputData, const IndexParams& params = AutotunedIndexParams(), Distance d = Distance()) : - dataset_(inputData), distance_(d) - { - target_precision_ = get_param(params, "target_precision",0.8f); - build_weight_ = get_param(params,"build_weight", 0.01f); - memory_weight_ = get_param(params, "memory_weight", 0.0f); - sample_fraction_ = get_param(params,"sample_fraction", 0.1f); - bestIndex_ = NULL; - } + NNIndex* bestIndex; - AutotunedIndex(const AutotunedIndex&); - AutotunedIndex& operator=(const AutotunedIndex&); + IndexParams* bestParams; + SearchParams bestSearchParams; - virtual ~AutotunedIndex() - { - if (bestIndex_ != NULL) { - delete bestIndex_; - bestIndex_ = NULL; - } - } - - /** - * Method responsible with building the index. - */ - virtual void buildIndex() - { - bestParams_ = estimateBuildParams(); - Logger::info("----------------------------------------------------\n"); - Logger::info("Autotuned parameters:\n"); - print_params(bestParams_); - Logger::info("----------------------------------------------------\n"); - - bestIndex_ = create_index_by_type(dataset_, bestParams_, distance_); - bestIndex_->buildIndex(); - speedup_ = estimateSearchParams(bestSearchParams_); - Logger::info("----------------------------------------------------\n"); - Logger::info("Search parameters:\n"); - print_params(bestSearchParams_); - Logger::info("----------------------------------------------------\n"); - } - - /** - * Saves the index to a stream - */ - virtual void saveIndex(FILE* stream) - { - save_value(stream, (int)bestIndex_->getType()); - bestIndex_->saveIndex(stream); - save_value(stream, get_param(bestSearchParams_, "checks")); - } + Matrix sampledDataset; + Matrix testDataset; + Matrix gt_matches; - /** - * Loads the index from a stream - */ - virtual void loadIndex(FILE* stream) - { - int index_type; + float speedup; - load_value(stream, index_type); - IndexParams params; - params["algorithm"] = (flann_algorithm_t)index_type; - bestIndex_ = create_index_by_type(dataset_, params, distance_); - bestIndex_->loadIndex(stream); - int checks; - load_value(stream, checks); - bestSearchParams_["checks"] = checks; - } + /** + * The dataset used by this index + */ + const Matrix dataset; /** - * Method that searches for nearest-neighbors + * Index parameters */ - virtual void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) - { - int checks = get_param(searchParams,"checks",FLANN_CHECKS_AUTOTUNED); - if (checks == FLANN_CHECKS_AUTOTUNED) { - bestIndex_->findNeighbors(result, vec, bestSearchParams_); - } - else { - bestIndex_->findNeighbors(result, vec, searchParams); - } - } + const AutotunedIndexParams& index_params; + AutotunedIndex& operator=(const AutotunedIndex&); + AutotunedIndex(const AutotunedIndex&); - IndexParams getParameters() const - { - return bestIndex_->getParameters(); - } +public: - SearchParams getSearchParameters() const - { - return bestSearchParams_; - } + AutotunedIndex(const Matrix& inputData, const AutotunedIndexParams& params = AutotunedIndexParams() ) : + dataset(inputData), index_params(params) + { + bestIndex = NULL; + bestParams = NULL; + } - float getSpeedup() const + virtual ~AutotunedIndex() { - return speedup_; - } - + if (bestIndex!=NULL) { + delete bestIndex; + } + if (bestParams!=NULL) { + delete bestParams; + } + }; /** - * Number of features in this index. - */ - virtual size_t size() const - { - return bestIndex_->size(); - } + Method responsible with building the index. + */ + virtual void buildIndex() + { + bestParams = estimateBuildParams(); + logger().info("----------------------------------------------------\n"); + logger().info("Autotuned parameters:\n"); + bestParams->print(); + logger().info("----------------------------------------------------\n"); + flann_algorithm_t index_type = bestParams->getIndexType(); + switch (index_type) { + case FLANN_INDEX_LINEAR: + bestIndex = new LinearIndex(dataset, (const LinearIndexParams&)*bestParams); + break; + case FLANN_INDEX_KDTREE: + bestIndex = new KDTreeIndex(dataset, (const KDTreeIndexParams&)*bestParams); + break; + case FLANN_INDEX_KMEANS: + bestIndex = new KMeansIndex(dataset, (const KMeansIndexParams&)*bestParams); + break; + default: + throw FLANNException("Unknown algorithm choosen by the autotuning, most likely a bug."); + } + bestIndex->buildIndex(); + speedup = estimateSearchParams(bestSearchParams); + } /** - * The length of each vector in this index. - */ - virtual size_t veclen() const + Saves the index to a stream + */ + virtual void saveIndex(FILE* stream) { - return bestIndex_->veclen(); + save_value(stream, (int)bestIndex->getType()); + bestIndex->saveIndex(stream); + save_value(stream, bestSearchParams); } /** - * The amount of memory (in bytes) this index uses. - */ - virtual int usedMemory() const + Loads the index from a stream + */ + virtual void loadIndex(FILE* stream) { - return bestIndex_->usedMemory(); + int index_type; + load_value(stream,index_type); + IndexParams* params = ParamsFactory_instance().create((flann_algorithm_t)index_type); + bestIndex = create_index_by_type(dataset, *params); + bestIndex->loadIndex(stream); + load_value(stream, bestSearchParams); } + /** + Method that searches for nearest-neighbors + */ + virtual void findNeighbors(ResultSet& result, const ELEM_TYPE* vec, const SearchParams& searchParams) + { + if (searchParams.checks==-2) { + bestIndex->findNeighbors(result, vec, bestSearchParams); + } + else { + bestIndex->findNeighbors(result, vec, searchParams); + } + } + + + const IndexParams* getParameters() const + { + return bestIndex->getParameters(); + } + + + /** + Number of features in this index. + */ + virtual size_t size() const + { + return bestIndex->size(); + } + + /** + The length of each vector in this index. + */ + virtual size_t veclen() const + { + return bestIndex->veclen(); + } + + /** + The amount of memory (in bytes) this index uses. + */ + virtual int usedMemory() const + { + return bestIndex->usedMemory(); + } + /** - * Algorithm name - */ + * Algorithm name + */ virtual flann_algorithm_t getType() const { - return FLANN_INDEX_AUTOTUNED; + return FLANN_INDEX_AUTOTUNED; } private: - struct CostData - { + struct CostData { float searchTimeCost; float buildTimeCost; + float timeCost; float memoryCost; float totalCost; - IndexParams params; }; - void evaluate_kmeans(CostData& cost) + typedef std::pair KDTreeCostData; + typedef std::pair KMeansCostData; + + + void evaluate_kmeans(CostData& cost, const KMeansIndexParams& kmeans_params) { StartStopTimer t; int checks; const int nn = 1; - Logger::info("KMeansTree using params: max_iterations=%d, branching=%d\n", - get_param(cost.params,"iterations"), - get_param(cost.params,"branching")); - KMeansIndex kmeans(sampledDataset_, cost.params, distance_); + logger().info("KMeansTree using params: max_iterations=%d, branching=%d\n", kmeans_params.iterations, kmeans_params.branching); + KMeansIndex kmeans(sampledDataset, kmeans_params); // measure index build time t.start(); kmeans.buildIndex(); @@ -232,24 +244,25 @@ private: float buildTime = (float)t.value; // measure search time - float searchTime = test_index_precision(kmeans, sampledDataset_, testDataset_, gt_matches_, target_precision_, checks, distance_, nn); + float searchTime = test_index_precision(kmeans, sampledDataset, testDataset, gt_matches, index_params.target_precision, checks, nn);; - float datasetMemory = float(sampledDataset_.rows * sampledDataset_.cols * sizeof(float)); - cost.memoryCost = (kmeans.usedMemory() + datasetMemory) / datasetMemory; + float datasetMemory = (float)(sampledDataset.rows*sampledDataset.cols*sizeof(float)); + cost.memoryCost = (kmeans.usedMemory()+datasetMemory)/datasetMemory; cost.searchTimeCost = searchTime; cost.buildTimeCost = buildTime; - Logger::info("KMeansTree buildTime=%g, searchTime=%g, build_weight=%g\n", buildTime, searchTime, build_weight_); + cost.timeCost = (buildTime*index_params.build_weight+searchTime); + logger().info("KMeansTree buildTime=%g, searchTime=%g, timeCost=%g, buildTimeFactor=%g\n",buildTime, searchTime, cost.timeCost, index_params.build_weight); } - void evaluate_kdtree(CostData& cost) + void evaluate_kdtree(CostData& cost, const KDTreeIndexParams& kdtree_params) { StartStopTimer t; int checks; const int nn = 1; - Logger::info("KDTree using params: trees=%d\n", get_param(cost.params,"trees")); - KDTreeIndex kdtree(sampledDataset_, cost.params, distance_); + logger().info("KDTree using params: trees=%d\n",kdtree_params.trees); + KDTreeIndex kdtree(sampledDataset, kdtree_params); t.start(); kdtree.buildIndex(); @@ -257,220 +270,267 @@ private: float buildTime = (float)t.value; //measure search time - float searchTime = test_index_precision(kdtree, sampledDataset_, testDataset_, gt_matches_, target_precision_, checks, distance_, nn); + float searchTime = test_index_precision(kdtree, sampledDataset, testDataset, gt_matches, index_params.target_precision, checks, nn); - float datasetMemory = float(sampledDataset_.rows * sampledDataset_.cols * sizeof(float)); - cost.memoryCost = (kdtree.usedMemory() + datasetMemory) / datasetMemory; + float datasetMemory = (float)(sampledDataset.rows*sampledDataset.cols*sizeof(float)); + cost.memoryCost = (kdtree.usedMemory()+datasetMemory)/datasetMemory; cost.searchTimeCost = searchTime; cost.buildTimeCost = buildTime; - Logger::info("KDTree buildTime=%g, searchTime=%g\n", buildTime, searchTime); + cost.timeCost = (buildTime*index_params.build_weight+searchTime); + logger().info("KDTree buildTime=%g, searchTime=%g, timeCost=%g\n",buildTime, searchTime, cost.timeCost); } - // struct KMeansSimpleDownhillFunctor { - // - // Autotune& autotuner; - // KMeansSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {}; - // - // float operator()(int* params) { - // - // float maxFloat = numeric_limits::max(); - // - // if (params[0]<2) return maxFloat; - // if (params[1]<0) return maxFloat; - // - // CostData c; - // c.params["algorithm"] = KMEANS; - // c.params["centers-init"] = CENTERS_RANDOM; - // c.params["branching"] = params[0]; - // c.params["max-iterations"] = params[1]; - // - // autotuner.evaluate_kmeans(c); - // - // return c.timeCost; - // - // } - // }; - // - // struct KDTreeSimpleDownhillFunctor { - // - // Autotune& autotuner; - // KDTreeSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {}; - // - // float operator()(int* params) { - // float maxFloat = numeric_limits::max(); - // - // if (params[0]<1) return maxFloat; - // - // CostData c; - // c.params["algorithm"] = KDTREE; - // c.params["trees"] = params[0]; - // - // autotuner.evaluate_kdtree(c); - // - // return c.timeCost; - // - // } - // }; - - - - void optimizeKMeans(std::vector& costs) +// struct KMeansSimpleDownhillFunctor { +// +// Autotune& autotuner; +// KMeansSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {}; +// +// float operator()(int* params) { +// +// float maxFloat = numeric_limits::max(); +// +// if (params[0]<2) return maxFloat; +// if (params[1]<0) return maxFloat; +// +// CostData c; +// c.params["algorithm"] = KMEANS; +// c.params["centers-init"] = CENTERS_RANDOM; +// c.params["branching"] = params[0]; +// c.params["max-iterations"] = params[1]; +// +// autotuner.evaluate_kmeans(c); +// +// return c.timeCost; +// +// } +// }; +// +// struct KDTreeSimpleDownhillFunctor { +// +// Autotune& autotuner; +// KDTreeSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {}; +// +// float operator()(int* params) { +// float maxFloat = numeric_limits::max(); +// +// if (params[0]<1) return maxFloat; +// +// CostData c; +// c.params["algorithm"] = KDTREE; +// c.params["trees"] = params[0]; +// +// autotuner.evaluate_kdtree(c); +// +// return c.timeCost; +// +// } +// }; + + + + KMeansCostData optimizeKMeans() { - Logger::info("KMEANS, Step 1: Exploring parameter space\n"); + logger().info("KMEANS, Step 1: Exploring parameter space\n"); // explore kmeans parameters space using combinations of the parameters below int maxIterations[] = { 1, 5, 10, 15 }; int branchingFactors[] = { 16, 32, 64, 128, 256 }; - int kmeansParamSpaceSize = FLANN_ARRAY_LEN(maxIterations) * FLANN_ARRAY_LEN(branchingFactors); - costs.reserve(costs.size() + kmeansParamSpaceSize); + int kmeansParamSpaceSize = ARRAY_LEN(maxIterations)*ARRAY_LEN(branchingFactors); + + std::vector kmeansCosts(kmeansParamSpaceSize); + +// CostData* kmeansCosts = new CostData[kmeansParamSpaceSize]; // evaluate kmeans for all parameter combinations - for (size_t i = 0; i < FLANN_ARRAY_LEN(maxIterations); ++i) { - for (size_t j = 0; j < FLANN_ARRAY_LEN(branchingFactors); ++j) { - CostData cost; - cost.params["algorithm"] = FLANN_INDEX_KMEANS; - cost.params["centers_init"] = FLANN_CENTERS_RANDOM; - cost.params["iterations"] = maxIterations[i]; - cost.params["branching"] = branchingFactors[j]; - - evaluate_kmeans(cost); - costs.push_back(cost); + int cnt = 0; + for (size_t i=0; i0 && kmeansCosts[k].first.timeCost < kmeansCosts[k-1].first.timeCost) { + swap(kmeansCosts[k],kmeansCosts[k-1]); + --k; + } + ++cnt; + } + } + +// logger().info("KMEANS, Step 2: simplex-downhill optimization\n"); +// +// const int n = 2; +// // choose initial simplex points as the best parameters so far +// int kmeansNMPoints[n*(n+1)]; +// float kmeansVals[n+1]; +// for (int i=0;i0 && kmeansCosts[k].first.totalCost < kmeansCosts[k-1].first.totalCost) { + swap(kmeansCosts[k],kmeansCosts[k-1]); + k--; } } + // display the costs obtained + for (int i=0;i& costs) + KDTreeCostData optimizeKDTree() { - Logger::info("KD-TREE, Step 1: Exploring parameter space\n"); + + logger().info("KD-TREE, Step 1: Exploring parameter space\n"); // explore kd-tree parameters space using the parameters below int testTrees[] = { 1, 4, 8, 16, 32 }; + size_t kdtreeParamSpaceSize = ARRAY_LEN(testTrees); + std::vector kdtreeCosts(kdtreeParamSpaceSize); + // evaluate kdtree for all parameter combinations - for (size_t i = 0; i < FLANN_ARRAY_LEN(testTrees); ++i) { - CostData cost; - cost.params["trees"] = testTrees[i]; + int cnt = 0; + for (size_t i=0; i0 && kdtreeCosts[k].first.timeCost < kdtreeCosts[k-1].first.timeCost) { + swap(kdtreeCosts[k],kdtreeCosts[k-1]); + --k; + } + ++cnt; + } - evaluate_kdtree(cost); - costs.push_back(cost); +// logger().info("KD-TREE, Step 2: simplex-downhill optimization\n"); +// +// const int n = 1; +// // choose initial simplex points as the best parameters so far +// int kdtreeNMPoints[n*(n+1)]; +// float kdtreeVals[n+1]; +// for (int i=0;i0 && kdtreeCosts[k].first.totalCost < kdtreeCosts[k-1].first.totalCost) { + swap(kdtreeCosts[k],kdtreeCosts[k-1]); + k--; + } + } + // display costs obtained + for (size_t i=0;i costs; + int sampleSize = int(index_params.sample_fraction*dataset.rows); + int testSampleSize = std::min(sampleSize/10, 1000); - int sampleSize = int(sample_fraction_ * dataset_.rows); - int testSampleSize = std::min(sampleSize / 10, 1000); - - Logger::info("Entering autotuning, dataset size: %d, sampleSize: %d, testSampleSize: %d, target precision: %g\n", dataset_.rows, sampleSize, testSampleSize, target_precision_); + logger().info("Entering autotuning, dataset size: %d, sampleSize: %d, testSampleSize: %d\n",dataset.rows, sampleSize, testSampleSize); // For a very small dataset, it makes no sense to build any fancy index, just // use linear search - if (testSampleSize < 10) { - Logger::info("Choosing linear, dataset too small\n"); - return LinearIndexParams(); + if (testSampleSize<10) { + logger().info("Choosing linear, dataset too small\n"); + return new LinearIndexParams(); } // We use a fraction of the original dataset to speedup the autotune algorithm - sampledDataset_ = random_sample(dataset_, sampleSize); + sampledDataset = random_sample(dataset,sampleSize); // We use a cross-validation approach, first we sample a testset from the dataset - testDataset_ = random_sample(sampledDataset_, testSampleSize, true); + testDataset = random_sample(sampledDataset,testSampleSize,true); // We compute the ground truth using linear search - Logger::info("Computing ground truth... \n"); - gt_matches_ = Matrix(new int[testDataset_.rows], testDataset_.rows, 1); + logger().info("Computing ground truth... \n"); + gt_matches = Matrix(new int[testDataset.rows],(long)testDataset.rows, 1); StartStopTimer t; t.start(); - compute_ground_truth(sampledDataset_, testDataset_, gt_matches_, 0, distance_); + compute_ground_truth(sampledDataset, testDataset, gt_matches, 0); t.stop(); - - CostData linear_cost; - linear_cost.searchTimeCost = (float)t.value; - linear_cost.buildTimeCost = 0; - linear_cost.memoryCost = 0; - linear_cost.params["algorithm"] = FLANN_INDEX_LINEAR; - - costs.push_back(linear_cost); + float bestCost = (float)t.value; + IndexParams* bestParams = new LinearIndexParams(); // Start parameter autotune process - Logger::info("Autotuning parameters...\n"); + logger().info("Autotuning parameters...\n"); - optimizeKMeans(costs); - optimizeKDTree(costs); - float bestTimeCost = costs[0].searchTimeCost; - for (size_t i = 0; i < costs.size(); ++i) { - float timeCost = costs[i].buildTimeCost * build_weight_ + costs[i].searchTimeCost; - if (timeCost < bestTimeCost) { - bestTimeCost = timeCost; - } + KMeansCostData kmeansCost = optimizeKMeans(); + if (kmeansCost.first.totalCost 0) { - for (size_t i = 0; i < costs.size(); ++i) { - float crtCost = (costs[i].buildTimeCost * build_weight_ + costs[i].searchTimeCost) / bestTimeCost + - memory_weight_ * costs[i].memoryCost; - if (crtCost < bestCost) { - bestCost = crtCost; - bestParams = costs[i].params; - } - } + KDTreeCostData kdtreeCost = optimizeKDTree(); + + if (kdtreeCost.first.totalCost 0) { - Matrix testDataset = random_sample(dataset_, samples); + int samples = (int)std::min(dataset.rows/10, SAMPLE_COUNT); + if (samples>0) { + Matrix testDataset = random_sample(dataset,samples); - Logger::info("Computing ground truth\n"); + logger().info("Computing ground truth\n"); // we need to compute the ground truth first - Matrix gt_matches(new int[testDataset.rows], testDataset.rows, 1); + Matrix gt_matches(new int[testDataset.rows],(long)testDataset.rows,1); StartStopTimer t; t.start(); - compute_ground_truth(dataset_, testDataset, gt_matches, 1, distance_); + compute_ground_truth(dataset, testDataset, gt_matches,1); t.stop(); float linear = (float)t.value; int checks; - Logger::info("Estimating number of checks\n"); + logger().info("Estimating number of checks\n"); float searchTime; float cb_index; - if (bestIndex_->getType() == FLANN_INDEX_KMEANS) { - Logger::info("KMeans algorithm, estimating cluster border factor\n"); - KMeansIndex* kmeans = (KMeansIndex*)bestIndex_; + if (bestIndex->getType() == FLANN_INDEX_KMEANS) { + logger().info("KMeans algorithm, estimating cluster border factor\n"); + KMeansIndex* kmeans = (KMeansIndex*)bestIndex; float bestSearchTime = -1; float best_cb_index = -1; int best_checks = -1; - for (cb_index = 0; cb_index < 1.1f; cb_index += 0.2f) { + for (cb_index = 0;cb_index<1.1f; cb_index+=0.2f) { kmeans->set_cb_index(cb_index); - searchTime = test_index_precision(*kmeans, dataset_, testDataset, gt_matches, target_precision_, checks, distance_, nn, 1); - if ((searchTime < bestSearchTime) || (bestSearchTime == -1)) { + searchTime = test_index_precision(*kmeans, dataset, testDataset, gt_matches, index_params.target_precision, checks, nn, 1); + if (searchTimeset_cb_index(best_cb_index); - Logger::info("Optimum cb_index: %g\n", cb_index); - bestParams_["cb_index"] = cb_index; + logger().info("Optimum cb_index: %g\n",cb_index); + ((KMeansIndexParams*)bestParams)->cb_index = cb_index; } else { - searchTime = test_index_precision(*bestIndex_, dataset_, testDataset, gt_matches, target_precision_, checks, distance_, nn, 1); + searchTime = test_index_precision(*bestIndex, dataset, testDataset, gt_matches, index_params.target_precision, checks, nn, 1); } - Logger::info("Required number of checks: %d \n", checks); - searchParams["checks"] = checks; + logger().info("Required number of checks: %d \n",checks);; + searchParams.checks = checks; - speedup = linear / searchTime; + speedup = linear/searchTime; - delete[] gt_matches.data; - delete[] testDataset.data; + gt_matches.release(); } return speedup; } -private: - NNIndex* bestIndex_; - - IndexParams bestParams_; - SearchParams bestSearchParams_; - - Matrix sampledDataset_; - Matrix testDataset_; - Matrix gt_matches_; - - float speedup_; - - /** - * The dataset used by this index - */ - const Matrix dataset_; - - /** - * Index parameters - */ - float target_precision_; - float build_weight_; - float memory_weight_; - float sample_fraction_; - - Distance distance_; - - }; -} -#endif /* OPENCV_FLANN_AUTOTUNED_INDEX_H_ */ +} // namespace cvflann + +#endif /* _OPENCV_AUTOTUNEDINDEX_H_ */ diff --git a/modules/flann/include/opencv2/flann/composite_index.h b/modules/flann/include/opencv2/flann/composite_index.h index 527ca1a..7738bf6 100644 --- a/modules/flann/include/opencv2/flann/composite_index.h +++ b/modules/flann/include/opencv2/flann/composite_index.h @@ -28,167 +28,135 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_COMPOSITE_INDEX_H_ -#define OPENCV_FLANN_COMPOSITE_INDEX_H_ +#ifndef _OPENCV_COMPOSITETREE_H_ +#define _OPENCV_COMPOSITETREE_H_ -#include "general.h" -#include "nn_index.h" -#include "kdtree_index.h" -#include "kmeans_index.h" +#include "opencv2/flann/general.h" +#include "opencv2/flann/nn_index.h" namespace cvflann { -/** - * Index parameters for the CompositeIndex. - */ -struct CompositeIndexParams : public IndexParams -{ - CompositeIndexParams(int trees = 4, int branching = 32, int iterations = 11, - flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, float cb_index = 0.2 ) - { - (*this)["algorithm"] = FLANN_INDEX_KMEANS; - // number of randomized trees to use (for kdtree) - (*this)["trees"] = trees; - // branching factor - (*this)["branching"] = branching; - // max iterations to perform in one kmeans clustering (kmeans tree) - (*this)["iterations"] = iterations; - // algorithm used for picking the initial cluster centers for kmeans tree - (*this)["centers_init"] = centers_init; - // cluster boundary index. Used when searching the kmeans tree - (*this)["cb_index"] = cb_index; - } + +struct CompositeIndexParams : public IndexParams { + CompositeIndexParams(int trees_ = 4, int branching_ = 32, int iterations_ = 11, + flann_centers_init_t centers_init_ = FLANN_CENTERS_RANDOM, float cb_index_ = 0.2 ) : + IndexParams(FLANN_INDEX_COMPOSITE), + trees(trees_), + branching(branching_), + iterations(iterations_), + centers_init(centers_init_), + cb_index(cb_index_) {}; + + int trees; // number of randomized trees to use (for kdtree) + int branching; // branching factor (for kmeans tree) + int iterations; // max iterations to perform in one kmeans clustering (kmeans tree) + flann_centers_init_t centers_init; // algorithm used for picking the initial cluster centers for kmeans tree + float cb_index; // cluster boundary index. Used when searching the kmeans tree + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + logger().info("Trees: %d\n", trees); + logger().info("Branching: %d\n", branching); + logger().info("Iterations: %d\n", iterations); + logger().info("Centres initialisation: %d\n", centers_init); + logger().info("Cluster boundary weight: %g\n", cb_index); + } }; -/** - * This index builds a kd-tree index and a k-means index and performs nearest - * neighbour search both indexes. This gives a slight boost in search performance - * as some of the neighbours that are missed by one index are found by the other. - */ -template -class CompositeIndex : public NNIndex + +template ::type > +class CompositeIndex : public NNIndex { + KMeansIndex* kmeans; + KDTreeIndex* kdtree; + + const Matrix dataset; + + const IndexParams& index_params; + + CompositeIndex& operator=(const CompositeIndex&); + CompositeIndex(const CompositeIndex&); public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - /** - * Index constructor - * @param inputData dataset containing the points to index - * @param params Index parameters - * @param d Distance functor - * @return - */ - CompositeIndex(const Matrix& inputData, const IndexParams& params = CompositeIndexParams(), - Distance d = Distance()) : index_params_(params) - { - kdtree_index_ = new KDTreeIndex(inputData, params, d); - kmeans_index_ = new KMeansIndex(inputData, params, d); - } + CompositeIndex(const Matrix& inputData, const CompositeIndexParams& params = CompositeIndexParams() ) : + dataset(inputData), index_params(params) + { + KDTreeIndexParams kdtree_params(params.trees); + KMeansIndexParams kmeans_params(params.branching, params.iterations, params.centers_init, params.cb_index); - CompositeIndex(const CompositeIndex&); - CompositeIndex& operator=(const CompositeIndex&); + kdtree = new KDTreeIndex(inputData,kdtree_params); + kmeans = new KMeansIndex(inputData,kmeans_params); + + } + + virtual ~CompositeIndex() + { + delete kdtree; + delete kmeans; + } - virtual ~CompositeIndex() - { - delete kdtree_index_; - delete kmeans_index_; - } - /** - * @return The index type - */ flann_algorithm_t getType() const { return FLANN_INDEX_COMPOSITE; } - /** - * @return Size of the index - */ + size_t size() const - { - return kdtree_index_->size(); - } + { + return dataset.rows; + } - /** - * \returns The dimensionality of the features in this index. - */ - size_t veclen() const - { - return kdtree_index_->veclen(); - } + size_t veclen() const + { + return dataset.cols; + } - /** - * \returns The amount of memory (in bytes) used by the index. - */ - int usedMemory() const - { - return kmeans_index_->usedMemory() + kdtree_index_->usedMemory(); - } - /** - * \brief Builds the index - */ - void buildIndex() - { - Logger::info("Building kmeans tree...\n"); - kmeans_index_->buildIndex(); - Logger::info("Building kdtree tree...\n"); - kdtree_index_->buildIndex(); - } + int usedMemory() const + { + return kmeans->usedMemory()+kdtree->usedMemory(); + } + + void buildIndex() + { + logger().info("Building kmeans tree...\n"); + kmeans->buildIndex(); + logger().info("Building kdtree tree...\n"); + kdtree->buildIndex(); + } + - /** - * \brief Saves the index to a stream - * \param stream The stream to save the index to - */ void saveIndex(FILE* stream) { - kmeans_index_->saveIndex(stream); - kdtree_index_->saveIndex(stream); + kmeans->saveIndex(stream); + kdtree->saveIndex(stream); } - /** - * \brief Loads the index from a stream - * \param stream The stream from which the index is loaded - */ - void loadIndex(FILE* stream) - { - kmeans_index_->loadIndex(stream); - kdtree_index_->loadIndex(stream); - } - /** - * \returns The index parameters - */ - IndexParams getParameters() const + void loadIndex(FILE* stream) { - return index_params_; + kmeans->loadIndex(stream); + kdtree->loadIndex(stream); } - /** - * \brief Method that searches for nearest-neighbours - */ - void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) - { - kmeans_index_->findNeighbors(result, vec, searchParams); - kdtree_index_->findNeighbors(result, vec, searchParams); - } + void findNeighbors(ResultSet& result, const ELEM_TYPE* vec, const SearchParams& searchParams) + { + kmeans->findNeighbors(result,vec,searchParams); + kdtree->findNeighbors(result,vec,searchParams); + } -private: - /** The k-means index */ - KMeansIndex* kmeans_index_; + const IndexParams* getParameters() const + { + return &index_params; + } - /** The kd-tree index */ - KDTreeIndex* kdtree_index_; - /** The index parameters */ - const IndexParams index_params_; }; -} +} // namespace cvflann -#endif //OPENCV_FLANN_COMPOSITE_INDEX_H_ +#endif //_OPENCV_COMPOSITETREE_H_ diff --git a/modules/flann/include/opencv2/flann/config.h b/modules/flann/include/opencv2/flann/config.h deleted file mode 100644 index ca6138d..0000000 --- a/modules/flann/include/opencv2/flann/config.h +++ /dev/null @@ -1,35 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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_FLANN_CONFIG_H_ -#define OPENCV_FLANN_CONFIG_H_ - -#define FLANN_VERSION "1.6.10" - -#endif /* OPENCV_FLANN_CONFIG_H_ */ diff --git a/modules/flann/include/opencv2/flann/defines.h b/modules/flann/include/opencv2/flann/defines.h deleted file mode 100644 index d1a0af8..0000000 --- a/modules/flann/include/opencv2/flann/defines.h +++ /dev/null @@ -1,160 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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_FLANN_DEFINES_H_ -#define OPENCV_FLANN_DEFINES_H_ - -#include "config.h" - -#ifdef WIN32 -/* win32 dll export/import directives */ - #ifdef FLANN_EXPORTS - #define FLANN_EXPORT __declspec(dllexport) - #elif defined(FLANN_STATIC) - #define FLANN_EXPORT - #else - #define FLANN_EXPORT __declspec(dllimport) - #endif -#else -/* unix needs nothing */ - #define FLANN_EXPORT -#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 - - -#if __amd64__ || __x86_64__ || _WIN64 || _M_X64 -#define FLANN_PLATFORM_64_BIT -#else -#define FLANN_PLATFORM_32_BIT -#endif - - -#define FLANN_ARRAY_LEN(a) (sizeof(a)/sizeof(a[0])) - -/* Nearest neighbour index algorithms */ -enum flann_algorithm_t -{ - FLANN_INDEX_LINEAR = 0, - FLANN_INDEX_KDTREE = 1, - FLANN_INDEX_KMEANS = 2, - FLANN_INDEX_COMPOSITE = 3, - FLANN_INDEX_KDTREE_SINGLE = 4, - FLANN_INDEX_HIERARCHICAL = 5, - FLANN_INDEX_LSH = 6, - FLANN_INDEX_SAVED = 254, - FLANN_INDEX_AUTOTUNED = 255, - - // deprecated constants, should use the FLANN_INDEX_* ones instead - LINEAR = 0, - KDTREE = 1, - KMEANS = 2, - COMPOSITE = 3, - KDTREE_SINGLE = 4, - SAVED = 254, - AUTOTUNED = 255 -}; - - - -enum flann_centers_init_t -{ - FLANN_CENTERS_RANDOM = 0, - FLANN_CENTERS_GONZALES = 1, - FLANN_CENTERS_KMEANSPP = 2, - - // deprecated constants, should use the FLANN_CENTERS_* ones instead - CENTERS_RANDOM = 0, - CENTERS_GONZALES = 1, - CENTERS_KMEANSPP = 2 -}; - -enum flann_log_level_t -{ - FLANN_LOG_NONE = 0, - FLANN_LOG_FATAL = 1, - FLANN_LOG_ERROR = 2, - FLANN_LOG_WARN = 3, - FLANN_LOG_INFO = 4, -}; - -enum flann_distance_t -{ - FLANN_DIST_EUCLIDEAN = 1, - FLANN_DIST_L2 = 1, - FLANN_DIST_MANHATTAN = 2, - FLANN_DIST_L1 = 2, - FLANN_DIST_MINKOWSKI = 3, - FLANN_DIST_MAX = 4, - FLANN_DIST_HIST_INTERSECT = 5, - FLANN_DIST_HELLINGER = 6, - FLANN_DIST_CHI_SQUARE = 7, - FLANN_DIST_CS = 7, - FLANN_DIST_KULLBACK_LEIBLER = 8, - FLANN_DIST_KL = 8, - - // deprecated constants, should use the FLANN_DIST_* ones instead - EUCLIDEAN = 1, - MANHATTAN = 2, - MINKOWSKI = 3, - MAX_DIST = 4, - HIST_INTERSECT = 5, - HELLINGER = 6, - CS = 7, - KL = 8, - KULLBACK_LEIBLER = 8 -}; - -enum flann_datatype_t -{ - FLANN_INT8 = 0, - FLANN_INT16 = 1, - FLANN_INT32 = 2, - FLANN_INT64 = 3, - FLANN_UINT8 = 4, - FLANN_UINT16 = 5, - FLANN_UINT32 = 6, - FLANN_UINT64 = 7, - FLANN_FLOAT32 = 8, - FLANN_FLOAT64 = 9 -}; - -const int FLANN_CHECKS_UNLIMITED = -1; -const int FLANN_CHECKS_AUTOTUNED = -2; - - -#endif /* OPENCV_FLANN_DEFINES_H_ */ diff --git a/modules/flann/include/opencv2/flann/dist.h b/modules/flann/include/opencv2/flann/dist.h index 2b30059..2ddbee3 100644 --- a/modules/flann/include/opencv2/flann/dist.h +++ b/modules/flann/include/opencv2/flann/dist.h @@ -28,775 +28,302 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_DIST_H_ -#define OPENCV_FLANN_DIST_H_ +#ifndef _OPENCV_DIST_H_ +#define _OPENCV_DIST_H_ #include -#include -#include -#ifdef _MSC_VER -typedef unsigned uint32_t; -typedef unsigned __int64 uint64_t; -#else -#include -#endif - -#include "defines.h" +#include "opencv2/flann/general.h" namespace cvflann { -template -inline T abs(T x) { return (x<0) ? -x : x; } - -template<> -inline int abs(int x) { return ::abs(x); } - -template<> -inline float abs(float x) { return fabsf(x); } - -template<> -inline double abs(double x) { return fabs(x); } - -template<> -inline long double abs(long double x) { return fabsl(x); } - - -template -struct Accumulator { typedef T Type; }; -template<> -struct Accumulator { typedef float Type; }; -template<> -struct Accumulator { typedef float Type; }; -template<> -struct Accumulator { typedef float Type; }; -template<> -struct Accumulator { typedef float Type; }; -template<> -struct Accumulator { typedef float Type; }; -template<> -struct Accumulator { typedef float Type; }; - - -class True -{ -}; - -class False -{ -}; +/** + * Distance function by default set to the custom distance + * function. This can be set to a specific distance function + * for further efficiency. + */ +#define flann_dist custom_dist +//#define flann_dist euclidean_dist /** - * Squared Euclidean distance functor. + * Compute the squared Euclidean distance between two vectors. + * + * This is highly optimised, with loop unrolling, as it is one + * of the most expensive inner loops. * - * This is the simpler, unrolled version. This is preferable for - * very low dimensionality data (eg 3D points) + * The computation of squared root at the end is omitted for + * efficiency. */ -template -struct L2_Simple +template +double euclidean_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const - { - ResultType result = ResultType(); - ResultType diff; - for(size_t i = 0; i < size; ++i ) { - diff = *a++ - *b++; - result += diff*diff; - } - return result; - } - - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return (a-b)*(a-b); - } -}; + double distsq = acc; + double diff0, diff1, diff2, diff3; + Iterator1 lastgroup = last1 - 3; + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + diff0 = first1[0] - first2[0]; + diff1 = first1[1] - first2[1]; + diff2 = first1[2] - first2[2]; + diff3 = first1[3] - first2[3]; + distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3; + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + diff0 = *first1++ - *first2++; + distsq += diff0 * diff0; + } + return distsq; +} +CV_EXPORTS double euclidean_dist(const unsigned char* first1, const unsigned char* last1, unsigned char* first2, double acc); /** - * Squared Euclidean distance functor, optimized version + * Compute the Manhattan (L_1) distance between two vectors. + * + * This is highly optimised, with loop unrolling, as it is one + * of the most expensive inner loops. */ -template -struct L2 +template +double manhattan_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the squared Euclidean distance between two vectors. - * - * This is highly optimised, with loop unrolling, as it is one - * of the most expensive inner loops. - * - * The computation of squared root at the end is omitted for - * efficiency. - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType diff0, diff1, diff2, diff3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - diff0 = (ResultType)(a[0] - b[0]); - diff1 = (ResultType)(a[1] - b[1]); - diff2 = (ResultType)(a[2] - b[2]); - diff3 = (ResultType)(a[3] - b[3]); - result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3; - a += 4; - b += 4; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - /* Process last 0-3 pixels. Not needed for standard vector lengths. */ - while (a < last) { - diff0 = *a++ - *b++; - result += diff0 * diff0; - } - return result; - } - - /** - * Partial euclidean distance, using just one dimension. This is used by the - * kd-tree when computing partial distances while traversing the tree. - * - * Squared root is omitted for efficiency. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return (a-b)*(a-b); - } -}; + double distsq = acc; + double diff0, diff1, diff2, diff3; + Iterator1 lastgroup = last1 - 3; + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + diff0 = fabs(first1[0] - first2[0]); + diff1 = fabs(first1[1] - first2[1]); + diff2 = fabs(first1[2] - first2[2]); + diff3 = fabs(first1[3] - first2[3]); + distsq += diff0 + diff1 + diff2 + diff3; + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + diff0 = fabs(*first1++ - *first2++); + distsq += diff0; + } + return distsq; +} -/* - * Manhattan distance functor, optimized version +CV_EXPORTS int flann_minkowski_order(); +/** + * Compute the Minkowski (L_p) distance between two vectors. + * + * This is highly optimised, with loop unrolling, as it is one + * of the most expensive inner loops. + * + * The computation of squared root at the end is omitted for + * efficiency. */ -template -struct L1 +template +double minkowski_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the Manhattan (L_1) distance between two vectors. - * - * This is highly optimised, with loop unrolling, as it is one - * of the most expensive inner loops. - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType diff0, diff1, diff2, diff3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - diff0 = abs(a[0] - b[0]); - diff1 = abs(a[1] - b[1]); - diff2 = abs(a[2] - b[2]); - diff3 = abs(a[3] - b[3]); - result += diff0 + diff1 + diff2 + diff3; - a += 4; - b += 4; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - /* Process last 0-3 pixels. Not needed for standard vector lengths. */ - while (a < last) { - diff0 = abs(*a++ - *b++); - result += diff0; - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return abs(a-b); - } -}; - + double distsq = acc; + double diff0, diff1, diff2, diff3; + Iterator1 lastgroup = last1 - 3; + + int p = flann_minkowski_order(); + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + diff0 = fabs(first1[0] - first2[0]); + diff1 = fabs(first1[1] - first2[1]); + diff2 = fabs(first1[2] - first2[2]); + diff3 = fabs(first1[3] - first2[3]); + distsq += pow(diff0,p) + pow(diff1,p) + pow(diff2,p) + pow(diff3,p); + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + diff0 = fabs(*first1++ - *first2++); + distsq += pow(diff0,p); + } + return distsq; +} -template -struct MinkowskiDistance +// L_infinity distance (NOT A VALID KD-TREE DISTANCE - NOT DIMENSIONWISE ADDITIVE) +template +double max_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - int order; - - MinkowskiDistance(int order_) : order(order_) {} - - /** - * Compute the Minkowsky (L_p) distance between two vectors. - * - * This is highly optimised, with loop unrolling, as it is one - * of the most expensive inner loops. - * - * The computation of squared root at the end is omitted for - * efficiency. - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType diff0, diff1, diff2, diff3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - diff0 = abs(a[0] - b[0]); - diff1 = abs(a[1] - b[1]); - diff2 = abs(a[2] - b[2]); - diff3 = abs(a[3] - b[3]); - result += pow(diff0,order) + pow(diff1,order) + pow(diff2,order) + pow(diff3,order); - a += 4; - b += 4; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - /* Process last 0-3 pixels. Not needed for standard vector lengths. */ - while (a < last) { - diff0 = abs(*a++ - *b++); - result += pow(diff0,order); - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return pow(static_cast(abs(a-b)),order); - } -}; - + double dist = acc; + Iterator1 lastgroup = last1 - 3; + double diff0, diff1, diff2, diff3; + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + diff0 = fabs(first1[0] - first2[0]); + diff1 = fabs(first1[1] - first2[1]); + diff2 = fabs(first1[2] - first2[2]); + diff3 = fabs(first1[3] - first2[3]); + if (diff0 > dist) dist = diff0; + if (diff1 > dist) dist = diff1; + if (diff2 > dist) dist = diff2; + if (diff3 > dist) dist = diff3; + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + diff0 = fabs(*first1++ - *first2++); + dist = (diff0 > dist) ? diff0 : dist; + } + return dist; +} -template -struct MaxDistance +template +double hist_intersection_kernel(Iterator1 first1, Iterator1 last1, Iterator2 first2) { - typedef False is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the max distance (L_infinity) between two vectors. - * - * This distance is not a valid kdtree distance, it's not dimensionwise additive. - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType diff0, diff1, diff2, diff3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - diff0 = abs(a[0] - b[0]); - diff1 = abs(a[1] - b[1]); - diff2 = abs(a[2] - b[2]); - diff3 = abs(a[3] - b[3]); - if (diff0>result) {result = diff0; } - if (diff1>result) {result = diff1; } - if (diff2>result) {result = diff2; } - if (diff3>result) {result = diff3; } - a += 4; - b += 4; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - /* Process last 0-3 pixels. Not needed for standard vector lengths. */ - while (a < last) { - diff0 = abs(*a++ - *b++); - result = (diff0>result) ? diff0 : result; - } - return result; - } - - /* This distance functor is not dimension-wise additive, which - * makes it an invalid kd-tree distance, not implementing the accum_dist method */ - -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + double kernel = 0; + Iterator1 lastgroup = last1 - 3; + double min0, min1, min2, min3; + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + min0 = first1[0] < first2[0] ? first1[0] : first2[0]; + min1 = first1[1] < first2[1] ? first1[1] : first2[1]; + min2 = first1[2] < first2[2] ? first1[2] : first2[2]; + min3 = first1[3] < first2[3] ? first1[3] : first2[3]; + kernel += min0 + min1 + min2 + min3; + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + min0 = first1[0] < first2[0] ? first1[0] : first2[0]; + kernel += min0; + first1++; + first2++; + } + return kernel; +} -/** - * Hamming distance functor - counts the bit differences between two strings - useful for the Brief descriptor - * bit count of A exclusive XOR'ed with B - */ -struct HammingLUT +template +double hist_intersection_dist_sq(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef False is_kdtree_distance; - typedef False is_vector_space_distance; - - typedef unsigned char ElementType; - typedef int ResultType; - - /** this will count the bits in a ^ b - */ - ResultType operator()(const unsigned char* a, const unsigned char* b, int size) const - { - ResultType result = 0; - for (int i = 0; i < size; i++) { - result += byteBitsLookUp(a[i] ^ b[i]); - } - return result; - } - - - /** \brief given a byte, count the bits using a look up table - * \param b the byte to count bits. The look up table has an entry for all - * values of b, where that entry is the number of bits. - * \return the number of bits in byte b - */ - static unsigned char byteBitsLookUp(unsigned char b) - { - static const unsigned char table[256] = { - /* 0 */ 0, /* 1 */ 1, /* 2 */ 1, /* 3 */ 2, - /* 4 */ 1, /* 5 */ 2, /* 6 */ 2, /* 7 */ 3, - /* 8 */ 1, /* 9 */ 2, /* a */ 2, /* b */ 3, - /* c */ 2, /* d */ 3, /* e */ 3, /* f */ 4, - /* 10 */ 1, /* 11 */ 2, /* 12 */ 2, /* 13 */ 3, - /* 14 */ 2, /* 15 */ 3, /* 16 */ 3, /* 17 */ 4, - /* 18 */ 2, /* 19 */ 3, /* 1a */ 3, /* 1b */ 4, - /* 1c */ 3, /* 1d */ 4, /* 1e */ 4, /* 1f */ 5, - /* 20 */ 1, /* 21 */ 2, /* 22 */ 2, /* 23 */ 3, - /* 24 */ 2, /* 25 */ 3, /* 26 */ 3, /* 27 */ 4, - /* 28 */ 2, /* 29 */ 3, /* 2a */ 3, /* 2b */ 4, - /* 2c */ 3, /* 2d */ 4, /* 2e */ 4, /* 2f */ 5, - /* 30 */ 2, /* 31 */ 3, /* 32 */ 3, /* 33 */ 4, - /* 34 */ 3, /* 35 */ 4, /* 36 */ 4, /* 37 */ 5, - /* 38 */ 3, /* 39 */ 4, /* 3a */ 4, /* 3b */ 5, - /* 3c */ 4, /* 3d */ 5, /* 3e */ 5, /* 3f */ 6, - /* 40 */ 1, /* 41 */ 2, /* 42 */ 2, /* 43 */ 3, - /* 44 */ 2, /* 45 */ 3, /* 46 */ 3, /* 47 */ 4, - /* 48 */ 2, /* 49 */ 3, /* 4a */ 3, /* 4b */ 4, - /* 4c */ 3, /* 4d */ 4, /* 4e */ 4, /* 4f */ 5, - /* 50 */ 2, /* 51 */ 3, /* 52 */ 3, /* 53 */ 4, - /* 54 */ 3, /* 55 */ 4, /* 56 */ 4, /* 57 */ 5, - /* 58 */ 3, /* 59 */ 4, /* 5a */ 4, /* 5b */ 5, - /* 5c */ 4, /* 5d */ 5, /* 5e */ 5, /* 5f */ 6, - /* 60 */ 2, /* 61 */ 3, /* 62 */ 3, /* 63 */ 4, - /* 64 */ 3, /* 65 */ 4, /* 66 */ 4, /* 67 */ 5, - /* 68 */ 3, /* 69 */ 4, /* 6a */ 4, /* 6b */ 5, - /* 6c */ 4, /* 6d */ 5, /* 6e */ 5, /* 6f */ 6, - /* 70 */ 3, /* 71 */ 4, /* 72 */ 4, /* 73 */ 5, - /* 74 */ 4, /* 75 */ 5, /* 76 */ 5, /* 77 */ 6, - /* 78 */ 4, /* 79 */ 5, /* 7a */ 5, /* 7b */ 6, - /* 7c */ 5, /* 7d */ 6, /* 7e */ 6, /* 7f */ 7, - /* 80 */ 1, /* 81 */ 2, /* 82 */ 2, /* 83 */ 3, - /* 84 */ 2, /* 85 */ 3, /* 86 */ 3, /* 87 */ 4, - /* 88 */ 2, /* 89 */ 3, /* 8a */ 3, /* 8b */ 4, - /* 8c */ 3, /* 8d */ 4, /* 8e */ 4, /* 8f */ 5, - /* 90 */ 2, /* 91 */ 3, /* 92 */ 3, /* 93 */ 4, - /* 94 */ 3, /* 95 */ 4, /* 96 */ 4, /* 97 */ 5, - /* 98 */ 3, /* 99 */ 4, /* 9a */ 4, /* 9b */ 5, - /* 9c */ 4, /* 9d */ 5, /* 9e */ 5, /* 9f */ 6, - /* a0 */ 2, /* a1 */ 3, /* a2 */ 3, /* a3 */ 4, - /* a4 */ 3, /* a5 */ 4, /* a6 */ 4, /* a7 */ 5, - /* a8 */ 3, /* a9 */ 4, /* aa */ 4, /* ab */ 5, - /* ac */ 4, /* ad */ 5, /* ae */ 5, /* af */ 6, - /* b0 */ 3, /* b1 */ 4, /* b2 */ 4, /* b3 */ 5, - /* b4 */ 4, /* b5 */ 5, /* b6 */ 5, /* b7 */ 6, - /* b8 */ 4, /* b9 */ 5, /* ba */ 5, /* bb */ 6, - /* bc */ 5, /* bd */ 6, /* be */ 6, /* bf */ 7, - /* c0 */ 2, /* c1 */ 3, /* c2 */ 3, /* c3 */ 4, - /* c4 */ 3, /* c5 */ 4, /* c6 */ 4, /* c7 */ 5, - /* c8 */ 3, /* c9 */ 4, /* ca */ 4, /* cb */ 5, - /* cc */ 4, /* cd */ 5, /* ce */ 5, /* cf */ 6, - /* d0 */ 3, /* d1 */ 4, /* d2 */ 4, /* d3 */ 5, - /* d4 */ 4, /* d5 */ 5, /* d6 */ 5, /* d7 */ 6, - /* d8 */ 4, /* d9 */ 5, /* da */ 5, /* db */ 6, - /* dc */ 5, /* dd */ 6, /* de */ 6, /* df */ 7, - /* e0 */ 3, /* e1 */ 4, /* e2 */ 4, /* e3 */ 5, - /* e4 */ 4, /* e5 */ 5, /* e6 */ 5, /* e7 */ 6, - /* e8 */ 4, /* e9 */ 5, /* ea */ 5, /* eb */ 6, - /* ec */ 5, /* ed */ 6, /* ee */ 6, /* ef */ 7, - /* f0 */ 4, /* f1 */ 5, /* f2 */ 5, /* f3 */ 6, - /* f4 */ 5, /* f5 */ 6, /* f6 */ 6, /* f7 */ 7, - /* f8 */ 5, /* f9 */ 6, /* fa */ 6, /* fb */ 7, - /* fc */ 6, /* fd */ 7, /* fe */ 7, /* ff */ 8 - }; - return table[b]; - } -}; + double dist_sq = acc - 2 * hist_intersection_kernel(first1, last1, first2); + while (first1 < last1) { + dist_sq += *first1 + *first2; + first1++; + first2++; + } + return dist_sq; +} -/** - * Hamming distance functor (pop count between two binary vectors, i.e. xor them and count the number of bits set) - * That code was taken from brief.cpp in OpenCV - */ -template -struct Hamming -{ - typedef False is_kdtree_distance; - typedef False is_vector_space_distance; - - - typedef T ElementType; - typedef int ResultType; - - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const - { - ResultType result = 0; -#if __GNUC__ -#if ANDROID && HAVE_NEON - static uint64_t features = android_getCpuFeatures(); - if ((features& ANDROID_CPU_ARM_FEATURE_NEON)) { - for (size_t i = 0; i < size; i += 16) { - uint8x16_t A_vec = vld1q_u8 (a + i); - uint8x16_t B_vec = vld1q_u8 (b + i); - //uint8x16_t veorq_u8 (uint8x16_t, uint8x16_t) - uint8x16_t AxorB = veorq_u8 (A_vec, B_vec); - - uint8x16_t bitsSet += vcntq_u8 (AxorB); - //uint16x8_t vpadalq_u8 (uint16x8_t, uint8x16_t) - uint16x8_t bitSet8 = vpaddlq_u8 (bitsSet); - uint32x4_t bitSet4 = vpaddlq_u16 (bitSet8); - - uint64x2_t bitSet2 = vpaddlq_u32 (bitSet4); - result += vgetq_lane_u64 (bitSet2,0); - result += vgetq_lane_u64 (bitSet2,1); - } - } - else -#endif - //for portability just use unsigned long -- and use the __builtin_popcountll (see docs for __builtin_popcountll) - typedef unsigned long long pop_t; - const size_t modulo = size % sizeof(pop_t); - const pop_t* a2 = reinterpret_cast (a); - const pop_t* b2 = reinterpret_cast (b); - const pop_t* a2_end = a2 + (size / sizeof(pop_t)); - - for (; a2 != a2_end; ++a2, ++b2) result += __builtin_popcountll((*a2) ^ (*b2)); - - if (modulo) { - //in the case where size is not dividable by sizeof(size_t) - //need to mask off the bits at the end - pop_t a_final = 0, b_final = 0; - memcpy(&a_final, a2, modulo); - memcpy(&b_final, b2, modulo); - result += __builtin_popcountll(a_final ^ b_final); - } -#else - HammingLUT lut; - result = lut(reinterpret_cast (a), - reinterpret_cast (b), size * sizeof(pop_t)); -#endif - return result; - } -}; -template -struct Hamming2 +// Hellinger distance +template +double hellinger_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef False is_kdtree_distance; - typedef False is_vector_space_distance; - - typedef T ElementType; - typedef int ResultType; - - /** This is popcount_3() from: - * http://en.wikipedia.org/wiki/Hamming_weight */ - unsigned int popcnt32(uint32_t n) const - { - n -= ((n >> 1) & 0x55555555); - n = (n & 0x33333333) + ((n >> 2) & 0x33333333); - return (((n + (n >> 4))& 0xF0F0F0F)* 0x1010101) >> 24; - } - - unsigned int popcnt64(uint64_t n) const - { - n -= ((n >> 1) & 0x5555555555555555); - n = (n & 0x3333333333333333) + ((n >> 2) & 0x3333333333333333); - return (((n + (n >> 4))& 0x0f0f0f0f0f0f0f0f)* 0x0101010101010101) >> 56; - } - - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const - { -#ifdef FLANN_PLATFORM_64_BIT - const uint64_t* pa = reinterpret_cast(a); - const uint64_t* pb = reinterpret_cast(b); - ResultType result = 0; - size /= (sizeof(uint64_t)/sizeof(unsigned char)); - for(size_t i = 0; i < size; ++i ) { - result += popcnt64(*pa ^ *pb); - ++pa; - ++pb; - } -#else - const uint32_t* pa = reinterpret_cast(a); - const uint32_t* pb = reinterpret_cast(b); - ResultType result = 0; - size /= (sizeof(uint32_t)/sizeof(unsigned char)); - for(size_t i = 0; i < size; ++i ) { - result += popcnt32(*pa ^ *pb); - ++pa; - ++pb; - } -#endif - return result; - } -}; - - + double distsq = acc; + double diff0, diff1, diff2, diff3; + Iterator1 lastgroup = last1 - 3; + + /* Process 4 items with each loop for efficiency. */ + while (first1 < lastgroup) { + diff0 = sqrt(first1[0]) - sqrt(first2[0]); + diff1 = sqrt(first1[1]) - sqrt(first2[1]); + diff2 = sqrt(first1[2]) - sqrt(first2[2]); + diff3 = sqrt(first1[3]) - sqrt(first2[3]); + distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3; + first1 += 4; + first2 += 4; + } + /* Process last 0-3 pixels. Not needed for standard vector lengths. */ + while (first1 < last1) { + diff0 = sqrt(*first1++) - sqrt(*first2++); + distsq += diff0 * diff0; + } + return distsq; +} -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -template -struct HistIntersectionDistance +// chi-dsquare distance +template +double chi_square_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the histogram intersection distance - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType min0, min1, min2, min3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - min0 = a[0] < b[0] ? a[0] : b[0]; - min1 = a[1] < b[1] ? a[1] : b[1]; - min2 = a[2] < b[2] ? a[2] : b[2]; - min3 = a[3] < b[3] ? a[3] : b[3]; - result += min0 + min1 + min2 + min3; - a += 4; - b += 4; - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - /* Process last 0-3 pixels. Not needed for standard vector lengths. */ - while (a < last) { - min0 = *a < *b ? *a : *b; - result += min0; - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return a 0) { + double diff = *first1 - *first2; + dist += diff * diff / sum; + } + first1++; + first2++; + } + return dist; +} -template -struct HellingerDistance +// Kullback–Leibler divergence (NOT SYMMETRIC) +template +double kl_divergence(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the histogram intersection distance - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType /*worst_dist*/ = -1) const - { - ResultType result = ResultType(); - ResultType diff0, diff1, diff2, diff3; - Iterator1 last = a + size; - Iterator1 lastgroup = last - 3; - - /* Process 4 items with each loop for efficiency. */ - while (a < lastgroup) { - diff0 = sqrt(static_cast(a[0])) - sqrt(static_cast(b[0])); - diff1 = sqrt(static_cast(a[1])) - sqrt(static_cast(b[1])); - diff2 = sqrt(static_cast(a[2])) - sqrt(static_cast(b[2])); - diff3 = sqrt(static_cast(a[3])) - sqrt(static_cast(b[3])); - result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3; - a += 4; - b += 4; - } - while (a < last) { - diff0 = sqrt(static_cast(*a++)) - sqrt(static_cast(*b++)); - result += diff0 * diff0; - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - return sqrt(static_cast(a)) - sqrt(static_cast(b)); - } -}; + double div = acc; + + while (first1 < last1) { + if (*first2 != 0) { + double ratio = *first1 / *first2; + if (ratio > 0) { + div += *first1 * log(ratio); + } + } + first1++; + first2++; + } + return div; +} -template -struct ChiSquareDistance -{ - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the chi-square distance - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - ResultType sum, diff; - Iterator1 last = a + size; - - while (a < last) { - sum = *a + *b; - if (sum>0) { - diff = *a - *b; - result += diff*diff/sum; - } - ++a; - ++b; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - ResultType result = ResultType(); - ResultType sum, diff; - - sum = a+b; - if (sum>0) { - diff = a-b; - result = diff*diff/sum; - } - return result; - } -}; -template -struct KL_Divergence +CV_EXPORTS flann_distance_t flann_distance_type(); +/** + * Custom distance function. The distance computed is dependent on the value + * of the 'flann_distance_type' global variable. + * + * If the last argument 'acc' is passed, the result is accumulated to the value + * of this argument. + */ +template +double custom_dist(Iterator1 first1, Iterator1 last1, Iterator2 first2, double acc = 0) { - typedef True is_kdtree_distance; - typedef True is_vector_space_distance; - - typedef T ElementType; - typedef typename Accumulator::Type ResultType; - - /** - * Compute the Kullback–Leibler divergence - */ - template - ResultType operator()(Iterator1 a, Iterator2 b, size_t size, ResultType worst_dist = -1) const - { - ResultType result = ResultType(); - Iterator1 last = a + size; - - while (a < last) { - if (* a != 0) { - ResultType ratio = *a / *b; - if (ratio>0) { - result += *a * log(ratio); - } - } - ++a; - ++b; - - if ((worst_dist>0)&&(result>worst_dist)) { - return result; - } - } - return result; - } - - /** - * Partial distance, used by the kd-tree. - */ - template - inline ResultType accum_dist(const U& a, const V& b, int) const - { - ResultType result = ResultType(); - ResultType ratio = a / b; - if (ratio>0) { - result = a * log(ratio); - } - return result; - } -}; - - + switch (flann_distance_type()) { + case FLANN_DIST_EUCLIDEAN: + return euclidean_dist(first1, last1, first2, acc); + case FLANN_DIST_MANHATTAN: + return manhattan_dist(first1, last1, first2, acc); + case FLANN_DIST_MINKOWSKI: + return minkowski_dist(first1, last1, first2, acc); + case FLANN_DIST_MAX: + return max_dist(first1, last1, first2, acc); + case FLANN_DIST_HIST_INTERSECT: + return hist_intersection_dist_sq(first1, last1, first2, acc); + case FLANN_DIST_HELLINGER: + return hellinger_dist(first1, last1, first2, acc); + case FLANN_DIST_CS: + return chi_square_dist(first1, last1, first2, acc); + case FLANN_DIST_KL: + return kl_divergence(first1, last1, first2, acc); + default: + return euclidean_dist(first1, last1, first2, acc); + } +} /* * This is a "zero iterator". It basically behaves like a zero filled @@ -806,36 +333,28 @@ struct KL_Divergence * zero-filled array. */ template -struct ZeroIterator -{ - - T operator*() - { - return 0; - } +struct ZeroIterator { - T operator[](int) - { - return 0; - } + T operator*() { + return 0; + } - const ZeroIterator& operator ++() - { - return *this; - } + T operator[](int) { + return 0; + } - ZeroIterator operator ++(int) - { - return *this; - } + ZeroIterator& operator ++(int) { + return *this; + } - ZeroIterator& operator+=(int) - { - return *this; - } + ZeroIterator& operator+=(int) { + return *this; + } }; -} +CV_EXPORTS ZeroIterator& zero(); + +} // namespace cvflann -#endif //OPENCV_FLANN_DIST_H_ +#endif //_OPENCV_DIST_H_ diff --git a/modules/flann/include/opencv2/flann/dynamic_bitset.h b/modules/flann/include/opencv2/flann/dynamic_bitset.h deleted file mode 100644 index e88cfaa..0000000 --- a/modules/flann/include/opencv2/flann/dynamic_bitset.h +++ /dev/null @@ -1,152 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * THE BSD LICENSE - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. - *************************************************************************/ - -/*********************************************************************** - * Author: Vincent Rabaud - *************************************************************************/ - -#ifndef OPENCV_FLANN_DYNAMIC_BITSET_H_ -#define OPENCV_FLANN_DYNAMIC_BITSET_H_ - -//#define FLANN_USE_BOOST 1 -#if FLANN_USE_BOOST -#include -typedef boost::dynamic_bitset<> DynamicBitset; -#else - -#include - -#include "dist.h" - -/** Class re-implementing the boost version of it - * This helps not depending on boost, it also does not do the bound checks - * and has a way to reset a block for speed - */ -class DynamicBitset -{ -public: - /** @param default constructor - */ - DynamicBitset() - { - } - - /** @param only constructor we use in our code - * @param the size of the bitset (in bits) - */ - DynamicBitset(size_t size) - { - resize(size); - reset(); - } - - /** Sets all the bits to 0 - */ - void clear() - { - std::fill(bitset_.begin(), bitset_.end(), 0); - } - - /** @brief checks if the bitset is empty - * @return true if the bitset is empty - */ - bool empty() const - { - return bitset_.empty(); - } - - /** @param set all the bits to 0 - */ - void reset() - { - std::fill(bitset_.begin(), bitset_.end(), 0); - } - - /** @brief set one bit to 0 - * @param - */ - void reset(size_t index) - { - bitset_[index / cell_bit_size_] &= ~(size_t(1) << (index % cell_bit_size_)); - } - - /** @brief sets a specific bit to 0, and more bits too - * This function is useful when resetting a given set of bits so that the - * whole bitset ends up being 0: if that's the case, we don't care about setting - * other bits to 0 - * @param - */ - void reset_block(size_t index) - { - bitset_[index / cell_bit_size_] = 0; - } - - /** @param resize the bitset so that it contains at least size bits - * @param size - */ - void resize(size_t size) - { - size_ = size; - bitset_.resize(size / cell_bit_size_ + 1); - } - - /** @param set a bit to true - * @param index the index of the bit to set to 1 - */ - void set(size_t index) - { - bitset_[index / cell_bit_size_] |= size_t(1) << (index % cell_bit_size_); - } - - /** @param gives the number of contained bits - */ - size_t size() const - { - return size_; - } - - /** @param check if a bit is set - * @param index the index of the bit to check - * @return true if the bit is set - */ - bool test(size_t index) const - { - return (bitset_[index / cell_bit_size_] & (size_t(1) << (index % cell_bit_size_))) != 0; - } - -private: - std::vector bitset_; - size_t size_; - static const unsigned int cell_bit_size_ = CHAR_BIT * sizeof(size_t); -}; - -#endif - -#endif // OPENCV_FLANN_DYNAMIC_BITSET_H_ diff --git a/modules/flann/include/opencv2/flann/flann.hpp b/modules/flann/include/opencv2/flann/flann.hpp index 99f4bef..642b17b 100644 --- a/modules/flann/include/opencv2/flann/flann.hpp +++ b/modules/flann/include/opencv2/flann/flann.hpp @@ -47,21 +47,6 @@ #include "opencv2/flann/flann_base.hpp" -namespace cvflann -{ - inline flann_distance_t& flann_distance_type_() - { - static flann_distance_t distance_type = FLANN_DIST_L2; - return distance_type; - } - - FLANN_DEPRECATED inline void set_distance_type(flann_distance_t distance_type, int order = 0) - { - flann_distance_type_() = (flann_distance_t)((size_t)distance_type + order*0); - } -} - - namespace cv { namespace flann @@ -76,360 +61,132 @@ template <> struct CvType { static int type() { return CV_32S; } }; template <> struct CvType { static int type() { return CV_32F; } }; template <> struct CvType { static int type() { return CV_64F; } }; - -// bring the flann parameters into this namespace + using ::cvflann::IndexParams; using ::cvflann::LinearIndexParams; using ::cvflann::KDTreeIndexParams; using ::cvflann::KMeansIndexParams; using ::cvflann::CompositeIndexParams; -using ::cvflann::LshIndexParams; -using ::cvflann::HierarchicalClusteringIndexParams; using ::cvflann::AutotunedIndexParams; using ::cvflann::SavedIndexParams; -using ::cvflann::SearchParams; -using ::cvflann::get_param; -using ::cvflann::print_params; - - -// bring the flann distances into this namespace -using ::cvflann::L2_Simple; -using ::cvflann::L2; -using ::cvflann::L1; -using ::cvflann::MinkowskiDistance; -using ::cvflann::MaxDistance; -using ::cvflann::HammingLUT; -using ::cvflann::Hamming; -using ::cvflann::Hamming2; -using ::cvflann::HistIntersectionDistance; -using ::cvflann::HellingerDistance; -using ::cvflann::ChiSquareDistance; -using ::cvflann::KL_Divergence; - - - -template -class GenericIndex -{ -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - GenericIndex(const Mat& features, const IndexParams& params, Distance distance = Distance()); - - ~GenericIndex(); - - void knnSearch(const vector& query, vector& indices, - vector& dists, int knn, const SearchParams& params); - void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params); - - int radiusSearch(const vector& query, vector& indices, - vector& dists, DistanceType radius, const SearchParams& params); - int radiusSearch(const Mat& query, Mat& indices, Mat& dists, - DistanceType radius, const SearchParams& params); - - void save(std::string filename) { nnIndex->save(filename); } - - int veclen() const { return nnIndex->veclen(); } - - int size() const { return nnIndex->size(); } - - IndexParams getParameters() { return nnIndex->getParameters(); } - - FLANN_DEPRECATED const IndexParams* getIndexParameters() { return nnIndex->getIndexParameters(); } - -private: - ::cvflann::Index* nnIndex; -}; - -#define FLANN_DISTANCE_CHECK \ - if ( ::cvflann::flann_distance_type_() != FLANN_DIST_L2) { \ - printf("[WARNING] You are using cv::flann::Index (or cv::flann::GenericIndex) and have also changed "\ - "the distance using cvflann::set_distance_type. This is no longer working as expected "\ - "(cv::flann::Index always uses L2). You should create the index templated on the distance, "\ - "for example for L1 distance use: GenericIndex< L1 > \n"); \ - } - - -template -GenericIndex::GenericIndex(const Mat& dataset, const IndexParams& params, Distance distance) -{ - CV_Assert(dataset.type() == CvType::type()); - CV_Assert(dataset.isContinuous()); - ::cvflann::Matrix m_dataset((ElementType*)dataset.ptr(0), dataset.rows, dataset.cols); - - nnIndex = new ::cvflann::Index(m_dataset, params, distance); - - FLANN_DISTANCE_CHECK - - nnIndex->buildIndex(); -} - -template -GenericIndex::~GenericIndex() -{ - delete nnIndex; -} - -template -void GenericIndex::knnSearch(const vector& query, vector& indices, vector& dists, int knn, const SearchParams& searchParams) -{ - ::cvflann::Matrix m_query((ElementType*)&query[0], 1, query.size()); - ::cvflann::Matrix m_indices(&indices[0], 1, indices.size()); - ::cvflann::Matrix m_dists(&dists[0], 1, dists.size()); - - FLANN_DISTANCE_CHECK - - nnIndex->knnSearch(m_query,m_indices,m_dists,knn,searchParams); -} - - -template -void GenericIndex::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams) -{ - CV_Assert(queries.type() == CvType::type()); - CV_Assert(queries.isContinuous()); - ::cvflann::Matrix m_queries((ElementType*)queries.ptr(0), queries.rows, queries.cols); - - CV_Assert(indices.type() == CV_32S); - CV_Assert(indices.isContinuous()); - ::cvflann::Matrix m_indices((int*)indices.ptr(0), indices.rows, indices.cols); - - CV_Assert(dists.type() == CvType::type()); - CV_Assert(dists.isContinuous()); - ::cvflann::Matrix m_dists((DistanceType*)dists.ptr(0), dists.rows, dists.cols); - - FLANN_DISTANCE_CHECK - - nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams); -} - -template -int GenericIndex::radiusSearch(const vector& query, vector& indices, vector& dists, DistanceType radius, const SearchParams& searchParams) -{ - ::cvflann::Matrix m_query((ElementType*)&query[0], 1, query.size()); - ::cvflann::Matrix m_indices(&indices[0], 1, indices.size()); - ::cvflann::Matrix m_dists(&dists[0], 1, dists.size()); - - FLANN_DISTANCE_CHECK - - return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); -} - -template -int GenericIndex::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const SearchParams& searchParams) -{ - CV_Assert(query.type() == CvType::type()); - CV_Assert(query.isContinuous()); - ::cvflann::Matrix m_query((ElementType*)query.ptr(0), query.rows, query.cols); - - CV_Assert(indices.type() == CV_32S); - CV_Assert(indices.isContinuous()); - ::cvflann::Matrix m_indices((int*)indices.ptr(0), indices.rows, indices.cols); - - CV_Assert(dists.type() == CvType::type()); - CV_Assert(dists.isContinuous()); - ::cvflann::Matrix m_dists((DistanceType*)dists.ptr(0), dists.rows, dists.cols); - - FLANN_DISTANCE_CHECK - - return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); -} - - -typedef GenericIndex< L2 > Index; +using ::cvflann::SearchParams; -/** - * @deprecated Use GenericIndex class instead - */ template -class FLANN_DEPRECATED Index_ { -public: - typedef typename L2::ElementType ElementType; - typedef typename L2::ResultType DistanceType; +class CV_EXPORTS Index_ { + ::cvflann::Index* nnIndex; +public: Index_(const Mat& features, const IndexParams& params); ~Index_(); - void knnSearch(const vector& query, vector& indices, vector& dists, int knn, const SearchParams& params); + void knnSearch(const vector& query, vector& indices, vector& dists, int knn, const SearchParams& params); void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params); - int radiusSearch(const vector& query, vector& indices, vector& dists, DistanceType radius, const SearchParams& params); - int radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const SearchParams& params); - - void save(std::string filename) - { - if (nnIndex_L1) nnIndex_L1->save(filename); - if (nnIndex_L2) nnIndex_L2->save(filename); - } + int radiusSearch(const vector& query, vector& indices, vector& dists, float radius, const SearchParams& params); + int radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& params); - int veclen() const - { - if (nnIndex_L1) return nnIndex_L1->veclen(); - if (nnIndex_L2) return nnIndex_L2->veclen(); - } + void save(std::string filename) { nnIndex->save(filename); } - int size() const - { - if (nnIndex_L1) return nnIndex_L1->size(); - if (nnIndex_L2) return nnIndex_L2->size(); - } + int veclen() const { return nnIndex->veclen(); } - IndexParams getParameters() - { - if (nnIndex_L1) return nnIndex_L1->getParameters(); - if (nnIndex_L2) return nnIndex_L2->getParameters(); - - } + int size() const { return nnIndex->size(); } - FLANN_DEPRECATED const IndexParams* getIndexParameters() - { - if (nnIndex_L1) return nnIndex_L1->getIndexParameters(); - if (nnIndex_L2) return nnIndex_L2->getIndexParameters(); - } + const IndexParams* getIndexParameters() { return nnIndex->getIndexParameters(); } -private: - // providing backwards compatibility for L2 and L1 distances (most common) - ::cvflann::Index< L2 >* nnIndex_L2; - ::cvflann::Index< L1 >* nnIndex_L1; }; template Index_::Index_(const Mat& dataset, const IndexParams& params) { - printf("[WARNING] The cv::flann::Index_ class is deperecated, use cv::flann::GenericIndex instead\n"); - - CV_Assert(dataset.type() == CvType::type()); + CV_Assert(dataset.type() == CvType::type()); CV_Assert(dataset.isContinuous()); - ::cvflann::Matrix m_dataset((ElementType*)dataset.ptr(0), dataset.rows, dataset.cols); + ::cvflann::Matrix m_dataset((T*)dataset.ptr(0), dataset.rows, dataset.cols); - if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L2 ) { - nnIndex_L1 = NULL; - nnIndex_L2 = new ::cvflann::Index< L2 >(m_dataset, params); - } - else if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L1 ) { - nnIndex_L1 = new ::cvflann::Index< L1 >(m_dataset, params); - nnIndex_L2 = NULL; - } - else { - printf("[ERROR] cv::flann::Index_ only provides backwards compatibility for the L1 and L2 distances. " - "For other distance types you must use cv::flann::GenericIndex\n"); - CV_Assert(0); - } - if (nnIndex_L1) nnIndex_L1->buildIndex(); - if (nnIndex_L2) nnIndex_L2->buildIndex(); + nnIndex = new ::cvflann::Index(m_dataset, params); + nnIndex->buildIndex(); } template Index_::~Index_() { - if (nnIndex_L1) delete nnIndex_L1; - if (nnIndex_L2) delete nnIndex_L2; + delete nnIndex; } template -void Index_::knnSearch(const vector& query, vector& indices, vector& dists, int knn, const SearchParams& searchParams) +void Index_::knnSearch(const vector& query, vector& indices, vector& dists, int knn, const SearchParams& searchParams) { - ::cvflann::Matrix m_query((ElementType*)&query[0], 1, query.size()); - ::cvflann::Matrix m_indices(&indices[0], 1, indices.size()); - ::cvflann::Matrix m_dists(&dists[0], 1, dists.size()); + ::cvflann::Matrix m_query((T*)&query[0], 1, (int)query.size()); + ::cvflann::Matrix m_indices(&indices[0], 1, (int)indices.size()); + ::cvflann::Matrix m_dists(&dists[0], 1, (int)dists.size()); - if (nnIndex_L1) nnIndex_L1->knnSearch(m_query,m_indices,m_dists,knn,searchParams); - if (nnIndex_L2) nnIndex_L2->knnSearch(m_query,m_indices,m_dists,knn,searchParams); + nnIndex->knnSearch(m_query,m_indices,m_dists,knn,searchParams); } template void Index_::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams) { - CV_Assert(queries.type() == CvType::type()); + CV_Assert(queries.type() == CvType::type()); CV_Assert(queries.isContinuous()); - ::cvflann::Matrix m_queries((ElementType*)queries.ptr(0), queries.rows, queries.cols); + ::cvflann::Matrix m_queries((T*)queries.ptr(0), queries.rows, queries.cols); CV_Assert(indices.type() == CV_32S); CV_Assert(indices.isContinuous()); ::cvflann::Matrix m_indices((int*)indices.ptr(0), indices.rows, indices.cols); - CV_Assert(dists.type() == CvType::type()); + CV_Assert(dists.type() == CV_32F); CV_Assert(dists.isContinuous()); - ::cvflann::Matrix m_dists((DistanceType*)dists.ptr(0), dists.rows, dists.cols); - - if (nnIndex_L1) nnIndex_L1->knnSearch(m_queries,m_indices,m_dists,knn, searchParams); - if (nnIndex_L2) nnIndex_L2->knnSearch(m_queries,m_indices,m_dists,knn, searchParams); + ::cvflann::Matrix m_dists((float*)dists.ptr(0), dists.rows, dists.cols); + + nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams); } template -int Index_::radiusSearch(const vector& query, vector& indices, vector& dists, DistanceType radius, const SearchParams& searchParams) +int Index_::radiusSearch(const vector& query, vector& indices, vector& dists, float radius, const SearchParams& searchParams) { - ::cvflann::Matrix m_query((ElementType*)&query[0], 1, query.size()); - ::cvflann::Matrix m_indices(&indices[0], 1, indices.size()); - ::cvflann::Matrix m_dists(&dists[0], 1, dists.size()); + ::cvflann::Matrix m_query((T*)&query[0], 1, (int)query.size()); + ::cvflann::Matrix m_indices(&indices[0], 1, (int)indices.size()); + ::cvflann::Matrix m_dists(&dists[0], 1, (int)dists.size()); - if (nnIndex_L1) return nnIndex_L1->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); - if (nnIndex_L2) return nnIndex_L2->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); + return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); } template -int Index_::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const SearchParams& searchParams) +int Index_::radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& searchParams) { - CV_Assert(query.type() == CvType::type()); + CV_Assert(query.type() == CvType::type()); CV_Assert(query.isContinuous()); - ::cvflann::Matrix m_query((ElementType*)query.ptr(0), query.rows, query.cols); + ::cvflann::Matrix m_query((T*)query.ptr(0), query.rows, query.cols); CV_Assert(indices.type() == CV_32S); CV_Assert(indices.isContinuous()); ::cvflann::Matrix m_indices((int*)indices.ptr(0), indices.rows, indices.cols); - CV_Assert(dists.type() == CvType::type()); + CV_Assert(dists.type() == CV_32F); CV_Assert(dists.isContinuous()); - ::cvflann::Matrix m_dists((DistanceType*)dists.ptr(0), dists.rows, dists.cols); + ::cvflann::Matrix m_dists((float*)dists.ptr(0), dists.rows, dists.cols); - if (nnIndex_L1) return nnIndex_L1->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); - if (nnIndex_L2) return nnIndex_L2->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); + return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams); } +typedef Index_ Index; -template -int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params, - Distance d = Distance()) +template +int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params) { - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - CV_Assert(features.type() == CvType::type()); + CV_Assert(features.type() == CvType::type()); CV_Assert(features.isContinuous()); - ::cvflann::Matrix m_features((ElementType*)features.ptr(0), features.rows, features.cols); + ::cvflann::Matrix m_features((ELEM_TYPE*)features.ptr(0), features.rows, features.cols); - CV_Assert(centers.type() == CvType::type()); + CV_Assert(centers.type() == CvType::type()); CV_Assert(centers.isContinuous()); - ::cvflann::Matrix m_centers((DistanceType*)centers.ptr(0), centers.rows, centers.cols); - - return ::cvflann::hierarchicalClustering(m_features, m_centers, params, d); -} - - -template -FLANN_DEPRECATED int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params) -{ - printf("[WARNING] cv::flann::hierarchicalClustering is deprecated, use " - "cv::flann::hierarchicalClustering instead\n"); - - if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L2 ) { - return hierarchicalClustering< L2 >(features, centers, params); - } - else if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L1 ) { - return hierarchicalClustering< L1 >(features, centers, params); - } - else { - printf("[ERROR] cv::flann::hierarchicalClustering only provides backwards " - "compatibility for the L1 and L2 distances. " - "For other distance types you must use cv::flann::hierarchicalClustering\n"); - CV_Assert(0); - } + ::cvflann::Matrix m_centers((DIST_TYPE*)centers.ptr(0), centers.rows, centers.cols); + + return ::cvflann::hierarchicalClustering(m_features, m_centers, params); } } } // namespace cv::flann diff --git a/modules/flann/include/opencv2/flann/flann_base.hpp b/modules/flann/include/opencv2/flann/flann_base.hpp index 0426262..46143df 100644 --- a/modules/flann/include/opencv2/flann/flann_base.hpp +++ b/modules/flann/include/opencv2/flann/flann_base.hpp @@ -28,264 +28,232 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef FLANN_BASE_HPP_ -#define FLANN_BASE_HPP_ +#ifndef _OPENCV_FLANN_BASE_HPP_ +#define _OPENCV_FLANN_BASE_HPP_ #include #include #include #include -#include "general.h" -#include "matrix.h" -#include "params.h" -#include "saving.h" +#include "opencv2/flann/general.h" +#include "opencv2/flann/matrix.h" +#include "opencv2/flann/result_set.h" +#include "opencv2/flann/index_testing.h" +#include "opencv2/flann/object_factory.h" +#include "opencv2/flann/saving.h" -#include "all_indices.h" +#include "opencv2/flann/all_indices.h" namespace cvflann { + /** - * Sets the log level used for all flann functions - * @param level Verbosity level - */ -inline void log_verbosity(int level) -{ - if (level >= 0) { - Logger::setLevel(level); - } -} +Sets the log level used for all flann functions + +Params: + level = verbosity level +*/ +CV_EXPORTS void log_verbosity(int level); + /** - * (Deprecated) Index parameters for creating a saved index. + * Sets the distance type to use throughout FLANN. + * If distance type specified is MINKOWSKI, the second argument + * specifies which order the minkowski distance should have. */ -struct SavedIndexParams : public IndexParams -{ - SavedIndexParams(std::string filename) - { - (* this)["algorithm"] = FLANN_INDEX_SAVED; - (*this)["filename"] = filename; - } +CV_EXPORTS void set_distance_type(flann_distance_t distance_type, int order); + + +struct CV_EXPORTS SavedIndexParams : public IndexParams { + SavedIndexParams(std::string filename_) : IndexParams(FLANN_INDEX_SAVED), filename(filename_) {} + + std::string filename; // filename of the stored index + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + logger().info("Filename: %s\n", filename.c_str()); + } }; +template +class CV_EXPORTS Index { + NNIndex* nnIndex; + bool built; -template -NNIndex* load_saved_index(const Matrix& dataset, const std::string& filename, Distance distance) -{ - typedef typename Distance::ElementType ElementType; +public: + Index(const Matrix& features, const IndexParams& params); - FILE* fin = fopen(filename.c_str(), "rb"); - if (fin == NULL) { - return NULL; - } - IndexHeader header = load_header(fin); - if (header.data_type != Datatype::type()) { - 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)) { - throw FLANNException("The index saved belongs to a different dataset"); - } + ~Index(); + + void buildIndex(); + + void knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params); + + int radiusSearch(const Matrix& query, Matrix& indices, Matrix& dists, float radius, const SearchParams& params); + + void save(std::string filename); + + int veclen() const; + + int size() const; - IndexParams params; - params["algorithm"] = header.index_type; - NNIndex* nnIndex = create_index_by_type(dataset, params, distance); - nnIndex->loadIndex(fin); - fclose(fin); + NNIndex* getIndex() { return nnIndex; } - return nnIndex; + const IndexParams* getIndexParameters() { return nnIndex->getParameters(); } +}; + + +template +NNIndex* load_saved_index(const Matrix& dataset, const std::string& filename) +{ + FILE* fin = fopen(filename.c_str(), "rb"); + if (fin==NULL) { + return NULL; + } + IndexHeader header = load_header(fin); + if (header.data_type!=Datatype::type()) { + 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) { + throw FLANNException("The index saved belongs to a different dataset"); + } + + IndexParams* params = ParamsFactory_instance().create(header.index_type); + NNIndex* nnIndex = create_index_by_type(dataset, *params); + nnIndex->loadIndex(fin); + fclose(fin); + + return nnIndex; } -template -class Index : public NNIndex +template +Index::Index(const Matrix& dataset, const IndexParams& params) { -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - Index(const Matrix& features, const IndexParams& params, Distance distance = Distance() ) - : index_params_(params) - { - flann_algorithm_t index_type = get_param(params,"algorithm"); - loaded_ = false; - - if (index_type == FLANN_INDEX_SAVED) { - nnIndex_ = load_saved_index(features, get_param(params,"filename"), distance); - loaded_ = true; - } - else { - nnIndex_ = create_index_by_type(features, params, distance); - } - } + flann_algorithm_t index_type = params.getIndexType(); + built = false; + + if (index_type==FLANN_INDEX_SAVED) { + nnIndex = load_saved_index(dataset, ((const SavedIndexParams&)params).filename); + built = true; + } + else { + nnIndex = create_index_by_type(dataset, params); + } +} - ~Index() - { - delete nnIndex_; - } +template +Index::~Index() +{ + delete nnIndex; +} - /** - * Builds the index. - */ - void buildIndex() - { - if (!loaded_) { - nnIndex_->buildIndex(); - } - } +template +void Index::buildIndex() +{ + if (!built) { + nnIndex->buildIndex(); + built = true; + } +} - void save(std::string filename) - { - FILE* fout = fopen(filename.c_str(), "wb"); - if (fout == NULL) { - throw FLANNException("Cannot open file"); - } - save_header(fout, *nnIndex_); - saveIndex(fout); - fclose(fout); +template +void Index::knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& searchParams) +{ + if (!built) { + throw FLANNException("You must build the index before searching."); } + assert(queries.cols==nnIndex->veclen()); + assert(indices.rows>=queries.rows); + assert(dists.rows>=queries.rows); + assert(int(indices.cols)>=knn); + assert(int(dists.cols)>=knn); - /** - * \brief Saves the index to a stream - * \param stream The stream to save the index to - */ - virtual void saveIndex(FILE* stream) - { - nnIndex_->saveIndex(stream); - } + KNNResultSet resultSet(knn); - /** - * \brief Loads the index from a stream - * \param stream The stream from which the index is loaded - */ - virtual void loadIndex(FILE* stream) - { - nnIndex_->loadIndex(stream); - } + for (size_t i = 0; i < queries.rows; i++) { + T* target = queries[i]; + resultSet.init(target, (int)queries.cols); - /** - * \returns number of features in this index. - */ - size_t veclen() const - { - return nnIndex_->veclen(); - } + nnIndex->findNeighbors(resultSet, target, searchParams); - /** - * \returns The dimensionality of the features in this index. - */ - size_t size() const - { - return nnIndex_->size(); + int* neighbors = resultSet.getNeighbors(); + float* distances = resultSet.getDistances(); + memcpy(indices[i], neighbors, knn*sizeof(int)); + memcpy(dists[i], distances, knn*sizeof(float)); } +} - /** - * \returns The index type (kdtree, kmeans,...) - */ - flann_algorithm_t getType() const - { - return nnIndex_->getType(); +template +int Index::radiusSearch(const Matrix& query, Matrix& indices, Matrix& dists, float radius, const SearchParams& searchParams) +{ + if (!built) { + throw FLANNException("You must build the index before searching."); } + if (query.rows!=1) { + fprintf(stderr, "I can only search one feature at a time for range search\n"); + return -1; + } + assert(query.cols==nnIndex->veclen()); - /** - * \returns The amount of memory (in bytes) used by the index. - */ - virtual int usedMemory() const - { - return nnIndex_->usedMemory(); - } + RadiusResultSet resultSet(radius); + resultSet.init(query.data, (int)query.cols); + nnIndex->findNeighbors(resultSet,query.data,searchParams); + // TODO: optimise here + int* neighbors = resultSet.getNeighbors(); + float* distances = resultSet.getDistances(); + size_t count_nn = std::min(resultSet.size(), indices.cols); - /** - * \returns The index parameters - */ - IndexParams getParameters() const - { - return nnIndex_->getParameters(); - } + assert (dists.cols>=count_nn); - /** - * \brief Perform k-nearest neighbor search - * \param[in] queries The query points for which to find the nearest neighbors - * \param[out] indices The indices of the nearest neighbors found - * \param[out] dists Distances to the nearest neighbors found - * \param[in] knn Number of nearest neighbors to return - * \param[in] params Search parameters - */ - void knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params) - { - nnIndex_->knnSearch(queries, indices, dists, knn, params); - } + for (size_t i=0;i& query, Matrix& indices, Matrix& dists, float radius, const SearchParams& params) - { - return nnIndex_->radiusSearch(query, indices, dists, radius, params); - } + return (int)count_nn; +} - /** - * \brief Method that searches for nearest-neighbours - */ - void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) - { - nnIndex_->findNeighbors(result, vec, searchParams); - } - /** - * \brief Returns actual index - */ - FLANN_DEPRECATED NNIndex* getIndex() - { - return nnIndex_; - } +template +void Index::save(std::string filename) +{ + FILE* fout = fopen(filename.c_str(), "wb"); + if (fout==NULL) { + throw FLANNException("Cannot open file"); + } + save_header(fout, *nnIndex); + nnIndex->saveIndex(fout); + fclose(fout); +} - /** - * \brief Returns index parameters. - * \deprecated use getParameters() instead. - */ - FLANN_DEPRECATED const IndexParams* getIndexParameters() - { - return &index_params_; - } -private: - /** Pointer to actual index class */ - NNIndex* nnIndex_; - /** Indices if the index was loaded from a file */ - bool loaded_; - /** Parameters passed to the index */ - IndexParams index_params_; -}; +template +int Index::size() const +{ + return nnIndex->size(); +} -/** - * Performs a hierarchical clustering of the points passed as argument and then takes a cut in the - * the clustering tree to return a flat clustering. - * @param[in] points Points to be clustered - * @param centers The computed cluster centres. Matrix should be preallocated and centers.rows is the - * number of clusters requested. - * @param params Clustering parameters (The same as for cvflann::KMeansIndex) - * @param d Distance to be used for clustering (eg: cvflann::L2) - * @return number of clusters computed (can be different than clusters.rows and is the highest number - * of the form (branching-1)*K+1 smaller than clusters.rows). - */ -template -int hierarchicalClustering(const Matrix& points, Matrix& centers, - const KMeansIndexParams& params, Distance d = Distance()) +template +int Index::veclen() const { - KMeansIndex kmeans(points, params, d); - kmeans.buildIndex(); + return nnIndex->veclen(); +} + + +template +int hierarchicalClustering(const Matrix& features, Matrix& centers, const KMeansIndexParams& params) +{ + KMeansIndex kmeans(features, params); + kmeans.buildIndex(); int clusterNum = kmeans.getClusterCenters(centers); - return clusterNum; + return clusterNum; } -} -#endif /* FLANN_BASE_HPP_ */ +} // namespace cvflann +#endif /* _OPENCV_FLANN_BASE_HPP_ */ diff --git a/modules/flann/include/opencv2/flann/general.h b/modules/flann/include/opencv2/flann/general.h index 28db33b..880cc84 100644 --- a/modules/flann/include/opencv2/flann/general.h +++ b/modules/flann/include/opencv2/flann/general.h @@ -28,30 +28,119 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_GENERAL_H_ -#define OPENCV_FLANN_GENERAL_H_ +#ifndef _OPENCV_GENERAL_H_ +#define _OPENCV_GENERAL_H_ + +#ifdef __cplusplus -#include "defines.h" #include #include +#include "opencv2/flann/object_factory.h" +#include "opencv2/flann/logger.h" + +namespace cvflann { + +#undef ARRAY_LEN +#define ARRAY_LEN(a) (sizeof(a)/sizeof(a[0])) + +/* Nearest neighbour index algorithms */ +enum flann_algorithm_t { + FLANN_INDEX_LINEAR = 0, + FLANN_INDEX_KDTREE = 1, + FLANN_INDEX_KMEANS = 2, + FLANN_INDEX_COMPOSITE = 3, + FLANN_INDEX_SAVED = 254, + FLANN_INDEX_AUTOTUNED = 255 +}; + +enum flann_centers_init_t { + FLANN_CENTERS_RANDOM = 0, + FLANN_CENTERS_GONZALES = 1, + FLANN_CENTERS_KMEANSPP = 2 +}; + -namespace cvflann +enum flann_distance_t { + FLANN_DIST_EUCLIDEAN = 1, + FLANN_DIST_L2 = 1, + FLANN_DIST_MANHATTAN = 2, + FLANN_DIST_L1 = 2, + FLANN_DIST_MINKOWSKI = 3, + FLANN_DIST_MAX = 4, + FLANN_DIST_HIST_INTERSECT = 5, + FLANN_DIST_HELLINGER = 6, + FLANN_DIST_CHI_SQUARE = 7, + FLANN_DIST_CS = 7, + FLANN_DIST_KULLBACK_LEIBLER = 8, + FLANN_DIST_KL = 8 +}; + +enum flann_datatype_t { + FLANN_INT8 = 0, + FLANN_INT16 = 1, + FLANN_INT32 = 2, + FLANN_INT64 = 3, + FLANN_UINT8 = 4, + FLANN_UINT16 = 5, + FLANN_UINT32 = 6, + FLANN_UINT64 = 7, + FLANN_FLOAT32 = 8, + FLANN_FLOAT64 = 9 +}; + +template +struct DistType { + typedef ELEM_TYPE type; +}; -class FLANNException : public std::runtime_error +template <> +struct DistType { + typedef float type; +}; + +template <> +struct DistType +{ + typedef float type; +}; + + +class FLANNException : public std::runtime_error { + public: + FLANNException(const char* message) : std::runtime_error(message) { } + + FLANNException(const std::string& message) : std::runtime_error(message) { } + }; + + +struct CV_EXPORTS IndexParams { +protected: + IndexParams(flann_algorithm_t algorithm_) : algorithm(algorithm_) {}; + public: - FLANNException(const char* message) : std::runtime_error(message) { } + virtual ~IndexParams() {} + virtual flann_algorithm_t getIndexType() const { return algorithm; } - FLANNException(const std::string& message) : std::runtime_error(message) { } + virtual void print() const = 0; + + flann_algorithm_t algorithm; }; -#if (defined WIN32 || defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS -__declspec(dllexport) -#endif -void dummyfunc(); -} +typedef ObjectFactory ParamsFactory; +CV_EXPORTS ParamsFactory& ParamsFactory_instance(); +struct CV_EXPORTS SearchParams { + SearchParams(int checks_ = 32) : + checks(checks_) {}; + + int checks; +}; + +} // namespace cvflann + +#endif -#endif /* OPENCV_FLANN_GENERAL_H_ */ +#endif /* _OPENCV_GENERAL_H_ */ diff --git a/modules/flann/include/opencv2/flann/ground_truth.h b/modules/flann/include/opencv2/flann/ground_truth.h index 8f1c698..cb21324 100644 --- a/modules/flann/include/opencv2/flann/ground_truth.h +++ b/modules/flann/include/opencv2/flann/ground_truth.h @@ -28,41 +28,39 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_GROUND_TRUTH_H_ -#define OPENCV_FLANN_GROUND_TRUTH_H_ - -#include "dist.h" -#include "matrix.h" +#ifndef _OPENCV_GROUND_TRUTH_H_ +#define _OPENCV_GROUND_TRUTH_H_ +#include "opencv2/flann/dist.h" +#include "opencv2/flann/matrix.h" namespace cvflann { -template -void find_nearest(const Matrix& dataset, typename Distance::ElementType* query, int* matches, int nn, - int skip = 0, Distance distance = Distance()) +template +void find_nearest(const Matrix& dataset, T* query, int* matches, int nn, int skip = 0) { - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; int n = nn + skip; - int* match = new int[n]; - DistanceType* dists = new DistanceType[n]; + T* query_end = query + dataset.cols; + + long* match = new long[n]; + T* dists = new T[n]; - dists[0] = distance(dataset[0], query, dataset.cols); + dists[0] = (float)flann_dist(query, query_end, dataset[0]); match[0] = 0; int dcnt = 1; - for (size_t i=1; i& dataset, typenam } } - for (int i=0; i& dataset, typenam } -template -void compute_ground_truth(const Matrix& dataset, const Matrix& testset, Matrix& matches, - int skip=0, Distance d = Distance()) +template +void compute_ground_truth(const Matrix& dataset, const Matrix& testset, Matrix& matches, int skip=0) { - for (size_t i=0; i(dataset, testset[i], matches[i], (int)matches.cols, skip, d); + for (size_t i=0;i +#include -#include "matrix.h" +#include "opencv2/flann/matrix.h" -namespace cvflann -{ -namespace -{ +#ifndef H5_NO_NAMESPACE + using namespace H5; +#endif -template -hid_t get_hdf5_type() +namespace cvflann { - throw FLANNException("Unsupported type for IO operations"); -} - -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_CHAR; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_UCHAR; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_SHORT; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_USHORT; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_INT; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_UINT; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_LONG; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_ULONG; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_FLOAT; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_DOUBLE; } -template<> -hid_t get_hdf5_type() { return H5T_NATIVE_LDOUBLE; } -} -#define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y)); +namespace { template -void save_to_file(const cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +PredType get_hdf5_type() { + throw FLANNException("Unsupported type for IO operations"); +} -#if H5Eset_auto_vers == 2 - H5Eset_auto( H5E_DEFAULT, NULL, NULL ); -#else - H5Eset_auto( NULL, NULL ); -#endif - - herr_t status; - hid_t file_id; - file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT); - if (file_id < 0) { - file_id = H5Fcreate(filename.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT); - } - CHECK_ERROR(file_id,"Error creating hdf5 file."); - - hsize_t dimsf[2]; // dataset dimensions - dimsf[0] = dataset.rows; - dimsf[1] = dataset.cols; - - hid_t space_id = H5Screate_simple(2, dimsf, NULL); - hid_t memspace_id = H5Screate_simple(2, dimsf, NULL); - - hid_t dataset_id; -#if H5Dcreate_vers == 2 - dataset_id = H5Dcreate2(file_id, name.c_str(), get_hdf5_type(), space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); -#else - dataset_id = H5Dcreate(file_id, name.c_str(), get_hdf5_type(), space_id, H5P_DEFAULT); -#endif - - if (dataset_id<0) { -#if H5Dopen_vers == 2 - dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT); -#else - dataset_id = H5Dopen(file_id, name.c_str()); -#endif - } - CHECK_ERROR(dataset_id,"Error creating or opening dataset in file."); - - status = H5Dwrite(dataset_id, get_hdf5_type(), memspace_id, space_id, H5P_DEFAULT, dataset.data ); - CHECK_ERROR(status, "Error writing to dataset"); - - H5Sclose(memspace_id); - H5Sclose(space_id); - H5Dclose(dataset_id); - H5Fclose(file_id); +template<> PredType get_hdf5_type() { return PredType::NATIVE_CHAR; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_UCHAR; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_SHORT; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_USHORT; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_INT; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_UINT; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_LONG; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_ULONG; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_FLOAT; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_DOUBLE; } +template<> PredType get_hdf5_type() { return PredType::NATIVE_LDOUBLE; } } template -void load_from_file(cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +void save_to_file(const cvflann::Matrix& flann_dataset, const std::string& filename, const std::string& name) { - herr_t status; - hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT); - CHECK_ERROR(file_id,"Error opening hdf5 file."); - - hid_t dataset_id; -#if H5Dopen_vers == 2 - dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT); -#else - dataset_id = H5Dopen(file_id, name.c_str()); -#endif - CHECK_ERROR(dataset_id,"Error opening dataset in file."); - - hid_t space_id = H5Dget_space(dataset_id); - - hsize_t dims_out[2]; - H5Sget_simple_extent_dims(space_id, dims_out, NULL); - - dataset = cvflann::Matrix(new T[dims_out[0]*dims_out[1]], dims_out[0], dims_out[1]); - - status = H5Dread(dataset_id, get_hdf5_type(), H5S_ALL, H5S_ALL, H5P_DEFAULT, dataset[0]); - CHECK_ERROR(status, "Error reading dataset"); - - H5Sclose(space_id); - H5Dclose(dataset_id); - H5Fclose(file_id); + // Try block to detect exceptions raised by any of the calls inside it + try + { + /* + * Turn off the auto-printing when failure occurs so that we can + * handle the errors appropriately + */ + Exception::dontPrint(); + + /* + * Create a new file using H5F_ACC_TRUNC access, + * default file creation properties, and default file + * access properties. + */ + H5File file( filename, H5F_ACC_TRUNC ); + + /* + * Define the size of the array and create the data space for fixed + * size dataset. + */ + hsize_t dimsf[2]; // dataset dimensions + dimsf[0] = flann_dataset.rows; + dimsf[1] = flann_dataset.cols; + DataSpace dataspace( 2, dimsf ); + + /* + * Create a new dataset within the file using defined dataspace and + * datatype and default dataset creation properties. + */ + DataSet dataset = file.createDataSet( name, get_hdf5_type(), dataspace ); + + /* + * Write the data to the dataset using default memory space, file + * space, and transfer properties. + */ + dataset.write( flann_dataset.data, get_hdf5_type() ); + } // end of try block + catch( H5::Exception& error ) + { + error.printError(); + throw FLANNException(error.getDetailMsg()); + } } -#ifdef HAVE_MPI - -namespace mpi -{ -/** - * Loads a the hyperslice corresponding to this processor from a hdf5 file. - * @param flann_dataset Dataset where the data is loaded - * @param filename HDF5 file name - * @param name Name of dataset inside file - */ template -void load_from_file(cvflann::Matrix& dataset, const std::string& filename, const std::string& name) +void load_from_file(cvflann::Matrix& flann_dataset, const std::string& filename, const std::string& name) { - MPI_Comm comm = MPI_COMM_WORLD; - MPI_Info info = MPI_INFO_NULL; - - int mpi_size, mpi_rank; - MPI_Comm_size(comm, &mpi_size); - MPI_Comm_rank(comm, &mpi_rank); - - herr_t status; - - hid_t plist_id = H5Pcreate(H5P_FILE_ACCESS); - H5Pset_fapl_mpio(plist_id, comm, info); - hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, plist_id); - CHECK_ERROR(file_id,"Error opening hdf5 file."); - H5Pclose(plist_id); - hid_t dataset_id; -#if H5Dopen_vers == 2 - dataset_id = H5Dopen2(file_id, name.c_str(), H5P_DEFAULT); -#else - dataset_id = H5Dopen(file_id, name.c_str()); -#endif - CHECK_ERROR(dataset_id,"Error opening dataset in file."); - - hid_t space_id = H5Dget_space(dataset_id); - hsize_t dims[2]; - H5Sget_simple_extent_dims(space_id, dims, NULL); - - hsize_t count[2]; - hsize_t offset[2]; - - hsize_t item_cnt = dims[0]/mpi_size+(dims[0]%mpi_size==0 ? 0 : 1); - hsize_t cnt = (mpi_rank())) { + throw FLANNException("Dataset matrix type does not match the type to be read."); + } + + /* + * Get dataspace of the dataset. + */ + DataSpace dataspace = dataset.getSpace(); + + /* + * Get the dimension size of each dimension in the dataspace and + * display them. + */ + hsize_t dims_out[2]; + dataspace.getSimpleExtentDims( dims_out, NULL); + + flann_dataset.rows = dims_out[0]; + flann_dataset.cols = dims_out[1]; + flann_dataset.data = new T[flann_dataset.rows*flann_dataset.cols]; + + dataset.read( flann_dataset.data, get_hdf5_type() ); + } // end of try block + catch( H5::Exception &error ) + { + error.printError(); + throw FLANNException(error.getDetailMsg()); + } +} - plist_id = H5Pcreate(H5P_DATASET_XFER); - H5Pset_dxpl_mpio(plist_id, H5FD_MPIO_COLLECTIVE); - status = H5Dread(dataset_id, get_hdf5_type(), memspace_id, space_id, plist_id, dataset.data); - CHECK_ERROR(status, "Error reading dataset"); - H5Pclose(plist_id); - H5Sclose(space_id); - H5Sclose(memspace_id); - H5Dclose(dataset_id); - H5Fclose(file_id); -} -} -#endif // HAVE_MPI -} // namespace cvflann::mpi +} // namespace cvflann -#endif /* OPENCV_FLANN_HDF5_H_ */ +#endif /* _OPENCV_HDF5_H_ */ diff --git a/modules/flann/include/opencv2/flann/heap.h b/modules/flann/include/opencv2/flann/heap.h index a189717..0e05451 100644 --- a/modules/flann/include/opencv2/flann/heap.h +++ b/modules/flann/include/opencv2/flann/heap.h @@ -28,11 +28,11 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_HEAP_H_ -#define OPENCV_FLANN_HEAP_H_ +#ifndef _OPENCV_HEAP_H_ +#define _OPENCV_HEAP_H_ + #include -#include namespace cvflann { @@ -43,123 +43,166 @@ namespace cvflann * The priority queue is implemented with a heap. A heap is a complete * (full) binary tree in which each parent is less than both of its * children, but the order of the children is unspecified. + * Note that a heap uses 1-based indexing to allow for power-of-2 + * location of parents and children. We ignore element 0 of Heap array. */ template -class Heap -{ +class Heap { - /** - * Storage array for the heap. - * Type T must be comparable. - */ - std::vector heap; + /** + * Storage array for the heap. + * Type T must be comparable. + */ + T* heap; int length; - /** - * Number of element in the heap - */ - int count; + /** + * Number of element in the heap + */ + int count; public: - /** - * Constructor. - * - * Params: - * size = heap size - */ - - Heap(int size) - { - length = size; - heap.reserve(length); - count = 0; - } - - /** - * - * Returns: heap size - */ - int size() - { - return count; - } - - /** - * Tests if the heap is empty - * - * Returns: true is heap empty, false otherwise - */ - bool empty() - { - return size()==0; - } - - /** - * Clears the heap. - */ - void clear() - { - heap.clear(); - count = 0; - } - - struct CompareT - { - bool operator()(const T& t_1, const T& t_2) const - { - return !(t_1 < t_2); - } - }; - - /** - * Insert a new element in the heap. - * - * We select the next empty leaf node, and then keep moving any larger - * parents down until the right location is found to store this element. - * - * Params: - * value = the new element to be inserted in the heap - */ - void insert(T value) - { - /* If heap is full, then return without adding this element. */ - if (count == length) { - return; - } - - heap.push_back(value); - static CompareT compareT; - std::push_heap(heap.begin(), heap.end(), compareT); - ++count; - } - - - - /** - * Returns the node of minimum value from the heap (top of the heap). - * - * Params: - * value = out parameter used to return the min element - * Returns: false if heap empty - */ - bool popMin(T& value) - { - if (count == 0) { - return false; - } - - value = heap[0]; - static CompareT compareT; - std::pop_heap(heap.begin(), heap.end(), compareT); - heap.pop_back(); - --count; - - return true; /* Return old last node. */ - } + /** + * Constructor. + * + * Params: + * size = heap size + */ + + Heap(int size) + { + length = size+1; + heap = new T[length]; // heap uses 1-based indexing + count = 0; + } + + + /** + * Destructor. + * + */ + ~Heap() + { + delete[] heap; + } + + /** + * + * Returns: heap size + */ + int size() + { + return count; + } + + /** + * Tests if the heap is empty + * + * Returns: true is heap empty, false otherwise + */ + bool empty() + { + return size()==0; + } + + /** + * Clears the heap. + */ + void clear() + { + count = 0; + } + + + /** + * Insert a new element in the heap. + * + * We select the next empty leaf node, and then keep moving any larger + * parents down until the right location is found to store this element. + * + * Params: + * value = the new element to be inserted in the heap + */ + void insert(T value) + { + /* If heap is full, then return without adding this element. */ + if (count == length-1) { + return; + } + + int loc = ++(count); /* Remember 1-based indexing. */ + + /* Keep moving parents down until a place is found for this node. */ + int par = loc / 2; /* Location of parent. */ + while (par > 0 && value < heap[par]) { + heap[loc] = heap[par]; /* Move parent down to loc. */ + loc = par; + par = loc / 2; + } + /* Insert the element at the determined location. */ + heap[loc] = value; + } + + + + /** + * Returns the node of minimum value from the heap (top of the heap). + * + * Params: + * value = out parameter used to return the min element + * Returns: false if heap empty + */ + bool popMin(T& value) + { + if (count == 0) { + return false; + } + + /* Switch first node with last. */ + std::swap(heap[1],heap[count]); + + count -= 1; + heapify(1); /* Move new node 1 to right position. */ + + value = heap[count + 1]; + return true; /* Return old last node. */ + } + + + /** + * Reorganizes the heap (a parent is smaller than its children) + * starting with a node. + * + * Params: + * parent = node form which to start heap reorganization. + */ + void heapify(int parent) + { + int minloc = parent; + + /* Check the left child */ + int left = 2 * parent; + if (left <= count && heap[left] < heap[parent]) { + minloc = left; + } + + /* Check the right child */ + int right = left + 1; + if (right <= count && heap[right] < heap[minloc]) { + minloc = right; + } + + /* If a child was smaller, than swap parent with it and Heapify. */ + if (minloc != parent) { + std::swap(heap[parent],heap[minloc]); + heapify(minloc); + } + } + }; -} +} // namespace cvflann -#endif //OPENCV_FLANN_HEAP_H_ +#endif //_OPENCV_HEAP_H_ diff --git a/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h b/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h deleted file mode 100644 index 9c3d16e..0000000 --- a/modules/flann/include/opencv2/flann/hierarchical_clustering_index.h +++ /dev/null @@ -1,717 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * THE BSD LICENSE - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_ -#define OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_ - -#include -#include -#include -#include -#include -#include - -#include "general.h" -#include "nn_index.h" -#include "dist.h" -#include "matrix.h" -#include "result_set.h" -#include "heap.h" -#include "allocator.h" -#include "random.h" -#include "saving.h" - - -namespace cvflann -{ - -struct HierarchicalClusteringIndexParams : public IndexParams -{ - HierarchicalClusteringIndexParams(int branching = 32, - flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, - int trees = 4, int leaf_size = 100) - { - (*this)["algorithm"] = FLANN_INDEX_HIERARCHICAL; - // The branching factor used in the hierarchical clustering - (*this)["branching"] = branching; - // Algorithm used for picking the initial cluster centers - (*this)["centers_init"] = centers_init; - // number of parallel trees to build - (*this)["trees"] = trees; - // maximum leaf size - (*this)["leaf_size"] = leaf_size; - } -}; - - -/** - * Hierarchical index - * - * Contains a tree constructed through a hierarchical clustering - * and other information for indexing a set of points for nearest-neighbour matching. - */ -template -class HierarchicalClusteringIndex : public NNIndex -{ -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - -private: - - - typedef void (HierarchicalClusteringIndex::* centersAlgFunction)(int, int*, int, int*, int&); - - /** - * The function used for choosing the cluster centers. - */ - centersAlgFunction chooseCenters; - - - - /** - * Chooses the initial centers in the k-means clustering in a random manner. - * - * Params: - * k = number of centers - * vecs = the dataset of points - * indices = indices in the dataset - * indices_length = length of indices vector - * - */ - void chooseCentersRandom(int k, int* indices, int indices_length, int* centers, int& centers_length) - { - UniqueRandom r(indices_length); - - int index; - for (index=0; index=0 && rnd < n); - - centers[0] = indices[rnd]; - - int index; - for (index=1; indexbest_val) { - best_val = dist; - best_index = j; - } - } - if (best_index!=-1) { - centers[index] = indices[best_index]; - } - else { - break; - } - } - centers_length = index; - } - - - /** - * Chooses the initial centers in the k-means using the algorithm - * proposed in the KMeans++ paper: - * Arthur, David; Vassilvitskii, Sergei - k-means++: The Advantages of Careful Seeding - * - * Implementation of this function was converted from the one provided in Arthur's code. - * - * Params: - * k = number of centers - * vecs = the dataset of points - * indices = indices in the dataset - * Returns: - */ - void chooseCentersKMeanspp(int k, int* indices, int indices_length, int* centers, int& centers_length) - { - int n = indices_length; - - double currentPot = 0; - DistanceType* closestDistSq = new DistanceType[n]; - - // Choose one random center and set the closestDistSq values - int index = rand_int(n); - assert(index >=0 && index < n); - centers[0] = indices[index]; - - for (int i = 0; i < n; i++) { - closestDistSq[i] = distance(dataset[indices[i]], dataset[indices[index]], dataset.cols); - currentPot += closestDistSq[i]; - } - - - const int numLocalTries = 1; - - // Choose each center - int centerCount; - for (centerCount = 1; centerCount < k; centerCount++) { - - // Repeat several trials - double bestNewPot = -1; - int bestNewIndex = 0; - for (int localTrial = 0; localTrial < numLocalTries; localTrial++) { - - // Choose our center - have to be slightly careful to return a valid answer even accounting - // for possible rounding errors - double randVal = rand_double(currentPot); - for (index = 0; index < n-1; index++) { - if (randVal <= closestDistSq[index]) break; - else randVal -= closestDistSq[index]; - } - - // Compute the new potential - double newPot = 0; - for (int i = 0; i < n; i++) newPot += std::min( distance(dataset[indices[i]], dataset[indices[index]], dataset.cols), closestDistSq[i] ); - - // Store the best result - if ((bestNewPot < 0)||(newPot < bestNewPot)) { - bestNewPot = newPot; - bestNewIndex = index; - } - } - - // Add the appropriate center - centers[centerCount] = indices[bestNewIndex]; - currentPot = bestNewPot; - for (int i = 0; i < n; i++) closestDistSq[i] = std::min( distance(dataset[indices[i]], dataset[indices[bestNewIndex]], dataset.cols), closestDistSq[i] ); - } - - centers_length = centerCount; - - delete[] closestDistSq; - } - - -public: - - - /** - * Index constructor - * - * Params: - * inputData = dataset with the input features - * params = parameters passed to the hierarchical k-means algorithm - */ - HierarchicalClusteringIndex(const Matrix& inputData, const IndexParams& index_params = HierarchicalClusteringIndexParams(), - Distance d = Distance()) - : dataset(inputData), params(index_params), root(NULL), indices(NULL), distance(d) - { - memoryCounter = 0; - - size_ = dataset.rows; - veclen_ = dataset.cols; - - branching_ = get_param(params,"branching",32); - centers_init_ = get_param(params,"centers_init", FLANN_CENTERS_RANDOM); - trees_ = get_param(params,"trees",4); - leaf_size_ = get_param(params,"leaf_size",100); - - if (centers_init_==FLANN_CENTERS_RANDOM) { - chooseCenters = &HierarchicalClusteringIndex::chooseCentersRandom; - } - else if (centers_init_==FLANN_CENTERS_GONZALES) { - chooseCenters = &HierarchicalClusteringIndex::chooseCentersGonzales; - } - else if (centers_init_==FLANN_CENTERS_KMEANSPP) { - chooseCenters = &HierarchicalClusteringIndex::chooseCentersKMeanspp; - } - else { - throw FLANNException("Unknown algorithm for choosing initial centers."); - } - - trees_ = get_param(params,"trees",4); - root = new NodePtr[trees_]; - indices = new int*[trees_]; - } - - HierarchicalClusteringIndex(const HierarchicalClusteringIndex&); - HierarchicalClusteringIndex& operator=(const HierarchicalClusteringIndex&); - - /** - * Index destructor. - * - * Release the memory used by the index. - */ - virtual ~HierarchicalClusteringIndex() - { - if (indices!=NULL) { - delete[] indices; - } - } - - /** - * Returns size of index. - */ - size_t size() const - { - return size_; - } - - /** - * Returns the length of an index feature. - */ - size_t veclen() const - { - return veclen_; - } - - - /** - * Computes the inde memory usage - * Returns: memory used by the index - */ - int usedMemory() const - { - return pool.usedMemory+pool.wastedMemory+memoryCounter; - } - - /** - * Builds the index - */ - void buildIndex() - { - if (branching_<2) { - throw FLANNException("Branching factor must be at least 2"); - } - for (int i=0; i(); - computeClustering(root[i], indices[i], size_, branching_,0); - } - } - - - flann_algorithm_t getType() const - { - return FLANN_INDEX_HIERARCHICAL; - } - - - void saveIndex(FILE* stream) - { - save_value(stream, branching_); - save_value(stream, trees_); - save_value(stream, centers_init_); - save_value(stream, leaf_size_); - save_value(stream, memoryCounter); - for (int i=0; i& result, const ElementType* vec, const SearchParams& searchParams) - { - - int maxChecks = get_param(searchParams,"checks",32); - - // Priority queue storing intermediate branches in the best-bin-first search - Heap* heap = new Heap(size_); - - std::vector checked(size_,false); - int checks = 0; - for (int i=0; ipopMin(branch) && (checks BranchSt; - - - - void save_tree(FILE* stream, NodePtr node, int num) - { - save_value(stream, *node); - if (node->childs==NULL) { - int indices_offset = node->indices - indices[num]; - save_value(stream, indices_offset); - } - else { - for(int i=0; ichilds[i], num); - } - } - } - - - void load_tree(FILE* stream, NodePtr& node, int num) - { - node = pool.allocate(); - load_value(stream, *node); - if (node->childs==NULL) { - int indices_offset; - load_value(stream, indices_offset); - node->indices = indices[num] + indices_offset; - } - else { - node->childs = pool.allocate(branching_); - for(int i=0; ichilds[i], num); - } - } - } - - - - - void computeLabels(int* indices, int indices_length, int* centers, int centers_length, int* labels, DistanceType& cost) - { - cost = 0; - for (int i=0; inew_dist) { - labels[i] = j; - dist = new_dist; - } - } - cost += dist; - } - } - - /** - * The method responsible with actually doing the recursive hierarchical - * clustering - * - * Params: - * node = the node to cluster - * indices = indices of the points belonging to the current node - * branching = the branching factor to use in the clustering - * - * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point) - */ - void computeClustering(NodePtr node, int* indices, int indices_length, int branching, int level) - { - node->size = indices_length; - node->level = level; - - if (indices_length < leaf_size_) { // leaf node - node->indices = indices; - std::sort(node->indices,node->indices+indices_length); - node->childs = NULL; - return; - } - - std::vector centers(branching); - std::vector labels(indices_length); - - int centers_length; - (this->*chooseCenters)(branching, indices, indices_length, ¢ers[0], centers_length); - - if (centers_lengthindices = indices; - std::sort(node->indices,node->indices+indices_length); - node->childs = NULL; - return; - } - - - // assign points to clusters - DistanceType cost; - computeLabels(indices, indices_length, ¢ers[0], centers_length, &labels[0], cost); - - node->childs = pool.allocate(branching); - int start = 0; - int end = start; - for (int i=0; ichilds[i] = pool.allocate(); - node->childs[i]->pivot = centers[i]; - node->childs[i]->indices = NULL; - computeClustering(node->childs[i],indices+start, end-start, branching, level+1); - start=end; - } - } - - - - /** - * Performs one descent in the hierarchical k-means tree. The branches not - * visited are stored in a priority queue. - * - * Params: - * node = node to explore - * result = container for the k-nearest neighbors found - * vec = query points - * checks = how many points in the dataset have been checked so far - * maxChecks = maximum dataset points to checks - */ - - - void findNN(NodePtr node, ResultSet& result, const ElementType* vec, int& checks, int maxChecks, - Heap* heap, std::vector& checked) - { - if (node->childs==NULL) { - if (checks>=maxChecks) { - if (result.full()) return; - } - checks += node->size; - for (int i=0; isize; ++i) { - int index = node->indices[i]; - if (!checked[index]) { - DistanceType dist = distance(dataset[index], vec, veclen_); - result.addPoint(dist, index); - checked[index] = true; - } - } - } - else { - DistanceType* domain_distances = new DistanceType[branching_]; - int best_index = 0; - domain_distances[best_index] = distance(vec, dataset[node->childs[best_index]->pivot], veclen_); - for (int i=1; ichilds[i]->pivot], veclen_); - if (domain_distances[i]insert(BranchSt(node->childs[i],domain_distances[i])); - } - } - delete[] domain_distances; - findNN(node->childs[best_index],result,vec, checks, maxChecks, heap, checked); - } - } - -private: - - - /** - * The dataset used by this index - */ - const Matrix dataset; - - /** - * Parameters used by this index - */ - IndexParams params; - - - /** - * Number of features in the dataset. - */ - size_t size_; - - /** - * Length of each feature. - */ - size_t veclen_; - - /** - * The root node in the tree. - */ - NodePtr* root; - - /** - * Array of indices to vectors in the dataset. - */ - int** indices; - - - /** - * The distance - */ - Distance distance; - - /** - * Pooled memory allocator. - * - * Using a pooled memory allocator is more efficient - * than allocating memory directly when there is a large - * number small of memory allocations. - */ - PooledAllocator pool; - - /** - * Memory occupied by the index. - */ - int memoryCounter; - - /** index parameters */ - int branching_; - int trees_; - flann_centers_init_t centers_init_; - int leaf_size_; - - -}; - -} - -#endif /* OPENCV_FLANN_HIERARCHICAL_CLUSTERING_INDEX_H_ */ diff --git a/modules/flann/include/opencv2/flann/index_testing.h b/modules/flann/include/opencv2/flann/index_testing.h index c98a14b..476c2c2 100644 --- a/modules/flann/include/opencv2/flann/index_testing.h +++ b/modules/flann/include/opencv2/flann/index_testing.h @@ -28,50 +28,36 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_INDEX_TESTING_H_ -#define OPENCV_FLANN_INDEX_TESTING_H_ +#ifndef _OPENCV_TESTING_H_ +#define _OPENCV_TESTING_H_ #include #include -#include -#include "matrix.h" -#include "nn_index.h" -#include "result_set.h" -#include "logger.h" -#include "timer.h" +#include "opencv2/flann/matrix.h" +#include "opencv2/flann/nn_index.h" +#include "opencv2/flann/result_set.h" +#include "opencv2/flann/logger.h" +#include "opencv2/flann/timer.h" + namespace cvflann { -inline int countCorrectMatches(int* neighbors, int* groundTruth, int n) -{ - int count = 0; - for (int i=0; i -typename Distance::ResultType computeDistanceRaport(const Matrix& inputData, typename Distance::ElementType* target, - int* neighbors, int* groundTruth, int veclen, int n, const Distance& distance) +template +float computeDistanceRaport(const Matrix& inputData, ELEM_TYPE* target, int* neighbors, int* groundTruth, int veclen, int n) { - typedef typename Distance::ResultType DistanceType; + ELEM_TYPE* target_end = target + veclen; + float ret = 0; + for (int i=0;i -float search_with_ground_truth(NNIndex& index, const Matrix& inputData, - const Matrix& testData, const Matrix& matches, int nn, int checks, - float& time, typename Distance::ResultType& dist, const Distance& distance, int skipMatches) +template +float search_with_ground_truth(NNIndex& index, const Matrix& inputData, const Matrix& testData, const Matrix& matches, int nn, int checks, float& time, float& dist, int skipMatches) { - typedef typename Distance::ResultType DistanceType; - if (matches.cols resultSet(nn+skipMatches); + KNNResultSet resultSet(nn+skipMatches); SearchParams searchParams(checks); - int* indices = new int[nn+skipMatches]; - DistanceType* dists = new DistanceType[nn+skipMatches]; - int* neighbors = indices + skipMatches; - int correct = 0; - DistanceType distR = 0; + float distR = 0; StartStopTimer t; int repeats = 0; while (t.value<0.2) { @@ -112,69 +90,65 @@ float search_with_ground_truth(NNIndex& index, const Matrix(inputData, testData[i], neighbors, matches[i], testData.cols, nn, distance); + distR += computeDistanceRaport(inputData, target,neighbors,matches[i], (int)testData.cols, nn); } t.stop(); } - time = float(t.value/repeats); + time = (float)(t.value/repeats); - delete[] indices; - delete[] dists; float precicion = (float)correct/(nn*testData.rows); dist = distR/(testData.rows*nn); - Logger::info("%8d %10.4g %10.5g %10.5g %10.5g\n", - checks, precicion, time, 1000.0 * time / testData.rows, dist); + logger().info("%8d %10.4g %10.5g %10.5g %10.5g\n", + checks, precicion, time, 1000.0 * time / testData.rows, dist); return precicion; } -template -float test_index_checks(NNIndex& index, const Matrix& inputData, - const Matrix& testData, const Matrix& matches, - int checks, float& precision, const Distance& distance, int nn = 1, int skipMatches = 0) +template +float test_index_checks(NNIndex& index, const Matrix& inputData, const Matrix& testData, const Matrix& matches, + int checks, float& precision, int nn = 1, int skipMatches = 0) { - typedef typename Distance::ResultType DistanceType; - - Logger::info(" Nodes Precision(%) Time(s) Time/vec(ms) Mean dist\n"); - Logger::info("---------------------------------------------------------\n"); + logger().info(" Nodes Precision(%) Time(s) Time/vec(ms) Mean dist\n"); + logger().info("---------------------------------------------------------\n"); float time = 0; - DistanceType dist = 0; - precision = search_with_ground_truth(index, inputData, testData, matches, nn, checks, time, dist, distance, skipMatches); + float dist = 0; + precision = search_with_ground_truth(index, inputData, testData, matches, nn, checks, time, dist, skipMatches); return time; } -template -float test_index_precision(NNIndex& index, const Matrix& inputData, - const Matrix& testData, const Matrix& matches, - float precision, int& checks, const Distance& distance, int nn = 1, int skipMatches = 0) +template +float test_index_precision(NNIndex& index, const Matrix& inputData, const Matrix& testData, const Matrix& matches, + float precision, int& checks, int nn = 1, int skipMatches = 0) { - typedef typename Distance::ResultType DistanceType; - const float SEARCH_EPS = 0.001f; + const float SEARCH_EPS = 0.001f; - Logger::info(" Nodes Precision(%) Time(s) Time/vec(ms) Mean dist\n"); - Logger::info("---------------------------------------------------------\n"); + logger().info(" Nodes Precision(%) Time(s) Time/vec(ms) Mean dist\n"); + logger().info("---------------------------------------------------------\n"); int c2 = 1; float p2; int c1 = 1; float p1; float time; - DistanceType dist; + float dist; - p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches); + p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches); if (p2>precision) { - Logger::info("Got as close as I can\n"); + logger().info("Got as close as I can\n"); checks = c2; return time; } @@ -183,18 +157,18 @@ float test_index_precision(NNIndex& index, const MatrixSEARCH_EPS) { - Logger::info("Start linear estimation\n"); + logger().info("Start linear estimation\n"); // after we got to values in the vecinity of the desired precision // use linear approximation get a better estimation cx = (c1+c2)/2; - realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches); + realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches); while (fabs(realPrecision-precision)>SEARCH_EPS) { if (realPrecision& index, const Matrix& index, const Matrix -void test_index_precisions(NNIndex& index, const Matrix& inputData, - const Matrix& testData, const Matrix& matches, - float* precisions, int precisions_length, const Distance& distance, int nn = 1, int skipMatches = 0, float maxTime = 0) +template +float test_index_precisions(NNIndex& index, const Matrix& inputData, const Matrix& testData, const Matrix& matches, + float* precisions, int precisions_length, int nn = 1, int skipMatches = 0, float maxTime = 0) { - typedef typename Distance::ResultType DistanceType; - - const float SEARCH_EPS = 0.001; + const float SEARCH_EPS = 0.001; // make sure precisions array is sorted std::sort(precisions, precisions+precisions_length); @@ -241,8 +211,8 @@ void test_index_precisions(NNIndex& index, const Matrix& index, const Matrix& index, const Matrix 0)&&(time > maxTime)&&(p2 0 && time > maxTime && p2SEARCH_EPS) { - Logger::info("Start linear estimation\n"); + logger().info("Start linear estimation\n"); // after we got to values in the vecinity of the desired precision // use linear approximation get a better estimation cx = (c1+c2)/2; - realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, distance, skipMatches); + realPrecision = search_with_ground_truth(index, inputData, testData, matches, nn, cx, time, dist, skipMatches); while (fabs(realPrecision-precision)>SEARCH_EPS) { if (realPrecision& index, const Matrix #include #include #include -#include "general.h" -#include "nn_index.h" -#include "dynamic_bitset.h" -#include "matrix.h" -#include "result_set.h" -#include "heap.h" -#include "allocator.h" -#include "random.h" -#include "saving.h" +#include "opencv2/flann/general.h" +#include "opencv2/flann/nn_index.h" +#include "opencv2/flann/matrix.h" +#include "opencv2/flann/result_set.h" +#include "opencv2/flann/heap.h" +#include "opencv2/flann/allocator.h" +#include "opencv2/flann/random.h" +#include "opencv2/flann/saving.h" namespace cvflann { -struct KDTreeIndexParams : public IndexParams -{ - KDTreeIndexParams(int trees = 4) - { - (*this)["algorithm"] = FLANN_INDEX_KDTREE; - (*this)["trees"] = trees; - } +struct CV_EXPORTS KDTreeIndexParams : public IndexParams { + KDTreeIndexParams(int trees_ = 4) : IndexParams(FLANN_INDEX_KDTREE), trees(trees_) {}; + + int trees; // number of randomized trees to use (for kdtree) + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + logger().info("Trees: %d\n", trees); + } + }; @@ -66,126 +69,223 @@ struct KDTreeIndexParams : public IndexParams * Contains the k-d trees and other information for indexing a set of points * for nearest-neighbor matching. */ -template -class KDTreeIndex : public NNIndex +template ::type > +class KDTreeIndex : public NNIndex { -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; + enum { + /** + * To improve efficiency, only SAMPLE_MEAN random values are used to + * compute the mean and variance at each level when building a tree. + * A value of 100 seems to perform as well as using all values. + */ + SAMPLE_MEAN = 100, + /** + * Top random dimensions to consider + * + * When creating random trees, the dimension on which to subdivide is + * selected at random from among the top RAND_DIM dimensions with the + * highest variance. A value of 5 works well. + */ + RAND_DIM=5 + }; + + + /** + * Number of randomized trees that are used + */ + int numTrees; + + /** + * Array of indices to vectors in the dataset. + */ + int* vind; + + + /** + * The dataset used by this index + */ + const Matrix dataset; + + const IndexParams& index_params; + + size_t size_; + size_t veclen_; + + + DIST_TYPE* mean; + DIST_TYPE* var; + + + /*--------------------- Internal Data Structures --------------------------*/ + + /** + * A node of the binary k-d tree. + * + * This is All nodes that have vec[divfeat] < divval are placed in the + * child1 subtree, else child2., A leaf node is indicated if both children are NULL. + */ + struct TreeSt { + /** + * Index of the vector feature used for subdivision. + * If this is a leaf node (both children are NULL) then + * this holds vector index for this leaf. + */ + int divfeat; + /** + * The value used for subdivision. + */ + DIST_TYPE divval; + /** + * The child nodes. + */ + TreeSt *child1, *child2; + }; + typedef TreeSt* Tree; /** - * KDTree constructor - * - * Params: - * inputData = dataset with the input features - * params = parameters passed to the kdtree algorithm + * Array of k-d trees used to find neighbours. */ - KDTreeIndex(const Matrix& inputData, const IndexParams& params = KDTreeIndexParams(), - Distance d = Distance() ) : - dataset_(inputData), index_params_(params), distance_(d) - { - size_ = dataset_.rows; - veclen_ = dataset_.cols; - - trees_ = get_param(index_params_,"trees",4); - tree_roots_ = new NodePtr[trees_]; - - // Create a permutable array of indices to the input vectors. - vind_.resize(size_); - for (size_t i = 0; i < size_; ++i) { - vind_[i] = int(i); - } - - mean_ = new DistanceType[veclen_]; - var_ = new DistanceType[veclen_]; - } + Tree* trees; + typedef BranchStruct BranchSt; + typedef BranchSt* Branch; + /** + * Pooled memory allocator. + * + * Using a pooled memory allocator is more efficient + * than allocating memory directly when there is a large + * number small of memory allocations. + */ + PooledAllocator pool; - KDTreeIndex(const KDTreeIndex&); - KDTreeIndex& operator=(const KDTreeIndex&); - /** - * Standard destructor - */ - ~KDTreeIndex() - { - if (tree_roots_!=NULL) { - delete[] tree_roots_; - } - delete[] mean_; - delete[] var_; - } - - /** - * Builds the index - */ - void buildIndex() - { - /* Construct the randomized trees. */ - for (int i = 0; i < trees_; i++) { - /* Randomize the order of vectors to allow for unbiased sampling. */ - std::random_shuffle(vind_.begin(), vind_.end()); - tree_roots_[i] = divideTree(vind_.data(), int(size_) ); - } - } +public: flann_algorithm_t getType() const { return FLANN_INDEX_KDTREE; } + /** + * KDTree constructor + * + * Params: + * inputData = dataset with the input features + * params = parameters passed to the kdtree algorithm + */ + KDTreeIndex(const Matrix& inputData, const KDTreeIndexParams& params = KDTreeIndexParams() ) : + dataset(inputData), index_params(params) + { + size_ = dataset.rows; + veclen_ = dataset.cols; + + numTrees = params.trees; + trees = new Tree[numTrees]; + + // get the parameters +// if (params.find("trees") != params.end()) { +// numTrees = (int)params["trees"]; +// trees = new Tree[numTrees]; +// } +// else { +// numTrees = -1; +// trees = NULL; +// } + + // Create a permutable array of indices to the input vectors. + vind = new int[size_]; + for (size_t i = 0; i < size_; i++) { + vind[i] = (int)i; + } + + mean = new DIST_TYPE[veclen_]; + var = new DIST_TYPE[veclen_]; + } + + /** + * Standard destructor + */ + ~KDTreeIndex() + { + delete[] vind; + if (trees!=NULL) { + delete[] trees; + } + delete[] mean; + delete[] var; + } + + + /** + * Builds the index + */ + void buildIndex() + { + /* Construct the randomized trees. */ + for (int i = 0; i < numTrees; i++) { + /* Randomize the order of vectors to allow for unbiased sampling. */ + for (int j = (int)size_; j > 0; --j) { + int rnd = rand_int(j); + std::swap(vind[j-1], vind[rnd]); + } + trees[i] = divideTree(0, (int)size_ - 1); + } + } + + void saveIndex(FILE* stream) { - save_value(stream, trees_); - for (int i=0; i& result, const ElementType* vec, const SearchParams& searchParams) + void findNeighbors(ResultSet& result, const ELEM_TYPE* vec, const SearchParams& searchParams) { - int maxChecks = get_param(searchParams,"checks", 32); - float epsError = 1+get_param(searchParams,"eps",0.0f); + int maxChecks = searchParams.checks; - if (maxChecks==FLANN_CHECKS_UNLIMITED) { - getExactNeighbors(result, vec, epsError); - } - else { - getNeighbors(result, vec, maxChecks, epsError); + if (maxChecks<0) { + getExactNeighbors(result, vec); + } else { + getNeighbors(result, vec, maxChecks); } } - IndexParams getParameters() const - { - return index_params_; - } + const IndexParams* getParameters() const + { + return &index_params; + } private: + KDTreeIndex& operator=(const KDTreeIndex&); + KDTreeIndex(const KDTreeIndex&); - /*--------------------- Internal Data Structures --------------------------*/ - struct Node - { - /** - * Dimension used for subdivision. - */ - int divfeat; - /** - * The values used for subdivision. - */ - DistanceType divval; - /** - * The child nodes. - */ - Node* child1, * child2; - }; - typedef Node* NodePtr; - typedef BranchStruct BranchSt; - typedef BranchSt* Branch; - - - void save_tree(FILE* stream, NodePtr tree) + void save_tree(FILE* stream, Tree tree) { - save_value(stream, *tree); - if (tree->child1!=NULL) { - save_tree(stream, tree->child1); - } - if (tree->child2!=NULL) { - save_tree(stream, tree->child2); - } + save_value(stream, *tree); + if (tree->child1!=NULL) { + save_tree(stream, tree->child1); + } + if (tree->child2!=NULL) { + save_tree(stream, tree->child2); + } } - void load_tree(FILE* stream, NodePtr& tree) + void load_tree(FILE* stream, Tree& tree) { - tree = pool_.allocate(); - load_value(stream, *tree); - if (tree->child1!=NULL) { - load_tree(stream, tree->child1); - } - if (tree->child2!=NULL) { - load_tree(stream, tree->child2); - } + tree = pool.allocate(); + load_value(stream, *tree); + if (tree->child1!=NULL) { + load_tree(stream, tree->child1); + } + if (tree->child2!=NULL) { + load_tree(stream, tree->child2); + } } - /** - * Create a tree node that subdivides the list of vecs from vind[first] - * to vind[last]. The routine is called recursively on each sublist. - * Place a pointer to this new tree node in the location pTree. - * - * Params: pTree = the new node to create - * first = index of the first vector - * last = index of the last vector - */ - NodePtr divideTree(int* ind, int count) - { - NodePtr node = pool_.allocate(); // allocate memory - - /* If too few exemplars remain, then make this a leaf node. */ - if ( count == 1) { - node->child1 = node->child2 = NULL; /* Mark as leaf node. */ - node->divfeat = *ind; /* Store index of this vec. */ - } - else { - int idx; - int cutfeat; - DistanceType cutval; - meanSplit(ind, count, idx, cutfeat, cutval); - - node->divfeat = cutfeat; - node->divval = cutval; - node->child1 = divideTree(ind, idx); - node->child2 = divideTree(ind+idx, count-idx); - } - - return node; - } - - - /** - * Choose which feature to use in order to subdivide this set of vectors. - * Make a random choice among those with the highest variance, and use - * its variance as the threshold value. - */ - void meanSplit(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval) - { - memset(mean_,0,veclen_*sizeof(DistanceType)); - memset(var_,0,veclen_*sizeof(DistanceType)); - - /* Compute mean values. Only the first SAMPLE_MEAN values need to be - sampled to get a good estimate. - */ - int cnt = std::min((int)SAMPLE_MEAN+1, count); - for (int j = 0; j < cnt; ++j) { - ElementType* v = dataset_[ind[j]]; + /** + * Create a tree node that subdivides the list of vecs from vind[first] + * to vind[last]. The routine is called recursively on each sublist. + * Place a pointer to this new tree node in the location pTree. + * + * Params: pTree = the new node to create + * first = index of the first vector + * last = index of the last vector + */ + Tree divideTree(int first, int last) + { + Tree node = pool.allocate(); // allocate memory + + /* If only one exemplar remains, then make this a leaf node. */ + if (first == last) { + node->child1 = node->child2 = NULL; /* Mark as leaf node. */ + node->divfeat = vind[first]; /* Store index of this vec. */ + } + else { + chooseDivision(node, first, last); + subdivide(node, first, last); + } + + return node; + } + + + /** + * Choose which feature to use in order to subdivide this set of vectors. + * Make a random choice among those with the highest variance, and use + * its variance as the threshold value. + */ + void chooseDivision(Tree node, int first, int last) + { + memset(mean,0,veclen_*sizeof(DIST_TYPE)); + memset(var,0,veclen_*sizeof(DIST_TYPE)); + + /* Compute mean values. Only the first SAMPLE_MEAN values need to be + sampled to get a good estimate. + */ + int end = std::min(first + SAMPLE_MEAN, last); + for (int j = first; j <= end; ++j) { + ELEM_TYPE* v = dataset[vind[j]]; for (size_t k=0; kcount/2) index = lim1; - else if (lim2 v[topind[num-1]])) { - /* Put this element at end of topind. */ - if (num < RAND_DIM) { - topind[num++] = i; /* Add to list. */ - } - else { - topind[num-1] = i; /* Replace last element. */ - } - /* Bubble end value down to right location by repeated swapping. */ - int j = num - 1; - while (j > 0 && v[topind[j]] > v[topind[j-1]]) { + } + /* Select one of the highest variance indices at random. */ + node->divfeat = selectDivision(var); + node->divval = mean[node->divfeat]; + + } + + + /** + * Select the top RAND_DIM largest values from v and return the index of + * one of these selected at random. + */ + int selectDivision(DIST_TYPE* v) + { + int num = 0; + int topind[RAND_DIM]; + + /* Create a list of the indices of the top RAND_DIM values. */ + for (size_t i = 0; i < veclen_; ++i) { + if (num < RAND_DIM || v[i] > v[topind[num-1]]) { + /* Put this element at end of topind. */ + if (num < RAND_DIM) { + topind[num++] = (int)i; /* Add to list. */ + } + else { + topind[num-1] = (int)i; /* Replace last element. */ + } + /* Bubble end value down to right location by repeated swapping. */ + int j = num - 1; + while (j > 0 && v[topind[j]] > v[topind[j-1]]) { std::swap(topind[j], topind[j-1]); - --j; - } - } - } - /* Select a random integer in range [0,num-1], and return that index. */ - int rnd = rand_int(num); - return (int)topind[rnd]; - } - - - /** - * Subdivide the list of points by a plane perpendicular on axe corresponding - * to the 'cutfeat' dimension at 'cutval' position. - * - * On return: - * dataset[ind[0..lim1-1]][cutfeat]cutval - */ - void planeSplit(int* ind, int count, int cutfeat, DistanceType cutval, int& lim1, int& lim2) - { - /* Move vector indices for left subtree to front of list. */ - int left = 0; - int right = count-1; - for (;; ) { - while (left<=right && dataset_[ind[left]][cutfeat]=cutval) --right; - if (left>right) break; - std::swap(ind[left], ind[right]); ++left; --right; - } - lim1 = left; - right = count-1; - for (;; ) { - while (left<=right && dataset_[ind[left]][cutfeat]<=cutval) ++left; - while (left<=right && dataset_[ind[right]][cutfeat]>cutval) --right; - if (left>right) break; - std::swap(ind[left], ind[right]); ++left; --right; - } - lim2 = left; - } - - /** - * Performs an exact nearest neighbor search. The exact search performs a full - * traversal of the tree. - */ - void getExactNeighbors(ResultSet& result, const ElementType* vec, float epsError) - { - // checkID -= 1; /* Set a different unique ID for each search. */ - - if (trees_ > 1) { + --j; + } + } + } + /* Select a random integer in range [0,num-1], and return that index. */ + int rnd = rand_int(num); + return topind[rnd]; + } + + + /** + * Subdivide the list of exemplars using the feature and division + * value given in this node. Call divideTree recursively on each list. + */ + void subdivide(Tree node, int first, int last) + { + /* Move vector indices for left subtree to front of list. */ + int i = first; + int j = last; + while (i <= j) { + int ind = vind[i]; + ELEM_TYPE val = dataset[ind][node->divfeat]; + if (val < node->divval) { + ++i; + } else { + /* Move to end of list by swapping vind i and j. */ + std::swap(vind[i], vind[j]); + --j; + } + } + /* If either list is empty, it means we have hit the unlikely case + in which all remaining features are identical. Split in the middle + to maintain a balanced tree. + */ + if ( (i == first) || (i == last+1)) { + i = (first+last+1)/2; + } + + node->child1 = divideTree(first, i - 1); + node->child2 = divideTree(i, last); + } + + + + /** + * Performs an exact nearest neighbor search. The exact search performs a full + * traversal of the tree. + */ + void getExactNeighbors(ResultSet& result, const ELEM_TYPE* vec) + { +// checkID -= 1; /* Set a different unique ID for each search. */ + + if (numTrees > 1) { fprintf(stderr,"It doesn't make any sense to use more than one tree for exact search"); - } - if (trees_>0) { - searchLevelExact(result, vec, tree_roots_[0], 0.0, epsError); - } - assert(result.full()); - } - - /** - * Performs the approximate nearest-neighbor search. The search is approximate - * because the tree traversal is abandoned after a given number of descends in - * the tree. - */ - void getNeighbors(ResultSet& result, const ElementType* vec, int maxCheck, float epsError) - { - int i; - BranchSt branch; - - int checkCount = 0; - Heap* heap = new Heap((int)size_); - DynamicBitset checked(size_); - - /* Search once through each tree down to root. */ - for (i = 0; i < trees_; ++i) { - searchLevel(result, vec, tree_roots_[i], 0, checkCount, maxCheck, epsError, heap, checked); - } - - /* Keep searching other branches from heap until finished. */ - while ( heap->popMin(branch) && (checkCount < maxCheck || !result.full() )) { - searchLevel(result, vec, branch.node, branch.mindist, checkCount, maxCheck, epsError, heap, checked); - } - - delete heap; - - assert(result.full()); - } - - - /** - * Search starting from a given node of the tree. Based on any mismatches at - * higher levels, all exemplars below this level must have a distance of - * at least "mindistsq". - */ - void searchLevel(ResultSet& result_set, const ElementType* vec, NodePtr node, DistanceType mindist, int& checkCount, int maxCheck, - float epsError, Heap* heap, DynamicBitset& checked) - { - if (result_set.worstDist()child1 == NULL)&&(node->child2 == NULL)) { - /* Do not check same node more than once when searching multiple trees. - Once a vector is checked, we set its location in vind to the - current checkID. - */ - int index = node->divfeat; - if ( checked.test(index) || ((checkCount>=maxCheck)&& result_set.full()) ) return; - checked.set(index); + } + if (numTrees>0) { + searchLevelExact(result, vec, trees[0], 0.0); + } + assert(result.full()); + } + + /** + * Performs the approximate nearest-neighbor search. The search is approximate + * because the tree traversal is abandoned after a given number of descends in + * the tree. + */ + void getNeighbors(ResultSet& result, const ELEM_TYPE* vec, int maxCheck) + { + int i; + BranchSt branch; + + int checkCount = 0; + Heap* heap = new Heap((int)size_); + std::vector checked(size_,false); + + /* Search once through each tree down to root. */ + for (i = 0; i < numTrees; ++i) { + searchLevel(result, vec, trees[i], 0.0, checkCount, maxCheck, heap, checked); + } + + /* Keep searching other branches from heap until finished. */ + while ( heap->popMin(branch) && (checkCount < maxCheck || !result.full() )) { + searchLevel(result, vec, branch.node, branch.mindistsq, checkCount, maxCheck, heap, checked); + } + + delete heap; + + assert(result.full()); + } + + + /** + * Search starting from a given node of the tree. Based on any mismatches at + * higher levels, all exemplars below this level must have a distance of + * at least "mindistsq". + */ + void searchLevel(ResultSet& result, const ELEM_TYPE* vec, Tree node, float mindistsq, int& checkCount, int maxCheck, + Heap* heap, std::vector& checked) + { + if (result.worstDist()child1 == NULL && node->child2 == NULL) { + + /* Do not check same node more than once when searching multiple trees. + Once a vector is checked, we set its location in vind to the + current checkID. + */ + if (checked[node->divfeat] == true || checkCount>=maxCheck) { + if (result.full()) return; + } checkCount++; - - DistanceType dist = distance_(dataset_[index], vec, veclen_); - result_set.addPoint(dist,index); - - return; - } - - /* Which child branch should be taken first? */ - ElementType val = vec[node->divfeat]; - DistanceType diff = val - node->divval; - NodePtr bestChild = (diff < 0) ? node->child1 : node->child2; - NodePtr otherChild = (diff < 0) ? node->child2 : node->child1; - - /* Create a branch record for the branch not taken. Add distance - of this feature boundary (we don't attempt to correct for any - use of this feature in a parent node, which is unlikely to - happen and would have only a small effect). Don't bother - adding more branches to heap after halfway point, as cost of - adding exceeds their value. - */ - - DistanceType new_distsq = mindist + distance_.accum_dist(val, node->divval, node->divfeat); - // if (2 * checkCount < maxCheck || !result.full()) { - if ((new_distsq*epsError < result_set.worstDist())|| !result_set.full()) { - heap->insert( BranchSt(otherChild, new_distsq) ); - } - - /* Call recursively to search next level down. */ - searchLevel(result_set, vec, bestChild, mindist, checkCount, maxCheck, epsError, heap, checked); - } - - /** - * Performs an exact search in the tree starting from a node. - */ - void searchLevelExact(ResultSet& result_set, const ElementType* vec, const NodePtr node, DistanceType mindist, const float epsError) - { - /* If this is a leaf node, then do check and return. */ - if ((node->child1 == NULL)&&(node->child2 == NULL)) { - int index = node->divfeat; - DistanceType dist = distance_(dataset_[index], vec, veclen_); - result_set.addPoint(dist,index); - return; - } - - /* Which child branch should be taken first? */ - ElementType val = vec[node->divfeat]; - DistanceType diff = val - node->divval; - NodePtr bestChild = (diff < 0) ? node->child1 : node->child2; - NodePtr otherChild = (diff < 0) ? node->child2 : node->child1; - - /* Create a branch record for the branch not taken. Add distance - of this feature boundary (we don't attempt to correct for any - use of this feature in a parent node, which is unlikely to - happen and would have only a small effect). Don't bother - adding more branches to heap after halfway point, as cost of - adding exceeds their value. - */ - - DistanceType new_distsq = mindist + distance_.accum_dist(val, node->divval, node->divfeat); - - /* Call recursively to search next level down. */ - searchLevelExact(result_set, vec, bestChild, mindist, epsError); - - if (new_distsq*epsError<=result_set.worstDist()) { - searchLevelExact(result_set, vec, otherChild, new_distsq, epsError); - } - } - - -private: - - enum - { - /** - * To improve efficiency, only SAMPLE_MEAN random values are used to - * compute the mean and variance at each level when building a tree. - * A value of 100 seems to perform as well as using all values. - */ - SAMPLE_MEAN = 100, - /** - * Top random dimensions to consider - * - * When creating random trees, the dimension on which to subdivide is - * selected at random from among the top RAND_DIM dimensions with the - * highest variance. A value of 5 works well. - */ - RAND_DIM=5 - }; - - - /** - * Number of randomized trees that are used - */ - int trees_; - - /** - * Array of indices to vectors in the dataset. - */ - std::vector vind_; - - /** - * The dataset used by this index - */ - const Matrix dataset_; - - IndexParams index_params_; - - size_t size_; - size_t veclen_; - - - DistanceType* mean_; - DistanceType* var_; - - - /** - * Array of k-d trees used to find neighbours. - */ - NodePtr* tree_roots_; - - /** - * Pooled memory allocator. - * - * Using a pooled memory allocator is more efficient - * than allocating memory directly when there is a large - * number small of memory allocations. - */ - PooledAllocator pool_; - - Distance distance_; - - -}; // class KDTreeForest - -} - -#endif //OPENCV_FLANN_KDTREE_INDEX_H_ + checked[node->divfeat] = true; + + result.addPoint(dataset[node->divfeat],node->divfeat); + return; + } + + /* Which child branch should be taken first? */ + ELEM_TYPE val = vec[node->divfeat]; + DIST_TYPE diff = val - node->divval; + Tree bestChild = (diff < 0) ? node->child1 : node->child2; + Tree otherChild = (diff < 0) ? node->child2 : node->child1; + + /* Create a branch record for the branch not taken. Add distance + of this feature boundary (we don't attempt to correct for any + use of this feature in a parent node, which is unlikely to + happen and would have only a small effect). Don't bother + adding more branches to heap after halfway point, as cost of + adding exceeds their value. + */ + + DIST_TYPE new_distsq = (DIST_TYPE)flann_dist(&val, &val+1, &node->divval, mindistsq); +// if (2 * checkCount < maxCheck || !result.full()) { + if (new_distsq < result.worstDist() || !result.full()) { + heap->insert( BranchSt::make_branch(otherChild, new_distsq) ); + } + + /* Call recursively to search next level down. */ + searchLevel(result, vec, bestChild, mindistsq, checkCount, maxCheck, heap, checked); + } + + /** + * Performs an exact search in the tree starting from a node. + */ + void searchLevelExact(ResultSet& result, const ELEM_TYPE* vec, Tree node, float mindistsq) + { + if (mindistsq>result.worstDist()) { + return; + } + + /* If this is a leaf node, then do check and return. */ + if (node->child1 == NULL && node->child2 == NULL) { + + /* Do not check same node more than once when searching multiple trees. + Once a vector is checked, we set its location in vind to the + current checkID. + */ +// if (vind[node->divfeat] == checkID) +// return; +// vind[node->divfeat] = checkID; + + result.addPoint(dataset[node->divfeat],node->divfeat); + return; + } + + /* Which child branch should be taken first? */ + ELEM_TYPE val = vec[node->divfeat]; + DIST_TYPE diff = val - node->divval; + Tree bestChild = (diff < 0) ? node->child1 : node->child2; + Tree otherChild = (diff < 0) ? node->child2 : node->child1; + + + /* Call recursively to search next level down. */ + searchLevelExact(result, vec, bestChild, mindistsq); + DIST_TYPE new_distsq = (DIST_TYPE)flann_dist(&val, &val+1, &node->divval, mindistsq); + searchLevelExact(result, vec, otherChild, new_distsq); + } + +}; // class KDTree + +} // namespace cvflann + +#endif //_OPENCV_KDTREE_H_ diff --git a/modules/flann/include/opencv2/flann/kdtree_single_index.h b/modules/flann/include/opencv2/flann/kdtree_single_index.h deleted file mode 100644 index f890af5..0000000 --- a/modules/flann/include/opencv2/flann/kdtree_single_index.h +++ /dev/null @@ -1,642 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * THE BSD LICENSE - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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_FLANN_KDTREE_SINGLE_INDEX_H_ -#define OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_ - -#include -#include -#include -#include - -#include "general.h" -#include "nn_index.h" -#include "matrix.h" -#include "result_set.h" -#include "heap.h" -#include "allocator.h" -#include "random.h" -#include "saving.h" - -namespace cvflann -{ - -struct KDTreeSingleIndexParams : public IndexParams -{ - KDTreeSingleIndexParams(int leaf_max_size = 10, bool reorder = true, int dim = -1) - { - (*this)["algorithm"] = FLANN_INDEX_KDTREE_SINGLE; - (*this)["leaf_max_size"] = leaf_max_size; - (*this)["reorder"] = reorder; - (*this)["dim"] = dim; - } -}; - - -/** - * Randomized kd-tree index - * - * Contains the k-d trees and other information for indexing a set of points - * for nearest-neighbor matching. - */ -template -class KDTreeSingleIndex : public NNIndex -{ -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - - /** - * KDTree constructor - * - * Params: - * inputData = dataset with the input features - * params = parameters passed to the kdtree algorithm - */ - KDTreeSingleIndex(const Matrix& inputData, const IndexParams& params = KDTreeSingleIndexParams(), - Distance d = Distance() ) : - dataset_(inputData), index_params_(params), distance_(d) - { - size_ = dataset_.rows; - dim_ = dataset_.cols; - 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); - reorder_ = get_param(params,"reorder",true); - - // Create a permutable array of indices to the input vectors. - vind_.resize(size_); - for (size_t i = 0; i < size_; i++) { - vind_[i] = i; - } - } - - KDTreeSingleIndex(const KDTreeSingleIndex&); - KDTreeSingleIndex& operator=(const KDTreeSingleIndex&); - - /** - * Standard destructor - */ - ~KDTreeSingleIndex() - { - if (reorder_) delete[] data_.data; - } - - /** - * Builds the index - */ - void buildIndex() - { - computeBoundingBox(root_bbox_); - root_node_ = divideTree(0, size_, root_bbox_ ); // construct the tree - - if (reorder_) { - delete[] data_.data; - data_ = cvflann::Matrix(new ElementType[size_*dim_], size_, dim_); - for (size_t i=0; i& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params) - { - assert(queries.cols == veclen()); - assert(indices.rows >= queries.rows); - assert(dists.rows >= queries.rows); - assert(int(indices.cols) >= knn); - assert(int(dists.cols) >= knn); - - KNNSimpleResultSet resultSet(knn); - for (size_t i = 0; i < queries.rows; i++) { - resultSet.init(indices[i], dists[i]); - findNeighbors(resultSet, queries[i], params); - } - } - - IndexParams getParameters() const - { - return index_params_; - } - - /** - * Find set of nearest neighbors to vec. Their indices are stored inside - * the result object. - * - * Params: - * result = the result object in which the indices of the nearest-neighbors are stored - * 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& result, const ElementType* vec, const SearchParams& searchParams) - { - float epsError = 1+get_param(searchParams,"eps",0.0f); - - std::vector dists(dim_,0); - DistanceType distsq = computeInitialDistances(vec, dists); - searchLevel(result, vec, root_node_, distsq, dists, epsError); - } - -private: - - - /*--------------------- Internal Data Structures --------------------------*/ - struct Node - { - union { - struct - { - /** - * Indices of points in leaf node - */ - int left, right; - }; - struct - { - /** - * Dimension used for subdivision. - */ - int divfeat; - /** - * The values used for subdivision. - */ - DistanceType divlow, divhigh; - }; - }; - /** - * The child nodes. - */ - Node* child1, * child2; - }; - typedef Node* NodePtr; - - - struct Interval - { - ElementType low, high; - }; - - typedef std::vector BoundingBox; - - typedef BranchStruct BranchSt; - typedef BranchSt* Branch; - - - - - void save_tree(FILE* stream, NodePtr tree) - { - save_value(stream, *tree); - if (tree->child1!=NULL) { - save_tree(stream, tree->child1); - } - if (tree->child2!=NULL) { - save_tree(stream, tree->child2); - } - } - - - void load_tree(FILE* stream, NodePtr& tree) - { - tree = pool_.allocate(); - load_value(stream, *tree); - if (tree->child1!=NULL) { - load_tree(stream, tree->child1); - } - if (tree->child2!=NULL) { - load_tree(stream, tree->child2); - } - } - - - void computeBoundingBox(BoundingBox& bbox) - { - bbox.resize(dim_); - for (size_t i=0; ibbox[i].high) bbox[i].high = dataset_[k][i]; - } - } - } - - - /** - * Create a tree node that subdivides the list of vecs from vind[first] - * to vind[last]. The routine is called recursively on each sublist. - * Place a pointer to this new tree node in the location pTree. - * - * Params: pTree = the new node to create - * first = index of the first vector - * last = index of the last vector - */ - NodePtr divideTree(int left, int right, BoundingBox& bbox) - { - NodePtr node = pool_.allocate(); // allocate memory - - /* If too few exemplars remain, then make this a leaf node. */ - if ( (right-left) <= leaf_max_size_) { - node->child1 = node->child2 = NULL; /* Mark as leaf node. */ - node->left = left; - node->right = right; - - // compute bounding-box of leaf points - for (size_t i=0; idataset_[vind_[k]][i]) bbox[i].low=dataset_[vind_[k]][i]; - if (bbox[i].highdivfeat = cutfeat; - - BoundingBox left_bbox(bbox); - left_bbox[cutfeat].high = cutval; - node->child1 = divideTree(left, left+idx, left_bbox); - - BoundingBox right_bbox(bbox); - right_bbox[cutfeat].low = cutval; - node->child2 = divideTree(left+idx, right, right_bbox); - - node->divlow = left_bbox[cutfeat].high; - node->divhigh = right_bbox[cutfeat].low; - - for (size_t i=0; imax_elem) max_elem = val; - } - } - - void middleSplit(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval, const BoundingBox& bbox) - { - // find the largest span from the approximate bounding box - ElementType max_span = bbox[0].high-bbox[0].low; - cutfeat = 0; - cutval = (bbox[0].high+bbox[0].low)/2; - for (size_t i=1; imax_span) { - max_span = span; - cutfeat = i; - cutval = (bbox[i].high+bbox[i].low)/2; - } - } - - // compute exact span on the found dimension - ElementType min_elem, max_elem; - computeMinMax(ind, count, cutfeat, min_elem, max_elem); - cutval = (min_elem+max_elem)/2; - max_span = max_elem - min_elem; - - // check if a dimension of a largest span exists - size_t k = cutfeat; - for (size_t i=0; imax_span) { - computeMinMax(ind, count, i, min_elem, max_elem); - span = max_elem - min_elem; - if (span>max_span) { - max_span = span; - cutfeat = i; - cutval = (min_elem+max_elem)/2; - } - } - } - int lim1, lim2; - planeSplit(ind, count, cutfeat, cutval, lim1, lim2); - - if (lim1>count/2) index = lim1; - else if (lim2max_span) { - max_span = span; - } - } - ElementType max_spread = -1; - cutfeat = 0; - for (size_t i=0; i(ElementType)((1-EPS)*max_span)) { - ElementType min_elem, max_elem; - computeMinMax(ind, count, cutfeat, min_elem, max_elem); - ElementType spread = max_elem-min_elem; - if (spread>max_spread) { - cutfeat = i; - max_spread = spread; - } - } - } - // split in the middle - DistanceType split_val = (bbox[cutfeat].low+bbox[cutfeat].high)/2; - ElementType min_elem, max_elem; - computeMinMax(ind, count, cutfeat, min_elem, max_elem); - - if (split_valmax_elem) cutval = max_elem; - else cutval = split_val; - - int lim1, lim2; - planeSplit(ind, count, cutfeat, cutval, lim1, lim2); - - if (lim1>count/2) index = lim1; - else if (lim2cutval - */ - void planeSplit(int* ind, int count, int cutfeat, DistanceType cutval, int& lim1, int& lim2) - { - /* Move vector indices for left subtree to front of list. */ - int left = 0; - int right = count-1; - for (;; ) { - while (left<=right && dataset_[ind[left]][cutfeat]=cutval) --right; - if (left>right) break; - std::swap(ind[left], ind[right]); ++left; --right; - } - /* If either list is empty, it means that all remaining features - * are identical. Split in the middle to maintain a balanced tree. - */ - lim1 = left; - right = count-1; - for (;; ) { - while (left<=right && dataset_[ind[left]][cutfeat]<=cutval) ++left; - while (left<=right && dataset_[ind[right]][cutfeat]>cutval) --right; - if (left>right) break; - std::swap(ind[left], ind[right]); ++left; --right; - } - lim2 = left; - } - - DistanceType computeInitialDistances(const ElementType* vec, std::vector& dists) - { - DistanceType distsq = 0.0; - - for (size_t i = 0; i < dim_; ++i) { - if (vec[i] < root_bbox_[i].low) { - dists[i] = distance_.accum_dist(vec[i], root_bbox_[i].low, i); - distsq += dists[i]; - } - if (vec[i] > root_bbox_[i].high) { - dists[i] = distance_.accum_dist(vec[i], root_bbox_[i].high, i); - distsq += dists[i]; - } - } - - return distsq; - } - - /** - * Performs an exact search in the tree starting from a node. - */ - void searchLevel(ResultSet& result_set, const ElementType* vec, const NodePtr node, DistanceType mindistsq, - std::vector& dists, const float epsError) - { - /* If this is a leaf node, then do check and return. */ - if ((node->child1 == NULL)&&(node->child2 == NULL)) { - DistanceType worst_dist = result_set.worstDist(); - for (int i=node->left; iright; ++i) { - int index = reorder_ ? i : vind_[i]; - DistanceType dist = distance_(vec, data_[index], dim_, worst_dist); - if (distdivfeat; - ElementType val = vec[idx]; - DistanceType diff1 = val - node->divlow; - DistanceType diff2 = val - node->divhigh; - - NodePtr bestChild; - NodePtr otherChild; - DistanceType cut_dist; - if ((diff1+diff2)<0) { - bestChild = node->child1; - otherChild = node->child2; - cut_dist = distance_.accum_dist(val, node->divhigh, idx); - } - else { - bestChild = node->child2; - otherChild = node->child1; - cut_dist = distance_.accum_dist( val, node->divlow, idx); - } - - /* Call recursively to search next level down. */ - searchLevel(result_set, vec, bestChild, mindistsq, dists, epsError); - - DistanceType dst = dists[idx]; - mindistsq = mindistsq + cut_dist - dst; - dists[idx] = cut_dist; - if (mindistsq*epsError<=result_set.worstDist()) { - searchLevel(result_set, vec, otherChild, mindistsq, dists, epsError); - } - dists[idx] = dst; - } - -private: - - /** - * The dataset used by this index - */ - const Matrix dataset_; - - IndexParams index_params_; - - int leaf_max_size_; - bool reorder_; - - - /** - * Array of indices to vectors in the dataset. - */ - std::vector vind_; - - Matrix data_; - - size_t size_; - size_t dim_; - - /** - * Array of k-d trees used to find neighbours. - */ - NodePtr root_node_; - - BoundingBox root_bbox_; - - /** - * Pooled memory allocator. - * - * Using a pooled memory allocator is more efficient - * than allocating memory directly when there is a large - * number small of memory allocations. - */ - PooledAllocator pool_; - - Distance distance_; -}; // class KDTree - -} - -#endif //OPENCV_FLANN_KDTREE_SINGLE_INDEX_H_ diff --git a/modules/flann/include/opencv2/flann/kmeans_index.h b/modules/flann/include/opencv2/flann/kmeans_index.h index 624c27a..67abba5 100644 --- a/modules/flann/include/opencv2/flann/kmeans_index.h +++ b/modules/flann/include/opencv2/flann/kmeans_index.h @@ -28,8 +28,8 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_KMEANS_INDEX_H_ -#define OPENCV_FLANN_KMEANS_INDEX_H_ +#ifndef _OPENCV_KMEANSTREE_H_ +#define _OPENCV_KMEANSTREE_H_ #include #include @@ -38,36 +38,41 @@ #include #include -#include "general.h" -#include "nn_index.h" -#include "dist.h" -#include "matrix.h" -#include "result_set.h" -#include "heap.h" -#include "allocator.h" -#include "random.h" -#include "saving.h" -#include "logger.h" +#include "opencv2/flann/general.h" +#include "opencv2/flann/nn_index.h" +#include "opencv2/flann/matrix.h" +#include "opencv2/flann/result_set.h" +#include "opencv2/flann/heap.h" +#include "opencv2/flann/allocator.h" +#include "opencv2/flann/random.h" namespace cvflann { -struct KMeansIndexParams : public IndexParams -{ - KMeansIndexParams(int branching = 32, int iterations = 11, - flann_centers_init_t centers_init = FLANN_CENTERS_RANDOM, float cb_index = 0.2 ) - { - (*this)["algorithm"] = FLANN_INDEX_KMEANS; - // branching factor - (*this)["branching"] = branching; - // max iterations to perform in one kmeans clustering (kmeans tree) - (*this)["iterations"] = iterations; - // algorithm used for picking the initial cluster centers for kmeans tree - (*this)["centers_init"] = centers_init; - // cluster boundary index. Used when searching the kmeans tree - (*this)["cb_index"] = cb_index; - } +struct CV_EXPORTS KMeansIndexParams : public IndexParams { + KMeansIndexParams(int branching_ = 32, int iterations_ = 11, + flann_centers_init_t centers_init_ = FLANN_CENTERS_RANDOM, float cb_index_ = 0.2 ) : + IndexParams(FLANN_INDEX_KMEANS), + branching(branching_), + iterations(iterations_), + centers_init(centers_init_), + cb_index(cb_index_) {}; + + int branching; // branching factor (for kmeans tree) + int iterations; // max iterations to perform in one kmeans clustering (kmeans tree) + flann_centers_init_t centers_init; // algorithm used for picking the initial cluster centers for kmeans tree + float cb_index; // cluster boundary index. Used when searching the kmeans tree + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + logger().info("Branching: %d\n", branching); + logger().info("Iterations: %d\n", iterations); + logger().info("Centres initialisation: %d\n", centers_init); + logger().info("Cluster boundary weight: %g\n", cb_index); + } + }; @@ -77,40 +82,145 @@ struct KMeansIndexParams : public IndexParams * Contains a tree constructed through a hierarchical kmeans clustering * and other information for indexing a set of points for nearest-neighbour matching. */ -template -class KMeansIndex : public NNIndex +template ::type > +class KMeansIndex : public NNIndex { -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; + + /** + * The branching factor used in the hierarchical k-means clustering + */ + int branching; + + /** + * Maximum number of iterations to use when performing k-means + * clustering + */ + int max_iter; + + /** + * Cluster border index. This is used in the tree search phase when determining + * the closest cluster to explore next. A zero value takes into account only + * the cluster centres, a value greater then zero also take into account the size + * of the cluster. + */ + float cb_index; + + /** + * The dataset used by this index + */ + const Matrix dataset; + + const IndexParams& index_params; + + /** + * Number of features in the dataset. + */ + size_t size_; + + /** + * Length of each feature. + */ + size_t veclen_; + /** + * Struture representing a node in the hierarchical k-means tree. + */ + struct KMeansNodeSt { + /** + * The cluster center. + */ + DIST_TYPE* pivot; + /** + * The cluster radius. + */ + DIST_TYPE radius; + /** + * The cluster mean radius. + */ + DIST_TYPE mean_radius; + /** + * The cluster variance. + */ + DIST_TYPE variance; + /** + * The cluster size (number of points in the cluster) + */ + int size; + /** + * Child nodes (only for non-terminal nodes) + */ + KMeansNodeSt** childs; + /** + * Node points (only for terminal nodes) + */ + int* indices; + /** + * Level + */ + int level; + }; + typedef KMeansNodeSt* KMeansNode; + - typedef void (KMeansIndex::* centersAlgFunction)(int, int*, int, int*, int&); /** - * The function used for choosing the cluster centers. + * Alias definition for a nicer syntax. */ + typedef BranchStruct BranchSt; + + + /** + * The root node in the tree. + */ + KMeansNode root; + + /** + * Array of indices to vectors in the dataset. + */ + int* indices; + + + /** + * Pooled memory allocator. + * + * Using a pooled memory allocator is more efficient + * than allocating memory directly when there is a large + * number small of memory allocations. + */ + PooledAllocator pool; + + /** + * Memory occupied by the index. + */ + int memoryCounter; + + + typedef void (KMeansIndex::*centersAlgFunction)(int, int*, int, int*, int&); + + /** + * The function used for choosing the cluster centers. + */ centersAlgFunction chooseCenters; /** - * Chooses the initial centers in the k-means clustering in a random manner. - * - * Params: - * k = number of centers - * vecs = the dataset of points - * indices = indices in the dataset - * indices_length = length of indices vector - * - */ + * Chooses the initial centers in the k-means clustering in a random manner. + * + * Params: + * k = number of centers + * vecs = the dataset of points + * indices = indices in the dataset + * indices_length = length of indices vector + * + */ void chooseCentersRandom(int k, int* indices, int indices_length, int* centers, int& centers_length) { UniqueRandom r(indices_length); int index; - for (index=0; index& inputData, const IndexParams& params = KMeansIndexParams(), - Distance d = Distance()) - : dataset_(inputData), index_params_(params), root_(NULL), indices_(NULL), distance_(d) - { - memoryCounter_ = 0; - - size_ = dataset_.rows; - veclen_ = dataset_.cols; - - branching_ = get_param(params,"branching",32); - iterations_ = get_param(params,"iterations",11); - if (iterations_<0) { - iterations_ = (std::numeric_limits::max)(); + /** + * Index constructor + * + * Params: + * inputData = dataset with the input features + * params = parameters passed to the hierarchical k-means algorithm + */ + KMeansIndex(const Matrix& inputData, const KMeansIndexParams& params = KMeansIndexParams() ) + : dataset(inputData), index_params(params), root(NULL), indices(NULL) + { + memoryCounter = 0; + + size_ = dataset.rows; + veclen_ = dataset.cols; + + branching = params.branching; + max_iter = params.iterations; + if (max_iter<0) { + max_iter = (std::numeric_limits::max)(); } - centers_init_ = get_param(params,"centers_init",FLANN_CENTERS_RANDOM); + flann_centers_init_t centersInit = params.centers_init; - if (centers_init_==FLANN_CENTERS_RANDOM) { - chooseCenters = &KMeansIndex::chooseCentersRandom; - } - else if (centers_init_==FLANN_CENTERS_GONZALES) { - chooseCenters = &KMeansIndex::chooseCentersGonzales; - } - else if (centers_init_==FLANN_CENTERS_KMEANSPP) { - chooseCenters = &KMeansIndex::chooseCentersKMeanspp; + if (centersInit==FLANN_CENTERS_RANDOM) { + chooseCenters = &KMeansIndex::chooseCentersRandom; } - else { - throw FLANNException("Unknown algorithm for choosing initial centers."); + else if (centersInit==FLANN_CENTERS_GONZALES) { + chooseCenters = &KMeansIndex::chooseCentersGonzales; } - cb_index_ = 0.4f; - - } - - - KMeansIndex(const KMeansIndex&); - KMeansIndex& operator=(const KMeansIndex&); - - - /** - * Index destructor. - * - * Release the memory used by the index. - */ - virtual ~KMeansIndex() - { - if (root_ != NULL) { - free_centers(root_); + else if (centersInit==FLANN_CENTERS_KMEANSPP) { + chooseCenters = &KMeansIndex::chooseCentersKMeanspp; } - if (indices_!=NULL) { - delete[] indices_; + else { + throw FLANNException("Unknown algorithm for choosing initial centers."); + } + cb_index = 0.4f; + + } + + + /** + * Index destructor. + * + * Release the memory used by the index. + */ + virtual ~KMeansIndex() + { + if (root != NULL) { + free_centers(root); + } + if (indices!=NULL) { + delete[] indices; } - } + } /** - * Returns size of index. - */ - size_t size() const + * Returns size of index. + */ + size_t size() const { return size_; } /** - * Returns the length of an index feature. - */ + * Returns the length of an index feature. + */ size_t veclen() const { return veclen_; @@ -343,73 +453,67 @@ public: void set_cb_index( float index) { - cb_index_ = index; + cb_index = index; } - /** - * Computes the inde memory usage - * Returns: memory used by the index - */ - int usedMemory() const - { - return pool_.usedMemory+pool_.wastedMemory+memoryCounter_; - } - /** - * Builds the index - */ - void buildIndex() - { - if (branching_<2) { - throw FLANNException("Branching factor must be at least 2"); - } + /** + * Computes the inde memory usage + * Returns: memory used by the index + */ + int usedMemory() const + { + return pool.usedMemory+pool.wastedMemory+memoryCounter; + } - indices_ = new int[size_]; - for (size_t i=0; i(); - computeNodeStatistics(root_, indices_, (int)size_); - computeClustering(root_, indices_, (int)size_, branching_,0); - } + indices = new int[size_]; + for (size_t i=0;i(); + computeNodeStatistics(root, indices, (int)size_); + computeClustering(root, indices, (int)size_, branching,0); + } void saveIndex(FILE* stream) { - save_value(stream, branching_); - save_value(stream, iterations_); - save_value(stream, memoryCounter_); - save_value(stream, cb_index_); - save_value(stream, *indices_, (int)size_); + save_value(stream, branching); + save_value(stream, max_iter); + save_value(stream, memoryCounter); + save_value(stream, cb_index); + save_value(stream, *indices, (int)size_); - save_tree(stream, root_); + save_tree(stream, root); } void loadIndex(FILE* stream) { - load_value(stream, branching_); - load_value(stream, iterations_); - load_value(stream, memoryCounter_); - load_value(stream, cb_index_); - if (indices_!=NULL) { - delete[] indices_; - } - indices_ = new int[size_]; - load_value(stream, *indices_, size_); - - if (root_!=NULL) { - free_centers(root_); - } - load_tree(stream, root_); - - index_params_["algorithm"] = getType(); - index_params_["branching"] = branching_; - index_params_["iterations"] = iterations_; - index_params_["centers_init"] = centers_init_; - index_params_["cb_index"] = cb_index_; - + load_value(stream, branching); + load_value(stream, max_iter); + load_value(stream, memoryCounter); + load_value(stream, cb_index); + if (indices!=NULL) { + delete[] indices; + } + indices = new int[size_]; + load_value(stream, *indices, (int)size_); + + if (root!=NULL) { + free_centers(root); + } + load_tree(stream, root); } @@ -422,24 +526,25 @@ public: * vec = the vector for which to search the nearest neighbors * searchParams = parameters that influence the search algorithm (checks, cb_index) */ - void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) + void findNeighbors(ResultSet& result, const ELEM_TYPE* vec, const SearchParams& searchParams) { - int maxChecks = get_param(searchParams,"checks",32); + int maxChecks = searchParams.checks; - if (maxChecks==FLANN_CHECKS_UNLIMITED) { - findExactNN(root_, result, vec); + if (maxChecks<0) { + findExactNN(root, result, vec); } else { - // Priority queue storing intermediate branches in the best-bin-first search + // Priority queue storing intermediate branches in the best-bin-first search Heap* heap = new Heap((int)size_); int checks = 0; - findNN(root_, result, vec, checks, maxChecks, heap); + + findNN(root, result, vec, checks, maxChecks, heap); BranchSt branch; while (heap->popMin(branch) && (checks& centers) + int getClusterCenters(Matrix& centers) { int numClusters = centers.rows; if (numClusters<1) { throw FLANNException("Number of clusters must be at least 1"); } - DistanceType variance; - KMeansNodePtr* clusters = new KMeansNodePtr[numClusters]; + float variance; + KMeansNode* clusters = new KMeansNode[numClusters]; - int clusterCount = getMinVarianceClusters(root_, clusters, numClusters, variance); + int clusterCount = getMinVarianceClusters(root, clusters, numClusters, variance); - Logger::info("Clusters requested: %d, returning %d\n",numClusters, clusterCount); +// logger().info("Clusters requested: %d, returning %d\n",numClusters, clusterCount); - for (int i=0; ipivot; - for (size_t j=0; jpivot; + for (size_t j=0;j BranchSt; + KMeansIndex& operator=(const KMeansIndex&); + KMeansIndex(const KMeansIndex&); - - - - void save_tree(FILE* stream, KMeansNodePtr node) + void save_tree(FILE* stream, KMeansNode node) { - save_value(stream, *node); - save_value(stream, *(node->pivot), (int)veclen_); - if (node->childs==NULL) { - int indices_offset = (int)(node->indices - indices_); - save_value(stream, indices_offset); - } - else { - for(int i=0; ichilds[i]); - } - } + save_value(stream, *node); + save_value(stream, *(node->pivot), (int)veclen_); + if (node->childs==NULL) { + int indices_offset = (int)(node->indices - indices); + save_value(stream, indices_offset); + } + else { + for(int i=0; ichilds[i]); + } + } } - void load_tree(FILE* stream, KMeansNodePtr& node) + void load_tree(FILE* stream, KMeansNode& node) { - node = pool_.allocate(); - load_value(stream, *node); - node->pivot = new DistanceType[veclen_]; - load_value(stream, *(node->pivot), (int)veclen_); - if (node->childs==NULL) { - int indices_offset; - load_value(stream, indices_offset); - node->indices = indices_ + indices_offset; - } - else { - node->childs = pool_.allocate(branching_); - for(int i=0; ichilds[i]); - } - } + node = pool.allocate(); + load_value(stream, *node); + node->pivot = new DIST_TYPE[veclen_]; + load_value(stream, *(node->pivot), (int)veclen_); + if (node->childs==NULL) { + int indices_offset; + load_value(stream, indices_offset); + node->indices = indices + indices_offset; + } + else { + node->childs = pool.allocate(branching); + for(int i=0; ichilds[i]); + } + } } /** - * Helper function - */ - void free_centers(KMeansNodePtr node) + * Helper function + */ + void free_centers(KMeansNode node) { delete[] node->pivot; if (node->childs!=NULL) { - for (int k=0; kchilds[k]); } } } - /** - * Computes the statistics of a node (mean, radius, variance). - * - * Params: - * node = the node to use - * indices = the indices of the points belonging to the node - */ - void computeNodeStatistics(KMeansNodePtr node, int* indices, int indices_length) - { - - DistanceType radius = 0; - DistanceType variance = 0; - DistanceType* mean = new DistanceType[veclen_]; - memoryCounter_ += int(veclen_*sizeof(DistanceType)); - - memset(mean,0,veclen_*sizeof(DistanceType)); - - for (size_t i=0; i(), veclen_); - } - for (size_t j=0; j(), veclen_); - - DistanceType tmp = 0; - for (int i=0; iradius) { - radius = tmp; - } - } - - node->variance = variance; - node->radius = radius; - node->pivot = mean; - } - - - /** - * The method responsible with actually doing the recursive hierarchical - * clustering - * - * Params: - * node = the node to cluster - * indices = indices of the points belonging to the current node - * branching = the branching factor to use in the clustering - * - * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point) - */ - void computeClustering(KMeansNodePtr node, int* indices, int indices_length, int branching, int level) - { - node->size = indices_length; - node->level = level; - - if (indices_length < branching) { - node->indices = indices; + variance += flann_dist(vec,vec+veclen_,zero()); + } + for (size_t j=0;jradius) { + radius = tmp; + } + } + + node->variance = (DIST_TYPE)variance; + node->radius = (DIST_TYPE)radius; + node->pivot = mean; + } + + + /** + * The method responsible with actually doing the recursive hierarchical + * clustering + * + * Params: + * node = the node to cluster + * indices = indices of the points belonging to the current node + * branching = the branching factor to use in the clustering + * + * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point) + */ + void computeClustering(KMeansNode node, int* indices, int indices_length, int branching, int level) + { + node->size = indices_length; + node->level = level; + + if (indices_length < branching) { + node->indices = indices; std::sort(node->indices,node->indices+indices_length); node->childs = NULL; - return; - } + return; + } - int* centers_idx = new int[branching]; + int* centers_idx = new int[branching]; int centers_length; - (this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length); + (this->*chooseCenters)(branching, indices, indices_length, centers_idx, centers_length); - if (centers_lengthindices = indices; std::sort(node->indices,node->indices+indices_length); node->childs = NULL; - delete [] centers_idx; - return; - } + return; + } - Matrix dcenters(new double[branching*veclen_],branching,veclen_); + Matrix dcenters(new double[branching*veclen_],branching,(long)veclen_); for (int i=0; inew_sq_dist) { - belongs_to[i] = j; - sq_dist = new_sq_dist; - } - } + int* belongs_to = new int[indices_length]; + for (int i=0;inew_sq_dist) { + belongs_to[i] = j; + sq_dist = new_sq_dist; + } + } if (sq_dist>radiuses[belongs_to[i]]) { - radiuses[belongs_to[i]] = sq_dist; + radiuses[belongs_to[i]] = (float)sq_dist; } - count[belongs_to[i]]++; - } + count[belongs_to[i]]++; + } - bool converged = false; - int iteration = 0; - while (!converged && iterationnew_sq_dist) { - new_centroid = j; - sq_dist = new_sq_dist; - } - } - if (sq_dist>radiuses[new_centroid]) { - radiuses[new_centroid] = sq_dist; - } - if (new_centroid != belongs_to[i]) { - count[belongs_to[i]]--; - count[new_centroid]++; - belongs_to[i] = new_centroid; - - converged = false; - } - } - - for (int i=0; inew_sq_dist) { + new_centroid = j; + sq_dist = new_sq_dist; + } + } + if (sq_dist>radiuses[new_centroid]) { + radiuses[new_centroid] = sq_dist; + } + if (new_centroid != belongs_to[i]) { + count[belongs_to[i]]--; + count[new_centroid]++; + belongs_to[i] = new_centroid; + + converged = false; + } + } + + for (int i=0;ichilds = pool_.allocate(branching); - int start = 0; - int end = start; - for (int c=0; c(), veclen_); - variance += d; - mean_radius += sqrt(d); + } + + + // compute kmeans clustering for each of the resulting clusters + node->childs = pool.allocate(branching); + int start = 0; + int end = start; + for (int c=0;c(), veclen_); - - node->childs[c] = pool_.allocate(); - 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[] dcenters.data; - delete[] centers; - delete[] radiuses; - delete[] count; - delete[] belongs_to; - } - - - - /** - * Performs one descent in the hierarchical k-means tree. The branches not - * visited are stored in a priority queue. + end++; + } + } + variance /= s; + mean_radius /= s; + variance -= flann_dist(centers[c],centers[c]+veclen_,zero()); + + node->childs[c] = pool.allocate(); + node->childs[c]->radius = radiuses[c]; + node->childs[c]->pivot = centers[c]; + node->childs[c]->variance = (float)variance; + node->childs[c]->mean_radius = (float)mean_radius; + node->childs[c]->indices = NULL; + computeClustering(node->childs[c],indices+start, end-start, branching, level+1); + start=end; + } + + delete[] dcenters.data; + delete[] centers; + delete[] radiuses; + delete[] count; + delete[] belongs_to; + } + + + + /** + * Performs one descent in the hierarchical k-means tree. The branches not + * visited are stored in a priority queue. * * Params: * node = node to explore @@ -837,279 +898,218 @@ private: */ - void findNN(KMeansNodePtr node, ResultSet& result, const ElementType* vec, int& checks, int maxChecks, - Heap* heap) - { - // Ignore those clusters that are too far away - { - DistanceType bsq = distance_(vec, node->pivot, veclen_); - DistanceType rsq = node->radius; - DistanceType wsq = result.worstDist(); - - DistanceType val = bsq-rsq-wsq; - DistanceType val2 = val*val-4*rsq*wsq; - - //if (val>0) { - if ((val>0)&&(val2>0)) { - return; - } - } + void findNN(KMeansNode node, ResultSet& result, const ELEM_TYPE* vec, int& checks, int maxChecks, + Heap* heap) + { + // Ignore those clusters that are too far away + { + DIST_TYPE bsq = (DIST_TYPE)flann_dist(vec, vec+veclen_, node->pivot); + DIST_TYPE rsq = node->radius; + DIST_TYPE wsq = result.worstDist(); + + DIST_TYPE val = bsq-rsq-wsq; + DIST_TYPE val2 = val*val-4*rsq*wsq; + + //if (val>0) { + if (val>0 && val2>0) { + return; + } + } - if (node->childs==NULL) { + if (node->childs==NULL) { if (checks>=maxChecks) { if (result.full()) return; } checks += node->size; - for (int i=0; isize; ++i) { - int index = node->indices[i]; - DistanceType dist = distance_(dataset_[index], vec, veclen_); - result.addPoint(dist, index); - } - } - else { - DistanceType* domain_distances = new DistanceType[branching_]; - int closest_center = exploreNodeBranches(node, vec, domain_distances, heap); - delete[] domain_distances; - findNN(node->childs[closest_center],result,vec, checks, maxChecks, heap); - } - } - - /** - * Helper function that computes the nearest childs of a node to a given query point. - * Params: - * node = the node - * q = the query point - * distances = array with the distances to each child node. - * Returns: - */ - int exploreNodeBranches(KMeansNodePtr node, const ElementType* q, DistanceType* domain_distances, Heap* heap) - { - - int best_index = 0; - domain_distances[best_index] = distance_(q, node->childs[best_index]->pivot, veclen_); - for (int i=1; ichilds[i]->pivot, veclen_); - if (domain_distances[i]childs[best_index]->pivot; - for (int i=0; ichilds[i]->variance; - - // float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q); - // if (domain_distances[i]insert(BranchSt(node->childs[i],domain_distances[i])); - } - } - - return best_index; - } - - - /** - * Function the performs exact nearest neighbor search by traversing the entire tree. - */ - void findExactNN(KMeansNodePtr node, ResultSet& result, const ElementType* vec) - { - // Ignore those clusters that are too far away - { - DistanceType bsq = distance_(vec, node->pivot, veclen_); - DistanceType rsq = node->radius; - DistanceType wsq = result.worstDist(); - - DistanceType val = bsq-rsq-wsq; - DistanceType val2 = val*val-4*rsq*wsq; - - // if (val>0) { - if ((val>0)&&(val2>0)) { - return; - } - } - - - if (node->childs==NULL) { - for (int i=0; isize; ++i) { - int index = node->indices[i]; - DistanceType dist = distance_(dataset_[index], vec, veclen_); - result.addPoint(dist, index); - } - } - else { - int* sort_indices = new int[branching_]; - - getCenterOrdering(node, vec, sort_indices); - - for (int i=0; ichilds[sort_indices[i]],result,vec); - } - - delete[] sort_indices; - } - } - - - /** - * Helper function. - * - * I computes the order in which to traverse the child nodes of a particular node. - */ - void getCenterOrdering(KMeansNodePtr node, const ElementType* q, int* sort_indices) - { - DistanceType* domain_distances = new DistanceType[branching_]; - for (int i=0; ichilds[i]->pivot, veclen_); - - int j=0; - while (domain_distances[j]j; --k) { - domain_distances[k] = domain_distances[k-1]; - sort_indices[k] = sort_indices[k-1]; - } - domain_distances[j] = dist; - sort_indices[j] = i; - } - delete[] domain_distances; - } - - /** - * Method that computes the squared distance from the query point q - * from inside region with center c to the border between this - * region and the region with center p - */ - DistanceType getDistanceToBorder(DistanceType* p, DistanceType* c, DistanceType* q) - { - DistanceType sum = 0; - DistanceType sum2 = 0; - - for (int i=0; ivariance*root->size; - - while (clusterCount::max)(); - int splitIndex = -1; - - for (int i=0; ichilds != NULL) { - - DistanceType variance = meanVariance - clusters[i]->variance*clusters[i]->size; - - for (int j=0; jchilds[j]->variance*clusters[i]->childs[j]->size; - } - if (variance clusters_length) break; - - meanVariance = minVariance; - - // split node - KMeansNodePtr toSplit = clusters[splitIndex]; - clusters[splitIndex] = toSplit->childs[0]; - for (int i=1; ichilds[i]; - } - } - - varianceValue = meanVariance/root->size; - return clusterCount; - } - -private: - /** The branching factor used in the hierarchical k-means clustering */ - int branching_; - - /** Maximum number of iterations to use when performing k-means clustering */ - int iterations_; - - /** Algorithm for choosing the cluster centers */ - flann_centers_init_t centers_init_; - - /** - * Cluster border index. This is used in the tree search phase when determining - * the closest cluster to explore next. A zero value takes into account only - * the cluster centres, a value greater then zero also take into account the size - * of the cluster. - */ - float cb_index_; - - /** - * The dataset used by this index - */ - const Matrix dataset_; - - /** Index parameters */ - IndexParams index_params_; - - /** - * Number of features in the dataset. - */ - size_t size_; - - /** - * Length of each feature. - */ - size_t veclen_; - - /** - * The root node in the tree. - */ - KMeansNodePtr root_; - - /** - * Array of indices to vectors in the dataset. - */ - int* indices_; + for (int i=0;isize;++i) { + result.addPoint(dataset[node->indices[i]], node->indices[i]); + } + } + else { + float* domain_distances = new float[branching]; + int closest_center = exploreNodeBranches(node, vec, domain_distances, heap); + delete[] domain_distances; + findNN(node->childs[closest_center],result,vec, checks, maxChecks, heap); + } + } + + /** + * Helper function that computes the nearest childs of a node to a given query point. + * Params: + * node = the node + * q = the query point + * distances = array with the distances to each child node. + * Returns: + */ + int exploreNodeBranches(KMeansNode node, const ELEM_TYPE* q, float* domain_distances, Heap* heap) + { + + int best_index = 0; + domain_distances[best_index] = (float)flann_dist(q,q+veclen_,node->childs[best_index]->pivot); + for (int i=1;ichilds[i]->pivot); + if (domain_distances[i]childs[best_index]->pivot; + for (int i=0;ichilds[i]->variance; + +// float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q); +// if (domain_distances[i]insert(BranchSt::make_branch(node->childs[i],domain_distances[i])); + } + } + + return best_index; + } + + + /** + * Function the performs exact nearest neighbor search by traversing the entire tree. + */ + void findExactNN(KMeansNode node, ResultSet& result, const ELEM_TYPE* vec) + { + // Ignore those clusters that are too far away + { + float bsq = (float)flann_dist(vec, vec+veclen_, node->pivot); + float rsq = node->radius; + float wsq = result.worstDist(); + + float val = bsq-rsq-wsq; + float val2 = val*val-4*rsq*wsq; + + // if (val>0) { + if (val>0 && val2>0) { + return; + } + } + + + if (node->childs==NULL) { + for (int i=0;isize;++i) { + result.addPoint(dataset[node->indices[i]], node->indices[i]); + } + } + else { + int* sort_indices = new int[branching]; + + getCenterOrdering(node, vec, sort_indices); + + for (int i=0; ichilds[sort_indices[i]],result,vec); + } + + delete[] sort_indices; + } + } + + + /** + * Helper function. + * + * I computes the order in which to traverse the child nodes of a particular node. + */ + void getCenterOrdering(KMeansNode node, const ELEM_TYPE* q, int* sort_indices) + { + float* domain_distances = new float[branching]; + for (int i=0;ichilds[i]->pivot); + + int j=0; + while (domain_distances[j]j;--k) { + domain_distances[k] = domain_distances[k-1]; + sort_indices[k] = sort_indices[k-1]; + } + domain_distances[j] = dist; + sort_indices[j] = i; + } + delete[] domain_distances; + } + + /** + * Method that computes the squared distance from the query point q + * from inside region with center c to the border between this + * region and the region with center p + */ + float getDistanceToBorder(float* p, float* c, float* q) + { + float sum = 0; + float sum2 = 0; + + for (int i=0;ivariance*root->size; + + while (clusterCount::max)(); + int splitIndex = -1; + + for (int i=0;ichilds != NULL) { + + float variance = meanVariance - clusters[i]->variance*clusters[i]->size; + + for (int j=0;jchilds[j]->variance*clusters[i]->childs[j]->size; + } + if (variance clusters_length) break; + + meanVariance = minVariance; + + // split node + KMeansNode toSplit = clusters[splitIndex]; + clusters[splitIndex] = toSplit->childs[0]; + for (int i=1;ichilds[i]; + } + } + + varianceValue = meanVariance/root->size; + return clusterCount; + } +}; - /** - * The distance - */ - Distance distance_; - /** - * Pooled memory allocator. - */ - PooledAllocator pool_; - /** - * Memory occupied by the index. - */ - int memoryCounter_; -}; +//register_index(KMEANS,KMeansTree) -} +} // namespace cvflann -#endif //OPENCV_FLANN_KMEANS_INDEX_H_ +#endif //_OPENCV_KMEANSTREE_H_ diff --git a/modules/flann/include/opencv2/flann/linear_index.h b/modules/flann/include/opencv2/flann/linear_index.h index ecb99f2..3a17ade 100644 --- a/modules/flann/include/opencv2/flann/linear_index.h +++ b/modules/flann/include/opencv2/flann/linear_index.h @@ -28,40 +28,41 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_LINEAR_INDEX_H_ -#define OPENCV_FLANN_LINEAR_INDEX_H_ +#ifndef _OPENCV_LINEARSEARCH_H_ +#define _OPENCV_LINEARSEARCH_H_ + +#include "opencv2/flann/general.h" +#include "opencv2/flann/nn_index.h" -#include "general.h" -#include "nn_index.h" namespace cvflann { -struct LinearIndexParams : public IndexParams -{ - LinearIndexParams() - { - (* this)["algorithm"] = FLANN_INDEX_LINEAR; - } +struct CV_EXPORTS LinearIndexParams : public IndexParams { + LinearIndexParams() : IndexParams(FLANN_INDEX_LINEAR) {}; + + void print() const + { + logger().info("Index type: %d\n",(int)algorithm); + } }; -template -class LinearIndex : public NNIndex -{ -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; +template ::type > +class LinearIndex : public NNIndex +{ + const Matrix dataset; + const LinearIndexParams& index_params; + LinearIndex(const LinearIndex&); + LinearIndex& operator=(const LinearIndex&); - LinearIndex(const Matrix& inputData, const IndexParams& params = LinearIndexParams(), - Distance d = Distance()) : - dataset_(inputData), index_params_(params), distance_(d) - { - } +public: - LinearIndex(const LinearIndex&); - LinearIndex& operator=(const LinearIndex&); + LinearIndex(const Matrix& inputData, const LinearIndexParams& params = LinearIndexParams() ) : + dataset(inputData), index_params(params) + { + } flann_algorithm_t getType() const { @@ -69,64 +70,52 @@ public: } - size_t size() const - { - return dataset_.rows; - } + size_t size() const + { + return dataset.rows; + } - size_t veclen() const - { - return dataset_.cols; - } + size_t veclen() const + { + return dataset.cols; + } - int usedMemory() const - { - return 0; - } + int usedMemory() const + { + return 0; + } - void buildIndex() - { - /* nothing to do here for linear search */ - } + void buildIndex() + { + /* nothing to do here for linear search */ + } void saveIndex(FILE*) { - /* nothing to do here for linear search */ + /* nothing to do here for linear search */ } void loadIndex(FILE*) { - /* nothing to do here for linear search */ - - index_params_["algorithm"] = getType(); - } - - void findNeighbors(ResultSet& resultSet, const ElementType* vec, const SearchParams& /*searchParams*/) - { - ElementType* data = dataset_.data; - for (size_t i = 0; i < dataset_.rows; ++i, data += dataset_.cols) { - DistanceType dist = distance_(data, vec, dataset_.cols); - resultSet.addPoint(dist, i); - } + /* nothing to do here for linear search */ } - IndexParams getParameters() const - { - return index_params_; - } + void findNeighbors(ResultSet& resultSet, const ELEM_TYPE*, const SearchParams&) + { + for (size_t i=0;i dataset_; - /** Index parameters */ - IndexParams index_params_; - /** Index distance */ - Distance distance_; + const IndexParams* getParameters() const + { + return &index_params; + } }; -} +} // namespace cvflann -#endif // OPENCV_FLANN_LINEAR_INDEX_H_ +#endif // _OPENCV_LINEARSEARCH_H_ diff --git a/modules/flann/include/opencv2/flann/logger.h b/modules/flann/include/opencv2/flann/logger.h index 303f0c9..979756d 100644 --- a/modules/flann/include/opencv2/flann/logger.h +++ b/modules/flann/include/opencv2/flann/logger.h @@ -28,36 +28,40 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef FLANN_LOGGER_H -#define FLANN_LOGGER_H +#ifndef _OPENCV_LOGGER_H_ +#define _OPENCV_LOGGER_H_ -#include +#include #include -#include "defines.h" - - namespace cvflann { - -class Logger + +enum flann_log_level_t { + FLANN_LOG_NONE = 0, + FLANN_LOG_FATAL = 1, + FLANN_LOG_ERROR = 2, + FLANN_LOG_WARN = 3, + FLANN_LOG_INFO = 4 +}; + +class CV_EXPORTS Logger { - Logger() : stream(stdout), logLevel(FLANN_LOG_WARN) {} + FILE* stream; + int logLevel; + +public: + + Logger() : stream(stdout), logLevel(FLANN_LOG_WARN) {}; ~Logger() { - if ((stream!=NULL)&&(stream!=stdout)) { + if (stream!=NULL && stream!=stdout) { fclose(stream); } } - static Logger& instance() - { - static Logger logger; - return logger; - } - - void _setDestination(const char* name) + void setDestination(const char* name) { if (name==NULL) { stream = stdout; @@ -70,61 +74,23 @@ class Logger } } - int _log(int level, const char* fmt, va_list arglist) - { - if (level > logLevel ) return -1; - int ret = vfprintf(stream, fmt, arglist); - return ret; - } + void setLevel(int level) { logLevel = level; } -public: - /** - * Sets the logging level. All messages with lower priority will be ignored. - * @param level Logging level - */ - static void setLevel(int level) { instance().logLevel = level; } - - /** - * Sets the logging destination - * @param name Filename or NULL for console - */ - static void setDestination(const char* name) { instance()._setDestination(name); } - - /** - * Print log message - * @param level Log level - * @param fmt Message format - * @return - */ - static int log(int level, const char* fmt, ...) - { - va_list arglist; - va_start(arglist, fmt); - int ret = instance()._log(level,fmt,arglist); - va_end(arglist); - return ret; - } + int log(int level, const char* fmt, ...); -#define LOG_METHOD(NAME,LEVEL) \ - static int NAME(const char* fmt, ...) \ - { \ - va_list ap; \ - va_start(ap, fmt); \ - int ret = instance()._log(LEVEL, fmt, ap); \ - va_end(ap); \ - return ret; \ - } + int log(int level, const char* fmt, va_list arglist); - LOG_METHOD(fatal, FLANN_LOG_FATAL) - LOG_METHOD(error, FLANN_LOG_ERROR) - LOG_METHOD(warn, FLANN_LOG_WARN) - LOG_METHOD(info, FLANN_LOG_INFO) + int fatal(const char* fmt, ...); -private: - FILE* stream; - int logLevel; + int error(const char* fmt, ...); + + int warn(const char* fmt, ...); + + int info(const char* fmt, ...); }; -} +CV_EXPORTS Logger& logger(); + +} // namespace cvflann -#endif //FLANN_LOGGER_H +#endif //_OPENCV_LOGGER_H_ diff --git a/modules/flann/include/opencv2/flann/lsh_index.h b/modules/flann/include/opencv2/flann/lsh_index.h deleted file mode 100644 index a777990..0000000 --- a/modules/flann/include/opencv2/flann/lsh_index.h +++ /dev/null @@ -1,388 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * THE BSD LICENSE - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. - *************************************************************************/ - -/*********************************************************************** - * Author: Vincent Rabaud - *************************************************************************/ - -#ifndef OPENCV_FLANN_LSH_INDEX_H_ -#define OPENCV_FLANN_LSH_INDEX_H_ - -#include -#include -#include -#include -#include - -#include "general.h" -#include "nn_index.h" -#include "matrix.h" -#include "result_set.h" -#include "heap.h" -#include "lsh_table.h" -#include "allocator.h" -#include "random.h" -#include "saving.h" - -namespace cvflann -{ - -struct LshIndexParams : public IndexParams -{ - LshIndexParams(unsigned int table_number, unsigned int key_size, unsigned int multi_probe_level) - { - (* this)["algorithm"] = FLANN_INDEX_LSH; - // The number of hash tables to use - (*this)["table_number"] = table_number; - // The length of the key in the hash tables - (*this)["key_size"] = key_size; - // Number of levels to use in multi-probe (0 for standard LSH) - (*this)["multi_probe_level"] = multi_probe_level; - } -}; - -/** - * Randomized kd-tree index - * - * Contains the k-d trees and other information for indexing a set of points - * for nearest-neighbor matching. - */ -template -class LshIndex : public NNIndex -{ -public: - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - - /** Constructor - * @param input_data dataset with the input features - * @param params parameters passed to the LSH algorithm - * @param d the distance used - */ - LshIndex(const Matrix& input_data, const IndexParams& params = LshIndexParams(), - Distance d = Distance()) : - dataset_(input_data), index_params_(params), distance_(d) - { - table_number_ = get_param(index_params_,"table_number",12); - key_size_ = get_param(index_params_,"key_size",20); - multi_probe_level_ = get_param(index_params_,"multi_probe_level",2); - - feature_size_ = dataset_.cols; - fill_xor_mask(0, key_size_, multi_probe_level_, xor_masks_); - } - - - LshIndex(const LshIndex&); - LshIndex& operator=(const LshIndex&); - - /** - * Builds the index - */ - void buildIndex() - { - tables_.resize(table_number_); - for (unsigned int i = 0; i < table_number_; ++i) { - lsh::LshTable& table = tables_[i]; - table = lsh::LshTable(feature_size_, key_size_); - - // Add the features to the table - table.add(dataset_); - } - } - - flann_algorithm_t getType() const - { - return FLANN_INDEX_LSH; - } - - - void saveIndex(FILE* stream) - { - save_value(stream,table_number_); - save_value(stream,key_size_); - save_value(stream,multi_probe_level_); - save_value(stream, dataset_); - } - - void loadIndex(FILE* stream) - { - load_value(stream, table_number_); - load_value(stream, key_size_); - load_value(stream, multi_probe_level_); - load_value(stream, dataset_); - // Building the index is so fast we can afford not storing it - buildIndex(); - - index_params_["algorithm"] = getType(); - index_params_["table_number"] = table_number_; - index_params_["key_size"] = key_size_; - index_params_["multi_probe_level"] = multi_probe_level_; - } - - /** - * Returns size of index. - */ - size_t size() const - { - return dataset_.rows; - } - - /** - * Returns the length of an index feature. - */ - size_t veclen() const - { - return feature_size_; - } - - /** - * Computes the index memory usage - * Returns: memory used by the index - */ - int usedMemory() const - { - return dataset_.rows * sizeof(int); - } - - - IndexParams getParameters() const - { - return index_params_; - } - - /** - * \brief Perform k-nearest neighbor search - * \param[in] queries The query points for which to find the nearest neighbors - * \param[out] indices The indices of the nearest neighbors found - * \param[out] dists Distances to the nearest neighbors found - * \param[in] knn Number of nearest neighbors to return - * \param[in] params Search parameters - */ - virtual void knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params) - { - assert(queries.cols == veclen()); - assert(indices.rows >= queries.rows); - assert(dists.rows >= queries.rows); - assert(int(indices.cols) >= knn); - assert(int(dists.cols) >= knn); - - - KNNUniqueResultSet resultSet(knn); - for (size_t i = 0; i < queries.rows; i++) { - resultSet.clear(); - findNeighbors(resultSet, queries[i], params); - if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices[i], dists[i], knn); - else resultSet.copy(indices[i], dists[i], knn); - } - } - - - /** - * Find set of nearest neighbors to vec. Their indices are stored inside - * the result object. - * - * Params: - * result = the result object in which the indices of the nearest-neighbors are stored - * 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& result, const ElementType* vec, const SearchParams& /*searchParams*/) - { - getNeighbors(vec, result); - } - -private: - /** Defines the comparator on score and index - */ - typedef std::pair ScoreIndexPair; - struct SortScoreIndexPairOnSecond - { - bool operator()(const ScoreIndexPair& left, const ScoreIndexPair& right) const - { - return left.second < right.second; - } - }; - - /** Fills the different xor masks to use when getting the neighbors in multi-probe LSH - * @param key the key we build neighbors from - * @param lowest_index the lowest index of the bit set - * @param level the multi-probe level we are at - * @param xor_masks all the xor mask - */ - void fill_xor_mask(lsh::BucketKey key, int lowest_index, unsigned int level, - std::vector& xor_masks) - { - xor_masks.push_back(key); - if (level == 0) return; - for (int index = lowest_index - 1; index >= 0; --index) { - // Create a new key - lsh::BucketKey new_key = key | (1 << index); - fill_xor_mask(new_key, index, level - 1, xor_masks); - } - } - - /** Performs the approximate nearest-neighbor search. - * @param vec the feature to analyze - * @param do_radius flag indicating if we check the radius too - * @param radius the radius if it is a radius search - * @param do_k flag indicating if we limit the number of nn - * @param k_nn the number of nearest neighbors - * @param checked_average used for debugging - */ - void getNeighbors(const ElementType* vec, bool do_radius, float radius, bool do_k, unsigned int k_nn, - float& checked_average) - { - static std::vector score_index_heap; - - if (do_k) { - unsigned int worst_score = std::numeric_limits::max(); - typename std::vector >::const_iterator table = tables_.begin(); - typename std::vector >::const_iterator table_end = tables_.end(); - for (; table != table_end; ++table) { - size_t key = table->getKey(vec); - std::vector::const_iterator xor_mask = xor_masks_.begin(); - std::vector::const_iterator xor_mask_end = xor_masks_.end(); - for (; xor_mask != xor_mask_end; ++xor_mask) { - size_t sub_key = key ^ (*xor_mask); - const lsh::Bucket* bucket = table->getBucketFromKey(sub_key); - if (bucket == 0) continue; - - // Go over each descriptor index - std::vector::const_iterator training_index = bucket->begin(); - std::vector::const_iterator last_training_index = bucket->end(); - DistanceType hamming_distance; - - // Process the rest of the candidates - for (; training_index < last_training_index; ++training_index) { - hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols); - - if (hamming_distance < worst_score) { - // Insert the new element - score_index_heap.push_back(ScoreIndexPair(hamming_distance, training_index)); - std::push_heap(score_index_heap.begin(), score_index_heap.end()); - - if (score_index_heap.size() > (unsigned int)k_nn) { - // Remove the highest distance value as we have too many elements - std::pop_heap(score_index_heap.begin(), score_index_heap.end()); - score_index_heap.pop_back(); - // Keep track of the worst score - worst_score = score_index_heap.front().first; - } - } - } - } - } - } - else { - typename std::vector >::const_iterator table = tables_.begin(); - typename std::vector >::const_iterator table_end = tables_.end(); - for (; table != table_end; ++table) { - size_t key = table->getKey(vec); - std::vector::const_iterator xor_mask = xor_masks_.begin(); - std::vector::const_iterator xor_mask_end = xor_masks_.end(); - for (; xor_mask != xor_mask_end; ++xor_mask) { - size_t sub_key = key ^ (*xor_mask); - const lsh::Bucket* bucket = table->getBucketFromKey(sub_key); - if (bucket == 0) continue; - - // Go over each descriptor index - std::vector::const_iterator training_index = bucket->begin(); - std::vector::const_iterator last_training_index = bucket->end(); - DistanceType hamming_distance; - - // Process the rest of the candidates - for (; training_index < last_training_index; ++training_index) { - // Compute the Hamming distance - hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols); - if (hamming_distance < radius) score_index_heap.push_back(ScoreIndexPair(hamming_distance, training_index)); - } - } - } - } - } - - /** Performs the approximate nearest-neighbor search. - * This is a slower version than the above as it uses the ResultSet - * @param vec the feature to analyze - */ - void getNeighbors(const ElementType* vec, ResultSet& result) - { - typename std::vector >::const_iterator table = tables_.begin(); - typename std::vector >::const_iterator table_end = tables_.end(); - for (; table != table_end; ++table) { - size_t key = table->getKey(vec); - std::vector::const_iterator xor_mask = xor_masks_.begin(); - std::vector::const_iterator xor_mask_end = xor_masks_.end(); - for (; xor_mask != xor_mask_end; ++xor_mask) { - size_t sub_key = key ^ (*xor_mask); - const lsh::Bucket* bucket = table->getBucketFromKey(sub_key); - if (bucket == 0) continue; - - // Go over each descriptor index - std::vector::const_iterator training_index = bucket->begin(); - std::vector::const_iterator last_training_index = bucket->end(); - DistanceType hamming_distance; - - // Process the rest of the candidates - for (; training_index < last_training_index; ++training_index) { - // Compute the Hamming distance - hamming_distance = distance_(vec, dataset_[*training_index], dataset_.cols); - result.addPoint(hamming_distance, *training_index); - } - } - } - } - - /** The different hash tables */ - std::vector > tables_; - - /** The data the LSH tables where built from */ - Matrix dataset_; - - /** The size of the features (as ElementType[]) */ - unsigned int feature_size_; - - IndexParams index_params_; - - /** table number */ - unsigned int table_number_; - /** key size */ - unsigned int key_size_; - /** How far should we look for neighbors in multi-probe LSH */ - unsigned int multi_probe_level_; - - /** The XOR masks to apply to a key to get the neighboring buckets */ - std::vector xor_masks_; - - Distance distance_; -}; -} - -#endif //OPENCV_FLANN_LSH_INDEX_H_ diff --git a/modules/flann/include/opencv2/flann/lsh_table.h b/modules/flann/include/opencv2/flann/lsh_table.h deleted file mode 100644 index c74baab..0000000 --- a/modules/flann/include/opencv2/flann/lsh_table.h +++ /dev/null @@ -1,477 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2009 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2009 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * THE BSD LICENSE - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. - *************************************************************************/ - -/*********************************************************************** - * Author: Vincent Rabaud - *************************************************************************/ - -#ifndef OPENCV_FLANN_LSH_TABLE_H_ -#define OPENCV_FLANN_LSH_TABLE_H_ - -#include -#include -#include -#include -// TODO as soon as we use C++0x, use the code in USE_UNORDERED_MAP -#if USE_UNORDERED_MAP -#include -#else -#include -#endif -#include -#include - -#include "dynamic_bitset.h" -#include "matrix.h" - -namespace cvflann -{ - -namespace lsh -{ - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/** What is stored in an LSH bucket - */ -typedef uint32_t FeatureIndex; -/** The id from which we can get a bucket back in an LSH table - */ -typedef unsigned int BucketKey; - -/** A bucket in an LSH table - */ -typedef std::vector Bucket; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/** POD for stats about an LSH table - */ -struct LshStats -{ - std::vector bucket_sizes_; - size_t n_buckets_; - size_t bucket_size_mean_; - size_t bucket_size_median_; - size_t bucket_size_min_; - size_t bucket_size_max_; - size_t bucket_size_std_dev; - /** Each contained vector contains three value: beginning/end for interval, number of elements in the bin - */ - std::vector > size_histogram_; -}; - -/** Overload the << operator for LshStats - * @param out the streams - * @param stats the stats to display - * @return the streams - */ -inline std::ostream& operator <<(std::ostream& out, const LshStats& stats) -{ - size_t w = 20; - out << "Lsh Table Stats:\n" << std::setw(w) << std::setiosflags(std::ios::right) << "N buckets : " - << stats.n_buckets_ << "\n" << std::setw(w) << std::setiosflags(std::ios::right) << "mean size : " - << std::setiosflags(std::ios::left) << stats.bucket_size_mean_ << "\n" << std::setw(w) - << std::setiosflags(std::ios::right) << "median size : " << stats.bucket_size_median_ << "\n" << std::setw(w) - << std::setiosflags(std::ios::right) << "min size : " << std::setiosflags(std::ios::left) - << stats.bucket_size_min_ << "\n" << std::setw(w) << std::setiosflags(std::ios::right) << "max size : " - << std::setiosflags(std::ios::left) << stats.bucket_size_max_; - - // Display the histogram - out << std::endl << std::setw(w) << std::setiosflags(std::ios::right) << "histogram : " - << std::setiosflags(std::ios::left); - for (std::vector >::const_iterator iterator = stats.size_histogram_.begin(), end = - stats.size_histogram_.end(); iterator != end; ++iterator) out << (*iterator)[0] << "-" << (*iterator)[1] << ": " << (*iterator)[2] << ", "; - - return out; -} - - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/** Lsh hash table. As its key is a sub-feature, and as usually - * the size of it is pretty small, we keep it as a continuous memory array. - * The value is an index in the corpus of features (we keep it as an unsigned - * int for pure memory reasons, it could be a size_t) - */ -template -class LshTable -{ -public: - /** A container of all the feature indices. Optimized for space - */ -#if USE_UNORDERED_MAP - typedef std::unordered_map BucketsSpace; -#else - typedef std::map BucketsSpace; -#endif - - /** A container of all the feature indices. Optimized for speed - */ - typedef std::vector BucketsSpeed; - - /** Default constructor - */ - LshTable() - { - } - - /** Default constructor - * Create the mask and allocate the memory - * @param feature_size is the size of the feature (considered as a ElementType[]) - * @param key_size is the number of bits that are turned on in the feature - */ - LshTable(unsigned int /*feature_size*/, unsigned int /*key_size*/) - { - std::cerr << "LSH is not implemented for that type" << std::endl; - throw; - } - - /** Add a feature to the table - * @param value the value to store for that feature - * @param feature the feature itself - */ - void add(unsigned int value, const ElementType* feature) - { - // Add the value to the corresponding bucket - BucketKey key = getKey(feature); - - switch (speed_level_) { - case kArray: - // That means we get the buckets from an array - buckets_speed_[key].push_back(value); - break; - case kBitsetHash: - // That means we can check the bitset for the presence of a key - key_bitset_.set(key); - buckets_space_[key].push_back(value); - break; - case kHash: - { - // That means we have to check for the hash table for the presence of a key - buckets_space_[key].push_back(value); - break; - } - } - } - - /** Add a set of features to the table - * @param dataset the values to store - */ - void add(Matrix dataset) - { -#if USE_UNORDERED_MAP - if (!use_speed_) buckets_space_.rehash((buckets_space_.size() + dataset.rows) * 1.2); -#endif - // Add the features to the table - for (unsigned int i = 0; i < dataset.rows; ++i) add(i, dataset[i]); - // Now that the table is full, optimize it for speed/space - optimize(); - } - - /** Get a bucket given the key - * @param key - * @return - */ - inline const Bucket* getBucketFromKey(BucketKey key) const - { - // Generate other buckets - switch (speed_level_) { - case kArray: - // That means we get the buckets from an array - return &buckets_speed_[key]; - break; - case kBitsetHash: - // That means we can check the bitset for the presence of a key - if (key_bitset_.test(key)) return &buckets_space_.at(key); - else return 0; - break; - case kHash: - { - // That means we have to check for the hash table for the presence of a key - BucketsSpace::const_iterator bucket_it, bucket_end = buckets_space_.end(); - bucket_it = buckets_space_.find(key); - // Stop here if that bucket does not exist - if (bucket_it == bucket_end) return 0; - else return &bucket_it->second; - break; - } - } - return 0; - } - - /** Compute the sub-signature of a feature - */ - size_t getKey(const ElementType* /*feature*/) const - { - std::cerr << "LSH is not implemented for that type" << std::endl; - throw; - return 1; - } - - /** Get statistics about the table - * @return - */ - LshStats getStats() const; - -private: - /** defines the speed fo the implementation - * kArray uses a vector for storing data - * kBitsetHash uses a hash map but checks for the validity of a key with a bitset - * kHash uses a hash map only - */ - enum SpeedLevel - { - kArray, kBitsetHash, kHash - }; - - /** Initialize some variables - */ - void initialize(size_t key_size) - { - speed_level_ = kHash; - key_size_ = key_size; - } - - /** Optimize the table for speed/space - */ - void optimize() - { - // If we are already using the fast storage, no need to do anything - if (speed_level_ == kArray) return; - - // Use an array if it will be more than half full - if (buckets_space_.size() > (unsigned int)((1 << key_size_) / 2)) { - speed_level_ = kArray; - // Fill the array version of it - buckets_speed_.resize(1 << key_size_); - for (BucketsSpace::const_iterator key_bucket = buckets_space_.begin(); key_bucket != buckets_space_.end(); ++key_bucket) buckets_speed_[key_bucket->first] = key_bucket->second; - - // Empty the hash table - buckets_space_.clear(); - return; - } - - // If the bitset is going to use less than 10% of the RAM of the hash map (at least 1 size_t for the key and two - // for the vector) or less than 512MB (key_size_ <= 30) - if (((std::max(buckets_space_.size(), buckets_speed_.size()) * CHAR_BIT * 3 * sizeof(BucketKey)) / 10 - >= size_t(1 << key_size_)) || (key_size_ <= 32)) { - speed_level_ = kBitsetHash; - key_bitset_.resize(1 << key_size_); - key_bitset_.reset(); - // Try with the BucketsSpace - for (BucketsSpace::const_iterator key_bucket = buckets_space_.begin(); key_bucket != buckets_space_.end(); ++key_bucket) key_bitset_.set(key_bucket->first); - } - else { - speed_level_ = kHash; - key_bitset_.clear(); - } - } - - /** The vector of all the buckets if they are held for speed - */ - BucketsSpeed buckets_speed_; - - /** The hash table of all the buckets in case we cannot use the speed version - */ - BucketsSpace buckets_space_; - - /** What is used to store the data */ - SpeedLevel speed_level_; - - /** If the subkey is small enough, it will keep track of which subkeys are set through that bitset - * That is just a speedup so that we don't look in the hash table (which can be mush slower that checking a bitset) - */ - DynamicBitset key_bitset_; - - /** The size of the sub-signature in bits - */ - unsigned int key_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 - */ - std::vector mask_; -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Specialization for unsigned char - -template<> -inline LshTable::LshTable(unsigned int feature_size, unsigned int subsignature_size) -{ - initialize(subsignature_size); - // Allocate the mask - mask_ = std::vector((size_t)ceil((float)(feature_size * sizeof(char)) / (float)sizeof(size_t)), 0); - - // A bit brutal but fast to code - std::vector indices(feature_size * CHAR_BIT); - for (size_t i = 0; i < feature_size * CHAR_BIT; ++i) indices[i] = i; - std::random_shuffle(indices.begin(), indices.end()); - - // Generate a random set of order of subsignature_size_ bits - for (unsigned int i = 0; i < key_size_; ++i) { - size_t index = indices[i]; - - // Set that bit in the mask - size_t divisor = CHAR_BIT * sizeof(size_t); - size_t idx = index / divisor; //pick the right size_t index - mask_[idx] |= size_t(1) << (index % divisor); //use modulo to find the bit offset - } - - // Set to 1 if you want to display the mask for debug -#if 0 - { - size_t bcount = 0; - BOOST_FOREACH(size_t mask_block, mask_){ - out << std::setw(sizeof(size_t) * CHAR_BIT / 4) << std::setfill('0') << std::hex << mask_block - << std::endl; - bcount += __builtin_popcountll(mask_block); - } - out << "bit count : " << std::dec << bcount << std::endl; - out << "mask size : " << mask_.size() << std::endl; - return out; - } -#endif -} - -/** Return the Subsignature of a feature - * @param feature the feature to analyze - */ -template<> -inline size_t LshTable::getKey(const unsigned char* feature) const -{ - // no need to check if T is dividable by sizeof(size_t) like in the Hamming - // distance computation as we have a mask - const size_t* feature_block_ptr = reinterpret_cast (feature); - - // Figure out the subsignature of the feature - // Given the feature ABCDEF, and the mask 001011, the output will be - // 000CEF - size_t subsignature = 0; - size_t bit_index = 1; - - for (std::vector::const_iterator pmask_block = mask_.begin(); pmask_block != mask_.end(); ++pmask_block) { - // get the mask and signature blocks - size_t feature_block = *feature_block_ptr; - size_t mask_block = *pmask_block; - while (mask_block) { - // Get the lowest set bit in the mask block - size_t lowest_bit = mask_block & (-(ptrdiff_t)mask_block); - // Add it to the current subsignature if necessary - subsignature += (feature_block & lowest_bit) ? bit_index : 0; - // Reset the bit in the mask block - mask_block ^= lowest_bit; - // increment the bit index for the subsignature - bit_index <<= 1; - } - // Check the next feature block - ++feature_block_ptr; - } - return subsignature; -} - -template<> -inline LshStats LshTable::getStats() const -{ - LshStats stats; - stats.bucket_size_mean_ = 0; - if ((buckets_speed_.empty()) && (buckets_space_.empty())) { - stats.n_buckets_ = 0; - stats.bucket_size_median_ = 0; - stats.bucket_size_min_ = 0; - stats.bucket_size_max_ = 0; - return stats; - } - - if (!buckets_speed_.empty()) { - for (BucketsSpeed::const_iterator pbucket = buckets_speed_.begin(); pbucket != buckets_speed_.end(); ++pbucket) { - stats.bucket_sizes_.push_back(pbucket->size()); - stats.bucket_size_mean_ += pbucket->size(); - } - stats.bucket_size_mean_ /= buckets_speed_.size(); - stats.n_buckets_ = buckets_speed_.size(); - } - else { - for (BucketsSpace::const_iterator x = buckets_space_.begin(); x != buckets_space_.end(); ++x) { - stats.bucket_sizes_.push_back(x->second.size()); - stats.bucket_size_mean_ += x->second.size(); - } - stats.bucket_size_mean_ /= buckets_space_.size(); - stats.n_buckets_ = buckets_space_.size(); - } - - std::sort(stats.bucket_sizes_.begin(), stats.bucket_sizes_.end()); - - // BOOST_FOREACH(int size, stats.bucket_sizes_) - // std::cout << size << " "; - // std::cout << std::endl; - stats.bucket_size_median_ = stats.bucket_sizes_[stats.bucket_sizes_.size() / 2]; - stats.bucket_size_min_ = stats.bucket_sizes_.front(); - stats.bucket_size_max_ = stats.bucket_sizes_.back(); - - // TODO compute mean and std - /*float mean, stddev; - stats.bucket_size_mean_ = mean; - stats.bucket_size_std_dev = stddev;*/ - - // Include a histogram of the buckets - unsigned int bin_start = 0; - unsigned int bin_end = 20; - bool is_new_bin = true; - for (std::vector::iterator iterator = stats.bucket_sizes_.begin(), end = stats.bucket_sizes_.end(); iterator - != end; ) - if (*iterator < bin_end) { - if (is_new_bin) { - stats.size_histogram_.push_back(std::vector(3, 0)); - stats.size_histogram_.back()[0] = bin_start; - stats.size_histogram_.back()[1] = bin_end - 1; - is_new_bin = false; - } - ++stats.size_histogram_.back()[2]; - ++iterator; - } - else { - bin_start += 20; - bin_end += 20; - is_new_bin = true; - } - - return stats; -} - -// End the two namespaces -} -} - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -#endif /* OPENCV_FLANN_LSH_TABLE_H_ */ diff --git a/modules/flann/include/opencv2/flann/matrix.h b/modules/flann/include/opencv2/flann/matrix.h index 51b6c63..170dc6d 100644 --- a/modules/flann/include/opencv2/flann/matrix.h +++ b/modules/flann/include/opencv2/flann/matrix.h @@ -28,58 +28,60 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_DATASET_H_ -#define OPENCV_FLANN_DATASET_H_ +#ifndef _OPENCV_DATASET_H_ +#define _OPENCV_DATASET_H_ #include -#include "general.h" +#include "opencv2/flann/general.h" -namespace cvflann + +namespace cvflann { /** - * Class that implements a simple rectangular matrix stored in a memory buffer and - * provides convenient matrix-like access using the [] operators. - */ +* Class that implements a simple rectangular matrix stored in a memory buffer and +* provides convenient matrix-like access using the [] operators. +*/ template -class Matrix -{ +class Matrix { public: - typedef T type; - size_t rows; size_t cols; - size_t stride; T* data; - Matrix() : rows(0), cols(0), stride(0), data(NULL) + Matrix() : rows(0), cols(0), data(NULL) { } - Matrix(T* data_, size_t rows_, size_t cols_, size_t stride_ = 0) : - rows(rows_), cols(cols_), stride(stride_), data(data_) - { - if (stride==0) stride = cols; - } + Matrix(T* data_, long rows_, long cols_) : + rows(rows_), cols(cols_), data(data_) + { + } /** * Convenience function for deallocating the storage data. */ - FLANN_DEPRECATED void free() + void release() { - fprintf(stderr, "The cvflann::Matrix::free() method is deprecated " - "and it does not do any memory deallocation any more. You are" - "responsible for deallocating the matrix memory (by doing" - "'delete[] matrix.data' for example)"); + if (data!=NULL) delete[] data; } + ~Matrix() + { + } + /** - * Operator that return a (pointer to a) row of the data. - */ + * Operator that return a (pointer to a) row of the data. + */ + T* operator[](size_t index) + { + return data+index*cols; + } + T* operator[](size_t index) const { - return data+index*stride; + return data+index*cols; } }; @@ -93,7 +95,7 @@ public: flann_datatype_t type; UntypedMatrix(void* data_, long rows_, long cols_) : - rows(rows_), cols(cols_), data(data_) + rows(rows_), cols(cols_), data(data_) { } @@ -111,6 +113,6 @@ public: -} +} // namespace cvflann -#endif //OPENCV_FLANN_DATASET_H_ +#endif //_OPENCV_DATASET_H_ diff --git a/modules/flann/include/opencv2/flann/nn_index.h b/modules/flann/include/opencv2/flann/nn_index.h index da4dd7f..081f9af 100644 --- a/modules/flann/include/opencv2/flann/nn_index.h +++ b/modules/flann/include/opencv2/flann/nn_index.h @@ -28,152 +28,79 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef FLANN_NNINDEX_H -#define FLANN_NNINDEX_H +#ifndef _OPENCV_NNINDEX_H_ +#define _OPENCV_NNINDEX_H_ #include -#include "general.h" -#include "matrix.h" -#include "result_set.h" -#include "params.h" +#include "opencv2/flann/general.h" +#include "opencv2/flann/matrix.h" namespace cvflann { + +template +class ResultSet; + /** - * Nearest-neighbour index base class - */ -template +* Nearest-neighbour index base class +*/ +template class NNIndex { - typedef typename Distance::ElementType ElementType; - typedef typename Distance::ResultType DistanceType; - public: - virtual ~NNIndex() {} - - /** - * \brief Builds the index - */ - virtual void buildIndex() = 0; - - /** - * \brief Perform k-nearest neighbor search - * \param[in] queries The query points for which to find the nearest neighbors - * \param[out] indices The indices of the nearest neighbors found - * \param[out] dists Distances to the nearest neighbors found - * \param[in] knn Number of nearest neighbors to return - * \param[in] params Search parameters - */ - virtual void knnSearch(const Matrix& queries, Matrix& indices, Matrix& dists, int knn, const SearchParams& params) - { - assert(queries.cols == veclen()); - assert(indices.rows >= queries.rows); - assert(dists.rows >= queries.rows); - assert(int(indices.cols) >= knn); - assert(int(dists.cols) >= knn); - -#if 0 - KNNResultSet resultSet(knn); - for (size_t i = 0; i < queries.rows; i++) { - resultSet.init(indices[i], dists[i]); - findNeighbors(resultSet, queries[i], params); - } -#else - KNNUniqueResultSet resultSet(knn); - for (size_t i = 0; i < queries.rows; i++) { - resultSet.clear(); - findNeighbors(resultSet, queries[i], params); - if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices[i], dists[i], knn); - else resultSet.copy(indices[i], dists[i], knn); - } -#endif - } - - /** - * \brief Perform radius search - * \param[in] query The query point - * \param[out] indices The indinces of the neighbors found within the given radius - * \param[out] dists The distances to the nearest neighbors found - * \param[in] radius The radius used for search - * \param[in] params Search parameters - * \returns Number of neighbors found - */ - virtual int radiusSearch(const Matrix& query, Matrix& indices, Matrix& dists, float radius, const SearchParams& params) - { - if (query.rows != 1) { - fprintf(stderr, "I can only search one feature at a time for range search\n"); - return -1; - } - assert(query.cols == veclen()); - assert(indices.cols == dists.cols); - - int n = 0; - int* indices_ptr = NULL; - DistanceType* dists_ptr = NULL; - if (indices.cols > 0) { - n = indices.cols; - indices_ptr = indices[0]; - dists_ptr = dists[0]; - } - - RadiusUniqueResultSet resultSet(radius); - resultSet.clear(); - findNeighbors(resultSet, query[0], params); - if (n>0) { - if (get_param(params,"sorted",true)) resultSet.sortAndCopy(indices_ptr, dists_ptr, n); - else resultSet.copy(indices_ptr, dists_ptr, n); - } - - return resultSet.size(); - } - - /** - * \brief Saves the index to a stream - * \param stream The stream to save the index to - */ - virtual void saveIndex(FILE* stream) = 0; - - /** - * \brief Loads the index from a stream - * \param stream The stream from which the index is loaded - */ - virtual void loadIndex(FILE* stream) = 0; - - /** - * \returns number of features in this index. - */ - virtual size_t size() const = 0; - - /** - * \returns The dimensionality of the features in this index. - */ - virtual size_t veclen() const = 0; - - /** - * \returns The amount of memory (in bytes) used by the index. - */ - virtual int usedMemory() const = 0; - - /** - * \returns The index type (kdtree, kmeans,...) - */ - virtual flann_algorithm_t getType() const = 0; - - /** - * \returns The index parameters - */ - virtual IndexParams getParameters() const = 0; - - - /** - * \brief Method that searches for nearest-neighbours - */ - virtual void findNeighbors(ResultSet& result, const ElementType* vec, const SearchParams& searchParams) = 0; + virtual ~NNIndex() {}; + + /** + Method responsible with building the index. + */ + virtual void buildIndex() = 0; + + /** + Saves the index to a stream + */ + virtual void saveIndex(FILE* stream) = 0; + + /** + Loads the index from a stream + */ + virtual void loadIndex(FILE* stream) = 0; + + /** + Method that searches for nearest-neighbors + */ + virtual void findNeighbors(ResultSet& result, const ELEM_TYPE* vec, const SearchParams& searchParams) = 0; + + /** + Number of features in this index. + */ + virtual size_t size() const = 0; + + /** + The length of each vector in this index. + */ + virtual size_t veclen() const = 0; + + /** + The amount of memory (in bytes) this index uses. + */ + virtual int usedMemory() const = 0; + + /** + * Algorithm name + */ + virtual flann_algorithm_t getType() const = 0; + + /** + * Returns the parameters used for the index + */ + virtual const IndexParams* getParameters() const = 0; + }; -} -#endif //FLANN_NNINDEX_H +} // namespace cvflann + +#endif //_OPENCV_NNINDEX_H_ diff --git a/modules/flann/include/opencv2/flann/object_factory.h b/modules/flann/include/opencv2/flann/object_factory.h index 7f971c5..5c51e0d 100644 --- a/modules/flann/include/opencv2/flann/object_factory.h +++ b/modules/flann/include/opencv2/flann/object_factory.h @@ -28,64 +28,67 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_OBJECT_FACTORY_H_ -#define OPENCV_FLANN_OBJECT_FACTORY_H_ +#ifndef _OPENCV_OBJECT_FACTORY_H_ +#define _OPENCV_OBJECT_FACTORY_H_ +#include "opencv2/core/types_c.h" #include namespace cvflann { -class CreatorNotFound +template +BaseClass* createObject() { -}; + return new DerivedClass(); +} -template +template class ObjectFactory { - typedef ObjectFactory ThisClass; - typedef std::map ObjectRegistry; + typedef BaseClass* (*CreateObjectFunc)(); + std::map object_registry; - // singleton class, private constructor - ObjectFactory() {} + // singleton class, private constructor + //ObjectFactory() {}; public: + typedef typename std::map::iterator Iterator; + + + template + bool register_(UniqueIdType id) + { + if (object_registry.find(id) != object_registry.end()) + return false; + + object_registry[id] = &createObject; + return true; + } + + bool unregister(UniqueIdType id) + { + return (object_registry.erase(id) == 1); + } + + BaseClass* create(UniqueIdType id) + { + Iterator iter = object_registry.find(id); + + if (iter == object_registry.end()) + return NULL; + + return ((*iter).second)(); + } + + /*static ObjectFactory& instance() + { + static ObjectFactory the_factory; + return the_factory; + }*/ - bool subscribe(UniqueIdType id, ObjectCreator creator) - { - if (object_registry.find(id) != object_registry.end()) return false; - - object_registry[id] = creator; - return true; - } - - bool unregister(UniqueIdType id) - { - return object_registry.erase(id) == 1; - } - - ObjectCreator create(UniqueIdType id) - { - typename ObjectRegistry::const_iterator iter = object_registry.find(id); - - if (iter == object_registry.end()) { - throw CreatorNotFound(); - } - - return iter->second; - } - - static ThisClass& instance() - { - static ThisClass the_factory; - return the_factory; - } -private: - ObjectRegistry object_registry; }; -} +} // namespace cvflann -#endif /* OPENCV_FLANN_OBJECT_FACTORY_H_ */ +#endif /* OBJECT_FACTORY_H_ */ diff --git a/modules/flann/include/opencv2/flann/params.h b/modules/flann/include/opencv2/flann/params.h deleted file mode 100644 index 9f3a468..0000000 --- a/modules/flann/include/opencv2/flann/params.h +++ /dev/null @@ -1,97 +0,0 @@ -/*********************************************************************** - * Software License Agreement (BSD License) - * - * Copyright 2008-2011 Marius Muja (mariusm@cs.ubc.ca). All rights reserved. - * Copyright 2008-2011 David G. Lowe (lowe@cs.ubc.ca). All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. 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. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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_FLANN_PARAMS_H_ -#define OPENCV_FLANN_PARAMS_H_ - -#include "any.h" -#include "general.h" -#include -#include - - -namespace cvflann -{ - -typedef cdiggins::any any; -typedef std::map IndexParams; - -struct SearchParams : public IndexParams -{ - SearchParams(int checks = 32, float eps = 0, bool sorted = true ) - { - // how many leafs to visit when searching for neighbours (-1 for unlimited) - (*this)["checks"] = checks; - // search for eps-approximate neighbours (default: 0) - (*this)["eps"] = eps; - // only for radius search, require neighbours sorted by distance (default: true) - (*this)["sorted"] = sorted; - } -}; - - -template -T get_param(const IndexParams& params, std::string name, const T& default_value) -{ - IndexParams::const_iterator it = params.find(name); - if (it != params.end()) { - return it->second.cast(); - } - else { - return default_value; - } -} - -template -T get_param(const IndexParams& params, std::string name) -{ - IndexParams::const_iterator it = params.find(name); - if (it != params.end()) { - return it->second.cast(); - } - else { - throw FLANNException(std::string("Missing parameter '")+name+std::string("' in the parameters given")); - } -} - -inline void print_params(const IndexParams& params) -{ - IndexParams::const_iterator it; - - for(it=params.begin(); it!=params.end(); ++it) { - std::cout << it->first << " : " << it->second << std::endl; - } -} - - - -} - - -#endif /* OPENCV_FLANN_PARAMS_H_ */ diff --git a/modules/flann/include/opencv2/flann/random.h b/modules/flann/include/opencv2/flann/random.h index b702807..d29a123 100644 --- a/modules/flann/include/opencv2/flann/random.h +++ b/modules/flann/include/opencv2/flann/random.h @@ -28,108 +28,106 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef FLANN_RANDOM_H -#define FLANN_RANDOM_H +#ifndef _OPENCV_RANDOM_H_ +#define _OPENCV_RANDOM_H_ #include #include -#include +#include -#include "general.h" namespace cvflann { /** * Seeds the random number generator - * @param seed Random seed */ -inline void seed_random(unsigned int seed) -{ - srand(seed); -} +CV_EXPORTS void seed_random(unsigned int seed); /* * Generates a random double value. */ -/** - * Generates a random double value. - * @param high Upper limit - * @param low Lower limit - * @return Random double value - */ -inline double rand_double(double high = 1.0, double low = 0) -{ - return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0))); -} +CV_EXPORTS double rand_double(double high = 1.0, double low=0); -/** +/* * Generates a random integer value. - * @param high Upper limit - * @param low Lower limit - * @return Random integer value */ -inline int rand_int(int high = RAND_MAX, int low = 0) -{ - return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0))); -} +CV_EXPORTS int rand_int(int high = RAND_MAX, int low = 0); + /** * Random number generator that returns a distinct number from * the [0,n) interval each time. + * + * TODO: improve on this to use a generator function instead of an + * array of randomly permuted numbers */ -class UniqueRandom +class CV_EXPORTS UniqueRandom { - std::vector vals_; - int size_; - int counter_; + int* vals; + int size; + int counter; public: - /** - * Constructor. - * @param n Size of the interval from which to generate - * @return - */ - UniqueRandom(int n) - { - init(n); - } - - /** - * Initializes the number generator. - * @param n the size of the interval from which to generate random numbers. - */ - void init(int n) - { - // create and initialize an array of size n - vals_.resize(n); - size_ = n; - for (int i = 0; i < size_; ++i) vals_[i] = i; - - // shuffle the elements in the array - std::random_shuffle(vals_.begin(), vals_.end()); - - counter_ = 0; - } - - /** - * Return a distinct random integer in greater or equal to 0 and less - * than 'n' on each call. It should be called maximum 'n' times. - * Returns: a random integer - */ - int next() - { - if (counter_ == size_) { - return -1; - } - else { - return vals_[counter_++]; - } - } + /** + * Constructor. + * Params: + * n = the size of the interval from which to generate + * random numbers. + */ + UniqueRandom(int n) : vals(NULL) { + init(n); + } + + ~UniqueRandom() + { + delete[] vals; + } + + /** + * Initializes the number generator. + * Params: + * n = the size of the interval from which to generate + * random numbers. + */ + void init(int n) + { + // create and initialize an array of size n + if (vals == NULL || n!=size) { + delete[] vals; + size = n; + vals = new int[size]; + } + for(int i=0;i0;--i) { +// int rand = cast(int) (drand48() * n); + int rnd = rand_int(i); + assert(rnd >=0 && rnd < i); + std::swap(vals[i-1], vals[rnd]); + } + + counter = 0; + } + + /** + * Return a distinct random integer in greater or equal to 0 and less + * than 'n' on each call. It should be called maximum 'n' times. + * Returns: a random integer + */ + int next() { + if (counter==size) { + return -1; + } else { + return vals[counter++]; + } + } }; -} - -#endif //FLANN_RANDOM_H - +} // namespace cvflann +#endif //_OPENCV_RANDOM_H_ diff --git a/modules/flann/include/opencv2/flann/result_set.h b/modules/flann/include/opencv2/flann/result_set.h index 047466f..5b1a8e2 100644 --- a/modules/flann/include/opencv2/flann/result_set.h +++ b/modules/flann/include/opencv2/flann/result_set.h @@ -28,516 +28,291 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef FLANN_RESULTSET_H -#define FLANN_RESULTSET_H +#ifndef _OPENCV_RESULTSET_H_ +#define _OPENCV_RESULTSET_H_ + #include -#include -#include #include -#include #include +#include "opencv2/flann/dist.h" + namespace cvflann { /* This record represents a branch point when finding neighbors in - the tree. It contains a record of the minimum distance to the query - point, as well as the node at which the search resumes. - */ + the tree. It contains a record of the minimum distance to the query + point, as well as the node at which the search resumes. +*/ -template -struct BranchStruct -{ - T node; /* Tree node at which search resumes */ - DistanceType mindist; /* Minimum distance to query for all nodes below. */ +template +struct BranchStruct { + T node; /* Tree node at which search resumes */ + float mindistsq; /* Minimum distance to query for all nodes below. */ - BranchStruct() {} - BranchStruct(const T& aNode, DistanceType dist) : node(aNode), mindist(dist) {} + bool operator<(const BranchStruct& rhs) + { + return mindistsq& rhs) const + static BranchStruct make_branch(const T& aNode, float dist) { - return mindist branch; + branch.node = aNode; + branch.mindistsq = dist; + return branch; } }; -template -class ResultSet -{ -public: - virtual ~ResultSet() {} - - virtual bool full() const = 0; - - virtual void addPoint(DistanceType dist, int index) = 0; - virtual DistanceType worstDist() const = 0; -}; -/** - * KNNSimpleResultSet does not ensure that the element it holds are unique. - * Is used in those cases where the nearest neighbour algorithm used does not - * attempt to insert the same element multiple times. - */ -template -class KNNSimpleResultSet : public ResultSet +template +class ResultSet { - int* indices; - DistanceType* dists; - int capacity; - int count; - DistanceType worst_distance_; +protected: public: - KNNSimpleResultSet(int capacity_) : capacity(capacity_), count(0) - { - } - void init(int* indices_, DistanceType* dists_) - { - indices = indices_; - dists = dists_; - count = 0; - worst_distance_ = (std::numeric_limits::max)(); - dists[capacity-1] = worst_distance_; - } - - size_t size() const - { - return count; - } - - bool full() const - { - return count == capacity; - } - - - void addPoint(DistanceType dist, int index) - { - if (dist >= worst_distance_) return; - int i; - for (i=count; i>0; --i) { -#ifdef FLANN_FIRST_MATCH - if ( (dists[i-1]>dist) || ((dist==dists[i-1])&&(indices[i-1]>index)) ) -#else - if (dists[i-1]>dist) -#endif - { - if (i -class KNNResultSet : public ResultSet -{ - int* indices; - DistanceType* dists; - int capacity; - int count; - DistanceType worst_distance_; + virtual void init(const ELEM_TYPE* target_, int veclen_) = 0; -public: - KNNResultSet(int capacity_) : capacity(capacity_), count(0) - { - } + virtual int* getNeighbors() = 0; - void init(int* indices_, DistanceType* dists_) - { - indices = indices_; - dists = dists_; - count = 0; - worst_distance_ = (std::numeric_limits::max)(); - dists[capacity-1] = worst_distance_; - } + virtual float* getDistances() = 0; - size_t size() const - { - return count; - } + virtual size_t size() const = 0; - bool full() const - { - return count == capacity; - } + virtual bool full() const = 0; + virtual bool addPoint(const ELEM_TYPE* point, int index) = 0; - void addPoint(DistanceType dist, int index) - { - if (dist >= worst_distance_) return; - int i; - for (i = count; i > 0; --i) { -#ifdef FLANN_FIRST_MATCH - if ( (dists[i-1]<=dist) && ((dist!=dists[i-1])||(indices[i-1]<=index)) ) -#else - if (dists[i-1]<=dist) -#endif - { - // Check for duplicate indices - int j = i - 1; - while ((j >= 0) && (dists[j] == dist)) { - if (indices[j] == index) { - return; - } - --j; - } - break; - } - } - - if (count < capacity) ++count; - for (int j = count-1; j > i; --j) { - dists[j] = dists[j-1]; - indices[j] = indices[j-1]; - } - dists[i] = dist; - indices[i] = index; - worst_distance_ = dists[capacity-1]; - } + virtual float worstDist() const = 0; - DistanceType worstDist() const - { - return worst_distance_; - } }; -/** - * A result-set class used when performing a radius based search. - */ -template -class RadiusResultSet : public ResultSet +template +class KNNResultSet : public ResultSet { - DistanceType radius; - int* indices; - DistanceType* dists; - size_t capacity; - size_t count; + const ELEM_TYPE* target; + const ELEM_TYPE* target_end; + int veclen; -public: - RadiusResultSet(DistanceType radius_, int* indices_, DistanceType* dists_, int capacity_) : - radius(radius_), indices(indices_), dists(dists_), capacity(capacity_) - { - init(); - } - - ~RadiusResultSet() - { - } - - void init() - { - count = 0; - } - - size_t size() const - { - return count; - } - - bool full() const - { - return true; - } - - void addPoint(DistanceType dist, int index) - { - if (dist0)&&(count < capacity)) { - dists[count] = dist; - indices[count] = index; - } - count++; - } - } - - DistanceType worstDist() const - { - return radius; - } - -}; + int* indices; + float* dists; + int capacity; -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + int count; -/** Class that holds the k NN neighbors - * Faster than KNNResultSet as it uses a binary heap and does not maintain two arrays - */ -template -class UniqueResultSet : public ResultSet -{ public: - struct DistIndex - { - DistIndex(DistanceType dist, unsigned int index) : - dist_(dist), index_(index) - { - } - bool operator<(const DistIndex dist_index) const - { - return (dist_ < dist_index.dist_) || ((dist_ == dist_index.dist_) && index_ < dist_index.index_); - } - DistanceType dist_; - unsigned int index_; - }; - - /** Default cosntructor */ - UniqueResultSet() : - worst_distance_(std::numeric_limits::max()) - { - } + KNNResultSet(int capacity_, ELEM_TYPE* target_ = NULL, int veclen_ = 0 ) : + target(target_), veclen(veclen_), capacity(capacity_), count(0) + { + target_end = target + veclen; + + indices = new int[capacity_]; + dists = new float[capacity_]; + } + + ~KNNResultSet() + { + delete[] indices; + delete[] dists; + } + + void init(const ELEM_TYPE* target_, int veclen_) + { + target = target_; + veclen = veclen_; + target_end = target + veclen; + count = 0; + } - /** Check the status of the set - * @return true if we have k NN - */ - inline bool full() const - { - return is_full_; - } - /** Remove all elements in the set - */ - virtual void clear() = 0; + int* getNeighbors() + { + return indices; + } - /** Copy the set to two C arrays - * @param indices pointer to a C array of indices - * @param dist pointer to a C array of distances - * @param n_neighbors the number of neighbors to copy - */ - virtual void copy(int* indices, DistanceType* dist, int n_neighbors = -1) const + float* getDistances() { - if (n_neighbors < 0) { - for (typename std::set::const_iterator dist_index = dist_indices_.begin(), dist_index_end = - dist_indices_.end(); dist_index != dist_index_end; ++dist_index, ++indices, ++dist) { - *indices = dist_index->index_; - *dist = dist_index->dist_; - } - } - else { - int i = 0; - for (typename std::set::const_iterator dist_index = dist_indices_.begin(), dist_index_end = - dist_indices_.end(); (dist_index != dist_index_end) && (i < n_neighbors); ++dist_index, ++indices, ++dist, ++i) { - *indices = dist_index->index_; - *dist = dist_index->dist_; - } - } + return dists; } - /** Copy the set to two C arrays but sort it according to the distance first - * @param indices pointer to a C array of indices - * @param dist pointer to a C array of distances - * @param n_neighbors the number of neighbors to copy - */ - virtual void sortAndCopy(int* indices, DistanceType* dist, int n_neighbors = -1) const - { - copy(indices, dist, n_neighbors); - } - - /** The number of neighbors in the set - * @return - */ size_t size() const { - return dist_indices_.size(); - } - - /** The distance of the furthest neighbor - * If we don't have enough neighbors, it returns the max possible value - * @return - */ - inline DistanceType worstDist() const - { - return worst_distance_; - } -protected: - /** Flag to say if the set is full */ - bool is_full_; - - /** The worst distance found so far */ - DistanceType worst_distance_; - - /** The best candidates so far */ - std::set dist_indices_; + return count; + } + + bool full() const + { + return count == capacity; + } + + + bool addPoint(const ELEM_TYPE* point, int index) + { + for (int i=0;i=1 && (dists[i]=1 && (dists[i]::max)() : dists[count-1]; + } }; -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** Class that holds the k NN neighbors - * Faster than KNNResultSet as it uses a binary heap and does not maintain two arrays +/** + * A result-set class used when performing a radius based search. */ -template -class KNNUniqueResultSet : public UniqueResultSet +template +class RadiusResultSet : public ResultSet { -public: - /** Constructor - * @param capacity the number of neighbors to store at max - */ - KNNUniqueResultSet(unsigned int capacity) : capacity_(capacity) - { - this->is_full_ = false; - this->clear(); - } + const ELEM_TYPE* target; + const ELEM_TYPE* target_end; + int veclen; - /** Add a possible candidate to the best neighbors - * @param dist distance for that neighbor - * @param index index of that neighbor - */ - inline void addPoint(DistanceType dist, int index) - { - // Don't do anything if we are worse than the worst - if (dist >= worst_distance_) return; - dist_indices_.insert(DistIndex(dist, index)); - - if (is_full_) { - if (dist_indices_.size() > capacity_) { - dist_indices_.erase(*dist_indices_.rbegin()); - worst_distance_ = dist_indices_.rbegin()->dist_; - } - } - else if (dist_indices_.size() == capacity_) { - is_full_ = true; - worst_distance_ = dist_indices_.rbegin()->dist_; - } - } + struct Item { + int index; + float dist; - /** Remove all elements in the set - */ - void clear() - { - dist_indices_.clear(); - worst_distance_ = std::numeric_limits::max(); - is_full_ = false; - } + bool operator<(Item rhs) { + return dist::DistIndex DistIndex; - using UniqueResultSet::is_full_; - using UniqueResultSet::worst_distance_; - using UniqueResultSet::dist_indices_; + std::vector items; + float radius; - /** The number of neighbors to keep */ - unsigned int capacity_; -}; + bool sorted; + int* indices; + float* dists; + size_t count; -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +private: + void resize_vecs() + { + if (items.size()>count) { + if (indices!=NULL) delete[] indices; + if (dists!=NULL) delete[] dists; + count = items.size(); + indices = new int[count]; + dists = new float[count]; + } + } -/** Class that holds the radius nearest neighbors - * It is more accurate than RadiusResult as it is not limited in the number of neighbors - */ -template -class RadiusUniqueResultSet : public UniqueResultSet -{ public: - /** Constructor - * @param capacity the number of neighbors to store at max - */ - RadiusUniqueResultSet(DistanceType radius) : - radius_(radius) - { - is_full_ = true; - } - - /** Add a possible candidate to the best neighbors - * @param dist distance for that neighbor - * @param index index of that neighbor - */ - void addPoint(DistanceType dist, int index) - { - if (dist <= radius_) dist_indices_.insert(DistIndex(dist, index)); - } - - /** Remove all elements in the set - */ - inline void clear() - { - dist_indices_.clear(); + RadiusResultSet(float radius_) : + radius(radius_), indices(NULL), dists(NULL) + { + sorted = false; + items.reserve(16); + count = 0; + } + + ~RadiusResultSet() + { + if (indices!=NULL) delete[] indices; + if (dists!=NULL) delete[] dists; + } + + void init(const ELEM_TYPE* target_, int veclen_) + { + target = target_; + veclen = veclen_; + target_end = target + veclen; + items.clear(); + sorted = false; + } + + int* getNeighbors() + { + if (!sorted) { + sorted = true; + sort_heap(items.begin(), items.end()); + } + resize_vecs(); + for (size_t i=0;i::DistIndex DistIndex; - using UniqueResultSet::dist_indices_; - using UniqueResultSet::is_full_; + bool full() const + { + return true; + } - /** The furthest distance a neighbor can be */ - DistanceType radius_; -}; - -//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/** Class that holds the k NN neighbors within a radius distance - */ -template -class KNNRadiusUniqueResultSet : public KNNUniqueResultSet -{ -public: - /** Constructor - * @param capacity the number of neighbors to store at max - */ - KNNRadiusUniqueResultSet(unsigned int capacity, DistanceType radius) - { - this->capacity_ = capacity; - this->radius_ = radius; - this->dist_indices_.reserve(capacity_); - this->clear(); - } - - /** Remove all elements in the set - */ - void clear() - { - dist_indices_.clear(); - worst_distance_ = radius_; - is_full_ = false; - } -private: - using KNNUniqueResultSet::dist_indices_; - using KNNUniqueResultSet::is_full_; - using KNNUniqueResultSet::worst_distance_; + bool addPoint(const ELEM_TYPE* point, int index) + { + Item it; + it.index = index; + it.dist = (float)flann_dist(target, target_end, point); + if (it.dist<=radius) { + items.push_back(it); + push_heap(items.begin(), items.end()); + return true; + } + return false; + } - /** The maximum number of neighbors to consider */ - unsigned int capacity_; + float worstDist() const + { + return radius; + } - /** The maximum distance of a neighbor */ - DistanceType radius_; }; -} -#endif //FLANN_RESULTSET_H +} // namespace cvflann +#endif //_OPENCV_RESULTSET_H_ diff --git a/modules/flann/include/opencv2/flann/sampling.h b/modules/flann/include/opencv2/flann/sampling.h index fd65150..95f6e15 100644 --- a/modules/flann/include/opencv2/flann/sampling.h +++ b/modules/flann/include/opencv2/flann/sampling.h @@ -27,11 +27,13 @@ *************************************************************************/ -#ifndef OPENCV_FLANN_SAMPLING_H_ -#define OPENCV_FLANN_SAMPLING_H_ +#ifndef _OPENCV_SAMPLING_H_ +#define _OPENCV_SAMPLING_H_ + + +#include "opencv2/flann/matrix.h" +#include "opencv2/flann/random.h" -#include "matrix.h" -#include "random.h" namespace cvflann { @@ -39,43 +41,54 @@ namespace cvflann template Matrix random_sample(Matrix& srcMatrix, long size, bool remove = false) { - Matrix newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols); + UniqueRandom rand((int)srcMatrix.rows); + Matrix newSet(new T[size * srcMatrix.cols], size, (long)srcMatrix.cols); - T* src,* dest; - for (long i=0; i Matrix random_sample(const Matrix& srcMatrix, size_t size) { - UniqueRandom rand(srcMatrix.rows); - Matrix newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols); + UniqueRandom rand((int)srcMatrix.rows); + Matrix newSet(new T[size * srcMatrix.cols], (long)size, (long)srcMatrix.cols); - T* src,* dest; - for (size_t i=0; i #include -#include - -#include "general.h" -#include "nn_index.h" - -#define FLANN_SIGNATURE "FLANN_INDEX" namespace cvflann { +template struct Datatype {}; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_INT8; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_INT16; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_INT32; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_UINT8; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_UINT16; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_UINT32; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT32; } }; +template<> struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT64; } }; -template -struct Datatype {}; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_INT8; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_INT16; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_INT32; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_UINT8; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_UINT16; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_UINT32; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT32; } }; -template<> -struct Datatype { static flann_datatype_t type() { return FLANN_FLOAT64; } }; +CV_EXPORTS const char* FLANN_SIGNATURE(); +CV_EXPORTS const char* FLANN_VERSION(); /** * Structure representing the index header. */ -struct IndexHeader +struct CV_EXPORTS IndexHeader { - char signature[16]; - char version[16]; - flann_datatype_t data_type; - flann_algorithm_t index_type; - size_t rows; - size_t cols; + char signature[16]; + char version[16]; + flann_datatype_t data_type; + flann_algorithm_t index_type; + int rows; + int cols; }; /** @@ -79,20 +69,20 @@ struct IndexHeader * @param stream - Stream to save to * @param index - The index to save */ -template -void save_header(FILE* stream, const NNIndex& index) +template +void save_header(FILE* stream, const NNIndex& index) { - IndexHeader header; - memset(header.signature, 0, sizeof(header.signature)); - strcpy(header.signature, FLANN_SIGNATURE); - memset(header.version, 0, sizeof(header.version)); - strcpy(header.version, FLANN_VERSION); - header.data_type = Datatype::type(); - header.index_type = index.getType(); - header.rows = index.size(); - header.cols = index.veclen(); - - std::fwrite(&header, sizeof(header),1,stream); + IndexHeader header; + memset(header.signature, 0 , sizeof(header.signature)); + strcpy(header.signature, FLANN_SIGNATURE()); + memset(header.version, 0 , sizeof(header.version)); + strcpy(header.version, FLANN_VERSION()); + header.data_type = Datatype::type(); + header.index_type = index.getType(); + header.rows = (int)index.size(); + header.cols = index.veclen(); + + std::fwrite(&header, sizeof(header),1,stream); } @@ -101,84 +91,25 @@ void save_header(FILE* stream, const NNIndex& index) * @param stream - Stream to load from * @return Index header */ -inline IndexHeader load_header(FILE* stream) -{ - IndexHeader header; - int read_size = fread(&header,sizeof(header),1,stream); - - if (read_size!=1) { - throw FLANNException("Invalid index file, cannot read"); - } - - if (strcmp(header.signature,FLANN_SIGNATURE)!=0) { - throw FLANNException("Invalid index file, wrong signature"); - } - - return header; - -} +CV_EXPORTS IndexHeader load_header(FILE* stream); template -void save_value(FILE* stream, const T& value, size_t count = 1) +void save_value(FILE* stream, const T& value, int count = 1) { - fwrite(&value, sizeof(value),count, stream); + fwrite(&value, 1, sizeof(value)*count, stream); } -template -void save_value(FILE* stream, const cvflann::Matrix& value) -{ - fwrite(&value, sizeof(value),1, stream); - fwrite(value.data, sizeof(T),value.rows*value.cols, stream); -} template -void save_value(FILE* stream, const std::vector& value) +void load_value(FILE* stream, T& value, int count = 1) { - size_t size = value.size(); - fwrite(&size, sizeof(size_t), 1, stream); - fwrite(&value[0], sizeof(T), size, stream); + int read_cnt = (int)fread(&value, sizeof(value),count, stream); + if (read_cnt!=count) { + throw FLANNException("Cannot read from file"); + } } -template -void load_value(FILE* stream, T& value, size_t count = 1) -{ - size_t read_cnt = fread(&value, sizeof(value), count, stream); - if (read_cnt != count) { - throw FLANNException("Cannot read from file"); - } -} - -template -void load_value(FILE* stream, cvflann::Matrix& value) -{ - size_t read_cnt = fread(&value, sizeof(value), 1, stream); - if (read_cnt != 1) { - throw FLANNException("Cannot read from file"); - } - value.data = new T[value.rows*value.cols]; - read_cnt = fread(value.data, sizeof(T), value.rows*value.cols, stream); - if (read_cnt != int(value.rows*value.cols)) { - throw FLANNException("Cannot read from file"); - } -} - - -template -void load_value(FILE* stream, std::vector& value) -{ - size_t size; - size_t read_cnt = fread(&size, sizeof(size_t), 1, stream); - if (read_cnt!=1) { - throw FLANNException("Cannot read from file"); - } - value.resize(size); - read_cnt = fread(&value[0], sizeof(T), size, stream); - if (read_cnt!=int(size)) { - throw FLANNException("Cannot read from file"); - } -} - -} +} // namespace cvflann -#endif /* OPENCV_FLANN_SAVING_H_ */ +#endif /* _OPENCV_SAVING_H_ */ diff --git a/modules/flann/include/opencv2/flann/simplex_downhill.h b/modules/flann/include/opencv2/flann/simplex_downhill.h index 145901a..21d3e94 100644 --- a/modules/flann/include/opencv2/flann/simplex_downhill.h +++ b/modules/flann/include/opencv2/flann/simplex_downhill.h @@ -28,20 +28,20 @@ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *************************************************************************/ -#ifndef OPENCV_FLANN_SIMPLEX_DOWNHILL_H_ -#define OPENCV_FLANN_SIMPLEX_DOWNHILL_H_ +#ifndef _OPENCV_SIMPLEX_DOWNHILL_H_ +#define _OPENCV_SIMPLEX_DOWNHILL_H_ namespace cvflann { /** Adds val to array vals (and point to array points) and keeping the arrays sorted by vals. - */ +*/ template void addValue(int pos, float val, float* vals, T* point, T* points, int n) { vals[pos] = val; - for (int i=0; i0 && vals[j] float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL ) { @@ -84,7 +84,7 @@ float optimizeSimplexDownhill(T* points, int n, F func, float* vals = NULL ) if (vals == NULL) { ownVals = true; vals = new float[n+1]; - for (int i=0; i MAX_ITERATIONS) break; // compute average of simplex points (except the highest point) - for (int j=0; j=vals[0])&&(val_r=vals[0] && val_r=vals[n]) { - for (int i=0; i @@ -42,7 +42,7 @@ namespace cvflann * * Can be used to time portions of code. */ -class StartStopTimer +class CV_EXPORTS StartStopTimer { clock_t startTime; @@ -64,16 +64,14 @@ public: /** * Starts the timer. */ - void start() - { + void start() { startTime = clock(); } /** * Stops the timer and updates timer value. */ - void stop() - { + void stop() { clock_t stopTime = clock(); value += ( (double)stopTime - startTime) / CLOCKS_PER_SEC; } @@ -81,13 +79,12 @@ public: /** * Resets the timer value to 0. */ - void reset() - { + void reset() { value = 0; } }; -} +}// namespace cvflann -#endif // FLANN_TIMER_H +#endif // _OPENCV_TIMER_H_ diff --git a/modules/flann/src/flann.cpp b/modules/flann/src/flann.cpp index 1002d6e..30a82ea 100644 --- a/modules/flann/src/flann.cpp +++ b/modules/flann/src/flann.cpp @@ -28,4 +28,198 @@ #include "precomp.hpp" -void cvflann::dummyfunc() {} +namespace cvflann +{ +// ----------------------- dist.cpp --------------------------- + +/** Global variable indicating the distance metric + * to be used. + */ +flann_distance_t flann_distance_type_ = FLANN_DIST_EUCLIDEAN; +flann_distance_t flann_distance_type() { return flann_distance_type_; } + +/** + * Zero iterator that emulates a zero feature. + */ +ZeroIterator zero_; +ZeroIterator& zero() { return zero_; } + +/** + * Order of Minkowski distance to use. + */ +int flann_minkowski_order_; +int flann_minkowski_order() { return flann_minkowski_order_; } + + +double euclidean_dist(const unsigned char* first1, const unsigned char* last1, unsigned char* first2, double acc) +{ + double distsq = acc; + double diff0, diff1, diff2, diff3; + const unsigned char* lastgroup = last1 - 3; + + while (first1 < lastgroup) { + diff0 = first1[0] - first2[0]; + diff1 = first1[1] - first2[1]; + diff2 = first1[2] - first2[2]; + diff3 = first1[3] - first2[3]; + distsq += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3; + first1 += 4; + first2 += 4; + } + while (first1 < last1) { + diff0 = *first1++ - *first2++; + distsq += diff0 * diff0; + } + return distsq; +} + +// ----------------------- index_testing.cpp --------------------------- + +int countCorrectMatches(int* neighbors, int* groundTruth, int n) +{ + int count = 0; + for (int i=0;i logLevel ) return -1; + + int ret; + va_list arglist; + va_start(arglist, fmt); + ret = vfprintf(stream, fmt, arglist); + va_end(arglist); + + return ret; +} + +int Logger::log(int level, const char* fmt, va_list arglist) +{ + if (level > logLevel ) return -1; + + int ret; + ret = vfprintf(stream, fmt, arglist); + + return ret; +} + + +#define LOG_METHOD(NAME,LEVEL) \ + int Logger::NAME(const char* fmt, ...) \ + { \ + int ret; \ + va_list ap; \ + va_start(ap, fmt); \ + ret = log(LEVEL, fmt, ap); \ + va_end(ap); \ + return ret; \ + } + + +LOG_METHOD(fatal, FLANN_LOG_FATAL) +LOG_METHOD(error, FLANN_LOG_ERROR) +LOG_METHOD(warn, FLANN_LOG_WARN) +LOG_METHOD(info, FLANN_LOG_INFO) + +// ----------------------- random.cpp --------------------------- + +void seed_random(unsigned int seed) +{ + srand(seed); +} + +double rand_double(double high, double low) +{ + return low + ((high-low) * (std::rand() / (RAND_MAX + 1.0))); +} + + +int rand_int(int high, int low) +{ + return low + (int) ( double(high-low) * (std::rand() / (RAND_MAX + 1.0))); +} + +// ----------------------- saving.cpp --------------------------- + +const char FLANN_SIGNATURE_[] = "FLANN_INDEX"; +const char FLANN_VERSION_[] = "1.5.0"; + +const char* FLANN_SIGNATURE() { return FLANN_SIGNATURE_; } +const char* FLANN_VERSION() { return FLANN_VERSION_; } + +IndexHeader load_header(FILE* stream) +{ + IndexHeader header; + size_t read_size = fread(&header,sizeof(header),1,stream); + + if (read_size!=1) { + throw FLANNException("Invalid index file, cannot read"); + } + + if (strcmp(header.signature,FLANN_SIGNATURE())!=0) { + throw FLANNException("Invalid index file, wrong signature"); + } + + return header; + +} + +// ----------------------- flann.cpp --------------------------- + + +void log_verbosity(int level) +{ + if (level>=0) { + logger().setLevel(level); + } +} + +void set_distance_type(flann_distance_t distance_type, int order) +{ + flann_distance_type_ = distance_type; + flann_minkowski_order_ = order; +} + + +static ParamsFactory the_factory; + +ParamsFactory& ParamsFactory_instance() +{ + return the_factory; +} + +class StaticInit +{ +public: + StaticInit() + { + ParamsFactory_instance().register_(FLANN_INDEX_LINEAR); + ParamsFactory_instance().register_(FLANN_INDEX_KDTREE); + ParamsFactory_instance().register_(FLANN_INDEX_KMEANS); + ParamsFactory_instance().register_(FLANN_INDEX_COMPOSITE); + ParamsFactory_instance().register_(FLANN_INDEX_AUTOTUNED); +// ParamsFactory::instance().register_(FLANN_INDEX_SAVED); + } +}; +StaticInit __init; + + +} // namespace cvflann + + + diff --git a/modules/flann/src/precomp.hpp b/modules/flann/src/precomp.hpp index 5b9d10f..8c511ce 100644 --- a/modules/flann/src/precomp.hpp +++ b/modules/flann/src/precomp.hpp @@ -7,7 +7,6 @@ #include "opencv2/flann/dist.h" #include "opencv2/flann/index_testing.h" -#include "opencv2/flann/params.h" #include "opencv2/flann/saving.h" #include "opencv2/flann/general.h" -- 2.7.4