Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

fixed some warnings and errors on windows

Browse Source
pull/31/head
Ilya Lavrenov 13 years ago
parent b1b5e392e6
commit fbd9bfba47
1 changed files with 120 additions and 122 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 242
      modules/imgproc/test/test_imgwarp_strict.cpp

242
modules/imgproc/test/test_imgwarp_strict.cpp
Unescape View File

@ -58,7 +58,7 @@ namespace internal
cvtest::TS::ptr()->printf(cvtest::TS::SUMMARY, buffer);
va_end(args);
}
#define PRINT_TO_LOG __wrap_printf_func
}
@ -78,7 +78,7 @@ public:
CV_ImageWarpBaseTest();
virtual ~CV_ImageWarpBaseTest();
virtual void run(int);
protected:
virtual void generate_test_data();
@ -89,7 +89,7 @@ protected:
virtual void prepare_test_data_for_reference_func();
Size randSize(RNG& rng) const;
const char* interpolation_to_string(int inter_type) const;
int interpolation;
@ -130,8 +130,8 @@ const char* CV_ImageWarpBaseTest::interpolation_to_string(int inter) const
Size CV_ImageWarpBaseTest::randSize(RNG& rng) const
{
Size size;
size.width = saturate_cast<uint>(std::exp(rng.uniform(1.0f, 7.0f)));
size.height = saturate_cast<uint>(std::exp(rng.uniform(1.0f, 7.0f)));
size.width = static_cast<int>(std::exp(rng.uniform(1.0f, 7.0f)));
size.height = static_cast<int>(std::exp(rng.uniform(1.0f, 7.0f)));
return size;
}
@ -150,7 +150,7 @@ void CV_ImageWarpBaseTest::generate_test_data()
int cn = rng.uniform(1, 4);
while (cn == 2)
cn = rng.uniform(1, 4);
src.create(ssize, CV_MAKE_TYPE(depth, cn));
// generating the src matrix
@ -170,10 +170,10 @@ void CV_ImageWarpBaseTest::generate_test_data()
for (x = cell_size; x < src.cols; x += cell_size)
line(src, Point2i(x, 0), Point2i(x, src.rows), Scalar::all(0), 1);
}
// generating an interpolation type
interpolation = rng.uniform(0, CV_INTER_LANCZOS4 + 1);
// generating the dst matrix structure
double scale_x = 2, scale_y = 2;
if (interpolation == INTER_AREA)
@ -196,13 +196,13 @@ void CV_ImageWarpBaseTest::generate_test_data()
scale_y = rng.uniform(0.4, 4.0);
}
CV_Assert(scale_x > 0.0f && scale_y > 0.0f);
dsize.width = saturate_cast<int>((ssize.width + scale_x - 1) / scale_x);
dsize.height = saturate_cast<int>((ssize.height + scale_y - 1) / scale_y);
dst = Mat::zeros(dsize, src.type());
reference_dst = Mat::zeros(dst.size(), CV_MAKE_TYPE(CV_32F, dst.channels()));
if (interpolation == INTER_AREA && (scale_x < 1.0 || scale_y < 1.0))
interpolation = INTER_LINEAR;
}
@ -228,7 +228,7 @@ void CV_ImageWarpBaseTest::validate_results() const
{
Mat _dst;
dst.convertTo(_dst, reference_dst.depth());
Size dsize = dst.size(), ssize = src.size();
int cn = _dst.channels();
dsize.width *= cn;
@ -241,12 +241,12 @@ void CV_ImageWarpBaseTest::validate_results() const
t = 1.0f;
else if (interpolation == INTER_AREA)
t = 2.0f;
for (int dy = 0; dy < dsize.height; ++dy)
{
const float* rD = reference_dst.ptr<float>(dy);
const float* D = _dst.ptr<float>(dy);
for (int dx = 0; dx < dsize.width; ++dx)
if (fabs(rD[dx] - D[dx]) > t &&
// fabs(rD[dx] - D[dx]) < 250.0f &&
@ -257,7 +257,7 @@ void CV_ImageWarpBaseTest::validate_results() const
PRINT_TO_LOG("Tuple (rD, D): (%f, %f)\n", rD[dx], D[dx]);
PRINT_TO_LOG("Dsize: (%d, %d)\n", dsize.width / cn, dsize.height);
PRINT_TO_LOG("Ssize: (%d, %d)\n", src.cols, src.rows);
float scale_x = static_cast<float>(ssize.width) / dsize.width,
scale_y = static_cast<float>(ssize.height) / dsize.height;
PRINT_TO_LOG("Interpolation: %s\n", interpolation_to_string(interpolation == INTER_AREA &&
@ -266,32 +266,32 @@ void CV_ImageWarpBaseTest::validate_results() const
PRINT_TO_LOG("Scale (x, y): (%lf, %lf)\n", scale_x, scale_y);
PRINT_TO_LOG("Elemsize: %d\n", src.elemSize1());
PRINT_TO_LOG("Channels: %d\n", cn);
#ifdef SHOW_IMAGE
const std::string w1("OpenCV impl (run func)"), w2("Reference func"), w3("Src image"), w4("Diff");
namedWindow(w1, CV_WINDOW_KEEPRATIO);
namedWindow(w2, CV_WINDOW_KEEPRATIO);
namedWindow(w3, CV_WINDOW_KEEPRATIO);
namedWindow(w4, CV_WINDOW_KEEPRATIO);
Mat diff;
absdiff(reference_dst, _dst, diff);
imshow(w1, dst);
imshow(w2, reference_dst);
imshow(w3, src);
imshow(w4, diff);
waitKey();
#endif
const int radius = 3;
int rmin = MAX(dy - radius, 0), rmax = MIN(dy + radius, dsize.height);
int cmin = MAX(dx / cn - radius, 0), cmax = MIN(dx / cn + radius, dsize.width);
std::cout << "opencv result:\n" << dst(Range(rmin, rmax), Range(cmin, cmax)) << std::endl;
std::cout << "reference result:\n" << reference_dst(Range(rmin, rmax), Range(cmin, cmax)) << std::endl;
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
return;
}
@ -324,7 +324,7 @@ protected:
virtual void run_func();
virtual void run_reference_func();
private:
double scale_x;
double scale_y;
@ -333,7 +333,7 @@ private:
void resize_generic();
void resize_area();
double getWeight(double a, double b, int x);
typedef std::vector<std::pair<int, double> > dim;
void generate_buffer(double scale, dim& _dim);
void resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _dim);
@ -356,23 +356,23 @@ namespace internal
coeffs[0] = 1.f - x;
coeffs[1] = x;
}
void interpolateCubic(float x, float* coeffs)
{
const float A = -0.75f;
coeffs[0] = ((A*(x + 1) - 5*A)*(x + 1) + 8*A)*(x + 1) - 4*A;
coeffs[1] = ((A + 2)*x - (A + 3))*x*x + 1;
coeffs[2] = ((A + 2)*(1 - x) - (A + 3))*(1 - x)*(1 - x) + 1;
coeffs[3] = 1.f - coeffs[0] - coeffs[1] - coeffs[2];
}
void interpolateLanczos4(float x, float* coeffs)
{
static const double s45 = 0.70710678118654752440084436210485;
static const double cs[][2]=
{{1, 0}, {-s45, -s45}, {0, 1}, {s45, -s45}, {-1, 0}, {s45, s45}, {0, -1}, {-s45, s45}};
if( x < FLT_EPSILON )
{
for( int i = 0; i < 8; i++ )
@ -380,7 +380,7 @@ namespace internal
coeffs[3] = 1;
return;
}
float sum = 0;
double y0=-(x+3)*CV_PI*0.25, s0 = sin(y0), c0=cos(y0);
for(int i = 0; i < 8; i++ )
@ -389,12 +389,12 @@ namespace internal
coeffs[i] = (float)((cs[i][0]*s0 + cs[i][1]*c0)/(y*y));
sum += coeffs[i];
}
sum = 1.f/sum;
for(int i = 0; i < 8; i++ )
coeffs[i] *= sum;
}
typedef void (*interpolate_method)(float x, float* coeffs);
interpolate_method inter_array[] = { &interpolateLinear, &interpolateCubic, &interpolateLanczos4 };
}
@ -402,10 +402,10 @@ namespace internal
void CV_Resize_Test::generate_test_data()
{
CV_ImageWarpBaseTest::generate_test_data();
scale_x = src.cols / static_cast<double>(dst.cols);
scale_y = src.rows / static_cast<double>(dst.rows);
area_fast = interpolation == INTER_AREA &&
fabs(scale_x - cvRound(scale_x)) < FLT_EPSILON &&
fabs(scale_y - cvRound(scale_y)) < FLT_EPSILON;
@ -424,7 +424,7 @@ void CV_Resize_Test::run_func()
void CV_Resize_Test::run_reference_func()
{
CV_ImageWarpBaseTest::prepare_test_data_for_reference_func();
if (interpolation == INTER_AREA)
resize_area();
else
@ -433,7 +433,7 @@ void CV_Resize_Test::run_reference_func()
double CV_Resize_Test::getWeight(double a, double b, int x)
{
float w = std::min<double>(x + 1, b) - std::max<double>(x, a);
float w = std::min(static_cast<double>(x + 1), b) - std::max(static_cast<double>(x), a);
CV_Assert(w >= 0);
return w;
}
@ -441,28 +441,28 @@ double CV_Resize_Test::getWeight(double a, double b, int x)
void CV_Resize_Test::resize_area()
{
Size ssize = src.size(), dsize = reference_dst.size();
CV_Assert(ssize.area() > 0 && dsize.area() > 0);
CV_Assert(ssize.area() > 0 && dsize.area() > 0);
int cn = src.channels();
CV_Assert(scale_x >= 1.0 && scale_y >= 1.0);
CV_Assert(scale_x >= 1.0 && scale_y >= 1.0);
double fsy0 = 0, fsy1 = scale_y;
for (int dy = 0; dy < dsize.height; ++dy)
{
float* yD = reference_dst.ptr<float>(dy);
int isy0 = cvFloor(fsy0), isy1 = std::min(cvFloor(fsy1), ssize.height - 1);
CV_Assert(isy1 <= ssize.height && isy0 < ssize.height);
float fsx0 = 0, fsx1 = scale_x;
double fsx0 = 0, fsx1 = scale_x;
for (int dx = 0; dx < dsize.width; ++dx)
{
float* xyD = yD + cn * dx;
int isx0 = cvFloor(fsx0), isx1 = std::min(ssize.width - 1, cvFloor(fsx1));
CV_Assert(isx1 <= ssize.width);
CV_Assert(isx0 < ssize.width);
// for each pixel of dst
for (int r = 0; r < cn; ++r)
{
@ -476,37 +476,37 @@ void CV_Resize_Test::resize_area()
double wy = getWeight(fsy0, fsy1, sy);
double wx = getWeight(fsx0, fsx1, sx);
double w = wx * wy;
xyD[r] += yS[sx * cn + r] * w;
xyD[r] += static_cast<float>(yS[sx * cn + r] * w);
area += w;
}
}
CV_Assert(area != 0);
// norming pixel
xyD[r] /= area;
xyD[r] = static_cast<float>(xyD[r] / area);
}
fsx1 = std::min<double>((fsx0 = fsx1) + scale_x, ssize.width);
fsx1 = std::min((fsx0 = fsx1) + scale_x, static_cast<double>(ssize.width));
}
fsy1 = std::min<double>((fsy0 = fsy1) + scale_y, ssize.height);
fsy1 = std::min((fsy0 = fsy1) + scale_y, static_cast<double>(ssize.height));
}
}
// for interpolation type : INTER_LINEAR, INTER_LINEAR, INTER_CUBIC, INTER_LANCZOS4
void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _dim)
{
Size dsize = _dst.size();
Size dsize = _dst.size();
int cn = _dst.channels();
float* yD = _dst.ptr<float>(dy);
if (interpolation == INTER_NEAREST)
{
const float* yS = _src.ptr<float>(dy);
for (int dx = 0; dx < dsize.width; ++dx)
{
int isx = _dim[dx].first;
const float* xyS = yS + isx * cn;
float* xyD = yD + dx * cn;
const float* xyS = yS + isx * cn;
float* xyD = yD + dx * cn;
for (int r = 0; r < cn; ++r)
xyD[r] = xyS[r];
}
@ -515,13 +515,13 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
{
internal::interpolate_method inter_func = internal::inter_array[interpolation - (interpolation == INTER_LANCZOS4 ? 2 : 1)];
int elemsize = _src.elemSize();
int ofs = 0, ksize = 2;
if (interpolation == INTER_CUBIC)
ofs = 1, ksize = 4;
else if (interpolation == INTER_LANCZOS4)
ofs = 3, ksize = 8;
Mat _extended_src_row(1, _src.cols + ksize * 2, _src.type());
uchar* srow = _src.data + dy * _src.step;
memcpy(_extended_src_row.data + elemsize * ksize, srow, _src.step);
@ -530,7 +530,7 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
memcpy(_extended_src_row.data + k * elemsize, srow, elemsize);
memcpy(_extended_src_row.data + (ksize + k) * elemsize + _src.step, srow + _src.step - elemsize, elemsize);
}
for (int dx = 0; dx < dsize.width; ++dx)
{
int isx = _dim[dx].first;
@ -539,8 +539,8 @@ void CV_Resize_Test::resize_1d(const Mat& _src, Mat& _dst, int dy, const dim& _d
float *xyD = yD + dx * cn;
const float* xyS = _extended_src_row.ptr<float>(0) + (isx + ksize - ofs) * cn;
float w[ksize];
inter_func(fsx, w);
float w[8];
inter_func(static_cast<float>(fsx), w);
for (int r = 0; r < cn; ++r)
{
@ -559,7 +559,7 @@ void CV_Resize_Test::generate_buffer(double scale, dim& _dim)
{
int length = _dim.size();
for (int dx = 0; dx < length; ++dx)
{
{
double fsx = scale * (dx + 0.5f) - 0.5f;
int isx = cvFloor(fsx);
_dim[dx] = std::make_pair(isx, fsx - isx);
@ -570,12 +570,12 @@ void CV_Resize_Test::resize_generic()
{
Size dsize = reference_dst.size(), ssize = src.size();
CV_Assert(dsize.area() > 0 && ssize.area() > 0);
dim dims[] = { dim(dsize.width), dim(dsize.height) };
if (interpolation == INTER_NEAREST)
{
for (int dx = 0; dx < dsize.width; ++dx)
dims[0][dx].first = std::min(cvFloor(dx * scale_x), ssize.width - 1);
dims[0][dx].first = std::min(cvFloor(dx * scale_x), ssize.width - 1);
for (int dy = 0; dy < dsize.height; ++dy)
dims[1][dy].first = std::min(cvFloor(dy * scale_y), ssize.height - 1);
}
@ -584,14 +584,14 @@ void CV_Resize_Test::resize_generic()
generate_buffer(scale_x, dims[0]);
generate_buffer(scale_y, dims[1]);
}
Mat tmp(ssize.height, dsize.width, reference_dst.type());
for (int dy = 0; dy < tmp.rows; ++dy)
resize_1d(src, tmp, dy, dims[0]);
transpose(tmp, tmp);
transpose(reference_dst, reference_dst);
for (int dy = 0; dy < tmp.rows; ++dy)
resize_1d(tmp, reference_dst, dy, dims[1]);
transpose(reference_dst, reference_dst);
@ -624,7 +624,7 @@ protected:
Scalar borderValue;
remap_func funcs[2];
private:
void remap_nearest(const Mat&, Mat&);
void remap_generic(const Mat&, Mat&);
@ -661,7 +661,7 @@ void CV_Remap_Test::generate_test_data()
const int n = std::min(std::min(src.cols, src.rows) / 10 + 1, 2);
float _n = 0; //static_cast<float>(-n);
switch (mapx.type())
{
case CV_16SC2:
@ -669,8 +669,8 @@ void CV_Remap_Test::generate_test_data()
MatIterator_<Vec2s> begin_x = mapx.begin<Vec2s>(), end_x = mapx.end<Vec2s>();
for ( ; begin_x != end_x; ++begin_x)
{
begin_x[0] = rng.uniform(static_cast<int>(_n), std::max(src.cols + n - 1, 0));
begin_x[1] = rng.uniform(static_cast<int>(_n), std::max(src.rows + n - 1, 0));
begin_x[0] = static_cast<short>(rng.uniform(static_cast<int>(_n), std::max(src.cols + n - 1, 0)));
begin_x[1] = static_cast<short>(rng.uniform(static_cast<int>(_n), std::max(src.rows + n - 1, 0)));
}
if (interpolation != INTER_NEAREST)
@ -684,7 +684,7 @@ void CV_Remap_Test::generate_test_data()
{
MatIterator_<ushort> begin_y = mapy.begin<ushort>(), end_y = mapy.end<ushort>();
for ( ; begin_y != end_y; ++begin_y)
begin_y[0] = rng.uniform(0, 1024);
begin_y[0] = static_cast<short>(rng.uniform(0, 1024));
}
break;
@ -692,7 +692,7 @@ void CV_Remap_Test::generate_test_data()
{
MatIterator_<short> begin_y = mapy.begin<short>(), end_y = mapy.end<short>();
for ( ; begin_y != end_y; ++begin_y)
begin_y[0] = rng.uniform(0, 1024);
begin_y[0] = static_cast<short>(rng.uniform(0, 1024));
}
break;
}
@ -727,7 +727,7 @@ void CV_Remap_Test::generate_test_data()
}
}
break;
default:
assert(0);
break;
@ -746,10 +746,10 @@ void CV_Remap_Test::convert_maps()
else if (interpolation != INTER_NEAREST)
if (mapy.type() != CV_16UC1)
mapy.clone().convertTo(mapy, CV_16UC1);
if (interpolation == INTER_NEAREST)
mapy = Mat();
CV_Assert(( (interpolation == INTER_NEAREST && !mapy.data) || mapy.type() == CV_16UC1 ||
CV_Assert(((interpolation == INTER_NEAREST && !mapy.data) || mapy.type() == CV_16UC1 ||
mapy.type() == CV_16SC1) && mapx.type() == CV_16SC2);
}
@ -793,7 +793,7 @@ void CV_Remap_Test::run_reference_func()
if (interpolation == INTER_AREA)
interpolation = INTER_LINEAR;
int index = interpolation == INTER_NEAREST ? 0 : 1;
(this->*funcs[index])(src, reference_dst);
}
@ -811,7 +811,7 @@ void CV_Remap_Test::remap_nearest(const Mat& _src, Mat& _dst)
{
const short* yM = mapx.ptr<short>(dy);
float* yD = _dst.ptr<float>(dy);
for (int dx = 0; dx < dsize.width; ++dx)
{
float* xyD = yD + cn * dx;
@ -828,7 +828,7 @@ void CV_Remap_Test::remap_nearest(const Mat& _src, Mat& _dst)
{
if (borderType == BORDER_CONSTANT)
for (int r = 0; r < cn; ++r)
xyD[r] = borderValue[r];
xyD[r] = saturate_cast<float>(borderValue[r]);
else
{
sx = borderInterpolate(sx, ssize.width, borderType);
@ -848,19 +848,16 @@ void CV_Remap_Test::remap_nearest(const Mat& _src, Mat& _dst)
void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
{
CV_Assert(mapx.type() == CV_16SC2 && mapy.type() == CV_16UC1);
int ksize;
if (interpolation == INTER_LINEAR)
ksize = 2;
else if (interpolation == INTER_CUBIC)
int ksize = 2;
if (interpolation == INTER_CUBIC)
ksize = 4;
else if (interpolation == INTER_LANCZOS4)
ksize = 8;
else
ksize = 0;
assert(ksize);
else if (interpolation != INTER_LINEAR)
assert(0);
int ofs = (ksize / 2) - 1;
CV_Assert(_src.depth() == CV_32F && _dst.type() == _src.type());
Size ssize = _src.size(), dsize = _dst.size();
int cn = _src.channels(), width1 = std::max(ssize.width - ksize + 1, 0),
@ -875,7 +872,7 @@ void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
const ushort* yMy = mapy.ptr<ushort>(dy);
float* yD = _dst.ptr<float>(dy);
for (int dx = 0; dx < dsize.width; ++dx)
{
float* xyD = yD + dx * cn;
@ -884,7 +881,7 @@ void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
inter_func((yMy[dx] & (INTER_TAB_SIZE - 1)) / static_cast<float>(INTER_TAB_SIZE), w);
inter_func(((yMy[dx] >> INTER_BITS) & (INTER_TAB_SIZE - 1)) / static_cast<float>(INTER_TAB_SIZE), w + ksize);
isx -= ofs;
isy -= ofs;
@ -908,7 +905,7 @@ void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
else if (borderType != BORDER_TRANSPARENT)
{
int ar_x[8], ar_y[8];
for (int k = 0; k < ksize; k++)
{
ar_x[k] = borderInterpolate(isx + k, ssize.width, borderType) * cn;
@ -925,14 +922,14 @@ void CV_Remap_Test::remap_generic(const Mat& _src, Mat& _dst)
{
const float* yS = _src.ptr<float>(ar_y[i]);
for (int j = 0; j < ksize; ++j)
ix[i] += (ar_x[j] >= 0 ? yS[ar_x[j] + r] : borderValue[r]) * w[j];
ix[i] += saturate_cast<float>((ar_x[j] >= 0 ? yS[ar_x[j] + r] : borderValue[r]) * w[j]);
}
else
for (int j = 0; j < ksize; ++j)
ix[i] += borderValue[r] * w[j];
ix[i] += saturate_cast<float>(borderValue[r] * w[j]);
}
for (int i = 0; i < ksize; ++i)
xyD[r] += w[ksize + i] * ix[i];
xyD[r] += saturate_cast<float>(w[ksize + i] * ix[i]);
}
}
}
@ -1002,7 +999,7 @@ void CV_WarpAffine_Test::generate_test_data()
M.convertTo(tmp, depth);
M = tmp;
}
// warp_matrix is inverse
if (rng.uniform(0., 1.) > 0)
interpolation |= CV_WARP_INVERSE_MAP;
@ -1035,7 +1032,7 @@ void CV_WarpAffine_Test::warpAffine(const Mat& _src, Mat& _dst)
Mat tM;
M.convertTo(tM, CV_64F);
int inter = interpolation & INTER_MAX;
if (inter == INTER_AREA)
inter = INTER_LINEAR;
@ -1045,35 +1042,35 @@ void CV_WarpAffine_Test::warpAffine(const Mat& _src, Mat& _dst)
mapy.create(dsize, CV_16SC1);
else
mapy = Mat();
if (!(interpolation & CV_WARP_INVERSE_MAP))
invertAffineTransform(tM.clone(), tM);
const int AB_BITS = MAX(10, (int)INTER_BITS);
const int AB_SCALE = 1 << AB_BITS;
const int AB_SCALE = 1 << AB_BITS;
int round_delta = (inter == INTER_NEAREST) ? AB_SCALE / 2 : (AB_SCALE / INTER_TAB_SIZE / 2);
const double* data_tM = tM.ptr<double>(0);
for (int dy = 0; dy < dsize.height; ++dy)
{
short* yM = mapx.ptr<short>(dy);
for (int dx = 0; dx < dsize.width; ++dx, yM += 2)
{
int v1 = saturate_cast<int>(saturate_cast<int>(data_tM[0] * dx * AB_SCALE) +
saturate_cast<int>((data_tM[1] * dy + data_tM[2]) * AB_SCALE) + round_delta),
v2 = saturate_cast<int>(saturate_cast<int>(data_tM[3] * dx * AB_SCALE) +
{
int v1 = saturate_cast<int>(saturate_cast<int>(data_tM[0] * dx * AB_SCALE) +
saturate_cast<int>((data_tM[1] * dy + data_tM[2]) * AB_SCALE) + round_delta),
v2 = saturate_cast<int>(saturate_cast<int>(data_tM[3] * dx * AB_SCALE) +
saturate_cast<int>((data_tM[4] * dy + data_tM[5]) * AB_SCALE) + round_delta);
v1 >>= AB_BITS - INTER_BITS;
v2 >>= AB_BITS - INTER_BITS;
yM[0] = saturate_cast<short>(v1 >> INTER_BITS);
yM[1] = saturate_cast<short>(v2 >> INTER_BITS);
if (inter != INTER_NEAREST)
mapy.ptr<short>(dy)[dx] = ((v2 & (INTER_TAB_SIZE - 1)) * INTER_TAB_SIZE + (v1 & (INTER_TAB_SIZE - 1)));
}
}
CV_Assert(mapx.type() == CV_16SC2 && ((inter == INTER_NEAREST && !mapy.data) || mapy.type() == CV_16SC1));
cv::remap(_src, _dst, mapx, mapy, inter, borderType, borderValue);
}
@ -1099,7 +1096,7 @@ protected:
private:
void warpPerspective(const Mat&, Mat&);
};
CV_WarpPerspective_Test::CV_WarpPerspective_Test() :
CV_WarpAffine_Test()
{
@ -1116,11 +1113,12 @@ void CV_WarpPerspective_Test::generate_test_data()
// generating the M 3x3 matrix
RNG& rng = ts->get_rng();
Point2f sp[] = { Point2f(0, 0), Point2f(src.cols, 0), Point2f(0, src.rows), Point2f(src.cols, src.rows) };
Point2f dp[] = { Point2f(rng.uniform(0, src.cols), rng.uniform(0, src.rows)),
Point2f(rng.uniform(0, src.cols), rng.uniform(0, src.rows)),
Point2f(rng.uniform(0, src.cols), rng.uniform(0, src.rows)),
Point2f(rng.uniform(0, src.cols), rng.uniform(0, src.rows)) };
float cols = static_cast<float>(src.cols), rows = static_cast<float>(src.rows);
Point2f sp[] = { Point2f(0.0f, 0.0f), Point2f(cols, 0.0f), Point2f(0.0f, rows), Point2f(cols, rows) };
Point2f dp[] = { Point2f(rng.uniform(0.0f, cols), rng.uniform(0.0f, rows)),
Point2f(rng.uniform(0.0f, cols), rng.uniform(0.0f, rows)),
Point2f(rng.uniform(0.0f, cols), rng.uniform(0.0f, rows)),
Point2f(rng.uniform(0.0f, cols), rng.uniform(0.0f, rows)) };
M = getPerspectiveTransform(sp, dp);
static const int depths[] = { CV_32F, CV_64F };
@ -1148,24 +1146,24 @@ void CV_WarpPerspective_Test::warpPerspective(const Mat& _src, Mat& _dst)
CV_Assert(dsize.area() > 0);
CV_Assert(_src.type() == _dst.type());
if (M.depth() != CV_64F)
{
Mat tmp;
M.convertTo(tmp, CV_64F);
M = tmp;
}
if (M.depth() != CV_64F)
{
Mat tmp;
M.convertTo(tmp, CV_64F);
M = tmp;
}
if (!(interpolation & CV_WARP_INVERSE_MAP))
{
Mat tmp;
invert(M, tmp);
M = tmp;
}
int inter = interpolation & INTER_MAX;
if (inter == INTER_AREA)
inter = INTER_LINEAR;
mapx.create(dsize, CV_16SC2);
if (inter != INTER_NEAREST)
mapy.create(dsize, CV_16SC1);
@ -1176,30 +1174,30 @@ void CV_WarpPerspective_Test::warpPerspective(const Mat& _src, Mat& _dst)
for (int dy = 0; dy < dsize.height; ++dy)
{
short* yMx = mapx.ptr<short>(dy);
for (int dx = 0; dx < dsize.width; ++dx, yMx += 2)
{
double den = tM[6] * dx + tM[7] * dy + tM[8];
den = den ? 1.0 / den : 0.0;
if (inter == INTER_NEAREST)
{
yMx[0] = saturate_cast<short>((tM[0] * dx + tM[1] * dy + tM[2]) * den);
yMx[1] = saturate_cast<short>((tM[3] * dx + tM[4] * dy + tM[5]) * den);
continue;
}
den *= INTER_TAB_SIZE;
int v0 = saturate_cast<int>((tM[0] * dx + tM[1] * dy + tM[2]) * den);
int v1 = saturate_cast<int>((tM[3] * dx + tM[4] * dy + tM[5]) * den);
yMx[0] = saturate_cast<short>(v0 >> INTER_BITS);
yMx[1] = saturate_cast<short>(v1 >> INTER_BITS);
mapy.ptr<short>(dy)[dx] = saturate_cast<short>((v1 & (INTER_TAB_SIZE - 1)) *
mapy.ptr<short>(dy)[dx] = saturate_cast<short>((v1 & (INTER_TAB_SIZE - 1)) *
INTER_TAB_SIZE + (v0 & (INTER_TAB_SIZE - 1)));
}
}
CV_Assert(mapx.type() == CV_16SC2 && ((inter == INTER_NEAREST && !mapy.data) || mapy.type() == CV_16SC1));
cv::remap(_src, _dst, mapx, mapy, inter, borderType, borderValue);
}

Write Preview
Loading…
Cancel
Save