*************************************************************************/
-#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<typename KDTreeCapability, typename VectorSpace, typename Distance>
-struct index_creator
-{
- static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
- {
- flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
-
- NNIndex<Distance>* nnIndex;
- switch (index_type) {
- case FLANN_INDEX_LINEAR:
- nnIndex = new LinearIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_KDTREE_SINGLE:
- nnIndex = new KDTreeSingleIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_KDTREE:
- nnIndex = new KDTreeIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_KMEANS:
- nnIndex = new KMeansIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_COMPOSITE:
- nnIndex = new CompositeIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_AUTOTUNED:
- nnIndex = new AutotunedIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_HIERARCHICAL:
- nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_LSH:
- nnIndex = new LshIndex<Distance>(dataset, params, distance);
- break;
- default:
- throw FLANNException("Unknown index type");
- }
-
- return nnIndex;
- }
-};
-
-template<typename VectorSpace, typename Distance>
-struct index_creator<False,VectorSpace,Distance>
+namespace cvflann
{
- static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
- {
- flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
- NNIndex<Distance>* nnIndex;
- switch (index_type) {
- case FLANN_INDEX_LINEAR:
- nnIndex = new LinearIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_KMEANS:
- nnIndex = new KMeansIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_HIERARCHICAL:
- nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_LSH:
- nnIndex = new LshIndex<Distance>(dataset, params, distance);
- break;
- default:
- throw FLANNException("Unknown index type");
- }
-
- return nnIndex;
- }
-};
-
-template<typename Distance>
-struct index_creator<False,False,Distance>
+template<typename T>
+NNIndex<T>* create_index_by_type(const Matrix<T>& dataset, const IndexParams& params)
{
- static NNIndex<Distance>* create(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
- {
- flann_algorithm_t index_type = get_param<flann_algorithm_t>(params, "algorithm");
-
- NNIndex<Distance>* nnIndex;
- switch (index_type) {
- case FLANN_INDEX_LINEAR:
- nnIndex = new LinearIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_HIERARCHICAL:
- nnIndex = new HierarchicalClusteringIndex<Distance>(dataset, params, distance);
- break;
- case FLANN_INDEX_LSH:
- nnIndex = new LshIndex<Distance>(dataset, params, distance);
- break;
- default:
- throw FLANNException("Unknown index type");
- }
-
- return nnIndex;
- }
-};
-
-template<typename Distance>
-NNIndex<Distance>* create_index_by_type(const Matrix<typename Distance::ElementType>& dataset, const IndexParams& params, const Distance& distance)
-{
- return index_creator<typename Distance::is_kdtree_distance,
- typename Distance::is_vector_space_distance,
- Distance>::create(dataset, params,distance);
+ flann_algorithm_t index_type = params.getIndexType();
+
+ NNIndex<T>* nnIndex;
+ switch (index_type) {
+ case FLANN_INDEX_LINEAR:
+ nnIndex = new LinearIndex<T>(dataset, (const LinearIndexParams&)params);
+ break;
+ case FLANN_INDEX_KDTREE:
+ nnIndex = new KDTreeIndex<T>(dataset, (const KDTreeIndexParams&)params);
+ break;
+ case FLANN_INDEX_KMEANS:
+ nnIndex = new KMeansIndex<T>(dataset, (const KMeansIndexParams&)params);
+ break;
+ case FLANN_INDEX_COMPOSITE:
+ nnIndex = new CompositeIndex<T>(dataset, (const CompositeIndexParams&) params);
+ break;
+ case FLANN_INDEX_AUTOTUNED:
+ nnIndex = new AutotunedIndex<T>(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_ */
* 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 <stdlib.h>
#include <stdio.h>
-
namespace cvflann
{
template <typename T>
T* allocate(size_t count = 1)
{
- T* mem = (T*) ::malloc(sizeof(T)*count);
- return mem;
+ T* mem = (T*) ::malloc(sizeof(T)*count);
+ return mem;
}
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 <typename T>
- 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_
+++ /dev/null
-#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 <stdexcept>
-#include <ostream>
-
-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<typename T>
-struct typed_base_any_policy : base_any_policy
-{
- virtual size_t get_size() { return sizeof(T); }
-
-};
-
-template<typename T>
-struct small_any_policy : typed_base_any_policy<T>
-{
- virtual void static_delete(void**) { }
- virtual void copy_from_value(void const* src, void** dest)
- {
- new (dest) T(* reinterpret_cast<T const*>(src));
- }
- virtual void clone(void* const* src, void** dest) { *dest = *src; }
- virtual void move(void* const* src, void** dest) { *dest = *src; }
- virtual void* get_value(void** src) { return reinterpret_cast<void*>(src); }
- virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(src); }
-};
-
-template<typename T>
-struct big_any_policy : typed_base_any_policy<T>
-{
- virtual void static_delete(void** x)
- {
- if (* x) delete (* reinterpret_cast<T**>(x)); *x = NULL;
- }
- virtual void copy_from_value(void const* src, void** dest)
- {
- *dest = new T(*reinterpret_cast<T const*>(src));
- }
- virtual void clone(void* const* src, void** dest)
- {
- *dest = new T(**reinterpret_cast<T* const*>(src));
- }
- virtual void move(void* const* src, void** dest)
- {
- (*reinterpret_cast<T**>(dest))->~T();
- **reinterpret_cast<T**>(dest) = **reinterpret_cast<T* const*>(src);
- }
- virtual void* get_value(void** src) { return *src; }
- virtual void print(std::ostream& out, void* const* src) { out << *reinterpret_cast<T const*>(*src); }
-};
-
-template<typename T>
-struct choose_policy
-{
- typedef big_any_policy<T> type;
-};
-
-template<typename T>
-struct choose_policy<T*>
-{
- typedef small_any_policy<T*> 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<any>
-{
- typedef void type;
-};
-
-/// Specializations for small types.
-#define SMALL_POLICY(TYPE) \
- template<> \
- struct choose_policy<TYPE> { typedef small_any_policy<TYPE> 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<typename T>
-base_any_policy* get_policy()
-{
- static typename choose_policy<T>::type policy;
- return &policy;
-}
-} // namespace anyimpl
-
-struct any
-{
-private:
- // fields
- anyimpl::base_any_policy* policy;
- void* object;
-
-public:
- /// Initializing constructor.
- template <typename T>
- any(const T& x)
- : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
- {
- assign(x);
- }
-
- /// Empty constructor.
- any()
- : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
- { }
-
- /// Special initializing constructor for string literals.
- any(const char* x)
- : policy(anyimpl::get_policy<anyimpl::empty_any>()), object(NULL)
- {
- assign(x);
- }
-
- /// Copy constructor.
- any(const any& x)
- : policy(anyimpl::get_policy<anyimpl::empty_any>()), 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 <typename T>
- any& assign(const T& x)
- {
- reset();
- policy = anyimpl::get_policy<T>();
- policy->copy_from_value(&x, &object);
- return *this;
- }
-
- /// Assignment operator.
- template<typename T>
- 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<typename T>
- T& cast()
- {
- if (policy != anyimpl::get_policy<T>()) throw anyimpl::bad_any_cast();
- T* r = reinterpret_cast<T*>(policy->get_value(&object));
- return *r;
- }
-
- /// Cast operator. You can only cast to the original type.
- template<typename T>
- const T& cast() const
- {
- if (policy != anyimpl::get_policy<T>()) throw anyimpl::bad_any_cast();
- T* r = reinterpret_cast<T*>(policy->get_value((void**)&object));
- return *r;
- }
-
- /// Returns true if the any contains no value.
- bool empty() const
- {
- return policy == anyimpl::get_policy<anyimpl::empty_any>();
- }
-
- /// Frees any allocated memory, and sets the value to NULL.
- void reset()
- {
- policy->static_delete(&object);
- policy = anyimpl::get_policy<anyimpl::empty_any>();
- }
-
- /// 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<typename T>
- bool has_type()
- {
- return policy == anyimpl::get_policy<T>();
- }
-
- 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_
* (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<typename Distance>
-NNIndex<Distance>* create_index_by_type(const Matrix<typename Distance::ElementType>& 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 <typename Distance>
-class AutotunedIndex : public NNIndex<Distance>
+template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
+class AutotunedIndex : public NNIndex<ELEM_TYPE>
{
-public:
- typedef typename Distance::ElementType ElementType;
- typedef typename Distance::ResultType DistanceType;
-
- AutotunedIndex(const Matrix<ElementType>& 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<ELEM_TYPE>* 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<int>(bestSearchParams_, "checks"));
- }
+ Matrix<ELEM_TYPE> sampledDataset;
+ Matrix<ELEM_TYPE> testDataset;
+ Matrix<int> 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<Distance>(dataset_, params, distance_);
- bestIndex_->loadIndex(stream);
- int checks;
- load_value(stream, checks);
- bestSearchParams_["checks"] = checks;
- }
+ /**
+ * The dataset used by this index
+ */
+ const Matrix<ELEM_TYPE> dataset;
/**
- * Method that searches for nearest-neighbors
+ * Index parameters
*/
- virtual void findNeighbors(ResultSet<DistanceType>& 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<ELEM_TYPE>& 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<ELEM_TYPE>(dataset, (const LinearIndexParams&)*bestParams);
+ break;
+ case FLANN_INDEX_KDTREE:
+ bestIndex = new KDTreeIndex<ELEM_TYPE>(dataset, (const KDTreeIndexParams&)*bestParams);
+ break;
+ case FLANN_INDEX_KMEANS:
+ bestIndex = new KMeansIndex<ELEM_TYPE>(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<ELEM_TYPE>& 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<CostData, KDTreeIndexParams> KDTreeCostData;
+ typedef std::pair<CostData, KMeansIndexParams> 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<int>(cost.params,"iterations"),
- get_param<int>(cost.params,"branching"));
- KMeansIndex<Distance> kmeans(sampledDataset_, cost.params, distance_);
+ logger().info("KMeansTree using params: max_iterations=%d, branching=%d\n", kmeans_params.iterations, kmeans_params.branching);
+ KMeansIndex<ELEM_TYPE> kmeans(sampledDataset, kmeans_params);
// measure index build time
t.start();
kmeans.buildIndex();
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<int>(cost.params,"trees"));
- KDTreeIndex<Distance> kdtree(sampledDataset_, cost.params, distance_);
+ logger().info("KDTree using params: trees=%d\n",kdtree_params.trees);
+ KDTreeIndex<ELEM_TYPE> kdtree(sampledDataset, kdtree_params);
t.start();
kdtree.buildIndex();
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<float>::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<float>::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<CostData>& costs)
+// struct KMeansSimpleDownhillFunctor {
+//
+// Autotune& autotuner;
+// KMeansSimpleDownhillFunctor(Autotune& autotuner_) : autotuner(autotuner_) {};
+//
+// float operator()(int* params) {
+//
+// float maxFloat = numeric_limits<float>::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<float>::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<KMeansCostData> 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; i<ARRAY_LEN(maxIterations); ++i) {
+ for (size_t j=0; j<ARRAY_LEN(branchingFactors); ++j) {
+
+ kmeansCosts[cnt].second.centers_init = FLANN_CENTERS_RANDOM;
+ kmeansCosts[cnt].second.iterations = maxIterations[i];
+ kmeansCosts[cnt].second.branching = branchingFactors[j];
+
+ evaluate_kmeans(kmeansCosts[cnt].first, kmeansCosts[cnt].second);
+
+ int k = cnt;
+ // order by time cost
+ while (k>0 && 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;i<n+1;++i) {
+// kmeansNMPoints[i*n] = (int)kmeansCosts[i].params["branching"];
+// kmeansNMPoints[i*n+1] = (int)kmeansCosts[i].params["max-iterations"];
+// kmeansVals[i] = kmeansCosts[i].timeCost;
+// }
+// KMeansSimpleDownhillFunctor kmeans_cost_func(*this);
+// // run optimization
+// optimizeSimplexDownhill(kmeansNMPoints,n,kmeans_cost_func,kmeansVals);
+// // store results
+// for (int i=0;i<n+1;++i) {
+// kmeansCosts[i].params["branching"] = kmeansNMPoints[i*2];
+// kmeansCosts[i].params["max-iterations"] = kmeansNMPoints[i*2+1];
+// kmeansCosts[i].timeCost = kmeansVals[i];
+// }
+
+ float optTimeCost = kmeansCosts[0].first.timeCost;
+ // recompute total costs factoring in the memory costs
+ for (int i=0;i<kmeansParamSpaceSize;++i) {
+ kmeansCosts[i].first.totalCost = (kmeansCosts[i].first.timeCost/optTimeCost + index_params.memory_weight * kmeansCosts[i].first.memoryCost);
+
+ int k = i;
+ while (k>0 && 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<kmeansParamSpaceSize;++i) {
+ logger().info("KMeans, branching=%d, iterations=%d, time_cost=%g[%g] (build=%g, search=%g), memory_cost=%g, cost=%g\n",
+ kmeansCosts[i].second.branching, kmeansCosts[i].second.iterations,
+ kmeansCosts[i].first.timeCost,kmeansCosts[i].first.timeCost/optTimeCost,
+ kmeansCosts[i].first.buildTimeCost, kmeansCosts[i].first.searchTimeCost,
+ kmeansCosts[i].first.memoryCost,kmeansCosts[i].first.totalCost);
+ }
- // 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;i<n+1;++i) {
- // kmeansNMPoints[i*n] = (int)kmeansCosts[i].params["branching"];
- // kmeansNMPoints[i*n+1] = (int)kmeansCosts[i].params["max-iterations"];
- // kmeansVals[i] = kmeansCosts[i].timeCost;
- // }
- // KMeansSimpleDownhillFunctor kmeans_cost_func(*this);
- // // run optimization
- // optimizeSimplexDownhill(kmeansNMPoints,n,kmeans_cost_func,kmeansVals);
- // // store results
- // for (int i=0;i<n+1;++i) {
- // kmeansCosts[i].params["branching"] = kmeansNMPoints[i*2];
- // kmeansCosts[i].params["max-iterations"] = kmeansNMPoints[i*2+1];
- // kmeansCosts[i].timeCost = kmeansVals[i];
- // }
+ return kmeansCosts[0];
}
- void optimizeKDTree(std::vector<CostData>& 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<KDTreeCostData> 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; i<ARRAY_LEN(testTrees); ++i) {
+ kdtreeCosts[cnt].second.trees = testTrees[i];
+
+ evaluate_kdtree(kdtreeCosts[cnt].first, kdtreeCosts[cnt].second);
+
+ int k = cnt;
+ // order by time cost
+ while (k>0 && 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;i<n+1;++i) {
+// kdtreeNMPoints[i] = (int)kdtreeCosts[i].params["trees"];
+// kdtreeVals[i] = kdtreeCosts[i].timeCost;
+// }
+// KDTreeSimpleDownhillFunctor kdtree_cost_func(*this);
+// // run optimization
+// optimizeSimplexDownhill(kdtreeNMPoints,n,kdtree_cost_func,kdtreeVals);
+// // store results
+// for (int i=0;i<n+1;++i) {
+// kdtreeCosts[i].params["trees"] = kdtreeNMPoints[i];
+// kdtreeCosts[i].timeCost = kdtreeVals[i];
+// }
+
+ float optTimeCost = kdtreeCosts[0].first.timeCost;
+ // recompute costs for kd-tree factoring in memory cost
+ for (size_t i=0;i<kdtreeParamSpaceSize;++i) {
+ kdtreeCosts[i].first.totalCost = (kdtreeCosts[i].first.timeCost/optTimeCost + index_params.memory_weight * kdtreeCosts[i].first.memoryCost);
+
+ int k = (int)i;
+ while (k>0 && 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<kdtreeParamSpaceSize;++i) {
+ logger().info("kd-tree, trees=%d, time_cost=%g[%g] (build=%g, search=%g), memory_cost=%g, cost=%g\n",
+ kdtreeCosts[i].second.trees,kdtreeCosts[i].first.timeCost,kdtreeCosts[i].first.timeCost/optTimeCost,
+ kdtreeCosts[i].first.buildTimeCost, kdtreeCosts[i].first.searchTimeCost,
+ kdtreeCosts[i].first.memoryCost,kdtreeCosts[i].first.totalCost);
}
- // 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;i<n+1;++i) {
- // kdtreeNMPoints[i] = (int)kdtreeCosts[i].params["trees"];
- // kdtreeVals[i] = kdtreeCosts[i].timeCost;
- // }
- // KDTreeSimpleDownhillFunctor kdtree_cost_func(*this);
- // // run optimization
- // optimizeSimplexDownhill(kdtreeNMPoints,n,kdtree_cost_func,kdtreeVals);
- // // store results
- // for (int i=0;i<n+1;++i) {
- // kdtreeCosts[i].params["trees"] = kdtreeNMPoints[i];
- // kdtreeCosts[i].timeCost = kdtreeVals[i];
- // }
+ return kdtreeCosts[0];
}
/**
- * Chooses the best nearest-neighbor algorithm and estimates the optimal
- * parameters to use when building the index (for a given precision).
- * Returns a dictionary with the optimal parameters.
- */
- IndexParams estimateBuildParams()
+ Chooses the best nearest-neighbor algorithm and estimates the optimal
+ parameters to use when building the index (for a given precision).
+ Returns a dictionary with the optimal parameters.
+ */
+ IndexParams* estimateBuildParams()
{
- std::vector<CostData> 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<int>(new int[testDataset_.rows], testDataset_.rows, 1);
+ logger().info("Computing ground truth... \n");
+ gt_matches = Matrix<int>(new int[testDataset.rows],(long)testDataset.rows, 1);
StartStopTimer t;
t.start();
- compute_ground_truth<Distance>(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<bestCost) {
+ bestParams = new KMeansIndexParams(kmeansCost.second);
+ bestCost = kmeansCost.first.totalCost;
}
- float bestCost = costs[0].searchTimeCost / bestTimeCost;
- IndexParams bestParams = costs[0].params;
- if (bestTimeCost > 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<bestCost) {
+ bestParams = new KDTreeIndexParams(kdtreeCost.second);
+ bestCost = kdtreeCost.first.totalCost;
}
- delete[] gt_matches_.data;
- delete[] testDataset_.data;
- delete[] sampledDataset_.data;
+ gt_matches.release();
+ sampledDataset.release();
+ testDataset.release();
return bestParams;
}
/**
- * Estimates the search time parameters needed to get the desired precision.
- * Precondition: the index is built
- * Postcondition: the searchParams will have the optimum params set, also the speedup obtained over linear search.
- */
+ Estimates the search time parameters needed to get the desired precision.
+ Precondition: the index is built
+ Postcondition: the searchParams will have the optimum params set, also the speedup obtained over linear search.
+ */
float estimateSearchParams(SearchParams& searchParams)
{
const int nn = 1;
const size_t SAMPLE_COUNT = 1000;
- assert(bestIndex_ != NULL); // must have a valid index
+ assert(bestIndex!=NULL); // must have a valid index
float speedup = 0;
- int samples = (int)std::min(dataset_.rows / 10, SAMPLE_COUNT);
- if (samples > 0) {
- Matrix<ElementType> testDataset = random_sample(dataset_, samples);
+ int samples = (int)std::min(dataset.rows/10, SAMPLE_COUNT);
+ if (samples>0) {
+ Matrix<ELEM_TYPE> 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<int> gt_matches(new int[testDataset.rows], testDataset.rows, 1);
+ Matrix<int> gt_matches(new int[testDataset.rows],(long)testDataset.rows,1);
StartStopTimer t;
t.start();
- compute_ground_truth<Distance>(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<Distance>* kmeans = (KMeansIndex<Distance>*)bestIndex_;
+ if (bestIndex->getType() == FLANN_INDEX_KMEANS) {
+ logger().info("KMeans algorithm, estimating cluster border factor\n");
+ KMeansIndex<ELEM_TYPE>* kmeans = (KMeansIndex<ELEM_TYPE>*)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 (searchTime<bestSearchTime || bestSearchTime == -1) {
bestSearchTime = searchTime;
best_cb_index = cb_index;
best_checks = checks;
checks = best_checks;
kmeans->set_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<Distance>* bestIndex_;
-
- IndexParams bestParams_;
- SearchParams bestSearchParams_;
-
- Matrix<ElementType> sampledDataset_;
- Matrix<ElementType> testDataset_;
- Matrix<int> gt_matches_;
-
- float speedup_;
-
- /**
- * The dataset used by this index
- */
- const Matrix<ElementType> 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_ */
* 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 <typename Distance>
-class CompositeIndex : public NNIndex<Distance>
+
+template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
+class CompositeIndex : public NNIndex<ELEM_TYPE>
{
+ KMeansIndex<ELEM_TYPE, DIST_TYPE>* kmeans;
+ KDTreeIndex<ELEM_TYPE, DIST_TYPE>* kdtree;
+
+ const Matrix<ELEM_TYPE> 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<ElementType>& inputData, const IndexParams& params = CompositeIndexParams(),
- Distance d = Distance()) : index_params_(params)
- {
- kdtree_index_ = new KDTreeIndex<Distance>(inputData, params, d);
- kmeans_index_ = new KMeansIndex<Distance>(inputData, params, d);
- }
+ CompositeIndex(const Matrix<ELEM_TYPE>& 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<ELEM_TYPE, DIST_TYPE>(inputData,kdtree_params);
+ kmeans = new KMeansIndex<ELEM_TYPE, DIST_TYPE>(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<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
- {
- kmeans_index_->findNeighbors(result, vec, searchParams);
- kdtree_index_->findNeighbors(result, vec, searchParams);
- }
+ void findNeighbors(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, const SearchParams& searchParams)
+ {
+ kmeans->findNeighbors(result,vec,searchParams);
+ kdtree->findNeighbors(result,vec,searchParams);
+ }
-private:
- /** The k-means index */
- KMeansIndex<Distance>* kmeans_index_;
+ const IndexParams* getParameters() const
+ {
+ return &index_params;
+ }
- /** The kd-tree index */
- KDTreeIndex<Distance>* kdtree_index_;
- /** The index parameters */
- const IndexParams index_params_;
};
-}
+} // namespace cvflann
-#endif //OPENCV_FLANN_COMPOSITE_INDEX_H_
+#endif //_OPENCV_COMPOSITETREE_H_
+++ /dev/null
-/***********************************************************************
- * 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_ */
+++ /dev/null
-/***********************************************************************
- * 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_ */
* 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 <cmath>
-#include <cstdlib>
-#include <string.h>
-#ifdef _MSC_VER
-typedef unsigned uint32_t;
-typedef unsigned __int64 uint64_t;
-#else
-#include <stdint.h>
-#endif
-
-#include "defines.h"
+#include "opencv2/flann/general.h"
namespace cvflann
{
-template<typename T>
-inline T abs(T x) { return (x<0) ? -x : x; }
-
-template<>
-inline int abs<int>(int x) { return ::abs(x); }
-
-template<>
-inline float abs<float>(float x) { return fabsf(x); }
-
-template<>
-inline double abs<double>(double x) { return fabs(x); }
-
-template<>
-inline long double abs<long double>(long double x) { return fabsl(x); }
-
-
-template<typename T>
-struct Accumulator { typedef T Type; };
-template<>
-struct Accumulator<unsigned char> { typedef float Type; };
-template<>
-struct Accumulator<unsigned short> { typedef float Type; };
-template<>
-struct Accumulator<unsigned int> { typedef float Type; };
-template<>
-struct Accumulator<char> { typedef float Type; };
-template<>
-struct Accumulator<short> { typedef float Type; };
-template<>
-struct Accumulator<int> { 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<class T>
-struct L2_Simple
+template <typename Iterator1, typename Iterator2>
+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<T>::Type ResultType;
-
- template <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- 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<class T>
-struct L2
+template <typename Iterator1, typename Iterator2>
+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<T>::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 <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- 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<class T>
-struct L1
+template <typename Iterator1, typename Iterator2>
+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<T>::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 <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- 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<class T>
-struct MinkowskiDistance
+// L_infinity distance (NOT A VALID KD-TREE DISTANCE - NOT DIMENSIONWISE ADDITIVE)
+template <typename Iterator1, typename Iterator2>
+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<T>::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 <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- inline ResultType accum_dist(const U& a, const V& b, int) const
- {
- return pow(static_cast<ResultType>(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<class T>
-struct MaxDistance
+template <typename Iterator1, typename Iterator2>
+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<T>::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 <typename Iterator1, typename Iterator2>
- 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 <typename Iterator1, typename Iterator2>
+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<class T>
-struct Hamming
-{
- typedef False is_kdtree_distance;
- typedef False is_vector_space_distance;
-
-
- typedef T ElementType;
- typedef int ResultType;
-
- template<typename Iterator1, typename Iterator2>
- 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<const pop_t*> (a);
- const pop_t* b2 = reinterpret_cast<const pop_t*> (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<const unsigned char*> (a),
- reinterpret_cast<const unsigned char*> (b), size * sizeof(pop_t));
-#endif
- return result;
- }
-};
-template<typename T>
-struct Hamming2
+// Hellinger distance
+template <typename Iterator1, typename Iterator2>
+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 <typename Iterator1, typename Iterator2>
- 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<const uint64_t*>(a);
- const uint64_t* pb = reinterpret_cast<const uint64_t*>(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<const uint32_t*>(a);
- const uint32_t* pb = reinterpret_cast<const uint32_t*>(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<class T>
-struct HistIntersectionDistance
+// chi-dsquare distance
+template <typename Iterator1, typename Iterator2>
+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<T>::Type ResultType;
-
- /**
- * Compute the histogram intersection distance
- */
- template <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- inline ResultType accum_dist(const U& a, const V& b, int) const
- {
- return a<b ? a : b;
- }
-};
-
+ double dist = acc;
+
+ while (first1 < last1) {
+ double sum = *first1 + *first2;
+ if (sum > 0) {
+ double diff = *first1 - *first2;
+ dist += diff * diff / sum;
+ }
+ first1++;
+ first2++;
+ }
+ return dist;
+}
-template<class T>
-struct HellingerDistance
+// Kullback–Leibler divergence (NOT SYMMETRIC)
+template <typename Iterator1, typename Iterator2>
+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<T>::Type ResultType;
-
- /**
- * Compute the histogram intersection distance
- */
- template <typename Iterator1, typename Iterator2>
- 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<ResultType>(a[0])) - sqrt(static_cast<ResultType>(b[0]));
- diff1 = sqrt(static_cast<ResultType>(a[1])) - sqrt(static_cast<ResultType>(b[1]));
- diff2 = sqrt(static_cast<ResultType>(a[2])) - sqrt(static_cast<ResultType>(b[2]));
- diff3 = sqrt(static_cast<ResultType>(a[3])) - sqrt(static_cast<ResultType>(b[3]));
- result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
- a += 4;
- b += 4;
- }
- while (a < last) {
- diff0 = sqrt(static_cast<ResultType>(*a++)) - sqrt(static_cast<ResultType>(*b++));
- result += diff0 * diff0;
- }
- return result;
- }
-
- /**
- * Partial distance, used by the kd-tree.
- */
- template <typename U, typename V>
- inline ResultType accum_dist(const U& a, const V& b, int) const
- {
- return sqrt(static_cast<ResultType>(a)) - sqrt(static_cast<ResultType>(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<class T>
-struct ChiSquareDistance
-{
- typedef True is_kdtree_distance;
- typedef True is_vector_space_distance;
-
- typedef T ElementType;
- typedef typename Accumulator<T>::Type ResultType;
-
- /**
- * Compute the chi-square distance
- */
- template <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- 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<class T>
-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 <typename Iterator1, typename Iterator2>
+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<T>::Type ResultType;
-
- /**
- * Compute the Kullback–Leibler divergence
- */
- template <typename Iterator1, typename Iterator2>
- 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 <typename U, typename V>
- 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
* zero-filled array.
*/
template <typename T>
-struct ZeroIterator
-{
-
- T operator*()
- {
- return 0;
- }
+struct ZeroIterator {
- T operator[](int)
- {
- return 0;
- }
+ T operator*() {
+ return 0;
+ }
- const ZeroIterator<T>& operator ++()
- {
- return *this;
- }
+ T operator[](int) {
+ return 0;
+ }
- ZeroIterator<T> operator ++(int)
- {
- return *this;
- }
+ ZeroIterator<T>& operator ++(int) {
+ return *this;
+ }
- ZeroIterator<T>& operator+=(int)
- {
- return *this;
- }
+ ZeroIterator<T>& operator+=(int) {
+ return *this;
+ }
};
-}
+CV_EXPORTS ZeroIterator<float>& zero();
+
+} // namespace cvflann
-#endif //OPENCV_FLANN_DIST_H_
+#endif //_OPENCV_DIST_H_
+++ /dev/null
-/***********************************************************************
- * 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 <boost/dynamic_bitset.hpp>
-typedef boost::dynamic_bitset<> DynamicBitset;
-#else
-
-#include <limits.h>
-
-#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<size_t> bitset_;
- size_t size_;
- static const unsigned int cell_bit_size_ = CHAR_BIT * sizeof(size_t);
-};
-
-#endif
-
-#endif // OPENCV_FLANN_DYNAMIC_BITSET_H_
#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
template <> struct CvType<float> { static int type() { return CV_32F; } };
template <> struct CvType<double> { 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 <typename Distance>
-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<ElementType>& query, vector<int>& indices,
- vector<DistanceType>& dists, int knn, const SearchParams& params);
- void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params);
-
- int radiusSearch(const vector<ElementType>& query, vector<int>& indices,
- vector<DistanceType>& 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<Distance>* 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<float> > \n"); \
- }
-
-
-template <typename Distance>
-GenericIndex<Distance>::GenericIndex(const Mat& dataset, const IndexParams& params, Distance distance)
-{
- CV_Assert(dataset.type() == CvType<ElementType>::type());
- CV_Assert(dataset.isContinuous());
- ::cvflann::Matrix<ElementType> m_dataset((ElementType*)dataset.ptr<ElementType>(0), dataset.rows, dataset.cols);
-
- nnIndex = new ::cvflann::Index<Distance>(m_dataset, params, distance);
-
- FLANN_DISTANCE_CHECK
-
- nnIndex->buildIndex();
-}
-
-template <typename Distance>
-GenericIndex<Distance>::~GenericIndex()
-{
- delete nnIndex;
-}
-
-template <typename Distance>
-void GenericIndex<Distance>::knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const SearchParams& searchParams)
-{
- ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
- ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
- ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
-
- FLANN_DISTANCE_CHECK
-
- nnIndex->knnSearch(m_query,m_indices,m_dists,knn,searchParams);
-}
-
-
-template <typename Distance>
-void GenericIndex<Distance>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams)
-{
- CV_Assert(queries.type() == CvType<ElementType>::type());
- CV_Assert(queries.isContinuous());
- ::cvflann::Matrix<ElementType> m_queries((ElementType*)queries.ptr<ElementType>(0), queries.rows, queries.cols);
-
- CV_Assert(indices.type() == CV_32S);
- CV_Assert(indices.isContinuous());
- ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
-
- CV_Assert(dists.type() == CvType<DistanceType>::type());
- CV_Assert(dists.isContinuous());
- ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
-
- FLANN_DISTANCE_CHECK
-
- nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
-}
-
-template <typename Distance>
-int GenericIndex<Distance>::radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, DistanceType radius, const SearchParams& searchParams)
-{
- ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
- ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
- ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
-
- FLANN_DISTANCE_CHECK
-
- return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
-}
-
-template <typename Distance>
-int GenericIndex<Distance>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const SearchParams& searchParams)
-{
- CV_Assert(query.type() == CvType<ElementType>::type());
- CV_Assert(query.isContinuous());
- ::cvflann::Matrix<ElementType> m_query((ElementType*)query.ptr<ElementType>(0), query.rows, query.cols);
-
- CV_Assert(indices.type() == CV_32S);
- CV_Assert(indices.isContinuous());
- ::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
-
- CV_Assert(dists.type() == CvType<DistanceType>::type());
- CV_Assert(dists.isContinuous());
- ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
-
- FLANN_DISTANCE_CHECK
-
- return nnIndex->radiusSearch(m_query,m_indices,m_dists,radius,searchParams);
-}
-
-
-typedef GenericIndex< L2<float> > Index;
+using ::cvflann::SearchParams;
-/**
- * @deprecated Use GenericIndex class instead
- */
template <typename T>
-class FLANN_DEPRECATED Index_ {
-public:
- typedef typename L2<T>::ElementType ElementType;
- typedef typename L2<T>::ResultType DistanceType;
+class CV_EXPORTS Index_ {
+ ::cvflann::Index<T>* nnIndex;
+public:
Index_(const Mat& features, const IndexParams& params);
~Index_();
- void knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const SearchParams& params);
+ void knnSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, int knn, const SearchParams& params);
void knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& params);
- int radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& 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<T>& query, vector<int>& indices, vector<float>& 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<ElementType> >* nnIndex_L2;
- ::cvflann::Index< L1<ElementType> >* nnIndex_L1;
};
template <typename T>
Index_<T>::Index_(const Mat& dataset, const IndexParams& params)
{
- printf("[WARNING] The cv::flann::Index_<T> class is deperecated, use cv::flann::GenericIndex<Distance> instead\n");
-
- CV_Assert(dataset.type() == CvType<ElementType>::type());
+ CV_Assert(dataset.type() == CvType<T>::type());
CV_Assert(dataset.isContinuous());
- ::cvflann::Matrix<ElementType> m_dataset((ElementType*)dataset.ptr<ElementType>(0), dataset.rows, dataset.cols);
+ ::cvflann::Matrix<T> m_dataset((T*)dataset.ptr<T>(0), dataset.rows, dataset.cols);
- if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L2 ) {
- nnIndex_L1 = NULL;
- nnIndex_L2 = new ::cvflann::Index< L2<ElementType> >(m_dataset, params);
- }
- else if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L1 ) {
- nnIndex_L1 = new ::cvflann::Index< L1<ElementType> >(m_dataset, params);
- nnIndex_L2 = NULL;
- }
- else {
- printf("[ERROR] cv::flann::Index_<T> only provides backwards compatibility for the L1 and L2 distances. "
- "For other distance types you must use cv::flann::GenericIndex<Distance>\n");
- CV_Assert(0);
- }
- if (nnIndex_L1) nnIndex_L1->buildIndex();
- if (nnIndex_L2) nnIndex_L2->buildIndex();
+ nnIndex = new ::cvflann::Index<T>(m_dataset, params);
+ nnIndex->buildIndex();
}
template <typename T>
Index_<T>::~Index_()
{
- if (nnIndex_L1) delete nnIndex_L1;
- if (nnIndex_L2) delete nnIndex_L2;
+ delete nnIndex;
}
template <typename T>
-void Index_<T>::knnSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, int knn, const SearchParams& searchParams)
+void Index_<T>::knnSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, int knn, const SearchParams& searchParams)
{
- ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
- ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
- ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
+ ::cvflann::Matrix<T> m_query((T*)&query[0], 1, (int)query.size());
+ ::cvflann::Matrix<int> m_indices(&indices[0], 1, (int)indices.size());
+ ::cvflann::Matrix<float> 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 <typename T>
void Index_<T>::knnSearch(const Mat& queries, Mat& indices, Mat& dists, int knn, const SearchParams& searchParams)
{
- CV_Assert(queries.type() == CvType<ElementType>::type());
+ CV_Assert(queries.type() == CvType<T>::type());
CV_Assert(queries.isContinuous());
- ::cvflann::Matrix<ElementType> m_queries((ElementType*)queries.ptr<ElementType>(0), queries.rows, queries.cols);
+ ::cvflann::Matrix<T> m_queries((T*)queries.ptr<T>(0), queries.rows, queries.cols);
CV_Assert(indices.type() == CV_32S);
CV_Assert(indices.isContinuous());
::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
- CV_Assert(dists.type() == CvType<DistanceType>::type());
+ CV_Assert(dists.type() == CV_32F);
CV_Assert(dists.isContinuous());
- ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(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<float> m_dists((float*)dists.ptr<float>(0), dists.rows, dists.cols);
+
+ nnIndex->knnSearch(m_queries,m_indices,m_dists,knn, searchParams);
}
template <typename T>
-int Index_<T>::radiusSearch(const vector<ElementType>& query, vector<int>& indices, vector<DistanceType>& dists, DistanceType radius, const SearchParams& searchParams)
+int Index_<T>::radiusSearch(const vector<T>& query, vector<int>& indices, vector<float>& dists, float radius, const SearchParams& searchParams)
{
- ::cvflann::Matrix<ElementType> m_query((ElementType*)&query[0], 1, query.size());
- ::cvflann::Matrix<int> m_indices(&indices[0], 1, indices.size());
- ::cvflann::Matrix<DistanceType> m_dists(&dists[0], 1, dists.size());
+ ::cvflann::Matrix<T> m_query((T*)&query[0], 1, (int)query.size());
+ ::cvflann::Matrix<int> m_indices(&indices[0], 1, (int)indices.size());
+ ::cvflann::Matrix<float> 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 <typename T>
-int Index_<T>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, DistanceType radius, const SearchParams& searchParams)
+int Index_<T>::radiusSearch(const Mat& query, Mat& indices, Mat& dists, float radius, const SearchParams& searchParams)
{
- CV_Assert(query.type() == CvType<ElementType>::type());
+ CV_Assert(query.type() == CvType<T>::type());
CV_Assert(query.isContinuous());
- ::cvflann::Matrix<ElementType> m_query((ElementType*)query.ptr<ElementType>(0), query.rows, query.cols);
+ ::cvflann::Matrix<T> m_query((T*)query.ptr<T>(0), query.rows, query.cols);
CV_Assert(indices.type() == CV_32S);
CV_Assert(indices.isContinuous());
::cvflann::Matrix<int> m_indices((int*)indices.ptr<int>(0), indices.rows, indices.cols);
- CV_Assert(dists.type() == CvType<DistanceType>::type());
+ CV_Assert(dists.type() == CV_32F);
CV_Assert(dists.isContinuous());
- ::cvflann::Matrix<DistanceType> m_dists((DistanceType*)dists.ptr<DistanceType>(0), dists.rows, dists.cols);
+ ::cvflann::Matrix<float> m_dists((float*)dists.ptr<float>(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_<float> Index;
-template <typename Distance>
-int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params,
- Distance d = Distance())
+template <typename ELEM_TYPE, typename DIST_TYPE>
+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<ElementType>::type());
+ CV_Assert(features.type() == CvType<ELEM_TYPE>::type());
CV_Assert(features.isContinuous());
- ::cvflann::Matrix<ElementType> m_features((ElementType*)features.ptr<ElementType>(0), features.rows, features.cols);
+ ::cvflann::Matrix<ELEM_TYPE> m_features((ELEM_TYPE*)features.ptr<ELEM_TYPE>(0), features.rows, features.cols);
- CV_Assert(centers.type() == CvType<DistanceType>::type());
+ CV_Assert(centers.type() == CvType<DIST_TYPE>::type());
CV_Assert(centers.isContinuous());
- ::cvflann::Matrix<DistanceType> m_centers((DistanceType*)centers.ptr<DistanceType>(0), centers.rows, centers.cols);
-
- return ::cvflann::hierarchicalClustering<Distance>(m_features, m_centers, params, d);
-}
-
-
-template <typename ELEM_TYPE, typename DIST_TYPE>
-FLANN_DEPRECATED int hierarchicalClustering(const Mat& features, Mat& centers, const KMeansIndexParams& params)
-{
- printf("[WARNING] cv::flann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE> is deprecated, use "
- "cv::flann::hierarchicalClustering<Distance> instead\n");
-
- if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L2 ) {
- return hierarchicalClustering< L2<ELEM_TYPE> >(features, centers, params);
- }
- else if ( ::cvflann::flann_distance_type_() == FLANN_DIST_L1 ) {
- return hierarchicalClustering< L1<ELEM_TYPE> >(features, centers, params);
- }
- else {
- printf("[ERROR] cv::flann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE> only provides backwards "
- "compatibility for the L1 and L2 distances. "
- "For other distance types you must use cv::flann::hierarchicalClustering<Distance>\n");
- CV_Assert(0);
- }
+ ::cvflann::Matrix<DIST_TYPE> m_centers((DIST_TYPE*)centers.ptr<DIST_TYPE>(0), centers.rows, centers.cols);
+
+ return ::cvflann::hierarchicalClustering<ELEM_TYPE,DIST_TYPE>(m_features, m_centers, params);
}
} } // namespace cv::flann
* 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 <vector>
#include <string>
#include <cassert>
#include <cstdio>
-#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<typename T>
+class CV_EXPORTS Index {
+ NNIndex<T>* nnIndex;
+ bool built;
-template<typename Distance>
-NNIndex<Distance>* load_saved_index(const Matrix<typename Distance::ElementType>& dataset, const std::string& filename, Distance distance)
-{
- typedef typename Distance::ElementType ElementType;
+public:
+ Index(const Matrix<T>& 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<ElementType>::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<T>& queries, Matrix<int>& indices, Matrix<float>& dists, int knn, const SearchParams& params);
+
+ int radiusSearch(const Matrix<T>& query, Matrix<int>& indices, Matrix<float>& 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<Distance>* nnIndex = create_index_by_type<Distance>(dataset, params, distance);
- nnIndex->loadIndex(fin);
- fclose(fin);
+ NNIndex<T>* getIndex() { return nnIndex; }
- return nnIndex;
+ const IndexParams* getIndexParameters() { return nnIndex->getParameters(); }
+};
+
+
+template<typename T>
+NNIndex<T>* load_saved_index(const Matrix<T>& 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<T>::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<T>* nnIndex = create_index_by_type(dataset, *params);
+ nnIndex->loadIndex(fin);
+ fclose(fin);
+
+ return nnIndex;
}
-template<typename Distance>
-class Index : public NNIndex<Distance>
+template<typename T>
+Index<T>::Index(const Matrix<T>& dataset, const IndexParams& params)
{
-public:
- typedef typename Distance::ElementType ElementType;
- typedef typename Distance::ResultType DistanceType;
-
- Index(const Matrix<ElementType>& features, const IndexParams& params, Distance distance = Distance() )
- : index_params_(params)
- {
- flann_algorithm_t index_type = get_param<flann_algorithm_t>(params,"algorithm");
- loaded_ = false;
-
- if (index_type == FLANN_INDEX_SAVED) {
- nnIndex_ = load_saved_index<Distance>(features, get_param<std::string>(params,"filename"), distance);
- loaded_ = true;
- }
- else {
- nnIndex_ = create_index_by_type<Distance>(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<typename T>
+Index<T>::~Index()
+{
+ delete nnIndex;
+}
- /**
- * Builds the index.
- */
- void buildIndex()
- {
- if (!loaded_) {
- nnIndex_->buildIndex();
- }
- }
+template<typename T>
+void Index<T>::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<typename T>
+void Index<T>::knnSearch(const Matrix<T>& queries, Matrix<int>& indices, Matrix<float>& 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<T> 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<typename T>
+int Index<T>::radiusSearch(const Matrix<T>& query, Matrix<int>& indices, Matrix<float>& 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<T> 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<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params)
- {
- nnIndex_->knnSearch(queries, indices, dists, knn, params);
- }
+ for (size_t i=0;i<count_nn;++i) {
+ indices[0][i] = neighbors[i];
+ dists[0][i] = distances[i];
+ }
- /**
- * \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
- */
- int radiusSearch(const Matrix<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& 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<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
- {
- nnIndex_->findNeighbors(result, vec, searchParams);
- }
- /**
- * \brief Returns actual index
- */
- FLANN_DEPRECATED NNIndex<Distance>* getIndex()
- {
- return nnIndex_;
- }
+template<typename T>
+void Index<T>::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<Distance>* nnIndex_;
- /** Indices if the index was loaded from a file */
- bool loaded_;
- /** Parameters passed to the index */
- IndexParams index_params_;
-};
+template<typename T>
+int Index<T>::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 <typename Distance>
-int hierarchicalClustering(const Matrix<typename Distance::ElementType>& points, Matrix<typename Distance::ResultType>& centers,
- const KMeansIndexParams& params, Distance d = Distance())
+template<typename T>
+int Index<T>::veclen() const
{
- KMeansIndex<Distance> kmeans(points, params, d);
- kmeans.buildIndex();
+ return nnIndex->veclen();
+}
+
+
+template <typename ELEM_TYPE, typename DIST_TYPE>
+int hierarchicalClustering(const Matrix<ELEM_TYPE>& features, Matrix<DIST_TYPE>& centers, const KMeansIndexParams& params)
+{
+ KMeansIndex<ELEM_TYPE, DIST_TYPE> 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_ */
* 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 <stdexcept>
#include <cassert>
+#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 <typename ELEM_TYPE>
+struct DistType
{
+ typedef ELEM_TYPE type;
+};
-class FLANNException : public std::runtime_error
+template <>
+struct DistType<unsigned char>
{
+ typedef float type;
+};
+
+template <>
+struct DistType<int>
+{
+ 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\r
-__declspec(dllexport)\r
-#endif
-void dummyfunc();
-}
+typedef ObjectFactory<IndexParams, flann_algorithm_t> 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_ */
* 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 <typename Distance>
-void find_nearest(const Matrix<typename Distance::ElementType>& dataset, typename Distance::ElementType* query, int* matches, int nn,
- int skip = 0, Distance distance = Distance())
+template <typename T>
+void find_nearest(const Matrix<T>& 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.rows; ++i) {
- DistanceType tmp = distance(dataset[i], query, dataset.cols);
+ for (size_t i=1;i<dataset.rows;++i) {
+ T tmp = (T)flann_dist(query, query_end, dataset[i]);
if (dcnt<n) {
- match[dcnt] = i;
+ match[dcnt] = (long)i;
dists[dcnt++] = tmp;
}
else if (tmp < dists[dcnt-1]) {
dists[dcnt-1] = tmp;
- match[dcnt-1] = i;
+ match[dcnt-1] = (long)i;
}
int j = dcnt-1;
}
}
- for (int i=0; i<nn; ++i) {
+ for (int i=0;i<nn;++i) {
matches[i] = match[i+skip];
}
}
-template <typename Distance>
-void compute_ground_truth(const Matrix<typename Distance::ElementType>& dataset, const Matrix<typename Distance::ElementType>& testset, Matrix<int>& matches,
- int skip=0, Distance d = Distance())
+template <typename T>
+void compute_ground_truth(const Matrix<T>& dataset, const Matrix<T>& testset, Matrix<int>& matches, int skip=0)
{
- for (size_t i=0; i<testset.rows; ++i) {
- find_nearest<Distance>(dataset, testset[i], matches[i], (int)matches.cols, skip, d);
+ for (size_t i=0;i<testset.rows;++i) {
+ find_nearest(dataset, testset[i], matches[i], (int)matches.cols, skip);
}
}
-}
+} // namespace cvflann
-#endif //OPENCV_FLANN_GROUND_TRUTH_H_
+#endif //_OPENCV_GROUND_TRUTH_H_
*************************************************************************/
-#ifndef OPENCV_FLANN_HDF5_H_
-#define OPENCV_FLANN_HDF5_H_
+#ifndef _OPENCV_HDF5_H_
+#define _OPENCV_HDF5_H_
-#include <hdf5.h>
+#include <H5Cpp.h>
-#include "matrix.h"
+#include "opencv2/flann/matrix.h"
-namespace cvflann
-{
-namespace
-{
+#ifndef H5_NO_NAMESPACE
+ using namespace H5;
+#endif
-template<typename T>
-hid_t get_hdf5_type()
+namespace cvflann
{
- throw FLANNException("Unsupported type for IO operations");
-}
-
-template<>
-hid_t get_hdf5_type<char>() { return H5T_NATIVE_CHAR; }
-template<>
-hid_t get_hdf5_type<unsigned char>() { return H5T_NATIVE_UCHAR; }
-template<>
-hid_t get_hdf5_type<short int>() { return H5T_NATIVE_SHORT; }
-template<>
-hid_t get_hdf5_type<unsigned short int>() { return H5T_NATIVE_USHORT; }
-template<>
-hid_t get_hdf5_type<int>() { return H5T_NATIVE_INT; }
-template<>
-hid_t get_hdf5_type<unsigned int>() { return H5T_NATIVE_UINT; }
-template<>
-hid_t get_hdf5_type<long>() { return H5T_NATIVE_LONG; }
-template<>
-hid_t get_hdf5_type<unsigned long>() { return H5T_NATIVE_ULONG; }
-template<>
-hid_t get_hdf5_type<float>() { return H5T_NATIVE_FLOAT; }
-template<>
-hid_t get_hdf5_type<double>() { return H5T_NATIVE_DOUBLE; }
-template<>
-hid_t get_hdf5_type<long double>() { return H5T_NATIVE_LDOUBLE; }
-}
-#define CHECK_ERROR(x,y) if ((x)<0) throw FLANNException((y));
+namespace {
template<typename T>
-void save_to_file(const cvflann::Matrix<T>& 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<T>(), space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-#else
- dataset_id = H5Dcreate(file_id, name.c_str(), get_hdf5_type<T>(), 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<T>(), 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<char>() { return PredType::NATIVE_CHAR; }
+template<> PredType get_hdf5_type<unsigned char>() { return PredType::NATIVE_UCHAR; }
+template<> PredType get_hdf5_type<short int>() { return PredType::NATIVE_SHORT; }
+template<> PredType get_hdf5_type<unsigned short int>() { return PredType::NATIVE_USHORT; }
+template<> PredType get_hdf5_type<int>() { return PredType::NATIVE_INT; }
+template<> PredType get_hdf5_type<unsigned int>() { return PredType::NATIVE_UINT; }
+template<> PredType get_hdf5_type<long>() { return PredType::NATIVE_LONG; }
+template<> PredType get_hdf5_type<unsigned long>() { return PredType::NATIVE_ULONG; }
+template<> PredType get_hdf5_type<float>() { return PredType::NATIVE_FLOAT; }
+template<> PredType get_hdf5_type<double>() { return PredType::NATIVE_DOUBLE; }
+template<> PredType get_hdf5_type<long double>() { return PredType::NATIVE_LDOUBLE; }
}
template<typename T>
-void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+void save_to_file(const cvflann::Matrix<T>& 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<T>(new T[dims_out[0]*dims_out[1]], dims_out[0], dims_out[1]);
-
- status = H5Dread(dataset_id, get_hdf5_type<T>(), 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<T>(), dataspace );
+
+ /*
+ * Write the data to the dataset using default memory space, file
+ * space, and transfer properties.
+ */
+ dataset.write( flann_dataset.data, get_hdf5_type<T>() );
+ } // 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<typename T>
-void load_from_file(cvflann::Matrix<T>& dataset, const std::string& filename, const std::string& name)
+void load_from_file(cvflann::Matrix<T>& 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<mpi_size-1 ? item_cnt : dims[0]-item_cnt*(mpi_size-1));
-
- count[0] = cnt;
- count[1] = dims[1];
- offset[0] = mpi_rank*item_cnt;
- offset[1] = 0;
-
- hid_t memspace_id = H5Screate_simple(2,count,NULL);
-
- H5Sselect_hyperslab(space_id, H5S_SELECT_SET, offset, NULL, count, NULL);
-
- dataset.rows = count[0];
- dataset.cols = count[1];
- dataset.data = new T[dataset.rows*dataset.cols];
+ try
+ {
+ Exception::dontPrint();
+
+ H5File file( filename, H5F_ACC_RDONLY );
+ DataSet dataset = file.openDataSet( name );
+
+ /*
+ * Check the type used by the dataset matches
+ */
+ if ( !(dataset.getDataType()==get_hdf5_type<T>())) {
+ 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<T>() );
+ } // 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<T>(), 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_ */
* 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 <algorithm>
-#include <vector>
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 <typename T>
-class Heap
-{
+class Heap {
- /**
- * Storage array for the heap.
- * Type T must be comparable.
- */
- std::vector<T> 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_
+++ /dev/null
-/***********************************************************************
- * 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 <algorithm>
-#include <string>
-#include <map>
-#include <cassert>
-#include <limits>
-#include <cmath>
-
-#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 <typename Distance>
-class HierarchicalClusteringIndex : public NNIndex<Distance>
-{
-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<k; ++index) {
- bool duplicate = true;
- int rnd;
- while (duplicate) {
- duplicate = false;
- rnd = r.next();
- if (rnd<0) {
- centers_length = index;
- return;
- }
-
- centers[index] = indices[rnd];
-
- for (int j=0; j<index; ++j) {
- float sq = distance(dataset[centers[index]], dataset[centers[j]], dataset.cols);
- if (sq<1e-16) {
- duplicate = true;
- }
- }
- }
- }
-
- centers_length = index;
- }
-
-
- /**
- * Chooses the initial centers in the k-means using Gonzales' algorithm
- * so that the centers are spaced apart from each other.
- *
- * Params:
- * k = number of centers
- * vecs = the dataset of points
- * indices = indices in the dataset
- * Returns:
- */
- void chooseCentersGonzales(int k, int* indices, int indices_length, int* centers, int& centers_length)
- {
- int n = indices_length;
-
- int rnd = rand_int(n);
- assert(rnd >=0 && rnd < n);
-
- centers[0] = indices[rnd];
-
- int index;
- for (index=1; index<k; ++index) {
-
- int best_index = -1;
- float best_val = 0;
- for (int j=0; j<n; ++j) {
- float dist = distance(dataset[centers[0]],dataset[indices[j]],dataset.cols);
- for (int i=1; i<index; ++i) {
- float tmp_dist = distance(dataset[centers[i]],dataset[indices[j]],dataset.cols);
- if (tmp_dist<dist) {
- dist = tmp_dist;
- }
- }
- if (dist>best_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<ElementType>& 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<trees_; ++i) {
- indices[i] = new int[size_];
- for (size_t j=0; j<size_; ++j) {
- indices[i][j] = j;
- }
- root[i] = pool.allocate<Node>();
- 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<trees_; ++i) {
- save_value(stream, *indices[i], size_);
- save_tree(stream, root[i], i);
- }
-
- }
-
-
- void loadIndex(FILE* stream)
- {
- load_value(stream, branching_);
- load_value(stream, trees_);
- load_value(stream, centers_init_);
- load_value(stream, leaf_size_);
- load_value(stream, memoryCounter);
- indices = new int*[trees_];
- root = new NodePtr[trees_];
- for (int i=0; i<trees_; ++i) {
- indices[i] = new int[size_];
- load_value(stream, *indices[i], size_);
- load_tree(stream, root[i], i);
- }
-
- params["algorithm"] = getType();
- params["branching"] = branching_;
- params["trees"] = trees_;
- params["centers_init"] = centers_init_;
- params["leaf_size"] = leaf_size_;
- }
-
-
- /**
- * 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
- * searchParams = parameters that influence the search algorithm (checks)
- */
- void findNeighbors(ResultSet<DistanceType>& 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<BranchSt>* heap = new Heap<BranchSt>(size_);
-
- std::vector<bool> checked(size_,false);
- int checks = 0;
- for (int i=0; i<trees_; ++i) {
- findNN(root[i], result, vec, checks, maxChecks, heap, checked);
- }
-
- BranchSt branch;
- while (heap->popMin(branch) && (checks<maxChecks || !result.full())) {
- NodePtr node = branch.node;
- findNN(node, result, vec, checks, maxChecks, heap, checked);
- }
- assert(result.full());
-
- delete heap;
-
- }
-
- IndexParams getParameters() const
- {
- return params;
- }
-
-
-private:
-
- /**
- * Struture representing a node in the hierarchical k-means tree.
- */
- struct Node
- {
- /**
- * The cluster center index
- */
- int pivot;
- /**
- * The cluster size (number of points in the cluster)
- */
- int size;
- /**
- * Child nodes (only for non-terminal nodes)
- */
- Node** childs;
- /**
- * Node points (only for terminal nodes)
- */
- int* indices;
- /**
- * Level
- */
- int level;
- };
- typedef Node* NodePtr;
-
-
-
- /**
- * Alias definition for a nicer syntax.
- */
- typedef BranchStruct<NodePtr, DistanceType> 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; i<branching_; ++i) {
- save_tree(stream, node->childs[i], num);
- }
- }
- }
-
-
- void load_tree(FILE* stream, NodePtr& node, int num)
- {
- node = pool.allocate<Node>();
- 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<NodePtr>(branching_);
- for(int i=0; i<branching_; ++i) {
- load_tree(stream, node->childs[i], num);
- }
- }
- }
-
-
-
-
- void computeLabels(int* indices, int indices_length, int* centers, int centers_length, int* labels, DistanceType& cost)
- {
- cost = 0;
- for (int i=0; i<indices_length; ++i) {
- ElementType* point = dataset[indices[i]];
- DistanceType dist = distance(point, dataset[centers[0]], veclen_);
- labels[i] = 0;
- for (int j=1; j<centers_length; ++j) {
- DistanceType new_dist = distance(point, dataset[centers[j]], veclen_);
- if (dist>new_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<int> centers(branching);
- std::vector<int> labels(indices_length);
-
- int centers_length;
- (this->*chooseCenters)(branching, indices, indices_length, ¢ers[0], centers_length);
-
- if (centers_length<branching) {
- node->indices = 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<NodePtr>(branching);
- int start = 0;
- int end = start;
- for (int i=0; i<branching; ++i) {
- for (int j=0; j<indices_length; ++j) {
- if (labels[j]==i) {
- std::swap(indices[j],indices[end]);
- std::swap(labels[j],labels[end]);
- end++;
- }
- }
-
- node->childs[i] = pool.allocate<Node>();
- 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<DistanceType>& result, const ElementType* vec, int& checks, int maxChecks,
- Heap<BranchSt>* heap, std::vector<bool>& checked)
- {
- if (node->childs==NULL) {
- if (checks>=maxChecks) {
- if (result.full()) return;
- }
- checks += node->size;
- for (int i=0; i<node->size; ++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; i<branching_; ++i) {
- domain_distances[i] = distance(vec, dataset[node->childs[i]->pivot], veclen_);
- if (domain_distances[i]<domain_distances[best_index]) {
- best_index = i;
- }
- }
- for (int i=0; i<branching_; ++i) {
- if (i!=best_index) {
- heap->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<ElementType> 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_ */
* 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 <cstring>
#include <cassert>
-#include <cmath>
-#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<n; ++i) {
- for (int k=0; k<n; ++k) {
- if (neighbors[i]==groundTruth[k]) {
- count++;
- break;
- }
- }
- }
- return count;
-}
+CV_EXPORTS int countCorrectMatches(int* neighbors, int* groundTruth, int n);
-template <typename Distance>
-typename Distance::ResultType computeDistanceRaport(const Matrix<typename Distance::ElementType>& inputData, typename Distance::ElementType* target,
- int* neighbors, int* groundTruth, int veclen, int n, const Distance& distance)
+template <typename ELEM_TYPE>
+float computeDistanceRaport(const Matrix<ELEM_TYPE>& 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<n;++i) {
+ float den = (float)flann_dist(target,target_end, inputData[groundTruth[i]]);
+ float num = (float)flann_dist(target,target_end, inputData[neighbors[i]]);
- DistanceType ret = 0;
- for (int i=0; i<n; ++i) {
- DistanceType den = distance(inputData[groundTruth[i]], target, veclen);
- DistanceType num = distance(inputData[neighbors[i]], target, veclen);
-
- if ((den==0)&&(num==0)) {
+ if (den==0 && num==0) {
ret += 1;
}
else {
return ret;
}
-template <typename Distance>
-float search_with_ground_truth(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
- const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches, int nn, int checks,
- float& time, typename Distance::ResultType& dist, const Distance& distance, int skipMatches)
+template <typename ELEM_TYPE>
+float search_with_ground_truth(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& matches, int nn, int checks, float& time, float& dist, int skipMatches)
{
- typedef typename Distance::ResultType DistanceType;
-
if (matches.cols<size_t(nn)) {
- Logger::info("matches.cols=%d, nn=%d\n",matches.cols,nn);
+ logger().info("matches.cols=%d, nn=%d\n",matches.cols,nn);
throw FLANNException("Ground truth is not computed for as many neighbors as requested");
}
- KNNResultSet<DistanceType> resultSet(nn+skipMatches);
+ KNNResultSet<ELEM_TYPE> 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) {
correct = 0;
distR = 0;
for (size_t i = 0; i < testData.rows; i++) {
- resultSet.init(indices, dists);
- index.findNeighbors(resultSet, testData[i], searchParams);
+ ELEM_TYPE* target = testData[i];
+ resultSet.init(target, (int)testData.cols);
+ index.findNeighbors(resultSet,target, searchParams);
+ int* neighbors = resultSet.getNeighbors();
+ neighbors = neighbors+skipMatches;
correct += countCorrectMatches(neighbors,matches[i], nn);
- distR += computeDistanceRaport<Distance>(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 <typename Distance>
-float test_index_checks(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
- const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
- int checks, float& precision, const Distance& distance, int nn = 1, int skipMatches = 0)
+template <typename ELEM_TYPE>
+float test_index_checks(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& 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 <typename Distance>
-float test_index_precision(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
- const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
- float precision, int& checks, const Distance& distance, int nn = 1, int skipMatches = 0)
+template <typename ELEM_TYPE>
+float test_index_precision(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& 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;
}
c1 = c2;
p1 = p2;
c2 *=2;
- 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);
}
int cx;
float realPrecision;
if (fabs(p2-precision)>SEARCH_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<precision) {
}
cx = (c1+c2)/2;
if (cx==c1) {
- Logger::info("Got as close as I can\n");
+ logger().info("Got as close as I can\n");
break;
}
- 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);
}
c2 = cx;
p2 = realPrecision;
- }
- else {
- Logger::info("No need for linear estimation\n");
+ } else {
+ logger().info("No need for linear estimation\n");
cx = c2;
realPrecision = p2;
}
}
-template <typename Distance>
-void test_index_precisions(NNIndex<Distance>& index, const Matrix<typename Distance::ElementType>& inputData,
- const Matrix<typename Distance::ElementType>& testData, const Matrix<int>& matches,
- float* precisions, int precisions_length, const Distance& distance, int nn = 1, int skipMatches = 0, float maxTime = 0)
+template <typename ELEM_TYPE>
+float test_index_precisions(NNIndex<ELEM_TYPE>& index, const Matrix<ELEM_TYPE>& inputData, const Matrix<ELEM_TYPE>& testData, const Matrix<int>& 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);
int pindex = 0;
float precision = precisions[pindex];
- 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");
+ logger().info("---------------------------------------------------------");
int c2 = 1;
float p2;
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 precision for 1 run down the tree is already
// better then some of the requested precisions, then
}
if (pindex==precisions_length) {
- Logger::info("Got as close as I can\n");
- return;
+ logger().info("Got as close as I can\n");
+ return time;
}
- for (int i=pindex; i<precisions_length; ++i) {
+ for (int i=pindex;i<precisions_length;++i) {
precision = precisions[i];
while (p2<precision) {
c1 = c2;
p1 = p2;
c2 *=2;
- p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, distance, skipMatches);
- if ((maxTime> 0)&&(time > maxTime)&&(p2<precision)) return;
+ p2 = search_with_ground_truth(index, inputData, testData, matches, nn, c2, time, dist, skipMatches);
+ if (maxTime> 0 && time > maxTime && p2<precision) return time;
}
int cx;
float realPrecision;
if (fabs(p2-precision)>SEARCH_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<precision) {
}
cx = (c1+c2)/2;
if (cx==c1) {
- Logger::info("Got as close as I can\n");
+ logger().info("Got as close as I can\n");
break;
}
- 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);
}
c2 = cx;
p2 = realPrecision;
- }
- else {
- Logger::info("No need for linear estimation\n");
+ } else {
+ logger().info("No need for linear estimation\n");
cx = c2;
realPrecision = p2;
}
}
+ return time;
}
-}
+} // namespace cvflann
-#endif //OPENCV_FLANN_INDEX_TESTING_H_
+#endif //_OPENCV_TESTING_H_
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*************************************************************************/
-#ifndef OPENCV_FLANN_KDTREE_INDEX_H_
-#define OPENCV_FLANN_KDTREE_INDEX_H_
+#ifndef _OPENCV_KDTREE_H_
+#define _OPENCV_KDTREE_H_
#include <algorithm>
#include <map>
#include <cassert>
#include <cstring>
-#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);
+ }
+
};
* Contains the k-d trees and other information for indexing a set of points
* for nearest-neighbor matching.
*/
-template <typename Distance>
-class KDTreeIndex : public NNIndex<Distance>
+template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
+class KDTreeIndex : public NNIndex<ELEM_TYPE>
{
-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<ELEM_TYPE> 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<ElementType>& 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<Tree> 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<ELEM_TYPE>& 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<trees_; ++i) {
- save_tree(stream, tree_roots_[i]);
- }
+ save_value(stream, numTrees);
+ for (int i=0;i<numTrees;++i) {
+ save_tree(stream, trees[i]);
+ }
}
void loadIndex(FILE* stream)
{
- load_value(stream, trees_);
- if (tree_roots_!=NULL) {
- delete[] tree_roots_;
- }
- tree_roots_ = new NodePtr[trees_];
- for (int i=0; i<trees_; ++i) {
- load_tree(stream,tree_roots_[i]);
- }
-
- index_params_["algorithm"] = getType();
- index_params_["trees"] = tree_roots_;
+ load_value(stream, numTrees);
+
+ if (trees!=NULL) {
+ delete[] trees;
+ }
+ trees = new Tree[numTrees];
+ for (int i=0;i<numTrees;++i) {
+ load_tree(stream,trees[i]);
+ }
}
+
/**
- * Returns size of index.
- */
+ * 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_;
}
- /**
- * Computes the inde memory usage
- * Returns: memory used by the index
- */
- int usedMemory() const
- {
- return int(pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int)); // pool memory and vind array memory
- }
+
+ /**
+ * Computes the inde memory usage
+ * Returns: memory used by the index
+ */
+ int usedMemory() const
+ {
+ return (int)(pool.usedMemory+pool.wastedMemory+dataset.rows*sizeof(int)); // pool memory and vind array memory
+ }
+
/**
* Find set of nearest neighbors to vec. Their indices are stored inside
* vec = the vector for which to search the nearest neighbors
* maxCheck = the maximum number of restarts (in a best-bin-first manner)
*/
- void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+ void findNeighbors(ResultSet<ELEM_TYPE>& 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<NodePtr, DistanceType> 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<Node>();
- 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<TreeSt>();
+ 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<Node>(); // 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<TreeSt>(); // 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; k<veclen_; ++k) {
- mean_[k] += v[k];
+ mean[k] += v[k];
}
- }
+ }
for (size_t k=0; k<veclen_; ++k) {
- mean_[k] /= cnt;
+ mean[k] /= (end - first + 1);
}
- /* Compute variances (no need to divide by count). */
- for (int j = 0; j < cnt; ++j) {
- ElementType* v = dataset_[ind[j]];
+ /* Compute variances (no need to divide by count). */
+ for (int j = first; j <= end; ++j) {
+ ELEM_TYPE* v = dataset[vind[j]];
for (size_t k=0; k<veclen_; ++k) {
- DistanceType dist = v[k] - mean_[k];
- var_[k] += dist * dist;
+ DIST_TYPE dist = v[k] - mean[k];
+ var[k] += dist * dist;
}
- }
- /* Select one of the highest variance indices at random. */
- cutfeat = selectDivision(var_);
- cutval = mean_[cutfeat];
-
- int lim1, lim2;
- planeSplit(ind, count, cutfeat, cutval, lim1, lim2);
-
- if (lim1>count/2) index = lim1;
- else if (lim2<count/2) index = lim2;
- else index = count/2;
-
- /* If either list is empty, it means that all remaining features
- * are identical. Split in the middle to maintain a balanced tree.
- */
- if ((lim1==count)||(lim2==0)) index = count/2;
- }
-
-
- /**
- * Select the top RAND_DIM largest values from v and return the index of
- * one of these selected at random.
- */
- int selectDivision(DistanceType* v)
- {
- int num = 0;
- size_t 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++] = 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
- * dataset[ind[lim1..lim2-1]][cutfeat]==cutval
- * dataset[ind[lim2..count]][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) ++left;
- while (left<=right && dataset_[ind[right]][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<DistanceType>& 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<ELEM_TYPE>& 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<DistanceType>& result, const ElementType* vec, int maxCheck, float epsError)
- {
- int i;
- BranchSt branch;
-
- int checkCount = 0;
- Heap<BranchSt>* heap = new Heap<BranchSt>((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<DistanceType>& result_set, const ElementType* vec, NodePtr node, DistanceType mindist, int& checkCount, int maxCheck,
- float epsError, Heap<BranchSt>* heap, DynamicBitset& checked)
- {
- if (result_set.worstDist()<mindist) {
- // printf("Ignoring branch, too far\n");
- 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.
- */
- 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<ELEM_TYPE>& result, const ELEM_TYPE* vec, int maxCheck)
+ {
+ int i;
+ BranchSt branch;
+
+ int checkCount = 0;
+ Heap<BranchSt>* heap = new Heap<BranchSt>((int)size_);
+ std::vector<bool> 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<ELEM_TYPE>& result, const ELEM_TYPE* vec, Tree node, float mindistsq, int& checkCount, int maxCheck,
+ Heap<BranchSt>* heap, std::vector<bool>& checked)
+ {
+ if (result.worstDist()<mindistsq) {
+// printf("Ignoring branch, too far\n");
+ 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 (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<DistanceType>& 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<int> vind_;
-
- /**
- * The dataset used by this index
- */
- const Matrix<ElementType> 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<ELEM_TYPE>& 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_
+++ /dev/null
-/***********************************************************************
- * 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 <algorithm>
-#include <map>
-#include <cassert>
-#include <cstring>
-
-#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 <typename Distance>
-class KDTreeSingleIndex : public NNIndex<Distance>
-{
-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<ElementType>& 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<ElementType>(new ElementType[size_*dim_], size_, dim_);
- for (size_t i=0; i<size_; ++i) {
- for (size_t j=0; j<dim_; ++j) {
- data_[i][j] = dataset_[vind_[i]][j];
- }
- }
- }
- else {
- data_ = dataset_;
- }
- }
-
- flann_algorithm_t getType() const
- {
- return FLANN_INDEX_KDTREE_SINGLE;
- }
-
-
- void saveIndex(FILE* stream)
- {
- save_value(stream, size_);
- save_value(stream, dim_);
- save_value(stream, root_bbox_);
- save_value(stream, reorder_);
- save_value(stream, leaf_max_size_);
- save_value(stream, vind_);
- if (reorder_) {
- save_value(stream, data_);
- }
- save_tree(stream, root_node_);
- }
-
-
- void loadIndex(FILE* stream)
- {
- load_value(stream, size_);
- load_value(stream, dim_);
- load_value(stream, root_bbox_);
- load_value(stream, reorder_);
- load_value(stream, leaf_max_size_);
- load_value(stream, vind_);
- if (reorder_) {
- load_value(stream, data_);
- }
- else {
- data_ = dataset_;
- }
- load_tree(stream, root_node_);
-
-
- index_params_["algorithm"] = getType();
- index_params_["leaf_max_size"] = leaf_max_size_;
- index_params_["reorder"] = reorder_;
- }
-
- /**
- * Returns size of index.
- */
- size_t size() const
- {
- return size_;
- }
-
- /**
- * Returns the length of an index feature.
- */
- size_t veclen() const
- {
- return dim_;
- }
-
- /**
- * Computes the inde memory usage
- * Returns: memory used by the index
- */
- int usedMemory() const
- {
- return pool_.usedMemory+pool_.wastedMemory+dataset_.rows*sizeof(int); // pool memory and vind array memory
- }
-
-
- /**
- * \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<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& 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<DistanceType> 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<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
- {
- float epsError = 1+get_param(searchParams,"eps",0.0f);
-
- std::vector<DistanceType> 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<Interval> BoundingBox;
-
- typedef BranchStruct<NodePtr, DistanceType> 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<Node>();
- 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; i<dim_; ++i) {
- bbox[i].low = dataset_[0][i];
- bbox[i].high = dataset_[0][i];
- }
- for (size_t k=1; k<dataset_.rows; ++k) {
- for (size_t i=0; i<dim_; ++i) {
- if (dataset_[k][i]<bbox[i].low) bbox[i].low = dataset_[k][i];
- if (dataset_[k][i]>bbox[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<Node>(); // 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; i<dim_; ++i) {
- bbox[i].low = dataset_[vind_[left]][i];
- bbox[i].high = dataset_[vind_[left]][i];
- }
- for (int k=left+1; k<right; ++k) {
- for (size_t i=0; i<dim_; ++i) {
- if (bbox[i].low>dataset_[vind_[k]][i]) bbox[i].low=dataset_[vind_[k]][i];
- if (bbox[i].high<dataset_[vind_[k]][i]) bbox[i].high=dataset_[vind_[k]][i];
- }
- }
- }
- else {
- int idx;
- int cutfeat;
- DistanceType cutval;
- middleSplit_(&vind_[0]+left, right-left, idx, cutfeat, cutval, bbox);
-
- node->divfeat = 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; i<dim_; ++i) {
- bbox[i].low = std::min(left_bbox[i].low, right_bbox[i].low);
- bbox[i].high = std::max(left_bbox[i].high, right_bbox[i].high);
- }
- }
-
- return node;
- }
-
- void computeMinMax(int* ind, int count, int dim, ElementType& min_elem, ElementType& max_elem)
- {
- min_elem = dataset_[ind[0]][dim];
- max_elem = dataset_[ind[0]][dim];
- for (int i=1; i<count; ++i) {
- ElementType val = dataset_[ind[i]][dim];
- if (val<min_elem) min_elem = val;
- if (val>max_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; i<dim_; ++i) {
- ElementType span = bbox[i].low-bbox[i].low;
- if (span>max_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; i<dim_; ++i) {
- if (i==k) continue;
- ElementType span = bbox[i].high-bbox[i].low;
- if (span>max_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 (lim2<count/2) index = lim2;
- else index = count/2;
- }
-
-
- void middleSplit_(int* ind, int count, int& index, int& cutfeat, DistanceType& cutval, const BoundingBox& bbox)
- {
- const float EPS=0.00001f;
- ElementType max_span = bbox[0].high-bbox[0].low;
- for (size_t i=1; i<dim_; ++i) {
- ElementType span = bbox[i].high-bbox[i].low;
- if (span>max_span) {
- max_span = span;
- }
- }
- ElementType max_spread = -1;
- cutfeat = 0;
- for (size_t i=0; i<dim_; ++i) {
- ElementType span = bbox[i].high-bbox[i].low;
- if (span>(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_val<min_elem) cutval = min_elem;
- else if (split_val>max_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 (lim2<count/2) index = lim2;
- else index = count/2;
- }
-
-
- /**
- * 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
- * dataset[ind[lim1..lim2-1]][cutfeat]==cutval
- * dataset[ind[lim2..count]][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) ++left;
- while (left<=right && dataset_[ind[right]][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<DistanceType>& 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<DistanceType>& result_set, const ElementType* vec, const NodePtr node, DistanceType mindistsq,
- std::vector<DistanceType>& 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; i<node->right; ++i) {
- int index = reorder_ ? i : vind_[i];
- DistanceType dist = distance_(vec, data_[index], dim_, worst_dist);
- if (dist<worst_dist) {
- result_set.addPoint(dist,vind_[i]);
- }
- }
- return;
- }
-
- /* Which child branch should be taken first? */
- int idx = node->divfeat;
- 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<ElementType> dataset_;
-
- IndexParams index_params_;
-
- int leaf_max_size_;
- bool reorder_;
-
-
- /**
- * Array of indices to vectors in the dataset.
- */
- std::vector<int> vind_;
-
- Matrix<ElementType> 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_
* 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 <algorithm>
#include <string>
#include <limits>
#include <cmath>
-#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);
+ }
+
};
* Contains a tree constructed through a hierarchical kmeans clustering
* and other information for indexing a set of points for nearest-neighbour matching.
*/
-template <typename Distance>
-class KMeansIndex : public NNIndex<Distance>
+template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
+class KMeansIndex : public NNIndex<ELEM_TYPE>
{
-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<ELEM_TYPE> 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<KMeansNode> 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<k; ++index) {
+ for (index=0;index<k;++index) {
bool duplicate = true;
int rnd;
while (duplicate) {
centers[index] = indices[rnd];
- for (int j=0; j<index; ++j) {
- DistanceType sq = distance_(dataset_[centers[index]], dataset_[centers[j]], dataset_.cols);
+ for (int j=0;j<index;++j) {
+ float sq = (float)flann_dist(dataset[centers[index]],dataset[centers[index]]+dataset.cols,dataset[centers[j]]);
if (sq<1e-16) {
duplicate = true;
}
/**
- * Chooses the initial centers in the k-means using Gonzales' algorithm
- * so that the centers are spaced apart from each other.
- *
- * Params:
- * k = number of centers
- * vecs = the dataset of points
- * indices = indices in the dataset
- * Returns:
- */
+ * Chooses the initial centers in the k-means using Gonzales' algorithm
+ * so that the centers are spaced apart from each other.
+ *
+ * Params:
+ * k = number of centers
+ * vecs = the dataset of points
+ * indices = indices in the dataset
+ * Returns:
+ */
void chooseCentersGonzales(int k, int* indices, int indices_length, int* centers, int& centers_length)
{
int n = indices_length;
for (index=1; index<k; ++index) {
int best_index = -1;
- DistanceType best_val = 0;
- for (int j=0; j<n; ++j) {
- DistanceType dist = distance_(dataset_[centers[0]],dataset_[indices[j]],dataset_.cols);
- for (int i=1; i<index; ++i) {
- DistanceType tmp_dist = distance_(dataset_[centers[i]],dataset_[indices[j]],dataset_.cols);
+ float best_val = 0;
+ for (int j=0;j<n;++j) {
+ float dist = (float)flann_dist(dataset[centers[0]],dataset[centers[0]]+dataset.cols,dataset[indices[j]]);
+ for (int i=1;i<index;++i) {
+ float tmp_dist = (float)flann_dist(dataset[centers[i]],dataset[centers[i]]+dataset.cols,dataset[indices[j]]);
if (tmp_dist<dist) {
dist = tmp_dist;
}
/**
- * 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:
- */
+ * 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];
+ double* closestDistSq = new double[n];
// Choose one random center and set the closestDistSq values
int index = rand_int(n);
centers[0] = indices[index];
for (int i = 0; i < n; i++) {
- closestDistSq[i] = distance_(dataset_[indices[i]], dataset_[indices[index]], dataset_.cols);
+ closestDistSq[i] = flann_dist(dataset[indices[i]], dataset[indices[i]] + dataset.cols, dataset[indices[index]]);
currentPot += closestDistSq[i];
}
// Choose our center - have to be slightly careful to return a valid answer even accounting
// for possible rounding errors
- double randVal = rand_double(currentPot);
+ double randVal = rand_double(currentPot);
for (index = 0; index < n-1; index++) {
- if (randVal <= closestDistSq[index]) break;
- else randVal -= closestDistSq[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] );
+ for (int i = 0; i < n; i++)
+ newPot += std::min( flann_dist(dataset[indices[i]], dataset[indices[i]] + dataset.cols, dataset[indices[index]]), closestDistSq[i] );
// Store the best result
- if ((bestNewPot < 0)||(newPot < bestNewPot)) {
+ 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] );
+ for (int i = 0; i < n; i++)
+ closestDistSq[i] = std::min( flann_dist(dataset[indices[i]], dataset[indices[i]]+dataset.cols, dataset[indices[bestNewIndex]]), closestDistSq[i] );
}
centers_length = centerCount;
- delete[] closestDistSq;
+ delete[] closestDistSq;
}
public:
+
flann_algorithm_t getType() const
{
return FLANN_INDEX_KMEANS;
}
- /**
- * Index constructor
- *
- * Params:
- * inputData = dataset with the input features
- * params = parameters passed to the hierarchical k-means algorithm
- */
- KMeansIndex(const Matrix<ElementType>& 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<int>::max)();
+ /**
+ * Index constructor
+ *
+ * Params:
+ * inputData = dataset with the input features
+ * params = parameters passed to the hierarchical k-means algorithm
+ */
+ KMeansIndex(const Matrix<ELEM_TYPE>& 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<int>::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_;
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<size_; ++i) {
- indices_[i] = int(i);
- }
+ /**
+ * Builds the index
+ */
+ void buildIndex()
+ {
+ if (branching<2) {
+ throw FLANNException("Branching factor must be at least 2");
+ }
- root_ = pool_.allocate<KMeansNode>();
- computeNodeStatistics(root_, indices_, (int)size_);
- computeClustering(root_, indices_, (int)size_, branching_,0);
- }
+ indices = new int[size_];
+ for (size_t i=0;i<size_;++i) {
+ indices[i] = (int)i;
+ }
+
+ root = pool.allocate<KMeansNodeSt>();
+ 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);
}
* vec = the vector for which to search the nearest neighbors
* searchParams = parameters that influence the search algorithm (checks, cb_index)
*/
- void findNeighbors(ResultSet<DistanceType>& result, const ElementType* vec, const SearchParams& searchParams)
+ void findNeighbors(ResultSet<ELEM_TYPE>& 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<BranchSt>* heap = new Heap<BranchSt>((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<maxChecks || !result.full())) {
- KMeansNodePtr node = branch.node;
+ KMeansNode node = branch.node;
findNN(node, result, vec, checks, maxChecks, heap);
}
assert(result.full());
}
+
/**
* Clustering function that takes a cut in the hierarchical k-means
* tree and return the clusters centers of that clustering.
* numClusters = number of clusters to have in the clustering computed
* Returns: number of cluster centers
*/
- int getClusterCenters(Matrix<DistanceType>& centers)
+ int getClusterCenters(Matrix<DIST_TYPE>& 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; i<clusterCount; ++i) {
- DistanceType* center = clusters[i]->pivot;
- for (size_t j=0; j<veclen_; ++j) {
+
+ for (int i=0;i<clusterCount;++i) {
+ DIST_TYPE* center = clusters[i]->pivot;
+ for (size_t j=0;j<veclen_;++j) {
centers[i][j] = center[j];
}
}
- delete[] clusters;
+ delete[] clusters;
return clusterCount;
}
- IndexParams getParameters() const
- {
- return index_params_;
- }
+ const IndexParams* getParameters() const
+ {
+ return &index_params;
+ }
private:
- /**
- * Struture representing a node in the hierarchical k-means tree.
- */
- struct KMeansNode
- {
- /**
- * The cluster center.
- */
- DistanceType* pivot;
- /**
- * The cluster radius.
- */
- DistanceType radius;
- /**
- * The cluster mean radius.
- */
- DistanceType mean_radius;
- /**
- * The cluster variance.
- */
- DistanceType variance;
- /**
- * The cluster size (number of points in the cluster)
- */
- int size;
- /**
- * Child nodes (only for non-terminal nodes)
- */
- KMeansNode** childs;
- /**
- * Node points (only for terminal nodes)
- */
- int* indices;
- /**
- * Level
- */
- int level;
- };
- typedef KMeansNode* KMeansNodePtr;
- /**
- * Alias definition for a nicer syntax.
- */
- typedef BranchStruct<KMeansNodePtr, DistanceType> 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; i<branching_; ++i) {
- save_tree(stream, node->childs[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; i<branching; ++i) {
+ save_tree(stream, node->childs[i]);
+ }
+ }
}
- void load_tree(FILE* stream, KMeansNodePtr& node)
+ void load_tree(FILE* stream, KMeansNode& node)
{
- node = pool_.allocate<KMeansNode>();
- 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<KMeansNodePtr>(branching_);
- for(int i=0; i<branching_; ++i) {
- load_tree(stream, node->childs[i]);
- }
- }
+ node = pool.allocate<KMeansNodeSt>();
+ 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<KMeansNode>(branching);
+ for(int i=0; i<branching; ++i) {
+ load_tree(stream, node->childs[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; k<branching_; ++k) {
+ for (int k=0;k<branching;++k) {
free_centers(node->childs[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<size_; ++i) {
- ElementType* vec = dataset_[indices[i]];
- for (size_t j=0; j<veclen_; ++j) {
+ /**
+ * 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(KMeansNode node, int* indices, int indices_length) {
+
+ double radius = 0;
+ double variance = 0;
+ DIST_TYPE* mean = new DIST_TYPE[veclen_];
+ memoryCounter += (int)(veclen_*sizeof(DIST_TYPE));
+
+ memset(mean,0,veclen_*sizeof(float));
+
+ for (size_t i=0;i<size_;++i) {
+ ELEM_TYPE* vec = dataset[indices[i]];
+ for (size_t j=0;j<veclen_;++j) {
mean[j] += vec[j];
}
- variance += distance_(vec, ZeroIterator<ElementType>(), veclen_);
- }
- for (size_t j=0; j<veclen_; ++j) {
- mean[j] /= size_;
- }
- variance /= size_;
- variance -= distance_(mean, ZeroIterator<ElementType>(), veclen_);
-
- DistanceType tmp = 0;
- for (int i=0; i<indices_length; ++i) {
- tmp = distance_(mean, dataset_[indices[i]], veclen_);
- if (tmp>radius) {
- 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;j<veclen_;++j) {
+ mean[j] /= size_;
+ }
+ variance /= size_;
+ variance -= flann_dist(mean,mean+veclen_,zero());
+
+ double tmp = 0;
+ for (int i=0;i<indices_length;++i) {
+ tmp = flann_dist(mean, mean + veclen_, dataset[indices[i]]);
+ if (tmp>radius) {
+ 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_length<branching) {
+ if (centers_length<branching) {
node->indices = indices;
std::sort(node->indices,node->indices+indices_length);
node->childs = NULL;
- delete [] centers_idx;
- return;
- }
+ return;
+ }
- Matrix<double> dcenters(new double[branching*veclen_],branching,veclen_);
+ Matrix<double> dcenters(new double[branching*veclen_],branching,(long)veclen_);
for (int i=0; i<centers_length; ++i) {
- ElementType* vec = dataset_[centers_idx[i]];
+ ELEM_TYPE* vec = dataset[centers_idx[i]];
for (size_t k=0; k<veclen_; ++k) {
dcenters[i][k] = double(vec[k]);
}
}
- delete[] centers_idx;
+ delete[] centers_idx;
- DistanceType* radiuses = new DistanceType[branching];
- int* count = new int[branching];
- for (int i=0; i<branching; ++i) {
+ float* radiuses = new float[branching];
+ int* count = new int[branching];
+ for (int i=0;i<branching;++i) {
radiuses[i] = 0;
count[i] = 0;
}
// assign points to clusters
- int* belongs_to = new int[indices_length];
- for (int i=0; i<indices_length; ++i) {
-
- DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
- belongs_to[i] = 0;
- for (int j=1; j<branching; ++j) {
- DistanceType new_sq_dist = distance_(dataset_[indices[i]], dcenters[j], veclen_);
- if (sq_dist>new_sq_dist) {
- belongs_to[i] = j;
- sq_dist = new_sq_dist;
- }
- }
+ int* belongs_to = new int[indices_length];
+ for (int i=0;i<indices_length;++i) {
+
+ double sq_dist = flann_dist(dataset[indices[i]], dataset[indices[i]] + veclen_ ,dcenters[0]);
+ belongs_to[i] = 0;
+ for (int j=1;j<branching;++j) {
+ double new_sq_dist = flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_, dcenters[j]);
+ if (sq_dist>new_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 && iteration<iterations_) {
- converged = true;
- iteration++;
+ bool converged = false;
+ int iteration = 0;
+ while (!converged && iteration<max_iter) {
+ converged = true;
+ iteration++;
- // compute the new cluster centers
- for (int i=0; i<branching; ++i) {
+ // compute the new cluster centers
+ for (int i=0;i<branching;++i) {
memset(dcenters[i],0,sizeof(double)*veclen_);
radiuses[i] = 0;
- }
- for (int i=0; i<indices_length; ++i) {
- ElementType* vec = dataset_[indices[i]];
- double* center = dcenters[belongs_to[i]];
- for (size_t k=0; k<veclen_; ++k) {
- center[k] += vec[k];
- }
- }
- for (int i=0; i<branching; ++i) {
+ }
+ for (int i=0;i<indices_length;++i) {
+ ELEM_TYPE* vec = dataset[indices[i]];
+ double* center = dcenters[belongs_to[i]];
+ for (size_t k=0;k<veclen_;++k) {
+ center[k] += vec[k];
+ }
+ }
+ for (int i=0;i<branching;++i) {
int cnt = count[i];
- for (size_t k=0; k<veclen_; ++k) {
+ for (size_t k=0;k<veclen_;++k) {
dcenters[i][k] /= cnt;
}
- }
-
- // reassign points to clusters
- for (int i=0; i<indices_length; ++i) {
- DistanceType sq_dist = distance_(dataset_[indices[i]], dcenters[0], veclen_);
- int new_centroid = 0;
- for (int j=1; j<branching; ++j) {
- DistanceType new_sq_dist = distance_(dataset_[indices[i]], dcenters[j], veclen_);
- if (sq_dist>new_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; i<branching; ++i) {
- // if one cluster converges to an empty cluster,
- // move an element into that cluster
- if (count[i]==0) {
- int j = (i+1)%branching;
- while (count[j]<=1) {
- j = (j+1)%branching;
- }
-
- for (int k=0; k<indices_length; ++k) {
- if (belongs_to[k]==j) {
- belongs_to[k] = i;
- count[j]--;
- count[i]++;
- break;
- }
- }
- converged = false;
- }
- }
-
- }
-
- DistanceType** centers = new DistanceType*[branching];
+ }
+
+ // reassign points to clusters
+ for (int i=0;i<indices_length;++i) {
+ float sq_dist = (float)flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_ ,dcenters[0]);
+ int new_centroid = 0;
+ for (int j=1;j<branching;++j) {
+ float new_sq_dist = (float)flann_dist(dataset[indices[i]], dataset[indices[i]]+veclen_,dcenters[j]);
+ if (sq_dist>new_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;i<branching;++i) {
+ // if one cluster converges to an empty cluster,
+ // move an element into that cluster
+ if (count[i]==0) {
+ int j = (i+1)%branching;
+ while (count[j]<=1) {
+ j = (j+1)%branching;
+ }
+
+ for (int k=0;k<indices_length;++k) {
+ if (belongs_to[k]==j) {
+ belongs_to[k] = i;
+ count[j]--;
+ count[i]++;
+ break;
+ }
+ }
+ converged = false;
+ }
+ }
+
+ }
+
+ DIST_TYPE** centers = new DIST_TYPE*[branching];
for (int i=0; i<branching; ++i) {
- centers[i] = new DistanceType[veclen_];
- memoryCounter_ += veclen_*sizeof(DistanceType);
+ centers[i] = new DIST_TYPE[veclen_];
+ memoryCounter += (int)(veclen_*sizeof(DIST_TYPE));
for (size_t k=0; k<veclen_; ++k) {
- centers[i][k] = (DistanceType)dcenters[i][k];
+ centers[i][k] = (DIST_TYPE)dcenters[i][k];
}
- }
-
-
- // compute kmeans clustering for each of the resulting clusters
- node->childs = pool_.allocate<KMeansNodePtr>(branching);
- int start = 0;
- int end = start;
- for (int c=0; c<branching; ++c) {
- int s = count[c];
-
- DistanceType variance = 0;
- DistanceType mean_radius =0;
- for (int i=0; i<indices_length; ++i) {
- if (belongs_to[i]==c) {
- DistanceType d = distance_(dataset_[indices[i]], ZeroIterator<ElementType>(), veclen_);
- variance += d;
- mean_radius += sqrt(d);
+ }
+
+
+ // compute kmeans clustering for each of the resulting clusters
+ node->childs = pool.allocate<KMeansNode>(branching);
+ int start = 0;
+ int end = start;
+ for (int c=0;c<branching;++c) {
+ int s = count[c];
+
+ double variance = 0;
+ double mean_radius =0;
+ for (int i=0;i<indices_length;++i) {
+ if (belongs_to[i]==c) {
+ double d = flann_dist(dataset[indices[i]],dataset[indices[i]]+veclen_,zero());
+ variance += d;
+ mean_radius += sqrt(d);
std::swap(indices[i],indices[end]);
std::swap(belongs_to[i],belongs_to[end]);
- end++;
- }
- }
- variance /= s;
- mean_radius /= s;
- variance -= distance_(centers[c], ZeroIterator<ElementType>(), veclen_);
-
- node->childs[c] = pool_.allocate<KMeansNode>();
- node->childs[c]->radius = radiuses[c];
- node->childs[c]->pivot = centers[c];
- node->childs[c]->variance = variance;
- node->childs[c]->mean_radius = mean_radius;
- node->childs[c]->indices = NULL;
- computeClustering(node->childs[c],indices+start, end-start, branching, level+1);
- start=end;
- }
-
- delete[] 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<KMeansNodeSt>();
+ 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
*/
- void findNN(KMeansNodePtr node, ResultSet<DistanceType>& result, const ElementType* vec, int& checks, int maxChecks,
- Heap<BranchSt>* 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<ELEM_TYPE>& result, const ELEM_TYPE* vec, int& checks, int maxChecks,
+ Heap<BranchSt>* 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; i<node->size; ++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<BranchSt>* heap)
- {
-
- int best_index = 0;
- domain_distances[best_index] = distance_(q, node->childs[best_index]->pivot, veclen_);
- for (int i=1; i<branching_; ++i) {
- domain_distances[i] = distance_(q, node->childs[i]->pivot, veclen_);
- if (domain_distances[i]<domain_distances[best_index]) {
- best_index = i;
- }
- }
-
- // float* best_center = node->childs[best_index]->pivot;
- for (int i=0; i<branching_; ++i) {
- if (i != best_index) {
- domain_distances[i] -= cb_index_*node->childs[i]->variance;
-
- // float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q);
- // if (domain_distances[i]<dist_to_border) {
- // domain_distances[i] = dist_to_border;
- // }
- heap->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<DistanceType>& 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; i<node->size; ++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; i<branching_; ++i) {
- findExactNN(node->childs[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; i<branching_; ++i) {
- DistanceType dist = distance_(q, node->childs[i]->pivot, veclen_);
-
- int j=0;
- while (domain_distances[j]<dist && j<i) j++;
- for (int k=i; k>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; i<veclen_; ++i) {
- DistanceType t = c[i]-p[i];
- sum += t*(q[i]-(c[i]+p[i])/2);
- sum2 += t*t;
- }
-
- return sum*sum/sum2;
- }
-
-
- /**
- * Helper function the descends in the hierarchical k-means tree by spliting those clusters that minimize
- * the overall variance of the clustering.
- * Params:
- * root = root node
- * clusters = array with clusters centers (return value)
- * varianceValue = variance of the clustering (return value)
- * Returns:
- */
- int getMinVarianceClusters(KMeansNodePtr root, KMeansNodePtr* clusters, int clusters_length, DistanceType& varianceValue)
- {
- int clusterCount = 1;
- clusters[0] = root;
-
- DistanceType meanVariance = root->variance*root->size;
-
- while (clusterCount<clusters_length) {
- DistanceType minVariance = (std::numeric_limits<DistanceType>::max)();
- int splitIndex = -1;
-
- for (int i=0; i<clusterCount; ++i) {
- if (clusters[i]->childs != NULL) {
-
- DistanceType variance = meanVariance - clusters[i]->variance*clusters[i]->size;
-
- for (int j=0; j<branching_; ++j) {
- variance += clusters[i]->childs[j]->variance*clusters[i]->childs[j]->size;
- }
- if (variance<minVariance) {
- minVariance = variance;
- splitIndex = i;
- }
- }
- }
-
- if (splitIndex==-1) break;
- if ( (branching_+clusterCount-1) > clusters_length) break;
-
- meanVariance = minVariance;
-
- // split node
- KMeansNodePtr toSplit = clusters[splitIndex];
- clusters[splitIndex] = toSplit->childs[0];
- for (int i=1; i<branching_; ++i) {
- clusters[clusterCount++] = toSplit->childs[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<ElementType> 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;i<node->size;++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<BranchSt>* heap)
+ {
+
+ int best_index = 0;
+ domain_distances[best_index] = (float)flann_dist(q,q+veclen_,node->childs[best_index]->pivot);
+ for (int i=1;i<branching;++i) {
+ domain_distances[i] = (float)flann_dist(q,q+veclen_,node->childs[i]->pivot);
+ if (domain_distances[i]<domain_distances[best_index]) {
+ best_index = i;
+ }
+ }
+
+// float* best_center = node->childs[best_index]->pivot;
+ for (int i=0;i<branching;++i) {
+ if (i != best_index) {
+ domain_distances[i] -= cb_index*node->childs[i]->variance;
+
+// float dist_to_border = getDistanceToBorder(node.childs[i].pivot,best_center,q);
+// if (domain_distances[i]<dist_to_border) {
+// domain_distances[i] = dist_to_border;
+// }
+ heap->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<ELEM_TYPE>& 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;i<node->size;++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; i<branching; ++i) {
+ findExactNN(node->childs[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;i<branching;++i) {
+ float dist = (float)flann_dist(q, q+veclen_, node->childs[i]->pivot);
+
+ int j=0;
+ while (domain_distances[j]<dist && j<i) j++;
+ for (int k=i;k>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;i<veclen_; ++i) {
+ float t = c[i]-p[i];
+ sum += t*(q[i]-(c[i]+p[i])/2);
+ sum2 += t*t;
+ }
+
+ return sum*sum/sum2;
+ }
+
+
+ /**
+ * Helper function the descends in the hierarchical k-means tree by spliting those clusters that minimize
+ * the overall variance of the clustering.
+ * Params:
+ * root = root node
+ * clusters = array with clusters centers (return value)
+ * varianceValue = variance of the clustering (return value)
+ * Returns:
+ */
+ int getMinVarianceClusters(KMeansNode root, KMeansNode* clusters, int clusters_length, float& varianceValue)
+ {
+ int clusterCount = 1;
+ clusters[0] = root;
+
+ float meanVariance = root->variance*root->size;
+
+ while (clusterCount<clusters_length) {
+ float minVariance = (std::numeric_limits<float>::max)();
+ int splitIndex = -1;
+
+ for (int i=0;i<clusterCount;++i) {
+ if (clusters[i]->childs != NULL) {
+
+ float variance = meanVariance - clusters[i]->variance*clusters[i]->size;
+
+ for (int j=0;j<branching;++j) {
+ variance += clusters[i]->childs[j]->variance*clusters[i]->childs[j]->size;
+ }
+ if (variance<minVariance) {
+ minVariance = variance;
+ splitIndex = i;
+ }
+ }
+ }
+
+ if (splitIndex==-1) break;
+ if ( (branching+clusterCount-1) > clusters_length) break;
+
+ meanVariance = minVariance;
+
+ // split node
+ KMeansNode toSplit = clusters[splitIndex];
+ clusters[splitIndex] = toSplit->childs[0];
+ for (int i=1;i<branching;++i) {
+ clusters[clusterCount++] = toSplit->childs[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_
* 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 <typename Distance>
-class LinearIndex : public NNIndex<Distance>
-{
-public:
- typedef typename Distance::ElementType ElementType;
- typedef typename Distance::ResultType DistanceType;
+template <typename ELEM_TYPE, typename DIST_TYPE = typename DistType<ELEM_TYPE>::type >
+class LinearIndex : public NNIndex<ELEM_TYPE>
+{
+ const Matrix<ELEM_TYPE> dataset;
+ const LinearIndexParams& index_params;
+ LinearIndex(const LinearIndex&);
+ LinearIndex& operator=(const LinearIndex&);
- LinearIndex(const Matrix<ElementType>& 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<ELEM_TYPE>& inputData, const LinearIndexParams& params = LinearIndexParams() ) :
+ dataset(inputData), index_params(params)
+ {
+ }
flann_algorithm_t getType() const
{
}
- 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<DistanceType>& 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<ELEM_TYPE>& resultSet, const ELEM_TYPE*, const SearchParams&)
+ {
+ for (size_t i=0;i<dataset.rows;++i) {
+ resultSet.addPoint(dataset[i],(int)i);
+ }
+ }
-private:
- /** The dataset */
- const Matrix<ElementType> 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_
* 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 <stdio.h>
+#include <cstdio>
#include <stdarg.h>
-#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;
}
}
- 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_
+++ /dev/null
-/***********************************************************************
- * 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 <algorithm>
-#include <cassert>
-#include <cstring>
-#include <map>
-#include <vector>
-
-#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<typename Distance>
-class LshIndex : public NNIndex<Distance>
-{
-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<ElementType>& input_data, const IndexParams& params = LshIndexParams(),
- Distance d = Distance()) :
- dataset_(input_data), index_params_(params), distance_(d)
- {
- table_number_ = get_param<unsigned int>(index_params_,"table_number",12);
- key_size_ = get_param<unsigned int>(index_params_,"key_size",20);
- multi_probe_level_ = get_param<unsigned int>(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<ElementType>& table = tables_[i];
- table = lsh::LshTable<ElementType>(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<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& 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<DistanceType> 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<DistanceType>& result, const ElementType* vec, const SearchParams& /*searchParams*/)
- {
- getNeighbors(vec, result);
- }
-
-private:
- /** Defines the comparator on score and index
- */
- typedef std::pair<float, unsigned int> 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<lsh::BucketKey>& 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<ScoreIndexPair> score_index_heap;
-
- if (do_k) {
- unsigned int worst_score = std::numeric_limits<unsigned int>::max();
- typename std::vector<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
- typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
- for (; table != table_end; ++table) {
- size_t key = table->getKey(vec);
- std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
- std::vector<lsh::BucketKey>::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<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
- std::vector<lsh::FeatureIndex>::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<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
- typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
- for (; table != table_end; ++table) {
- size_t key = table->getKey(vec);
- std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
- std::vector<lsh::BucketKey>::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<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
- std::vector<lsh::FeatureIndex>::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<DistanceType>& result)
- {
- typename std::vector<lsh::LshTable<ElementType> >::const_iterator table = tables_.begin();
- typename std::vector<lsh::LshTable<ElementType> >::const_iterator table_end = tables_.end();
- for (; table != table_end; ++table) {
- size_t key = table->getKey(vec);
- std::vector<lsh::BucketKey>::const_iterator xor_mask = xor_masks_.begin();
- std::vector<lsh::BucketKey>::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<lsh::FeatureIndex>::const_iterator training_index = bucket->begin();
- std::vector<lsh::FeatureIndex>::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<lsh::LshTable<ElementType> > tables_;
-
- /** The data the LSH tables where built from */
- Matrix<ElementType> 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<lsh::BucketKey> xor_masks_;
-
- Distance distance_;
-};
-}
-
-#endif //OPENCV_FLANN_LSH_INDEX_H_
+++ /dev/null
-/***********************************************************************
- * 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 <algorithm>
-#include <iostream>
-#include <iomanip>
-#include <limits.h>
-// TODO as soon as we use C++0x, use the code in USE_UNORDERED_MAP
-#if USE_UNORDERED_MAP
-#include <unordered_map>
-#else
-#include <map>
-#endif
-#include <math.h>
-#include <stddef.h>
-
-#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<FeatureIndex> Bucket;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/** POD for stats about an LSH table
- */
-struct LshStats
-{
- std::vector<unsigned int> 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<std::vector<unsigned int> > 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<std::vector<unsigned int> >::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<typename ElementType>
-class LshTable
-{
-public:
- /** A container of all the feature indices. Optimized for space
- */
-#if USE_UNORDERED_MAP
- typedef std::unordered_map<BucketKey, Bucket> BucketsSpace;
-#else
- typedef std::map<BucketKey, Bucket> BucketsSpace;
-#endif
-
- /** A container of all the feature indices. Optimized for speed
- */
- typedef std::vector<Bucket> 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<ElementType> 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<size_t> mask_;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Specialization for unsigned char
-
-template<>
-inline LshTable<unsigned char>::LshTable(unsigned int feature_size, unsigned int subsignature_size)
-{
- initialize(subsignature_size);
- // Allocate the mask
- mask_ = std::vector<size_t>((size_t)ceil((float)(feature_size * sizeof(char)) / (float)sizeof(size_t)), 0);
-
- // A bit brutal but fast to code
- std::vector<size_t> indices(feature_size * CHAR_BIT);
- for (size_t i = 0; i < feature_size * CHAR_BIT; ++i) indices[i] = i;
- std::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<unsigned char>::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<const size_t*> (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<size_t>::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<unsigned char>::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<unsigned int>::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<unsigned int>(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_ */
* 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 <stdio.h>
-#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 <typename T>
-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<T>::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;
}
};
flann_datatype_t type;
UntypedMatrix(void* data_, long rows_, long cols_) :
- rows(rows_), cols(cols_), data(data_)
+ rows(rows_), cols(cols_), data(data_)
{
}
-}
+} // namespace cvflann
-#endif //OPENCV_FLANN_DATASET_H_
+#endif //_OPENCV_DATASET_H_
* 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 <string>
-#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 <typename ELEM_TYPE>
+class ResultSet;
+
/**
- * Nearest-neighbour index base class
- */
-template <typename Distance>
+* Nearest-neighbour index base class
+*/
+template <typename ELEM_TYPE>
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<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& 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<DistanceType> resultSet(knn);
- for (size_t i = 0; i < queries.rows; i++) {
- resultSet.init(indices[i], dists[i]);
- findNeighbors(resultSet, queries[i], params);
- }
-#else
- KNNUniqueResultSet<DistanceType> 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<ElementType>& query, Matrix<int>& indices, Matrix<DistanceType>& 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<DistanceType> 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<DistanceType>& 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<ELEM_TYPE>& 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_
* 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 <map>
namespace cvflann
{
-class CreatorNotFound
+template<typename BaseClass, typename DerivedClass>
+BaseClass* createObject()
{
-};
+ return new DerivedClass();
+}
-template<typename BaseClass,
- typename UniqueIdType,
- typename ObjectCreator = BaseClass* (*)()>
+template<typename BaseClass, typename UniqueIdType>
class ObjectFactory
{
- typedef ObjectFactory<BaseClass,UniqueIdType,ObjectCreator> ThisClass;
- typedef std::map<UniqueIdType, ObjectCreator> ObjectRegistry;
+ typedef BaseClass* (*CreateObjectFunc)();
+ std::map<UniqueIdType, CreateObjectFunc> object_registry;
- // singleton class, private constructor
- ObjectFactory() {}
+ // singleton class, private constructor
+ //ObjectFactory() {};
public:
+ typedef typename std::map<UniqueIdType, CreateObjectFunc>::iterator Iterator;
+
+
+ template<typename DerivedClass>
+ bool register_(UniqueIdType id)
+ {
+ if (object_registry.find(id) != object_registry.end())
+ return false;
+
+ object_registry[id] = &createObject<BaseClass, DerivedClass>;
+ 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<BaseClass,UniqueIdType>& instance()
+ {
+ static ObjectFactory<BaseClass,UniqueIdType> 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_ */
+++ /dev/null
-/***********************************************************************
- * 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 <iostream>
-#include <map>
-
-
-namespace cvflann
-{
-
-typedef cdiggins::any any;
-typedef std::map<std::string, any> 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<typename T>
-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<T>();
- }
- else {
- return default_value;
- }
-}
-
-template<typename T>
-T get_param(const IndexParams& params, std::string name)
-{
- IndexParams::const_iterator it = params.find(name);
- if (it != params.end()) {
- return it->second.cast<T>();
- }
- 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_ */
* 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 <algorithm>
#include <cstdlib>
-#include <vector>
+#include <cassert>
-#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<int> 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;i<size;++i) {
+ vals[i] = i;
+ }
+
+ // shuffle the elements in the array
+ // Fisher-Yates shuffle
+ for (int i=size;i>0;--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_
* 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 <algorithm>
-#include <cstring>
-#include <iostream>
#include <limits>
-#include <set>
#include <vector>
+#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 <typename T, typename DistanceType>
-struct BranchStruct
-{
- T node; /* Tree node at which search resumes */
- DistanceType mindist; /* Minimum distance to query for all nodes below. */
+template <typename T>
+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<T>& rhs)
+ {
+ return mindistsq<rhs.mindistsq;
+ }
- bool operator<(const BranchStruct<T, DistanceType>& rhs) const
+ static BranchStruct<T> make_branch(const T& aNode, float dist)
{
- return mindist<rhs.mindist;
+ BranchStruct<T> branch;
+ branch.node = aNode;
+ branch.mindistsq = dist;
+ return branch;
}
};
-template <typename DistanceType>
-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 <typename DistanceType>
-class KNNSimpleResultSet : public ResultSet<DistanceType>
+template <typename ELEM_TYPE>
+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<DistanceType>::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<capacity) {
- dists[i] = dists[i-1];
- indices[i] = indices[i-1];
- }
- }
- else break;
- }
- if (count < capacity) ++count;
- dists[i] = dist;
- indices[i] = index;
- worst_distance_ = dists[capacity-1];
- }
-
- DistanceType worstDist() const
- {
- return worst_distance_;
- }
-};
+ virtual ~ResultSet() {};
-/**
- * K-Nearest neighbour result set. Ensures that the elements inserted are unique
- */
-template <typename DistanceType>
-class KNNResultSet : public ResultSet<DistanceType>
-{
- 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<DistanceType>::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 <typename DistanceType>
-class RadiusResultSet : public ResultSet<DistanceType>
+template <typename ELEM_TYPE>
+class KNNResultSet : public ResultSet<ELEM_TYPE>
{
- 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 (dist<radius) {
- if ((capacity>0)&&(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<typename DistanceType>
-class UniqueResultSet : public ResultSet<DistanceType>
-{
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<DistanceType>::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<DistIndex>::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<DistIndex>::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<DistIndex> dist_indices_;
+ return count;
+ }
+
+ bool full() const
+ {
+ return count == capacity;
+ }
+
+
+ bool addPoint(const ELEM_TYPE* point, int index)
+ {
+ for (int i=0;i<count;++i) {
+ if (indices[i]==index) return false;
+ }
+ float dist = (float)flann_dist(target, target_end, point);
+
+ if (count<capacity) {
+ indices[count] = index;
+ dists[count] = dist;
+ ++count;
+ }
+ else if (dist < dists[count-1] || (dist == dists[count-1] && index < indices[count-1])) {
+// else if (dist < dists[count-1]) {
+ indices[count-1] = index;
+ dists[count-1] = dist;
+ }
+ else {
+ return false;
+ }
+
+ int i = count-1;
+ // bubble up
+ while (i>=1 && (dists[i]<dists[i-1] || (dists[i]==dists[i-1] && indices[i]<indices[i-1]) ) ) {
+// while (i>=1 && (dists[i]<dists[i-1]) ) {
+ std::swap(indices[i],indices[i-1]);
+ std::swap(dists[i],dists[i-1]);
+ i--;
+ }
+
+ return true;
+ }
+
+ float worstDist() const
+ {
+ return (count<capacity) ? (std::numeric_limits<float>::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<typename DistanceType>
-class KNNUniqueResultSet : public UniqueResultSet<DistanceType>
+template <typename ELEM_TYPE>
+class RadiusResultSet : public ResultSet<ELEM_TYPE>
{
-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<DistanceType>::max();
- is_full_ = false;
- }
+ bool operator<(Item rhs) {
+ return dist<rhs.dist;
+ }
+ };
-protected:
- typedef typename UniqueResultSet<DistanceType>::DistIndex DistIndex;
- using UniqueResultSet<DistanceType>::is_full_;
- using UniqueResultSet<DistanceType>::worst_distance_;
- using UniqueResultSet<DistanceType>::dist_indices_;
+ std::vector<Item> 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<typename DistanceType>
-class RadiusUniqueResultSet : public UniqueResultSet<DistanceType>
-{
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<items.size();++i) {
+ indices[i] = items[i].index;
+ }
+ return indices;
+ }
+
+ float* getDistances()
+ {
+ if (!sorted) {
+ sorted = true;
+ sort_heap(items.begin(), items.end());
+ }
+ resize_vecs();
+ for (size_t i=0;i<items.size();++i) {
+ dists[i] = items[i].dist;
+ }
+ return dists;
}
-
- /** Check the status of the set
- * @return alwys false
- */
- inline bool full() const
+ size_t size() const
{
- return true;
+ return items.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 radius_;
- }
-private:
- typedef typename UniqueResultSet<DistanceType>::DistIndex DistIndex;
- using UniqueResultSet<DistanceType>::dist_indices_;
- using UniqueResultSet<DistanceType>::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<typename DistanceType>
-class KNNRadiusUniqueResultSet : public KNNUniqueResultSet<DistanceType>
-{
-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<DistanceType>::dist_indices_;
- using KNNUniqueResultSet<DistanceType>::is_full_;
- using KNNUniqueResultSet<DistanceType>::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_
*************************************************************************/
-#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
{
template<typename T>
Matrix<T> random_sample(Matrix<T>& srcMatrix, long size, bool remove = false)
{
- Matrix<T> newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols);
+ UniqueRandom rand((int)srcMatrix.rows);
+ Matrix<T> newSet(new T[size * srcMatrix.cols], size, (long)srcMatrix.cols);
- T* src,* dest;
- for (long i=0; i<size; ++i) {
- long r = rand_int(srcMatrix.rows-i);
+ T *src,*dest;
+ for (long i=0;i<size;++i) {
+ long r = rand.next();
dest = newSet[i];
src = srcMatrix[r];
- std::copy(src, src+srcMatrix.cols, dest);
+ for (size_t j=0;j<srcMatrix.cols;++j) {
+ dest[j] = src[j];
+ }
if (remove) {
- src = srcMatrix[srcMatrix.rows-i-1];
- dest = srcMatrix[r];
- std::copy(src, src+srcMatrix.cols, dest);
+ dest = srcMatrix[srcMatrix.rows-i-1];
+ src = srcMatrix[r];
+ for (size_t j=0;j<srcMatrix.cols;++j) {
+ std::swap(*src,*dest);
+ src++;
+ dest++;
+ }
}
}
+
if (remove) {
- srcMatrix.rows -= size;
+ srcMatrix.rows -= size;
}
+
return newSet;
}
template<typename T>
Matrix<T> random_sample(const Matrix<T>& srcMatrix, size_t size)
{
- UniqueRandom rand(srcMatrix.rows);
- Matrix<T> newSet(new T[size * srcMatrix.cols], size,srcMatrix.cols);
+ UniqueRandom rand((int)srcMatrix.rows);
+ Matrix<T> newSet(new T[size * srcMatrix.cols], (long)size, (long)srcMatrix.cols);
- T* src,* dest;
- for (size_t i=0; i<size; ++i) {
+ T *src,*dest;
+ for (size_t i=0;i<size;++i) {
long r = rand.next();
dest = newSet[i];
src = srcMatrix[r];
- std::copy(src, src+srcMatrix.cols, dest);
+ for (size_t j=0;j<srcMatrix.cols;++j) {
+ dest[j] = src[j];
+ }
}
+
return newSet;
}
-} // namespace
-
+} // namespace cvflann
-#endif /* OPENCV_FLANN_SAMPLING_H_ */
+#endif /* _OPENCV_SAMPLING_H_ */
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*************************************************************************/
-#ifndef OPENCV_FLANN_SAVING_H_
-#define OPENCV_FLANN_SAVING_H_
+#ifndef _OPENCV_SAVING_H_
+#define _OPENCV_SAVING_H_
+#include "opencv2/flann/general.h"
+#include "opencv2/flann/nn_index.h"
+#include <cstdio>
#include <cstring>
-#include <vector>
-
-#include "general.h"
-#include "nn_index.h"
-
-#define FLANN_SIGNATURE "FLANN_INDEX"
namespace cvflann
{
+template <typename T> struct Datatype {};
+template<> struct Datatype<char> { static flann_datatype_t type() { return FLANN_INT8; } };
+template<> struct Datatype<short> { static flann_datatype_t type() { return FLANN_INT16; } };
+template<> struct Datatype<int> { static flann_datatype_t type() { return FLANN_INT32; } };
+template<> struct Datatype<unsigned char> { static flann_datatype_t type() { return FLANN_UINT8; } };
+template<> struct Datatype<unsigned short> { static flann_datatype_t type() { return FLANN_UINT16; } };
+template<> struct Datatype<unsigned int> { static flann_datatype_t type() { return FLANN_UINT32; } };
+template<> struct Datatype<float> { static flann_datatype_t type() { return FLANN_FLOAT32; } };
+template<> struct Datatype<double> { static flann_datatype_t type() { return FLANN_FLOAT64; } };
-template <typename T>
-struct Datatype {};
-template<>
-struct Datatype<char> { static flann_datatype_t type() { return FLANN_INT8; } };
-template<>
-struct Datatype<short> { static flann_datatype_t type() { return FLANN_INT16; } };
-template<>
-struct Datatype<int> { static flann_datatype_t type() { return FLANN_INT32; } };
-template<>
-struct Datatype<unsigned char> { static flann_datatype_t type() { return FLANN_UINT8; } };
-template<>
-struct Datatype<unsigned short> { static flann_datatype_t type() { return FLANN_UINT16; } };
-template<>
-struct Datatype<unsigned int> { static flann_datatype_t type() { return FLANN_UINT32; } };
-template<>
-struct Datatype<float> { static flann_datatype_t type() { return FLANN_FLOAT32; } };
-template<>
-struct Datatype<double> { 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;
};
/**
* @param stream - Stream to save to
* @param index - The index to save
*/
-template<typename Distance>
-void save_header(FILE* stream, const NNIndex<Distance>& index)
+template<typename ELEM_TYPE>
+void save_header(FILE* stream, const NNIndex<ELEM_TYPE>& 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<typename Distance::ElementType>::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<ELEM_TYPE>::type();
+ header.index_type = index.getType();
+ header.rows = (int)index.size();
+ header.cols = index.veclen();
+
+ std::fwrite(&header, sizeof(header),1,stream);
}
* @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<typename T>
-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<typename T>
-void save_value(FILE* stream, const cvflann::Matrix<T>& value)
-{
- fwrite(&value, sizeof(value),1, stream);
- fwrite(value.data, sizeof(T),value.rows*value.cols, stream);
-}
template<typename T>
-void save_value(FILE* stream, const std::vector<T>& 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<typename T>
-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<typename T>
-void load_value(FILE* stream, cvflann::Matrix<T>& 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<typename T>
-void load_value(FILE* stream, std::vector<T>& 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_ */
* 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 <typename T>
void addValue(int pos, float val, float* vals, T* point, T* points, int n)
{
vals[pos] = val;
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
points[pos*n+i] = point[i];
}
int j=pos;
while (j>0 && vals[j]<vals[j-1]) {
swap(vals[j],vals[j-1]);
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
swap(points[j*n+i],points[(j-1)*n+i]);
}
--j;
vals is the cost function in the n+1 simplex points, if NULL it will be computed
Postcondition: returns optimum value and points[0..n] are the optimum parameters
- */
+*/
template <typename T, typename F>
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<n+1; ++i) {
+ for (int i=0;i<n+1;++i) {
float val = func(points+i*n);
addValue(i, val, vals, points+i*n, points, n);
}
if (iterations++ > MAX_ITERATIONS) break;
// compute average of simplex points (except the highest point)
- for (int j=0; j<n; ++j) {
+ for (int j=0;j<n;++j) {
p_o[j] = 0;
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
p_o[i] += points[j*n+i];
}
}
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
p_o[i] /= n;
}
bool converged = true;
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
if (p_o[i] != points[nn+i]) {
converged = false;
}
if (converged) break;
// trying a reflection
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
p_r[i] = p_o[i] + alpha*(p_o[i]-points[nn+i]);
}
float val_r = func(p_r);
- if ((val_r>=vals[0])&&(val_r<vals[n])) {
+ if (val_r>=vals[0] && val_r<vals[n]) {
// reflection between second highest and lowest
// add it to the simplex
- Logger::info("Choosing reflection\n");
+ logger().info("Choosing reflection\n");
addValue(n, val_r,vals, p_r, points, n);
continue;
}
// value is smaller than smalest in simplex
// expand some more to see if it drops further
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
p_e[i] = 2*p_r[i]-p_o[i];
}
float val_e = func(p_e);
if (val_e<val_r) {
- Logger::info("Choosing reflection and expansion\n");
+ logger().info("Choosing reflection and expansion\n");
addValue(n, val_e,vals,p_e,points,n);
}
else {
- Logger::info("Choosing reflection\n");
+ logger().info("Choosing reflection\n");
addValue(n, val_r,vals,p_r,points,n);
}
continue;
}
if (val_r>=vals[n]) {
- for (int i=0; i<n; ++i) {
+ for (int i=0;i<n;++i) {
p_e[i] = (p_o[i]+points[nn+i])/2;
}
float val_e = func(p_e);
if (val_e<vals[n]) {
- Logger::info("Choosing contraction\n");
+ logger().info("Choosing contraction\n");
addValue(n,val_e,vals,p_e,points,n);
continue;
}
}
{
- Logger::info("Full contraction\n");
- for (int j=1; j<=n; ++j) {
- for (int i=0; i<n; ++i) {
+ logger().info("Full contraction\n");
+ for (int j=1;j<=n;++j) {
+ for (int i=0;i<n;++i) {
points[j*n+i] = (points[j*n+i]+points[i])/2;
}
float val = func(points+j*n);
return bestVal;
}
-}
+} // namespace cvflann
-#endif //OPENCV_FLANN_SIMPLEX_DOWNHILL_H_
+#endif //_OPENCV_SIMPLEX_DOWNHILL_H_
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*************************************************************************/
-#ifndef FLANN_TIMER_H
-#define FLANN_TIMER_H
+#ifndef _OPENCV_TIMER_H_
+#define _OPENCV_TIMER_H_
#include <time.h>
*
* Can be used to time portions of code.
*/
-class StartStopTimer
+class CV_EXPORTS StartStopTimer
{
clock_t startTime;
/**
* 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;
}
/**
* Resets the timer value to 0.
*/
- void reset()
- {
+ void reset() {
value = 0;
}
};
-}
+}// namespace cvflann
-#endif // FLANN_TIMER_H
+#endif // _OPENCV_TIMER_H_
#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<float> zero_;
+ZeroIterator<float>& 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<n;++i) {
+ for (int k=0;k<n;++k) {
+ if (neighbors[i]==groundTruth[k]) {
+ count++;
+ break;
+ }
+ }
+ }
+ return count;
+}
+
+// ----------------------- logger.cpp ---------------------------
+
+Logger logger_;
+
+Logger& logger() { return logger_; }
+
+int Logger::log(int level, const char* fmt, ...)
+{
+ if (level > 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_<LinearIndexParams>(FLANN_INDEX_LINEAR);
+ ParamsFactory_instance().register_<KDTreeIndexParams>(FLANN_INDEX_KDTREE);
+ ParamsFactory_instance().register_<KMeansIndexParams>(FLANN_INDEX_KMEANS);
+ ParamsFactory_instance().register_<CompositeIndexParams>(FLANN_INDEX_COMPOSITE);
+ ParamsFactory_instance().register_<AutotunedIndexParams>(FLANN_INDEX_AUTOTUNED);
+// ParamsFactory::instance().register_<SavedIndexParams>(FLANN_INDEX_SAVED);
+ }
+};
+StaticInit __init;
+
+
+} // namespace cvflann
+
+
+
\r
#include "opencv2/flann/dist.h"\r
#include "opencv2/flann/index_testing.h"\r
-#include "opencv2/flann/params.h"\r
#include "opencv2/flann/saving.h"\r
#include "opencv2/flann/general.h"\r
\r
projects / platform / upstream / opencv.git / commitdiff