const int nn = 1;
const size_t SAMPLE_COUNT = 1000;
- assert(bestIndex_ != NULL); // must have a valid index
+ CV_Assert(bestIndex_ != NULL && "Requires a valid index"); // must have a valid index
float speedup = 0;
//! @cond IGNORED
#include <vector>
-#include <cassert>
#include <cstdio>
#include "general.h"
#include <algorithm>
#include <map>
-#include <cassert>
#include <limits>
#include <cmath>
int n = indices_length;
int rnd = rand_int(n);
- assert(rnd >=0 && rnd < n);
+ CV_DbgAssert(rnd >=0 && rnd < n);
centers[0] = dsindices[rnd];
// Choose one random center and set the closestDistSq values
int index = rand_int(n);
- assert(index >=0 && index < n);
+ CV_DbgAssert(index >=0 && index < n);
centers[0] = dsindices[index];
// Computing distance^2 will have the advantage of even higher probability further to pick new centers
// Choose one random center and set the closestDistSq values
int index = rand_int(n);
- assert(index >=0 && index < n);
+ CV_DbgAssert(index >=0 && index < n);
centers[0] = dsindices[index];
for (int i = 0; i < n; i++) {
NodePtr node = branch.node;
findNN(node, result, vec, checks, maxChecks, heap, checked);
}
- assert(result.full());
delete heap;
+ CV_Assert(result.full());
}
IndexParams getParameters() const CV_OVERRIDE
//! @cond IGNORED
#include <cstring>
-#include <cassert>
#include <cmath>
#include "matrix.h"
#include <algorithm>
#include <map>
-#include <cassert>
#include <cstring>
#include "general.h"
if (trees_>0) {
searchLevelExact(result, vec, tree_roots_[0], 0.0, epsError);
}
- assert(result.full());
+ CV_Assert(result.full());
}
/**
delete heap;
- assert(result.full());
+ CV_Assert(result.full());
}
#include <algorithm>
#include <map>
-#include <cassert>
#include <cstring>
#include "general.h"
*/
void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params) CV_OVERRIDE
{
- assert(queries.cols == veclen());
- assert(indices.rows >= queries.rows);
- assert(dists.rows >= queries.rows);
- assert(int(indices.cols) >= knn);
- assert(int(dists.cols) >= knn);
+ CV_Assert(queries.cols == veclen());
+ CV_Assert(indices.rows >= queries.rows);
+ CV_Assert(dists.rows >= queries.rows);
+ CV_Assert(int(indices.cols) >= knn);
+ CV_Assert(int(dists.cols) >= knn);
KNNSimpleResultSet<DistanceType> resultSet(knn);
for (size_t i = 0; i < queries.rows; i++) {
#include <algorithm>
#include <map>
-#include <cassert>
#include <limits>
#include <cmath>
int n = indices_length;
int rnd = rand_int(n);
- assert(rnd >=0 && rnd < n);
+ CV_DbgAssert(rnd >=0 && rnd < n);
centers[0] = indices[rnd];
// Choose one random center and set the closestDistSq values
int index = rand_int(n);
- assert(index >=0 && index < n);
+ CV_DbgAssert(index >=0 && index < n);
centers[0] = indices[index];
for (int i = 0; i < n; i++) {
KMeansNodePtr node = branch.node;
findNN(node, result, vec, checks, maxChecks, heap);
}
- assert(result.full());
-
delete heap;
+
+ CV_Assert(result.full());
}
}
//! @cond IGNORED
#include <algorithm>
-#include <cassert>
#include <cstring>
#include <map>
#include <vector>
#include "random.h"
#include "saving.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4702) //disable unreachable code
+#endif
+
namespace cvflann
{
*/
virtual void knnSearch(const Matrix<ElementType>& queries, Matrix<int>& indices, Matrix<DistanceType>& dists, int knn, const SearchParams& params) CV_OVERRIDE
{
- assert(queries.cols == veclen());
- assert(indices.rows >= queries.rows);
- assert(dists.rows >= queries.rows);
- assert(int(indices.cols) >= knn);
- assert(int(dists.cols) >= knn);
+ CV_Assert(queries.cols == veclen());
+ CV_Assert(indices.rows >= queries.rows);
+ CV_Assert(dists.rows >= queries.rows);
+ CV_Assert(int(indices.cols) >= knn);
+ CV_Assert(int(dists.cols) >= knn);
KNNUniqueResultSet<DistanceType> resultSet(knn);
};
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
//! @endcond
#endif //OPENCV_FLANN_LSH_INDEX_H_
#include "dynamic_bitset.h"
#include "matrix.h"
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4702) //disable unreachable code
+#endif
+
+
namespace cvflann
{
{
feature_size_ = feature_size;
CV_UNUSED(key_size);
- std::cerr << "LSH is not implemented for that type" << std::endl;
- assert(0);
+ CV_Error(cv::Error::StsUnsupportedFormat, "LSH is not implemented for that type" );
}
/** Add a feature to the table
*/
size_t getKey(const ElementType* /*feature*/) const
{
- std::cerr << "LSH is not implemented for that type" << std::endl;
- assert(0);
+ CV_Error(cv::Error::StsUnsupportedFormat, "LSH is not implemented for that type" );
return 0;
}
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//! @endcond
*/
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);
+ CV_Assert(queries.cols == veclen());
+ CV_Assert(indices.rows >= queries.rows);
+ CV_Assert(dists.rows >= queries.rows);
+ CV_Assert(int(indices.cols) >= knn);
+ CV_Assert(int(dists.cols) >= knn);
#if 0
KNNResultSet<DistanceType> resultSet(knn);
{
const int MAX_ITERATIONS = 10;
- assert(n>0);
+ CV_DbgAssert(n>0);
T* p_o = new T[n];
T* p_r = new T[n];