some design code changes in new tests
This commit is contained in:
Alexander Reshetnikov
parent
ea5d01558c
commit
07fa62f0c4
File diff suppressed because it is too large
Load Diff
@ -18,26 +18,26 @@ const int INT_TYPE [5] = {CV_8U, CV_8S, CV_16U, CV_16S, CV_32S};
|
||||
|
||||
class CV_CountNonZeroTest: public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
public:
|
||||
CV_CountNonZeroTest();
|
||||
~CV_CountNonZeroTest();
|
||||
|
||||
protected:
|
||||
protected:
|
||||
void run (int);
|
||||
|
||||
private:
|
||||
float eps_32;
|
||||
double eps_64;
|
||||
Mat src;
|
||||
int current_type;
|
||||
private:
|
||||
float eps_32;
|
||||
double eps_64;
|
||||
Mat src;
|
||||
int current_type;
|
||||
|
||||
void generate_src_data(cv::Size size, int type);
|
||||
void generate_src_data(cv::Size size, int type, int count_non_zero);
|
||||
void generate_src_stat_data(cv::Size size, int type, int distribution);
|
||||
void generate_src_data(cv::Size size, int type);
|
||||
void generate_src_data(cv::Size size, int type, int count_non_zero);
|
||||
void generate_src_stat_data(cv::Size size, int type, int distribution);
|
||||
|
||||
int get_count_non_zero();
|
||||
int get_count_non_zero();
|
||||
|
||||
void print_information(int right, int result);
|
||||
void print_information(int right, int result);
|
||||
};
|
||||
|
||||
CV_CountNonZeroTest::CV_CountNonZeroTest(): eps_32(1e-8), eps_64(1e-16), src(Mat()), current_type(-1) {}
|
||||
@ -45,174 +45,174 @@ CV_CountNonZeroTest::~CV_CountNonZeroTest() {}
|
||||
|
||||
void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type)
|
||||
{
|
||||
src.create(size, CV_MAKETYPE(type, 1));
|
||||
src.create(size, CV_MAKETYPE(type, 1));
|
||||
|
||||
for (size_t j = 0; j < size.width; ++j)
|
||||
for (size_t i = 0; i < size.height; ++i)
|
||||
switch (type)
|
||||
{
|
||||
case CV_8U: { src.at<uchar>(i, j) = cv::randu<uchar>(); break; }
|
||||
case CV_8S: { src.at<char>(i, j) = cv::randu<uchar>() - 128; break; }
|
||||
case CV_16U: { src.at<ushort>(i, j) = cv::randu<ushort>(); break; }
|
||||
case CV_16S: { src.at<short>(i, j) = cv::randu<short>(); break; }
|
||||
case CV_32S: { src.at<int>(i, j) = cv::randu<int>(); break; }
|
||||
case CV_32F: { src.at<float>(i, j) = cv::randu<float>(); break; }
|
||||
case CV_64F: { src.at<double>(i, j) = cv::randu<double>(); break; }
|
||||
default: break;
|
||||
}
|
||||
for (int j = 0; j < size.width; ++j)
|
||||
for (int i = 0; i < size.height; ++i)
|
||||
switch (type)
|
||||
{
|
||||
case CV_8U: { src.at<uchar>(i, j) = cv::randu<uchar>(); break; }
|
||||
case CV_8S: { src.at<char>(i, j) = cv::randu<uchar>() - 128; break; }
|
||||
case CV_16U: { src.at<ushort>(i, j) = cv::randu<ushort>(); break; }
|
||||
case CV_16S: { src.at<short>(i, j) = cv::randu<short>(); break; }
|
||||
case CV_32S: { src.at<int>(i, j) = cv::randu<int>(); break; }
|
||||
case CV_32F: { src.at<float>(i, j) = cv::randu<float>(); break; }
|
||||
case CV_64F: { src.at<double>(i, j) = cv::randu<double>(); break; }
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type, int count_non_zero)
|
||||
{
|
||||
src = Mat::zeros(size, CV_MAKETYPE(type, 1));
|
||||
|
||||
int n = 0; RNG& rng = ts->get_rng();
|
||||
src = Mat::zeros(size, CV_MAKETYPE(type, 1));
|
||||
|
||||
while (n < count_non_zero)
|
||||
{
|
||||
size_t i = rng.next()%size.height, j = rng.next()%size.width;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case CV_8U: { if (!src.at<uchar>(i, j)) {src.at<uchar>(i, j) = cv::randu<uchar>(); n += (src.at<uchar>(i, j) > 0);} break; }
|
||||
case CV_8S: { if (!src.at<char>(i, j)) {src.at<char>(i, j) = cv::randu<uchar>() - 128; n += abs(sign(src.at<char>(i, j)));} break; }
|
||||
case CV_16U: { if (!src.at<ushort>(i, j)) {src.at<ushort>(i, j) = cv::randu<ushort>(); n += (src.at<ushort>(i, j) > 0);} break; }
|
||||
case CV_16S: { if (!src.at<short>(i, j)) {src.at<short>(i, j) = cv::randu<short>(); n += abs(sign(src.at<short>(i, j)));} break; }
|
||||
case CV_32S: { if (!src.at<int>(i, j)) {src.at<int>(i, j) = cv::randu<int>(); n += abs(sign(src.at<int>(i, j)));} break; }
|
||||
case CV_32F: { if (fabs(src.at<float>(i, j)) <= eps_32) {src.at<float>(i, j) = cv::randu<float>(); n += (fabs(src.at<float>(i, j)) > eps_32);} break; }
|
||||
case CV_64F: { if (fabs(src.at<double>(i, j)) <= eps_64) {src.at<double>(i, j) = cv::randu<double>(); n += (fabs(src.at<double>(i, j)) > eps_64);} break; }
|
||||
int n = 0; RNG& rng = ts->get_rng();
|
||||
|
||||
while (n < count_non_zero)
|
||||
{
|
||||
size_t i = rng.next()%size.height, j = rng.next()%size.width;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case CV_8U: { if (!src.at<uchar>(i, j)) {src.at<uchar>(i, j) = cv::randu<uchar>(); n += (src.at<uchar>(i, j) > 0);} break; }
|
||||
case CV_8S: { if (!src.at<char>(i, j)) {src.at<char>(i, j) = cv::randu<uchar>() - 128; n += abs(sign(src.at<char>(i, j)));} break; }
|
||||
case CV_16U: { if (!src.at<ushort>(i, j)) {src.at<ushort>(i, j) = cv::randu<ushort>(); n += (src.at<ushort>(i, j) > 0);} break; }
|
||||
case CV_16S: { if (!src.at<short>(i, j)) {src.at<short>(i, j) = cv::randu<short>(); n += abs(sign(src.at<short>(i, j)));} break; }
|
||||
case CV_32S: { if (!src.at<int>(i, j)) {src.at<int>(i, j) = cv::randu<int>(); n += abs(sign(src.at<int>(i, j)));} break; }
|
||||
case CV_32F: { if (fabs(src.at<float>(i, j)) <= eps_32) {src.at<float>(i, j) = cv::randu<float>(); n += (fabs(src.at<float>(i, j)) > eps_32);} break; }
|
||||
case CV_64F: { if (fabs(src.at<double>(i, j)) <= eps_64) {src.at<double>(i, j) = cv::randu<double>(); n += (fabs(src.at<double>(i, j)) > eps_64);} break; }
|
||||
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void CV_CountNonZeroTest::generate_src_stat_data(cv::Size size, int type, int distribution)
|
||||
{
|
||||
src.create(size, CV_MAKETYPE(type, 1));
|
||||
src.create(size, CV_MAKETYPE(type, 1));
|
||||
|
||||
double mean = 0.0, sigma = 1.0;
|
||||
double left = -1.0, right = 1.0;
|
||||
double mean = 0.0, sigma = 1.0;
|
||||
double left = -1.0, right = 1.0;
|
||||
|
||||
RNG& rng = ts->get_rng();
|
||||
RNG& rng = ts->get_rng();
|
||||
|
||||
if (distribution == RNG::NORMAL)
|
||||
rng.fill(src, RNG::NORMAL, Scalar::all(mean), Scalar::all(sigma));
|
||||
else if (distribution == RNG::UNIFORM)
|
||||
rng.fill(src, RNG::UNIFORM, Scalar::all(left), Scalar::all(right));
|
||||
if (distribution == RNG::NORMAL)
|
||||
rng.fill(src, RNG::NORMAL, Scalar::all(mean), Scalar::all(sigma));
|
||||
else if (distribution == RNG::UNIFORM)
|
||||
rng.fill(src, RNG::UNIFORM, Scalar::all(left), Scalar::all(right));
|
||||
}
|
||||
|
||||
int CV_CountNonZeroTest::get_count_non_zero()
|
||||
{
|
||||
int result = 0;
|
||||
int result = 0;
|
||||
|
||||
for (size_t i = 0; i < src.rows; ++i)
|
||||
for (size_t j = 0; j < src.cols; ++j)
|
||||
for (int i = 0; i < src.rows; ++i)
|
||||
for (int j = 0; j < src.cols; ++j)
|
||||
|
||||
if (current_type == CV_8U) result += (src.at<uchar>(i, j) > 0);
|
||||
|
||||
else if (current_type == CV_8S) result += abs(sign(src.at<char>(i, j)));
|
||||
if (current_type == CV_8U) result += (src.at<uchar>(i, j) > 0);
|
||||
|
||||
else if (current_type == CV_16U) result += (src.at<ushort>(i, j) > 0);
|
||||
else if (current_type == CV_8S) result += abs(sign(src.at<char>(i, j)));
|
||||
|
||||
else if (current_type == CV_16S) result += abs(sign(src.at<short>(i, j)));
|
||||
else if (current_type == CV_16U) result += (src.at<ushort>(i, j) > 0);
|
||||
|
||||
else if (current_type == CV_32S) result += abs(sign(src.at<int>(i, j)));
|
||||
else if (current_type == CV_16S) result += abs(sign(src.at<short>(i, j)));
|
||||
|
||||
else if (current_type == CV_32F) result += (fabs(src.at<float>(i, j)) > eps_32);
|
||||
else if (current_type == CV_32S) result += abs(sign(src.at<int>(i, j)));
|
||||
|
||||
else result += (fabs(src.at<double>(i, j)) > eps_64);
|
||||
else if (current_type == CV_32F) result += (fabs(src.at<float>(i, j)) > eps_32);
|
||||
|
||||
return result;
|
||||
else result += (fabs(src.at<double>(i, j)) > eps_64);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void CV_CountNonZeroTest::print_information(int right, int result)
|
||||
{
|
||||
cout << endl; cout << "Checking for the work of countNonZero function..." << endl; cout << endl;
|
||||
cout << "Type of Mat: ";
|
||||
switch (current_type)
|
||||
{
|
||||
case 0: {cout << "CV_8U"; break;}
|
||||
case 1: {cout << "CV_8S"; break;}
|
||||
case 2: {cout << "CV_16U"; break;}
|
||||
case 3: {cout << "CV_16S"; break;}
|
||||
case 4: {cout << "CV_32S"; break;}
|
||||
case 5: {cout << "CV_32F"; break;}
|
||||
case 6: {cout << "CV_64F"; break;}
|
||||
default: break;
|
||||
}
|
||||
cout << endl;
|
||||
cout << "Number of rows: " << src.rows << " Number of cols: " << src.cols << endl;
|
||||
cout << "True count non zero elements: " << right << " Result: " << result << endl;
|
||||
cout << endl;
|
||||
cout << endl; cout << "Checking for the work of countNonZero function..." << endl; cout << endl;
|
||||
cout << "Type of Mat: ";
|
||||
switch (current_type)
|
||||
{
|
||||
case 0: {cout << "CV_8U"; break;}
|
||||
case 1: {cout << "CV_8S"; break;}
|
||||
case 2: {cout << "CV_16U"; break;}
|
||||
case 3: {cout << "CV_16S"; break;}
|
||||
case 4: {cout << "CV_32S"; break;}
|
||||
case 5: {cout << "CV_32F"; break;}
|
||||
case 6: {cout << "CV_64F"; break;}
|
||||
default: break;
|
||||
}
|
||||
cout << endl;
|
||||
cout << "Number of rows: " << src.rows << " Number of cols: " << src.cols << endl;
|
||||
cout << "True count non zero elements: " << right << " Result: " << result << endl;
|
||||
cout << endl;
|
||||
}
|
||||
|
||||
void CV_CountNonZeroTest::run(int)
|
||||
{
|
||||
const size_t N = 1500;
|
||||
const size_t N = 1500;
|
||||
|
||||
for (int k = 1; k <= 3; ++k)
|
||||
for (size_t i = 0; i < N; ++i)
|
||||
{
|
||||
RNG& rng = ts->get_rng();
|
||||
for (int k = 1; k <= 3; ++k)
|
||||
for (size_t i = 0; i < N; ++i)
|
||||
{
|
||||
RNG& rng = ts->get_rng();
|
||||
|
||||
int w = rng.next()%MAX_WIDTH + 1, h = rng.next()%MAX_HEIGHT + 1;
|
||||
int w = rng.next()%MAX_WIDTH + 1, h = rng.next()%MAX_HEIGHT + 1;
|
||||
|
||||
current_type = rng.next()%7;
|
||||
current_type = rng.next()%7;
|
||||
|
||||
switch (k)
|
||||
{
|
||||
case 1: {
|
||||
generate_src_data(Size(w, h), current_type);
|
||||
int right = get_count_non_zero(), result = countNonZero(src);
|
||||
if (result != right)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: RANDOM" << endl;
|
||||
print_information(right, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
switch (k)
|
||||
{
|
||||
case 1: {
|
||||
generate_src_data(Size(w, h), current_type);
|
||||
int right = get_count_non_zero(), result = countNonZero(src);
|
||||
if (result != right)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: RANDOM" << endl;
|
||||
print_information(right, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 2: {
|
||||
int count_non_zero = rng.next()%(w*h);
|
||||
generate_src_data(Size(w, h), current_type, count_non_zero);
|
||||
int result = countNonZero(src);
|
||||
if (result != count_non_zero)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: HALF-RANDOM" << endl;
|
||||
print_information(count_non_zero, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
case 2: {
|
||||
int count_non_zero = rng.next()%(w*h);
|
||||
generate_src_data(Size(w, h), current_type, count_non_zero);
|
||||
int result = countNonZero(src);
|
||||
if (result != count_non_zero)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: HALF-RANDOM" << endl;
|
||||
print_information(count_non_zero, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 3: {
|
||||
int distribution = cv::randu<uchar>()%2;
|
||||
generate_src_stat_data(Size(w, h), current_type, distribution);
|
||||
int right = get_count_non_zero(), result = countNonZero(src);
|
||||
if (right != result)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: STATISTIC" << endl;
|
||||
print_information(right, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
case 3: {
|
||||
int distribution = cv::randu<uchar>()%2;
|
||||
generate_src_stat_data(Size(w, h), current_type, distribution);
|
||||
int right = get_count_non_zero(), result = countNonZero(src);
|
||||
if (right != result)
|
||||
{
|
||||
cout << "Number of experiment: " << i << endl;
|
||||
cout << "Method of data generation: STATISTIC" << endl;
|
||||
print_information(right, result);
|
||||
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }
|
||||
// TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }
|
||||
|
||||
@ -12,50 +12,65 @@ using namespace std;
|
||||
#define CORE_EIGEN_ERROR_ORTHO 4
|
||||
#define CORE_EIGEN_ERROR_ORDER 5
|
||||
|
||||
#define MESSAGE_ERROR_COUNT "Matrix of eigen values must have the same rows as source matrix and 1 column."
|
||||
#define MESSAGE_ERROR_SIZE "Source matrix and matrix of eigen vectors must have the same sizes."
|
||||
#define MESSAGE_ERROR_DIFF_1 "Accurasy of eigen values computing less than required."
|
||||
#define MESSAGE_ERROR_DIFF_2 "Accuracy of eigen vectors computing less than required."
|
||||
#define MESSAGE_ERROR_ORTHO "Matrix of eigen vectors is not orthogonal."
|
||||
#define MESSAGE_ERROR_ORDER "Eigen values are not sorted in ascending order."
|
||||
|
||||
const size_t COUNT_NORM_TYPES = 3;
|
||||
const size_t NORM_TYPE[COUNT_NORM_TYPES] = {cv::NORM_L1, cv::NORM_L2, cv::NORM_INF};
|
||||
|
||||
enum TASK_TYPE_EIGEN {VALUES, VECTORS};
|
||||
|
||||
class Core_EigenTest: public cvtest::BaseTest
|
||||
{
|
||||
public:
|
||||
public:
|
||||
|
||||
Core_EigenTest();
|
||||
Core_EigenTest();
|
||||
~Core_EigenTest();
|
||||
|
||||
protected:
|
||||
protected:
|
||||
|
||||
bool test_values(const cv::Mat& src); // complex test for eigen without vectors
|
||||
bool check_full(int type); // compex test for symmetric matrix
|
||||
virtual void run (int) = 0; // main testing method
|
||||
bool test_values(const cv::Mat& src); // complex test for eigen without vectors
|
||||
bool check_full(int type); // compex test for symmetric matrix
|
||||
virtual void run (int) = 0; // main testing method
|
||||
|
||||
private:
|
||||
|
||||
float eps_val_32, eps_vec_32;
|
||||
float eps_val_64, eps_vec_64;
|
||||
bool check_pair_count(const cv::Mat& src, const cv::Mat& evalues, int low_index = -1, int high_index = -1);
|
||||
bool check_pair_count(const cv::Mat& src, const cv::Mat& evalues, const cv::Mat& evectors, int low_index = -1, int high_index = -1);
|
||||
bool check_pairs_order(const cv::Mat& eigen_values); // checking order of eigen values & vectors (it should be none up)
|
||||
bool check_orthogonality(const cv::Mat& U); // checking is matrix of eigen vectors orthogonal
|
||||
bool test_pairs(const cv::Mat& src); // complex test for eigen with vectors
|
||||
private:
|
||||
|
||||
float eps_val_32, eps_vec_32;
|
||||
float eps_val_64, eps_vec_64;
|
||||
bool check_pair_count(const cv::Mat& src, const cv::Mat& evalues, int low_index = -1, int high_index = -1);
|
||||
bool check_pair_count(const cv::Mat& src, const cv::Mat& evalues, const cv::Mat& evectors, int low_index = -1, int high_index = -1);
|
||||
bool check_pairs_order(const cv::Mat& eigen_values); // checking order of eigen values & vectors (it should be none up)
|
||||
bool check_orthogonality(const cv::Mat& U); // checking is matrix of eigen vectors orthogonal
|
||||
bool test_pairs(const cv::Mat& src); // complex test for eigen with vectors
|
||||
|
||||
void print_information(const size_t norm_idx, const cv::Mat& src, double diff, double max_diff);
|
||||
};
|
||||
|
||||
class Core_EigenTest_Scalar : public Core_EigenTest
|
||||
{
|
||||
public:
|
||||
Core_EigenTest_Scalar() : Core_EigenTest() {}
|
||||
~Core_EigenTest_Scalar();
|
||||
virtual void run(int) = 0;
|
||||
public:
|
||||
Core_EigenTest_Scalar() : Core_EigenTest() {}
|
||||
~Core_EigenTest_Scalar();
|
||||
|
||||
virtual void run(int) = 0;
|
||||
};
|
||||
|
||||
class Core_EigenTest_Scalar_32 : public Core_EigenTest_Scalar
|
||||
{
|
||||
public:
|
||||
Core_EigenTest_Scalar_32() : Core_EigenTest_Scalar() {}
|
||||
~Core_EigenTest_Scalar_32();
|
||||
public:
|
||||
Core_EigenTest_Scalar_32() : Core_EigenTest_Scalar() {}
|
||||
~Core_EigenTest_Scalar_32();
|
||||
|
||||
void run(int);
|
||||
void run(int);
|
||||
};
|
||||
|
||||
class Core_EigenTest_Scalar_64 : public Core_EigenTest_Scalar
|
||||
{
|
||||
public:
|
||||
public:
|
||||
Core_EigenTest_Scalar_64() : Core_EigenTest_Scalar() {}
|
||||
~Core_EigenTest_Scalar_64();
|
||||
void run(int);
|
||||
@ -63,7 +78,7 @@ class Core_EigenTest_Scalar_64 : public Core_EigenTest_Scalar
|
||||
|
||||
class Core_EigenTest_32 : public Core_EigenTest
|
||||
{
|
||||
public:
|
||||
public:
|
||||
Core_EigenTest_32(): Core_EigenTest() {}
|
||||
~Core_EigenTest_32() {}
|
||||
void run(int);
|
||||
@ -71,10 +86,10 @@ class Core_EigenTest_32 : public Core_EigenTest
|
||||
|
||||
class Core_EigenTest_64 : public Core_EigenTest
|
||||
{
|
||||
public:
|
||||
Core_EigenTest_64(): Core_EigenTest() {}
|
||||
~Core_EigenTest_64() {}
|
||||
void run(int);
|
||||
public:
|
||||
Core_EigenTest_64(): Core_EigenTest() {}
|
||||
~Core_EigenTest_64() {}
|
||||
void run(int);
|
||||
};
|
||||
|
||||
Core_EigenTest_Scalar::~Core_EigenTest_Scalar() {}
|
||||
@ -83,18 +98,18 @@ Core_EigenTest_Scalar_64::~Core_EigenTest_Scalar_64() {}
|
||||
|
||||
void Core_EigenTest_Scalar_32::run(int)
|
||||
{
|
||||
float value = cv::randu<float>();
|
||||
cv::Mat src(1, 1, CV_32FC1, Scalar::all((float)value));
|
||||
test_values(src);
|
||||
src.~Mat();
|
||||
float value = cv::randu<float>();
|
||||
cv::Mat src(1, 1, CV_32FC1, Scalar::all((float)value));
|
||||
test_values(src);
|
||||
src.~Mat();
|
||||
}
|
||||
|
||||
void Core_EigenTest_Scalar_64::run(int)
|
||||
{
|
||||
float value = cv::randu<float>();
|
||||
cv::Mat src(1, 1, CV_64FC1, Scalar::all((double)value));
|
||||
test_values(src);
|
||||
src.~Mat();
|
||||
float value = cv::randu<float>();
|
||||
cv::Mat src(1, 1, CV_64FC1, Scalar::all((double)value));
|
||||
test_values(src);
|
||||
src.~Mat();
|
||||
}
|
||||
|
||||
void Core_EigenTest_32::run(int) { check_full(CV_32FC1); }
|
||||
@ -105,207 +120,245 @@ Core_EigenTest::~Core_EigenTest() {}
|
||||
|
||||
bool Core_EigenTest::check_pair_count(const cv::Mat& src, const cv::Mat& evalues, int low_index, int high_index)
|
||||
{
|
||||
int n = src.rows, s = sign(high_index);
|
||||
if (!( (evalues.rows == n - max<int>(0, low_index) - ((int)((n/2.0)*(s*s-s)) + (1+s-s*s)*(n - (high_index+1)))) && (evalues.cols == 1)))
|
||||
{
|
||||
std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_COUNT, "Matrix of eigen values must have the same rows as source matrix and 1 column.");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
int n = src.rows, s = sign(high_index);
|
||||
if (!( (evalues.rows == n - max<int>(0, low_index) - ((int)((n/2.0)*(s*s-s)) + (1+s-s*s)*(n - (high_index+1)))) && (evalues.cols == 1)))
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl;
|
||||
std::cout << "Number of rows: " << evalues.rows << " Number of cols: " << evalues.cols << endl;
|
||||
std:: cout << "Size of src symmetric matrix: " << src.rows << " * " << src.cols << endl; std::cout << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::check_pair_count(const cv::Mat& src, const cv::Mat& evalues, const cv::Mat& evectors, int low_index, int high_index)
|
||||
{
|
||||
int n = src.rows, s = sign(high_index);
|
||||
int right_eigen_pair_count = n - max<int>(0, low_index) - ((int)((n/2.0)*(s*s-s)) + (1+s-s*s)*(n - (high_index+1)));
|
||||
int n = src.rows, s = sign(high_index);
|
||||
int right_eigen_pair_count = n - max<int>(0, low_index) - ((int)((n/2.0)*(s*s-s)) + (1+s-s*s)*(n - (high_index+1)));
|
||||
|
||||
if (!((evectors.rows == right_eigen_pair_count) && (evectors.cols == right_eigen_pair_count)))
|
||||
{
|
||||
std::cout << "Checking sizes of eigen vectors matrix " << evectors << "..." << endl;
|
||||
CV_Error (CORE_EIGEN_ERROR_SIZE, "Source matrix and matrix of eigen vectors must have the same sizes.");
|
||||
return false;
|
||||
}
|
||||
if (!((evectors.rows == right_eigen_pair_count) && (evectors.cols == right_eigen_pair_count)))
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking sizes of eigen vectors matrix " << evectors << "..." << endl;
|
||||
std::cout << "Number of rows: " << evectors.rows << " Number of cols: " << evectors.cols << endl;
|
||||
std:: cout << "Size of src symmetric matrix: " << src.rows << " * " << src.cols << endl; std::cout << endl;
|
||||
CV_Error (CORE_EIGEN_ERROR_SIZE, MESSAGE_ERROR_SIZE);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!((evalues.rows == right_eigen_pair_count) && (evalues.cols == 1)))
|
||||
{
|
||||
std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl;
|
||||
CV_Error (CORE_EIGEN_ERROR_COUNT, "Matrix of eigen values must have the same rows as source matrix and 1 column.");
|
||||
return false;
|
||||
}
|
||||
if (!((evalues.rows == right_eigen_pair_count) && (evalues.cols == 1)))
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking sizes of eigen values matrix " << evalues << "..." << endl;
|
||||
std::cout << "Number of rows: " << evalues.rows << " Number of cols: " << evalues.cols << endl;
|
||||
std:: cout << "Size of src symmetric matrix: " << src.rows << " * " << src.cols << endl; std::cout << endl;
|
||||
CV_Error (CORE_EIGEN_ERROR_COUNT, MESSAGE_ERROR_COUNT);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void Core_EigenTest::print_information(const size_t norm_idx, const cv::Mat& src, double diff, double max_diff)
|
||||
{
|
||||
switch (NORM_TYPE[norm_idx])
|
||||
{
|
||||
case cv::NORM_L1: {std::cout << "L1"; break;}
|
||||
case cv::NORM_L2: {std::cout << "L2"; break;}
|
||||
case cv::NORM_INF: {std::cout << "INF"; break;}
|
||||
default: break;
|
||||
}
|
||||
|
||||
cout << "-criteria... " << endl;
|
||||
cout << "Source size: " << src.rows << " * " << src.cols << endl;
|
||||
cout << "Difference between original eigen vectors matrix and result: " << diff << endl;
|
||||
cout << "Maximum allowed difference: " << max_diff << endl; cout << endl;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::check_orthogonality(const cv::Mat& U)
|
||||
{
|
||||
int type = U.type();
|
||||
double eps_vec = type == CV_32FC1 ? eps_vec_32 : eps_vec_64;
|
||||
cv::Mat UUt; cv::mulTransposed(U, UUt, false);
|
||||
int type = U.type();
|
||||
double eps_vec = type == CV_32FC1 ? eps_vec_32 : eps_vec_64;
|
||||
cv::Mat UUt; cv::mulTransposed(U, UUt, false);
|
||||
|
||||
cv::Mat E = Mat::eye(U.rows, U.cols, type);
|
||||
|
||||
double diff_L1 = cv::norm(UUt, E, NORM_L1);
|
||||
double diff_L2 = cv::norm(UUt, E, NORM_L2);
|
||||
double diff_INF = cv::norm(UUt, E, NORM_INF);
|
||||
cv::Mat E = Mat::eye(U.rows, U.cols, type);
|
||||
|
||||
if (diff_L1 > eps_vec) { std::cout << "Checking orthogonality of matrix " << U << "..." << endl; CV_Error(CORE_EIGEN_ERROR_ORTHO, "Matrix of eigen vectors is not orthogonal."); return false; }
|
||||
if (diff_L2 > eps_vec) { std::cout << "Checking orthogonality of matrix " << U << "..." << endl; CV_Error(CORE_EIGEN_ERROR_ORTHO, "Matrix of eigen vectors is not orthogonal."); return false; }
|
||||
if (diff_INF > eps_vec) { std::cout << "Checking orthogonality of matrix " << U << "..." << endl; CV_Error(CORE_EIGEN_ERROR_ORTHO, "Matrix of eigen vectors is not orthogonal."); return false; }
|
||||
for (size_t i = 0; i < COUNT_NORM_TYPES; ++i)
|
||||
{
|
||||
double diff = cv::norm(UUt, E, NORM_TYPE[i]);
|
||||
if (diff > eps_vec)
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking orthogonality of matrix " << U << ": ";
|
||||
print_information(i, U, diff, eps_vec);
|
||||
CV_Error(CORE_EIGEN_ERROR_ORTHO, MESSAGE_ERROR_ORTHO);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::check_pairs_order(const cv::Mat& eigen_values)
|
||||
{
|
||||
switch (eigen_values.type())
|
||||
{
|
||||
case CV_32FC1:
|
||||
{
|
||||
for (int i = 0; i < eigen_values.total() - 1; ++i)
|
||||
if (!(eigen_values.at<float>(i, 0) > eigen_values.at<float>(i+1, 0)))
|
||||
{
|
||||
std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order.");
|
||||
return false;
|
||||
}
|
||||
switch (eigen_values.type())
|
||||
{
|
||||
case CV_32FC1:
|
||||
{
|
||||
for (size_t i = 0; i < eigen_values.total() - 1; ++i)
|
||||
if (!(eigen_values.at<float>(i, 0) > eigen_values.at<float>(i+1, 0)))
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
|
||||
std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl;
|
||||
std::cout << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_ORDER, MESSAGE_ERROR_ORDER);
|
||||
return false;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case CV_64FC1:
|
||||
{
|
||||
for (int i = 0; i < eigen_values.total() - 1; ++i)
|
||||
if (!(eigen_values.at<double>(i, 0) > eigen_values.at<double>(i+1, 0)))
|
||||
{
|
||||
std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order.");
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
case CV_64FC1:
|
||||
{
|
||||
for (size_t i = 0; i < eigen_values.total() - 1; ++i)
|
||||
if (!(eigen_values.at<double>(i, 0) > eigen_values.at<double>(i+1, 0)))
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking order of eigen values vector " << eigen_values << "..." << endl;
|
||||
std::cout << "Pair of indexes with non ascending of eigen values: (" << i << ", " << i+1 << ")." << endl;
|
||||
std::cout << endl;
|
||||
CV_Error(CORE_EIGEN_ERROR_ORDER, "Eigen values are not sorted in ascending order.");
|
||||
return false;
|
||||
}
|
||||
|
||||
default:;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
default:;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::test_pairs(const cv::Mat& src)
|
||||
{
|
||||
int type = src.type();
|
||||
double eps_vec = type == CV_32FC1 ? eps_vec_32 : eps_vec_64;
|
||||
int type = src.type();
|
||||
double eps_vec = type == CV_32FC1 ? eps_vec_32 : eps_vec_64;
|
||||
|
||||
cv::Mat eigen_values, eigen_vectors;
|
||||
|
||||
cv::eigen(src, true, eigen_values, eigen_vectors);
|
||||
cv::Mat eigen_values, eigen_vectors;
|
||||
|
||||
if (!check_pair_count(src, eigen_values, eigen_vectors)) return false;
|
||||
cv::eigen(src, true, eigen_values, eigen_vectors);
|
||||
|
||||
if (!check_orthogonality (eigen_vectors)) return false;
|
||||
if (!check_pair_count(src, eigen_values, eigen_vectors)) return false;
|
||||
|
||||
if (!check_pairs_order(eigen_values)) return false;
|
||||
if (!check_orthogonality (eigen_vectors)) return false;
|
||||
|
||||
cv::Mat eigen_vectors_t; cv::transpose(eigen_vectors, eigen_vectors_t);
|
||||
if (!check_pairs_order(eigen_values)) return false;
|
||||
|
||||
cv::Mat src_evec(src.rows, src.cols, type);
|
||||
src_evec = src*eigen_vectors_t;
|
||||
cv::Mat eigen_vectors_t; cv::transpose(eigen_vectors, eigen_vectors_t);
|
||||
|
||||
cv::Mat eval_evec(src.rows, src.cols, type);
|
||||
cv::Mat src_evec(src.rows, src.cols, type);
|
||||
src_evec = src*eigen_vectors_t;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case CV_32FC1:
|
||||
{
|
||||
for (size_t i = 0; i < src.cols; ++i)
|
||||
{
|
||||
cv::Mat tmp = eigen_values.at<float>(i, 0) * eigen_vectors_t.col(i);
|
||||
for (size_t j = 0; j < src.rows; ++j) eval_evec.at<float>(j, i) = tmp.at<float>(j, 0);
|
||||
}
|
||||
cv::Mat eval_evec(src.rows, src.cols, type);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case CV_64FC1:
|
||||
{
|
||||
for (size_t i = 0; i < src.cols; ++i)
|
||||
{
|
||||
cv::Mat tmp = eigen_values.at<double>(i, 0) * eigen_vectors_t.col(i);
|
||||
for (size_t j = 0; j < src.rows; ++j) eval_evec.at<double>(j, i) = tmp.at<double>(j, 0);
|
||||
}
|
||||
switch (type)
|
||||
{
|
||||
case CV_32FC1:
|
||||
{
|
||||
for (int i = 0; i < src.cols; ++i)
|
||||
{
|
||||
cv::Mat tmp = eigen_values.at<float>(i, 0) * eigen_vectors_t.col(i);
|
||||
for (int j = 0; j < src.rows; ++j) eval_evec.at<float>(j, i) = tmp.at<float>(j, 0);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
default:;
|
||||
}
|
||||
case CV_64FC1:
|
||||
{
|
||||
for (int i = 0; i < src.cols; ++i)
|
||||
{
|
||||
cv::Mat tmp = eigen_values.at<double>(i, 0) * eigen_vectors_t.col(i);
|
||||
for (int j = 0; j < src.rows; ++j) eval_evec.at<double>(j, i) = tmp.at<double>(j, 0);
|
||||
}
|
||||
|
||||
cv::Mat disparity = src_evec - eval_evec;
|
||||
break;
|
||||
}
|
||||
|
||||
double diff_L1 = cv::norm(disparity, NORM_L1);
|
||||
double diff_L2 = cv::norm(disparity, NORM_L2);
|
||||
double diff_INF = cv::norm(disparity, NORM_INF);
|
||||
default:;
|
||||
}
|
||||
|
||||
if (diff_L1 > eps_vec) { std::cout << "Checking accuracy of eigen vectors computing for matrix " << src << ": L1-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen vectors computing less than required."); return false; }
|
||||
if (diff_L2 > eps_vec) { std::cout << "Checking accuracy of eigen vectors computing for matrix " << src << ": L2-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen vectors computing less than required."); return false; }
|
||||
if (diff_INF > eps_vec) { std::cout << "Checking accuracy of eigen vectors computing for matrix " << src << ": INF-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen vectors computing less than required."); return false; }
|
||||
cv::Mat disparity = src_evec - eval_evec;
|
||||
|
||||
return true;
|
||||
for (size_t i = 0; i < COUNT_NORM_TYPES; ++i)
|
||||
{
|
||||
double diff = cv::norm(disparity, NORM_TYPE[i]);
|
||||
if (diff > eps_vec)
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking accuracy of eigen vectors computing for matrix " << src << ": ";
|
||||
print_information(i, src, diff, eps_vec);
|
||||
CV_Error(CORE_EIGEN_ERROR_DIFF, MESSAGE_ERROR_DIFF_2);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::test_values(const cv::Mat& src)
|
||||
{
|
||||
int type = src.type();
|
||||
double eps_val = type == CV_32FC1 ? eps_val_32 : eps_val_64;
|
||||
int type = src.type();
|
||||
double eps_val = type == CV_32FC1 ? eps_val_32 : eps_val_64;
|
||||
|
||||
cv::Mat eigen_values_1, eigen_values_2, eigen_vectors;
|
||||
cv::Mat eigen_values_1, eigen_values_2, eigen_vectors;
|
||||
|
||||
if (!test_pairs(src)) return false;
|
||||
if (!test_pairs(src)) return false;
|
||||
|
||||
cv::eigen(src, true, eigen_values_1, eigen_vectors);
|
||||
cv::eigen(src, false, eigen_values_2, eigen_vectors);
|
||||
cv::eigen(src, true, eigen_values_1, eigen_vectors);
|
||||
cv::eigen(src, false, eigen_values_2, eigen_vectors);
|
||||
|
||||
if (!check_pair_count(src, eigen_values_2)) return false;
|
||||
if (!check_pair_count(src, eigen_values_2)) return false;
|
||||
|
||||
double diff_L1 = cv::norm(eigen_values_1, eigen_values_2, NORM_L1);
|
||||
double diff_L2 = cv::norm(eigen_values_1, eigen_values_2, NORM_L2);
|
||||
double diff_INF = cv::norm(eigen_values_1, eigen_values_2, NORM_INF);
|
||||
|
||||
if (diff_L1 > eps_val) { std::cout << "Checking accuracy of eigen values computing for matrix " << src << ": L1-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen values computing less than required."); return false; }
|
||||
if (diff_L2 > eps_val) { std::cout << "Checking accuracy of eigen values computing for matrix " << src << ": L2-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen vectors computing less than required."); return false; }
|
||||
if (diff_INF > eps_val) { std::cout << "Checking accuracy of eigen values computing for matrix " << src << ": INF-criteria..." << endl; CV_Error(CORE_EIGEN_ERROR_DIFF, "Accuracy of eigen vectors computing less than required."); return false; }
|
||||
for (size_t i = 0; i < COUNT_NORM_TYPES; ++i)
|
||||
{
|
||||
double diff = cv::norm(eigen_values_1, eigen_values_2, NORM_TYPE[i]);
|
||||
if (diff > eps_val)
|
||||
{
|
||||
std::cout << endl; std::cout << "Checking accuracy of eigen values computing for matrix " << src << ": ";
|
||||
print_information(i, src, diff, eps_val);
|
||||
CV_Error(CORE_EIGEN_ERROR_DIFF, MESSAGE_ERROR_DIFF_1);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Core_EigenTest::check_full(int type)
|
||||
{
|
||||
const int MATRIX_COUNT = 500;
|
||||
const int MAX_DEGREE = 7;
|
||||
const int MATRIX_COUNT = 500;
|
||||
const int MAX_DEGREE = 7;
|
||||
|
||||
srand(time(0));
|
||||
srand(time(0));
|
||||
|
||||
for (size_t i = 1; i <= MATRIX_COUNT; ++i)
|
||||
{
|
||||
size_t src_size = (int)(std::pow(2.0, (rand()%MAX_DEGREE+1)*1.0));
|
||||
|
||||
cv::Mat src(src_size, src_size, type);
|
||||
for (int i = 1; i <= MATRIX_COUNT; ++i)
|
||||
{
|
||||
size_t src_size = (int)(std::pow(2.0, (rand()%MAX_DEGREE+1)*1.0));
|
||||
|
||||
for (int j = 0; j < src.rows; ++j)
|
||||
for (int k = j; k < src.cols; ++k)
|
||||
if (type == CV_32FC1) src.at<float>(k, j) = src.at<float>(j, k) = cv::randu<float>();
|
||||
else src.at<double>(k, j) = src.at<double>(j, k) = cv::randu<double>();
|
||||
|
||||
if (!test_values(src)) return false;
|
||||
cv::Mat src(src_size, src_size, type);
|
||||
|
||||
src.~Mat();
|
||||
}
|
||||
for (int j = 0; j < src.rows; ++j)
|
||||
for (int k = j; k < src.cols; ++k)
|
||||
if (type == CV_32FC1) src.at<float>(k, j) = src.at<float>(j, k) = cv::randu<float>();
|
||||
else src.at<double>(k, j) = src.at<double>(j, k) = cv::randu<double>();
|
||||
|
||||
return true;
|
||||
if (!test_values(src)) return false;
|
||||
|
||||
src.~Mat();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// TEST(Core_Eigen_Scalar_32, single_complex) {Core_EigenTest_Scalar_32 test; test.safe_run(); }
|
||||
// TEST(Core_Eigen_Scalar_64, single_complex) {Core_EigenTest_Scalar_64 test; test.safe_run(); }
|
||||
TEST(Core_Eigen_32, complex) { Core_EigenTest_32 test; test.safe_run(); }
|
||||
TEST(Core_Eigen_64, complex) { Core_EigenTest_64 test; test.safe_run(); }
|
||||
// TEST(Core_Eigen_Scalar_32, accuracy) {Core_EigenTest_Scalar_32 test; test.safe_run(); }
|
||||
// TEST(Core_Eigen_Scalar_64, accuracy) {Core_EigenTest_Scalar_64 test; test.safe_run(); }
|
||||
TEST(Core_Eigen_32, accuracy) { Core_EigenTest_32 test; test.safe_run(); }
|
||||
TEST(Core_Eigen_64, accuracy) { Core_EigenTest_64 test; test.safe_run(); }
|
||||
|
||||
@ -1,6 +1,5 @@
|
||||
#include "test_precomp.hpp"
|
||||
#include <time.h>
|
||||
#include <iostream>
|
||||
|
||||
#define IMGPROC_BOUNDINGRECT_ERROR_DIFF 1
|
||||
|
||||
@ -11,94 +10,93 @@ using namespace std;
|
||||
|
||||
class CV_BoundingRectTest: public cvtest::ArrayTest
|
||||
{
|
||||
public:
|
||||
public:
|
||||
CV_BoundingRectTest();
|
||||
~CV_BoundingRectTest();
|
||||
|
||||
protected:
|
||||
protected:
|
||||
void run (int);
|
||||
|
||||
private:
|
||||
template <class T> void generate_src_points(vector <Point_<T> >& src, int n);
|
||||
template <class T> cv::Rect get_bounding_rect(const vector <Point_<T> > src);
|
||||
template <class T> bool checking_function_work(vector <Point_<T> >& src, int type);
|
||||
private:
|
||||
template <typename T> void generate_src_points(vector <Point_<T> >& src, int n);
|
||||
template <typename T> cv::Rect get_bounding_rect(const vector <Point_<T> > src);
|
||||
template <typename T> bool checking_function_work(vector <Point_<T> >& src, int type);
|
||||
};
|
||||
|
||||
CV_BoundingRectTest::CV_BoundingRectTest() {}
|
||||
CV_BoundingRectTest::~CV_BoundingRectTest() {}
|
||||
|
||||
template <class T> void CV_BoundingRectTest::generate_src_points(vector <Point_<T> >& src, int n)
|
||||
template <typename T> void CV_BoundingRectTest::generate_src_points(vector <Point_<T> >& src, int n)
|
||||
{
|
||||
src.clear();
|
||||
for (size_t i = 0; i < n; ++i)
|
||||
src.push_back(Point_<T>(cv::randu<T>(), cv::randu<T>()));
|
||||
src.clear();
|
||||
for (int i = 0; i < n; ++i)
|
||||
src.push_back(Point_<T>(cv::randu<T>(), cv::randu<T>()));
|
||||
}
|
||||
|
||||
template <class T> cv::Rect CV_BoundingRectTest::get_bounding_rect(const vector <Point_<T> > src)
|
||||
template <typename T> cv::Rect CV_BoundingRectTest::get_bounding_rect(const vector <Point_<T> > src)
|
||||
{
|
||||
int n = src.size();
|
||||
T min_w = std::numeric_limits<T>::max(), max_w = std::numeric_limits<T>::min();
|
||||
T min_h = min_w, max_h = max_w;
|
||||
int n = src.size();
|
||||
T min_w = std::numeric_limits<T>::max(), max_w = std::numeric_limits<T>::min();
|
||||
T min_h = min_w, max_h = max_w;
|
||||
|
||||
for (size_t i = 0; i < n; ++i)
|
||||
{
|
||||
min_w = std::min<T>(src.at(i).x, min_w);
|
||||
max_w = std::max<T>(src.at(i).x, max_w);
|
||||
min_h = std::min<T>(src.at(i).y, min_h);
|
||||
max_h = std::max<T>(src.at(i).y, max_h);
|
||||
}
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
min_w = std::min<T>(src.at(i).x, min_w);
|
||||
max_w = std::max<T>(src.at(i).x, max_w);
|
||||
min_h = std::min<T>(src.at(i).y, min_h);
|
||||
max_h = std::max<T>(src.at(i).y, max_h);
|
||||
}
|
||||
|
||||
return Rect((int)min_w, (int)min_h, (int)(floor(1.0*(max_w-min_w)) + 1), (int)(floor(1.0*(max_h-min_h)) + 1));
|
||||
return Rect((int)min_w, (int)min_h, (int)(floor(1.0*(max_w-min_w)) + 1), (int)(floor(1.0*(max_h-min_h)) + 1));
|
||||
}
|
||||
|
||||
template <class T> bool CV_BoundingRectTest::checking_function_work(vector <Point_<T> >& src, int type)
|
||||
template <typename T> bool CV_BoundingRectTest::checking_function_work(vector <Point_<T> >& src, int type)
|
||||
{
|
||||
const int MAX_COUNT_OF_POINTS = 1000;
|
||||
const int N = 10000;
|
||||
const int MAX_COUNT_OF_POINTS = 1000;
|
||||
const int N = 10000;
|
||||
|
||||
for (int k = 0; k < N; ++k)
|
||||
{
|
||||
for (int k = 0; k < N; ++k)
|
||||
{
|
||||
|
||||
RNG& rng = ts->get_rng();
|
||||
RNG& rng = ts->get_rng();
|
||||
|
||||
int n = rng.next()%MAX_COUNT_OF_POINTS + 1;
|
||||
int n = rng.next()%MAX_COUNT_OF_POINTS + 1;
|
||||
|
||||
generate_src_points <T> (src, n);
|
||||
generate_src_points <T> (src, n);
|
||||
|
||||
cv::Rect right = get_bounding_rect <T> (src);
|
||||
cv::Rect right = get_bounding_rect <T> (src);
|
||||
|
||||
cv::Rect rect[2] = { boundingRect(src), boundingRect(Mat(src)) };
|
||||
|
||||
for (int i = 0; i < 2; ++i) if (rect[i] != right)
|
||||
{
|
||||
cout << endl; cout << "Checking for the work of boundingRect function..." << endl;
|
||||
cout << "Type of src points: ";
|
||||
switch (type)
|
||||
{
|
||||
case 0: {cout << "INT"; break;}
|
||||
case 1: {cout << "FLOAT"; break;}
|
||||
case 2: {cout << "DOUBLE"; break;}
|
||||
default: break;
|
||||
}
|
||||
cout << endl;
|
||||
cout << "Src points are stored as "; if (i == 0) cout << "VECTOR" << endl; else cout << "MAT" << endl;
|
||||
cout << "Number of points: " << n << endl;
|
||||
cout << "Right rect (x, y, w, h): [" << right.x << ", " << right.y << ", " << right.width << ", " << right.height << "]" << endl;
|
||||
cout << "Result rect (x, y, w, h): [" << rect[i].x << ", " << rect[i].y << ", " << rect[i].width << ", " << rect[i].height << "]" << endl;
|
||||
cout << endl;
|
||||
CV_Error(IMGPROC_BOUNDINGRECT_ERROR_DIFF, MESSAGE_ERROR_DIFF);
|
||||
return false;
|
||||
}
|
||||
cv::Rect rect[2] = { boundingRect(src), boundingRect(Mat(src)) };
|
||||
|
||||
}
|
||||
for (int i = 0; i < 2; ++i) if (rect[i] != right)
|
||||
{
|
||||
cout << endl; cout << "Checking for the work of boundingRect function..." << endl;
|
||||
cout << "Type of src points: ";
|
||||
switch (type)
|
||||
{
|
||||
case 0: {cout << "INT"; break;}
|
||||
case 1: {cout << "FLOAT"; break;}
|
||||
default: break;
|
||||
}
|
||||
cout << endl;
|
||||
cout << "Src points are stored as "; if (i == 0) cout << "VECTOR" << endl; else cout << "MAT" << endl;
|
||||
cout << "Number of points: " << n << endl;
|
||||
cout << "Right rect (x, y, w, h): [" << right.x << ", " << right.y << ", " << right.width << ", " << right.height << "]" << endl;
|
||||
cout << "Result rect (x, y, w, h): [" << rect[i].x << ", " << rect[i].y << ", " << rect[i].width << ", " << rect[i].height << "]" << endl;
|
||||
cout << endl;
|
||||
CV_Error(IMGPROC_BOUNDINGRECT_ERROR_DIFF, MESSAGE_ERROR_DIFF);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CV_BoundingRectTest::run(int)
|
||||
{
|
||||
vector <Point> src_veci; if (!checking_function_work(src_veci, 0)) return;
|
||||
vector <Point2f> src_vecf; checking_function_work(src_vecf, 1);
|
||||
vector <Point> src_veci; if (!checking_function_work(src_veci, 0)) return;
|
||||
vector <Point2f> src_vecf; checking_function_work(src_vecf, 1);
|
||||
}
|
||||
|
||||
TEST (Imgproc_BoundingRect, accuracy) { CV_BoundingRectTest test; test.safe_run(); }
|
||||
TEST (Imgproc_BoundingRect, accuracy) { CV_BoundingRectTest test; test.safe_run(); }
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user