Skip to content

O
opencv
Commit b5bbce5b authored by Alexander Reshetnikov's avatar Alexander Reshetnikov
Browse files
Options

Completed countNonZero test (found that it's already exist, so new implementation isn't used now).

parent aaace633
Hide whitespace changes
Inline Side-by-side
Showing with 162 additions and 315 deletions
modules/core/test/test_countnonzero.cpp
View file @ b5bbce5b
...@@ -4,14 +4,17 @@ ...@@ -4,14 +4,17 @@
using namespace cv; using namespace cv;
using namespace std; using namespace std;
#define CORE_COUNTNONZERO_ERROR_COUNT 1
#define MESSAGE_ERROR_COUNT "Count non zero elements returned by OpenCV function is incorrect."
#define sign(a) a > 0 ? 1 : a == 0 ? 0 : -1 #define sign(a) a > 0 ? 1 : a == 0 ? 0 : -1
const int FLOAT_TYPE [2] = {CV_32F, CV_64F}; const int FLOAT_TYPE [2] = {CV_32F, CV_64F};
const int INT_TYPE [5] = {CV_8U, CV_8S, CV_16U, CV_16S, CV_32S}; const int INT_TYPE [5] = {CV_8U, CV_8S, CV_16U, CV_16S, CV_32S};
#define MAX_CHANNELS 4 #define MAX_WIDTH 100
#define MAX_WIDTH 1e+2 #define MAX_HEIGHT 100
#define MAX_HEIGHT 1e+2
class CV_CountNonZeroTest: public cvtest::BaseTest class CV_CountNonZeroTest: public cvtest::BaseTest
{ {
...@@ -23,360 +26,193 @@ class CV_CountNonZeroTest: public cvtest::BaseTest ...@@ -23,360 +26,193 @@ class CV_CountNonZeroTest: public cvtest::BaseTest
void run (int); void run (int);
private: private:
float eps_32; double eps_64; Mat src; float eps_32;
double eps_64;
Mat src;
int current_type;
void generate_src_data(cv::Size size, int type, int channels); void generate_src_data(cv::Size size, int type);
void generate_src_data(cv::Size size, int type, int channels, int count_non_zero); void generate_src_data(cv::Size size, int type, int count_non_zero);
void generate_src_float_data(cv::Size size, int type, int channels, int distribution); void generate_src_stat_data(cv::Size size, int type, int distribution);
int get_count_non_zero();
void checking_function_work(); void print_information(int right, int result);
void checking_function_work(int count_non_zero);
}; };
CV_CountNonZeroTest::CV_CountNonZeroTest(): eps_32(1e-2), eps_64(1e-4), src(Mat()) {} CV_CountNonZeroTest::CV_CountNonZeroTest(): eps_32(1e-8), eps_64(1e-16), src(Mat()), current_type(-1) {}
CV_CountNonZeroTest::~CV_CountNonZeroTest() {} CV_CountNonZeroTest::~CV_CountNonZeroTest() {}
void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type, int channels) void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type)
{ {
src.create(size, CV_MAKETYPE(type, channels)); src.create(size, CV_MAKETYPE(type, 1));
for (size_t i = 0; i < size.width; ++i) for (size_t j = 0; j < size.width; ++j)
for (size_t j = 0; j < size.height; ++j) for (size_t i = 0; i < size.height; ++i)
switch (type)
{ {
if (type == CV_8U) switch (channels) 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 1: {src.at<uchar>(j, i) = cv::randu<uchar>(); break;} case CV_16U: { src.at<ushort>(i, j) = cv::randu<ushort>(); break; }
case 2: {src.at<Vec2b>(j, i) = Vec2b(cv::randu<uchar>(), cv::randu<uchar>()); break;} case CV_16S: { src.at<short>(i, j) = cv::randu<short>(); break; }
case 3: {src.at<Vec3b>(j, i) = Vec3b(cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>()); break;} case CV_32S: { src.at<int>(i, j) = cv::randu<int>(); break; }
case 4: {src.at<Vec4b>(j, i) = Vec4b(cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>()); 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; default: break;
}
else if (type == CV_8S) switch (channels)
{
case 1: {src.at<char>(j,i) = cv::randu<uchar>()-128; break; }
case 2: {src.at< Vec<char, 2> >(j, i) = Vec<char, 2>(cv::randu<uchar>()-128, cv::randu<uchar>()-128); break;}
case 3: {src.at< Vec<char, 3> >(j, i) = Vec<char, 3>(cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128); break;}
case 4: {src.at< Vec<char, 4> >(j, i) = Vec<char, 4>(cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128); break;}
default:break;
}
else if (type == CV_16U) switch (channels)
{
case 1: {src.at<ushort>(j, i) = cv::randu<ushort>(); break;}
case 2: {src.at< Vec<ushort, 2> >(j, i) = Vec<ushort, 2>(cv::randu<ushort>(), cv::randu<ushort>()); break;}
case 3: {src.at< Vec<ushort, 3> >(j, i) = Vec<ushort, 3>(cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>()); break;}
case 4: {src.at< Vec<ushort, 4> >(j, i) = Vec<ushort, 4>(cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>()); break;}
default: break;
}
else if (type == CV_16S) switch (channels)
{
case 1: {src.at<short>(j, i) = cv::randu<short>(); break;}
case 2: {src.at<Vec2s>(j, i) = Vec2s(cv::randu<short>(), cv::randu<short>()); break;}
case 3: {src.at<Vec3s>(j, i) = Vec3s(cv::randu<short>(), cv::randu<short>(), cv::randu<short>()); break;}
case 4: {src.at<Vec4s>(j, i) = Vec4s(cv::randu<short>(), cv::randu<short>(), cv::randu<short>(), cv::randu<short>()); break;}
default: break;
}
else if (type == CV_32S) switch (channels)
{
case 1: {src.at<int>(j, i) = cv::randu<int>(); break;}
case 2: {src.at<Vec2i>(j, i) = Vec2i(cv::randu<int>(), cv::randu<int>()); break;}
case 3: {src.at<Vec3i>(j, i) = Vec3i(cv::randu<int>(), cv::randu<int>(), cv::randu<int>()); break;}
case 4: {src.at<Vec4i>(j, i) = Vec4i(cv::randu<int>(), cv::randu<int>(), cv::randu<int>(), cv::randu<int>()); break;}
default: break;
}
else if (type == CV_32F) switch (channels)
{
case 1: {src.at<float>(j, i) = cv::randu<float>(); break;}
case 2: {src.at<Vec2f>(j, i) = Vec2i(cv::randu<float>(), cv::randu<float>()); break;}
case 3: {src.at<Vec3f>(j, i) = Vec3i(cv::randu<float>(), cv::randu<float>(), cv::randu<float>()); break;}
case 4: {src.at<Vec4f>(j, i) = Vec4i(cv::randu<float>(), cv::randu<float>(), cv::randu<float>(), cv::randu<float>()); break;}
default: break;
}
else if (type == CV_64F) switch (channels)
{
case 1: {src.at<double>(j, i) = cv::randu<double>(); break;}
case 2: {src.at<Vec2d>(j, i) = Vec2d(cv::randu<double>(), cv::randu<double>()); break;}
case 3: {src.at<Vec3d>(j, i) = Vec3d(cv::randu<double>(), cv::randu<double>(), cv::randu<double>()); break;}
case 4: {src.at<Vec4d>(j, i) = Vec4d(cv::randu<double>(), cv::randu<double>(), cv::randu<double>(), cv::randu<double>()); break;}
default: break;
}
} }
} }
void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type, int channels, int count_non_zero) void CV_CountNonZeroTest::generate_src_data(cv::Size size, int type, int count_non_zero)
{ {
src = Mat::zeros(size, CV_MAKETYPE(type, channels)); src = Mat::zeros(size, CV_MAKETYPE(type, 1));
int n = -1; int n = 0; RNG& rng = ts->get_rng();
while (n < count_non_zero) while (n < count_non_zero)
{ {
RNG& rng = ts->get_rng(); size_t i = rng.next()%size.height, j = rng.next()%size.width;
size_t i = rng.next()%size.height, j = rng.next()%size.width;
switch (type) switch (type)
{ {
case CV_8U: case CV_8U: { if (!src.at<uchar>(i, j)) {src.at<uchar>(i, j) = cv::randu<uchar>(); n += abs(sign(src.at<uchar>(i, j)));} 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; }
if (channels == 1) case CV_16U: { if (!src.at<ushort>(i, j)) {src.at<ushort>(i, j) = cv::randu<ushort>(); n += abs(sign(src.at<ushort>(i, j)));} 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; }
uchar value = cv::randu<uchar>(); 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; }
if (value != 0) {src.at<uchar>(i, j) = value; n++;} case CV_32F: { if (fabs(src.at<float>(i, j)) <= eps_32) {src.at<float>(i, j) = cv::randu<float>(); n += sign(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 += sign(fabs(src.at<double>(i, j)) > eps_64);} break; }
else if (channels == 2) default: break;
{ }
Vec2b value(cv::randu<uchar>(), cv::randu<uchar>()); }
if (value != Vec2b(0, 0)) {src.at<Vec2b>(i, j) = value; n++;}
} }
else if (channels == 3)
{
Vec3b value(cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>());
if (value != Vec3b(0, 0, 0)) {src.at<Vec3b>(i, j) = value; n++;}
}
else
{
Vec4b value(cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>(), cv::randu<uchar>());
if (value != Vec4b(0, 0, 0, 0)) {src.at<Vec4b>(i, j) = value; n++;}
}
break;
}
case CV_8S:
{
if (channels == 1)
{
char value = cv::randu<uchar>()-128;
if (value != 0) {src.at<char>(i, j) = value; n++;}
}
else if (channels == 2)
{
Vec<char, 2> value(cv::randu<uchar>()-128, cv::randu<uchar>()-128);
if (value != Vec<char, 2>(0, 0)) {src.at< Vec<char, 2 > >(i, j) = value; n++;}
}
else if (channels == 3)
{
Vec<char, 3> value(cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128);
if (value != Vec<char, 3>(0, 0, 0)) {src.at< Vec<char, 3> >(i, j) = value; n++;}
}
else
{
Vec<char, 4> value(cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128, cv::randu<uchar>()-128);
if (value != Vec<char, 4>(0, 0, 0, 0)) {src.at< Vec<char, 4> >(i, j) = value; n++;}
}
break;
}
case CV_16U:
{
if (channels == 1)
{
ushort value = cv::randu<ushort>();
n += abs(sign(value));
src.at<ushort>(i, j) = value;
}
else if (channels == 2)
{
Vec<ushort, 2> value(cv::randu<ushort>(), cv::randu<ushort>());
if (value != Vec<ushort, 2>(0, 0)) {src.at< Vec<ushort, 2> >(i, j) = value; n++;}
}
else if (channels == 3)
{
Vec<ushort, 3> value(cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>());
if (value != Vec<ushort, 3>(0, 0, 0)) {src.at< Vec<ushort, 3> >(i, j) = value; n++;}
}
else
{
Vec<ushort, 4> value(cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>(), cv::randu<ushort>());
if (value != Vec<ushort, 4>(0, 0, 0, 0)) {src.at< Vec<ushort, 4> >(i, j) = value; n++;}
}
break; void CV_CountNonZeroTest::generate_src_stat_data(cv::Size size, int type, int distribution)
} {
src.create(size, CV_MAKETYPE(type, 1));
case CV_16S: double mean = 0.0, sigma = 1.0;
{ double left = -1.0, right = 1.0;
if (channels == 1)
{
short value = cv::randu<short>();
n += abs(sign(value));
src.at<short>(i, j) = value;
}
else if (channels == 2)
{
Vec2s value(cv::randu<short>(), cv::randu<short>());
if (value != Vec2s(0, 0)) {src.at<Vec2s>(i, j) = value; n++;}
}
else if (channels == 3) RNG& rng = ts->get_rng();
{
Vec3s value(cv::randu<short>(), cv::randu<short>(), cv::randu<short>());
if (value != Vec3s(0, 0, 0)) {src.at<Vec3s>(i, j) = value; n++;}
}
else 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()
Vec4s value(cv::randu<short>(), cv::randu<short>(), cv::randu<short>(), cv::randu<short>()); {
if (value != Vec4s(0, 0, 0, 0)) {src.at<Vec4s>(i, j) = value; n++;} int result = 0, channels = src.channels();
}
break; for (size_t i = 0; i < src.rows; ++i)
} for (size_t j = 0; j < src.cols; ++j)
case CV_32S: if (current_type == CV_8U) result += abs(sign(src.at<uchar>(i, j)));
{
if (channels == 1) else if (current_type == CV_8S) result += abs(sign(src.at<char>(i, j)));
{
int value = cv::randu<int>();
n += abs(sign(value));
src.at<int>(i, j) = value;
}
else if (channels == 2)
{
Vec2i value(cv::randu<int>(), cv::randu<int>());
if (value != Vec2i(0, 0)) {src.at<Vec2i>(i, j) = value; n++;}
}
else if (channels == 3) else if (current_type == CV_16U) result += abs(sign(src.at<ushort>(i, j)));
{
Vec3i value(cv::randu<int>(), cv::randu<int>(), cv::randu<int>());
if (value != Vec3i(0, 0, 0)) {src.at<Vec3i>(i, j) = value; n++;}
}
else else if (current_type == CV_16S) result += abs(sign(src.at<short>(i, j)));
{ else if (current_type == CV_32S) result += abs(sign(src.at<int>(i, j)));
Vec4i value(cv::randu<int>(), cv::randu<int>(), cv::randu<int>(), cv::randu<int>());
if (value != Vec4i(0, 0, 0, 0)) {src.at<Vec4i>(i, j) = value; n++;}
}
break; else if (current_type == CV_32F) result += sign(fabs(src.at<float>(i, j)) > eps_32);
}
else result += sign(fabs(src.at<double>(i, j)) > eps_64);
case CV_32F: return result;
{ }
if (channels == 1)
{
float value = cv::randu<float>();
n += sign(fabs(value) > eps_32);
src.at<float>(i, j) = value;
}
else
if (channels == 2) void CV_CountNonZeroTest::print_information(int right, int result)
{ {
Vec2f value(cv::randu<float>(), cv::randu<float>()); cout << endl; cout << "Checking for the work of countNonZero function..." << endl; cout << endl;
n += sign(cv::norm(value) > eps_32); cout << "Type of Mat: ";
src.at<Vec2f>(i, j) = value; 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;
}
else void CV_CountNonZeroTest::run(int)
{
const size_t N = 1500;
if (channels == 3) for (int k = 1; k <= 3; ++k)
{ for (size_t i = 0; i < N; ++i)
Vec3f value(cv::randu<float>(), cv::randu<float>(), cv::randu<float>()); {
n += sign(cv::norm(value) > eps_32); RNG& rng = ts->get_rng();
src.at<Vec3f>(i, j) = value;
} int w = rng.next()%MAX_WIDTH + 1, h = rng.next()%MAX_HEIGHT + 1;
else 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;
}
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)
{ {
Vec4f value(cv::randu<float>(), cv::randu<float>(), cv::randu<float>(), cv::randu<float>()); cout << "Number of experiment: " << i << endl;
n += sign(cv::norm(value) > eps_32); cout << "Method of data generation: HALF-RANDOM" << endl;
src.at<Vec4f>(i, j) = value; print_information(count_non_zero, result);
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
return;
} }
break; break;
} }
case CV_64F:
{
if (channels == 1)
{
double value = cv::randu<double>();
n += sign(fabs(value) > eps_64);
src.at<double>(i, j) = value;
}
else
if (channels == 2)
{
Vec2d value(cv::randu<double>(), cv::randu<double>());
n += sign(cv::norm(value) > eps_64);
src.at<Vec2d>(i, j) = value;
}
else
if (channels == 3) case 3: {
{ int distribution = cv::randu<uchar>()%2;
Vec3d value(cv::randu<double>(), cv::randu<double>(), cv::randu<double>()); generate_src_stat_data(Size(w, h), current_type, distribution);
n += sign(cv::norm(value) > eps_64); int right = get_count_non_zero(), result = countNonZero(src);
src.at<Vec3d>(i, j) = value; if (right != result)
}
else
{ {
Vec4d value(cv::randu<double>(), cv::randu<double>(), cv::randu<double>(), cv::randu<double>()); cout << "Number of experiment: " << i << endl;
n += sign(cv::norm(value) > eps_64); cout << "Method of data generation: STATISTIC" << endl;
src.at<Vec4d>(i, j) = value; print_information(right, result);
CV_Error(CORE_COUNTNONZERO_ERROR_COUNT, MESSAGE_ERROR_COUNT);
return;
} }
break; break;
} }
default: break; default: break;
} }
} }
}
void CV_CountNonZeroTest::generate_src_float_data(cv::Size size, int type, int channels, int distribution)
{
src.create(size, CV_MAKETYPE(type, channels));
double mean = 0.0, sigma = 1.0;
double left = -1.0, right = 1.0;
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));
}
void CV_CountNonZeroTest::run(int)
{
} }
TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); } // TEST (Core_CountNonZero, accuracy) { CV_CountNonZeroTest test; test.safe_run(); }
\ No newline at end of file \ No newline at end of file
modules/imgproc/test/test_boundingrect.cpp
View file @ b5bbce5b
...@@ -22,7 +22,17 @@ CV_BoundingRectTest::~CV_BoundingRectTest() {} ...@@ -22,7 +22,17 @@ CV_BoundingRectTest::~CV_BoundingRectTest() {}
void CV_BoundingRectTest::run(int) void CV_BoundingRectTest::run(int)
{ {
const int MAX_WIDTH = 100;
const int MAX_HEIGHT = 100;
const int N = 100;
RNG& rng = ts->get_rng();
for (size_t i = 0; i < N; ++i)
{
int w = rng.next()%MAX_WIDTH + 1, h = rng.next()%MAX_HEIGHT + 1;
cv::Mat src(h, w, CV_8U); cv::randu(src, Scalar_<bool>::all(false), Scalar_<bool>::all(true));
}
} }
TEST (Imgproc_BoundingRect, accuracy) { CV_BoundingRectTest test; test.safe_run(); } TEST (Imgproc_BoundingRect, accuracy) { CV_BoundingRectTest test; test.safe_run(); }
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment