Normalize line endings and whitespace
This commit is contained in:
committed by
Andrey Kamaev
parent
69020da607
commit
04384a71e4
@@ -13,12 +13,12 @@ static Mat initDFTWave( int n, bool inv )
|
||||
Complexd wi, w1;
|
||||
Mat wave(1, n, CV_64FC2);
|
||||
Complexd* w = wave.ptr<Complexd>();
|
||||
|
||||
|
||||
w1.re = cos(angle);
|
||||
w1.im = sin(angle);
|
||||
w[0].re = wi.re = 1.;
|
||||
w[0].im = wi.im = 0.;
|
||||
|
||||
|
||||
for( i = 1; i < n; i++ )
|
||||
{
|
||||
double t = wi.re*w1.re - wi.im*w1.im;
|
||||
@@ -26,7 +26,7 @@ static Mat initDFTWave( int n, bool inv )
|
||||
wi.re = t;
|
||||
w[i] = wi;
|
||||
}
|
||||
|
||||
|
||||
return wave;
|
||||
}
|
||||
|
||||
@@ -41,18 +41,18 @@ static void DFT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
size_t srcstep = esz, dststep = esz;
|
||||
const uchar* src0 = _src.data;
|
||||
uchar* dst0 = _dst.data;
|
||||
|
||||
|
||||
CV_Assert( _src.cols + _src.rows - 1 == n );
|
||||
|
||||
|
||||
if( wave.empty() )
|
||||
wave = initDFTWave( n, (flags & DFT_INVERSE) != 0 );
|
||||
|
||||
|
||||
const Complexd* w = wave.ptr<Complexd>();
|
||||
if( !_src.isContinuous() )
|
||||
srcstep = _src.step;
|
||||
if( !_dst.isContinuous() )
|
||||
dststep = _dst.step;
|
||||
|
||||
|
||||
if( _src.type() == CV_32FC2 )
|
||||
{
|
||||
for( i = 0; i < n; i++ )
|
||||
@@ -61,7 +61,7 @@ static void DFT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
Complexd sum(0,0);
|
||||
int delta = i;
|
||||
k = 0;
|
||||
|
||||
|
||||
for( j = 0; j < n; j++ )
|
||||
{
|
||||
const Complexf* src = (const Complexf*)(src0 + j*srcstep);
|
||||
@@ -70,7 +70,7 @@ static void DFT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
k += delta;
|
||||
k -= (k >= n ? n : 0);
|
||||
}
|
||||
|
||||
|
||||
dst->re = (float)(sum.re*scale);
|
||||
dst->im = (float)(sum.im*scale);
|
||||
}
|
||||
@@ -83,7 +83,7 @@ static void DFT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
Complexd sum(0,0);
|
||||
int delta = i;
|
||||
k = 0;
|
||||
|
||||
|
||||
for( j = 0; j < n; j++ )
|
||||
{
|
||||
const Complexd* src = (const Complexd*)(src0 + j*srcstep);
|
||||
@@ -92,7 +92,7 @@ static void DFT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
k += delta;
|
||||
k -= (k >= n ? n : 0);
|
||||
}
|
||||
|
||||
|
||||
dst->re = sum.re*scale;
|
||||
dst->im = sum.im*scale;
|
||||
}
|
||||
@@ -109,19 +109,19 @@ static void DFT_2D( const Mat& src, Mat& dst, int flags )
|
||||
dst.create(src.size(), src.type());
|
||||
Mat tmp( src.cols, src.rows, src.type());
|
||||
Mat wave = initDFTWave( dst.cols, (flags & DFT_INVERSE) != 0 );
|
||||
|
||||
|
||||
// 1. row-wise transform
|
||||
for( i = 0; i < dst.rows; i++ )
|
||||
{
|
||||
Mat srci = src.row(i).reshape(cn, src.cols), dsti = tmp.col(i);
|
||||
DFT_1D(srci, dsti, flags, wave );
|
||||
}
|
||||
|
||||
|
||||
if( (flags & DFT_ROWS) == 0 )
|
||||
{
|
||||
if( dst.cols != dst.rows )
|
||||
wave = initDFTWave( dst.rows, (flags & DFT_INVERSE) != 0 );
|
||||
|
||||
|
||||
// 2. column-wise transform
|
||||
for( i = 0; i < dst.cols; i++ )
|
||||
{
|
||||
@@ -139,7 +139,7 @@ static Mat initDCTWave( int n, bool inv )
|
||||
int i, k;
|
||||
double angle = CV_PI*0.5/n;
|
||||
Mat wave(n, n, CV_64F);
|
||||
|
||||
|
||||
double scale = sqrt(1./n);
|
||||
for( k = 0; k < n; k++ )
|
||||
wave.at<double>(0, k) = scale;
|
||||
@@ -147,10 +147,10 @@ static Mat initDCTWave( int n, bool inv )
|
||||
for( i = 1; i < n; i++ )
|
||||
for( k = 0; k < n; k++ )
|
||||
wave.at<double>(i, k) = scale*cos( angle*i*(2*k + 1) );
|
||||
|
||||
|
||||
if( inv )
|
||||
cv::transpose( wave, wave );
|
||||
|
||||
|
||||
return wave;
|
||||
}
|
||||
|
||||
@@ -162,27 +162,27 @@ static void DCT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
Mat wave = _wave;
|
||||
int srcstep = 1, dststep = 1;
|
||||
double* w;
|
||||
|
||||
|
||||
CV_Assert( _src.cols + _src.rows - 1 == n);
|
||||
|
||||
|
||||
if( wave.empty() )
|
||||
wave = initDCTWave( n, (flags & DFT_INVERSE) != 0 );
|
||||
w = wave.ptr<double>();
|
||||
|
||||
|
||||
if( !_src.isContinuous() )
|
||||
srcstep = (int)(_src.step/_src.elemSize());
|
||||
if( !_dst.isContinuous() )
|
||||
dststep = (int)(_dst.step/_dst.elemSize());
|
||||
|
||||
|
||||
if( _src.type() == CV_32FC1 )
|
||||
{
|
||||
float *dst = _dst.ptr<float>();
|
||||
|
||||
|
||||
for( i = 0; i < n; i++, dst += dststep )
|
||||
{
|
||||
const float* src = _src.ptr<float>();
|
||||
double sum = 0;
|
||||
|
||||
|
||||
for( j = 0; j < n; j++, src += srcstep )
|
||||
sum += src[0]*w[j];
|
||||
w += n;
|
||||
@@ -192,12 +192,12 @@ static void DCT_1D( const Mat& _src, Mat& _dst, int flags, const Mat& _wave=Mat(
|
||||
else if( _src.type() == CV_64FC1 )
|
||||
{
|
||||
double *dst = _dst.ptr<double>();
|
||||
|
||||
|
||||
for( i = 0; i < n; i++, dst += dststep )
|
||||
{
|
||||
const double* src = _src.ptr<double>();
|
||||
double sum = 0;
|
||||
|
||||
|
||||
for( j = 0; j < n; j++, src += srcstep )
|
||||
sum += src[0]*w[j];
|
||||
w += n;
|
||||
@@ -216,7 +216,7 @@ static void DCT_2D( const Mat& src, Mat& dst, int flags )
|
||||
dst.create( src.size(), src.type() );
|
||||
Mat tmp(dst.cols, dst.rows, dst.type() );
|
||||
Mat wave = initDCTWave( dst.cols, (flags & DCT_INVERSE) != 0 );
|
||||
|
||||
|
||||
// 1. row-wise transform
|
||||
for( i = 0; i < dst.rows; i++ )
|
||||
{
|
||||
@@ -224,12 +224,12 @@ static void DCT_2D( const Mat& src, Mat& dst, int flags )
|
||||
Mat dsti = tmp.col(i);
|
||||
DCT_1D(srci, dsti, flags, wave);
|
||||
}
|
||||
|
||||
|
||||
if( (flags & DCT_ROWS) == 0 )
|
||||
{
|
||||
if( dst.cols != dst.rows )
|
||||
wave = initDCTWave( dst.rows, (flags & DCT_INVERSE) != 0 );
|
||||
|
||||
|
||||
// 2. column-wise transform
|
||||
for( i = 0; i < dst.cols; i++ )
|
||||
{
|
||||
@@ -258,7 +258,7 @@ static void convertFromCCS( const Mat& _src0, const Mat& _src1, Mat& _dst, int f
|
||||
dstrow = _dst.row(i);
|
||||
convertFromCCS( src0row, src1row, dstrow, 0 );
|
||||
}
|
||||
|
||||
|
||||
if( is2d )
|
||||
{
|
||||
src0row = _src0.col(0);
|
||||
@@ -277,45 +277,45 @@ static void convertFromCCS( const Mat& _src0, const Mat& _src1, Mat& _dst, int f
|
||||
int i, n = _dst.cols + _dst.rows - 1, n2 = (n+1) >> 1;
|
||||
int cn = _src0.channels();
|
||||
int srcstep = cn, dststep = 1;
|
||||
|
||||
|
||||
if( !_dst.isContinuous() )
|
||||
dststep = (int)(_dst.step/_dst.elemSize());
|
||||
|
||||
|
||||
if( !_src0.isContinuous() )
|
||||
srcstep = (int)(_src0.step/_src0.elemSize1());
|
||||
|
||||
|
||||
if( _dst.depth() == CV_32F )
|
||||
{
|
||||
Complexf* dst = _dst.ptr<Complexf>();
|
||||
const float* src0 = _src0.ptr<float>();
|
||||
const float* src1 = _src1.ptr<float>();
|
||||
int delta0, delta1;
|
||||
|
||||
|
||||
dst->re = src0[0];
|
||||
dst->im = 0;
|
||||
|
||||
|
||||
if( (n & 1) == 0 )
|
||||
{
|
||||
dst[n2*dststep].re = src0[(cn == 1 ? n-1 : n2)*srcstep];
|
||||
dst[n2*dststep].im = 0;
|
||||
}
|
||||
|
||||
|
||||
delta0 = srcstep;
|
||||
delta1 = delta0 + (cn == 1 ? srcstep : 1);
|
||||
if( cn == 1 )
|
||||
srcstep *= 2;
|
||||
|
||||
|
||||
for( i = 1; i < n2; i++, delta0 += srcstep, delta1 += srcstep )
|
||||
{
|
||||
float t0 = src0[delta0];
|
||||
float t1 = src0[delta1];
|
||||
|
||||
|
||||
dst[i*dststep].re = t0;
|
||||
dst[i*dststep].im = t1;
|
||||
|
||||
|
||||
t0 = src1[delta0];
|
||||
t1 = -src1[delta1];
|
||||
|
||||
|
||||
dst[(n-i)*dststep].re = t0;
|
||||
dst[(n-i)*dststep].im = t1;
|
||||
}
|
||||
@@ -326,32 +326,32 @@ static void convertFromCCS( const Mat& _src0, const Mat& _src1, Mat& _dst, int f
|
||||
const double* src0 = _src0.ptr<double>();
|
||||
const double* src1 = _src1.ptr<double>();
|
||||
int delta0, delta1;
|
||||
|
||||
|
||||
dst->re = src0[0];
|
||||
dst->im = 0;
|
||||
|
||||
|
||||
if( (n & 1) == 0 )
|
||||
{
|
||||
dst[n2*dststep].re = src0[(cn == 1 ? n-1 : n2)*srcstep];
|
||||
dst[n2*dststep].im = 0;
|
||||
}
|
||||
|
||||
|
||||
delta0 = srcstep;
|
||||
delta1 = delta0 + (cn == 1 ? srcstep : 1);
|
||||
if( cn == 1 )
|
||||
srcstep *= 2;
|
||||
|
||||
|
||||
for( i = 1; i < n2; i++, delta0 += srcstep, delta1 += srcstep )
|
||||
{
|
||||
double t0 = src0[delta0];
|
||||
double t1 = src0[delta1];
|
||||
|
||||
|
||||
dst[i*dststep].re = t0;
|
||||
dst[i*dststep].im = t1;
|
||||
|
||||
|
||||
t0 = src1[delta0];
|
||||
t1 = -src1[delta1];
|
||||
|
||||
|
||||
dst[(n-i)*dststep].re = t0;
|
||||
dst[(n-i)*dststep].im = t1;
|
||||
}
|
||||
@@ -364,9 +364,9 @@ static void fixCCS( Mat& mat, int cols, int flags )
|
||||
{
|
||||
int i, rows = mat.rows;
|
||||
int rows2 = (flags & DFT_ROWS) ? rows : rows/2 + 1, cols2 = cols/2 + 1;
|
||||
|
||||
|
||||
CV_Assert( cols2 == mat.cols );
|
||||
|
||||
|
||||
if( mat.type() == CV_32FC2 )
|
||||
{
|
||||
for( i = 0; i < rows2; i++ )
|
||||
@@ -383,7 +383,7 @@ static void fixCCS( Mat& mat, int cols, int flags )
|
||||
Complexf* row2 = mat.ptr<Complexf>(rows-i);
|
||||
row2[0].re = row[0].re;
|
||||
row2[0].im = -row[0].im;
|
||||
|
||||
|
||||
if( cols % 2 == 0 )
|
||||
{
|
||||
row2[cols2-1].re = row[cols2-1].re;
|
||||
@@ -408,7 +408,7 @@ static void fixCCS( Mat& mat, int cols, int flags )
|
||||
Complexd* row2 = mat.ptr<Complexd>(rows-i);
|
||||
row2[0].re = row[0].re;
|
||||
row2[0].im = -row[0].im;
|
||||
|
||||
|
||||
if( cols % 2 == 0 )
|
||||
{
|
||||
row2[cols2-1].re = row[cols2-1].re;
|
||||
@@ -418,16 +418,16 @@ static void fixCCS( Mat& mat, int cols, int flags )
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
|
||||
{
|
||||
dst.create(src1.rows, src1.cols, src1.type());
|
||||
int i, j, depth = src1.depth(), cols = src1.cols*2;
|
||||
|
||||
|
||||
CV_Assert( src1.size == src2.size && src1.type() == src2.type() &&
|
||||
(src1.type() == CV_32FC2 || src1.type() == CV_64FC2) );
|
||||
|
||||
|
||||
for( i = 0; i < dst.rows; i++ )
|
||||
{
|
||||
if( depth == CV_32F )
|
||||
@@ -435,13 +435,13 @@ static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
|
||||
const float* a = src1.ptr<float>(i);
|
||||
const float* b = src2.ptr<float>(i);
|
||||
float* c = dst.ptr<float>(i);
|
||||
|
||||
|
||||
if( !(flags & CV_DXT_MUL_CONJ) )
|
||||
for( j = 0; j < cols; j += 2 )
|
||||
{
|
||||
double re = (double)a[j]*b[j] - (double)a[j+1]*b[j+1];
|
||||
double im = (double)a[j+1]*b[j] + (double)a[j]*b[j+1];
|
||||
|
||||
|
||||
c[j] = (float)re;
|
||||
c[j+1] = (float)im;
|
||||
}
|
||||
@@ -450,7 +450,7 @@ static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
|
||||
{
|
||||
double re = (double)a[j]*b[j] + (double)a[j+1]*b[j+1];
|
||||
double im = (double)a[j+1]*b[j] - (double)a[j]*b[j+1];
|
||||
|
||||
|
||||
c[j] = (float)re;
|
||||
c[j+1] = (float)im;
|
||||
}
|
||||
@@ -460,13 +460,13 @@ static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
|
||||
const double* a = src1.ptr<double>(i);
|
||||
const double* b = src2.ptr<double>(i);
|
||||
double* c = dst.ptr<double>(i);
|
||||
|
||||
|
||||
if( !(flags & CV_DXT_MUL_CONJ) )
|
||||
for( j = 0; j < cols; j += 2 )
|
||||
{
|
||||
double re = a[j]*b[j] - a[j+1]*b[j+1];
|
||||
double im = a[j+1]*b[j] + a[j]*b[j+1];
|
||||
|
||||
|
||||
c[j] = re;
|
||||
c[j+1] = im;
|
||||
}
|
||||
@@ -475,14 +475,14 @@ static void mulComplex( const Mat& src1, const Mat& src2, Mat& dst, int flags )
|
||||
{
|
||||
double re = a[j]*b[j] + a[j+1]*b[j+1];
|
||||
double im = a[j+1]*b[j] - a[j]*b[j+1];
|
||||
|
||||
|
||||
c[j] = re;
|
||||
c[j+1] = im;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -519,7 +519,7 @@ spectrum_mode(_spectrum_mode), inplace(false), temp_dst(false)
|
||||
test_array[REF_OUTPUT].push_back(NULL);
|
||||
test_array[TEMP].push_back(NULL);
|
||||
test_array[TEMP].push_back(NULL);
|
||||
|
||||
|
||||
max_log_array_size = 9;
|
||||
element_wise_relative_error = spectrum_mode;
|
||||
}
|
||||
@@ -535,16 +535,16 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
int cn = !allow_complex || !(bits & 256) ? 1 : 2;
|
||||
Size size;
|
||||
Base::get_test_array_types_and_sizes( test_case_idx, sizes, types );
|
||||
|
||||
|
||||
flags = bits & (CV_DXT_INVERSE | CV_DXT_SCALE | CV_DXT_ROWS | CV_DXT_MUL_CONJ);
|
||||
if( spectrum_mode )
|
||||
flags &= ~CV_DXT_INVERSE;
|
||||
types[TEMP][0] = types[TEMP][1] = types[INPUT][0] =
|
||||
types[OUTPUT][0] = CV_MAKETYPE(depth, cn);
|
||||
size = sizes[INPUT][0];
|
||||
|
||||
|
||||
temp_dst = false;
|
||||
|
||||
|
||||
if( flags & CV_DXT_ROWS && (bits&1024) )
|
||||
{
|
||||
if( bits&16 )
|
||||
@@ -553,7 +553,7 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
size.height = 1;
|
||||
flags &= ~CV_DXT_ROWS;
|
||||
}
|
||||
|
||||
|
||||
const int P2_MIN_SIZE = 32;
|
||||
if( ((bits >> 10) & 1) == 0 )
|
||||
{
|
||||
@@ -562,19 +562,19 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
size.height = (size.height / P2_MIN_SIZE)*P2_MIN_SIZE;
|
||||
size.height = MAX(size.height, 1);
|
||||
}
|
||||
|
||||
|
||||
if( !allow_odd )
|
||||
{
|
||||
if( size.width > 1 && (size.width&1) != 0 )
|
||||
size.width = (size.width + 1) & -2;
|
||||
|
||||
|
||||
if( size.height > 1 && (size.height&1) != 0 && !(flags & CV_DXT_ROWS) )
|
||||
size.height = (size.height + 1) & -2;
|
||||
}
|
||||
|
||||
|
||||
sizes[INPUT][0] = sizes[OUTPUT][0] = size;
|
||||
sizes[TEMP][0] = sizes[TEMP][1] = cvSize(0,0);
|
||||
|
||||
|
||||
if( spectrum_mode )
|
||||
{
|
||||
if( cn == 1 )
|
||||
@@ -590,7 +590,7 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
types[TEMP][0] = depth + 8; // CV_??FC2
|
||||
sizes[TEMP][0] = size;
|
||||
size = cvSize(size.width/2+1, size.height);
|
||||
|
||||
|
||||
if( flags & CV_DXT_INVERSE )
|
||||
{
|
||||
if( cn == 2 )
|
||||
@@ -605,7 +605,7 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
{
|
||||
if( allow_complex )
|
||||
types[OUTPUT][0] = depth + 8;
|
||||
|
||||
|
||||
if( cn == 2 )
|
||||
{
|
||||
types[INPUT][0] = depth;
|
||||
@@ -620,13 +620,13 @@ void CxCore_DXTBaseTest::get_test_array_types_and_sizes( int test_case_idx,
|
||||
temp_dst = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inplace = false;
|
||||
if( spectrum_mode ||
|
||||
(!temp_dst && types[INPUT][0] == types[OUTPUT][0]) ||
|
||||
(temp_dst && types[INPUT][0] == types[TEMP][1]) )
|
||||
inplace = (bits & 64) != 0;
|
||||
|
||||
|
||||
types[REF_OUTPUT][0] = types[OUTPUT][0];
|
||||
sizes[REF_OUTPUT][0] = sizes[OUTPUT][0];
|
||||
}
|
||||
@@ -645,17 +645,17 @@ int CxCore_DXTBaseTest::prepare_test_case( int test_case_idx )
|
||||
{
|
||||
int in_type = test_mat[INPUT][0].type();
|
||||
int out_type = test_mat[OUTPUT][0].type();
|
||||
|
||||
|
||||
if( CV_MAT_CN(in_type) == 2 && CV_MAT_CN(out_type) == 1 )
|
||||
cvtest::fixCCS( test_mat[INPUT][0], test_mat[OUTPUT][0].cols, flags );
|
||||
|
||||
|
||||
if( inplace )
|
||||
cvtest::copy( test_mat[INPUT][test_case_idx & (int)spectrum_mode],
|
||||
temp_dst ? test_mat[TEMP][1] :
|
||||
in_type == out_type ? test_mat[OUTPUT][0] :
|
||||
test_mat[TEMP][0] );
|
||||
}
|
||||
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
@@ -680,7 +680,7 @@ void CxCore_DFTTest::run_func()
|
||||
{
|
||||
Mat& dst = temp_dst ? test_mat[TEMP][1] : test_mat[OUTPUT][0];
|
||||
const Mat& src = inplace ? dst : test_mat[INPUT][0];
|
||||
|
||||
|
||||
if(!(flags & CV_DXT_INVERSE))
|
||||
cv::dft( src, dst, flags );
|
||||
else
|
||||
@@ -696,11 +696,11 @@ void CxCore_DFTTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
Mat* tmp_dst = &dst;
|
||||
int src_cn = src.channels();
|
||||
int dst_cn = dst.channels();
|
||||
|
||||
|
||||
if( src_cn != 2 || dst_cn != 2 )
|
||||
{
|
||||
tmp_src = &test_mat[TEMP][0];
|
||||
|
||||
|
||||
if( !(flags & CV_DXT_INVERSE ) )
|
||||
{
|
||||
Mat& cvdft_dst = test_mat[TEMP][1];
|
||||
@@ -715,12 +715,12 @@ void CxCore_DFTTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
tmp_dst = &test_mat[TEMP][1];
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if( src.rows == 1 || (src.cols == 1 && !(flags & CV_DXT_ROWS)) )
|
||||
cvtest::DFT_1D( *tmp_src, *tmp_dst, flags );
|
||||
else
|
||||
cvtest::DFT_2D( *tmp_src, *tmp_dst, flags );
|
||||
|
||||
|
||||
if( tmp_dst != &dst )
|
||||
cvtest::extract( *tmp_dst, dst, 0 );
|
||||
}
|
||||
@@ -745,7 +745,7 @@ void CxCore_DCTTest::run_func()
|
||||
{
|
||||
Mat& dst = test_mat[OUTPUT][0];
|
||||
const Mat& src = inplace ? dst : test_mat[INPUT][0];
|
||||
|
||||
|
||||
if(!(flags & CV_DXT_INVERSE))
|
||||
cv::dct( src, dst, flags );
|
||||
else
|
||||
@@ -757,7 +757,7 @@ void CxCore_DCTTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
{
|
||||
const Mat& src = test_mat[INPUT][0];
|
||||
Mat& dst = test_mat[REF_OUTPUT][0];
|
||||
|
||||
|
||||
if( src.rows == 1 || (src.cols == 1 && !(flags & CV_DXT_ROWS)) )
|
||||
cvtest::DCT_1D( src, dst, flags );
|
||||
else
|
||||
@@ -786,7 +786,7 @@ void CxCore_MulSpectrumsTest::run_func()
|
||||
Mat& dst = !test_mat[TEMP].empty() && !test_mat[TEMP][0].empty() ?
|
||||
test_mat[TEMP][0] : test_mat[OUTPUT][0];
|
||||
const Mat* src1 = &test_mat[INPUT][0], *src2 = &test_mat[INPUT][1];
|
||||
|
||||
|
||||
if( inplace )
|
||||
{
|
||||
if( ts->get_current_test_info()->test_case_idx & 1 )
|
||||
@@ -794,7 +794,7 @@ void CxCore_MulSpectrumsTest::run_func()
|
||||
else
|
||||
src1 = &dst;
|
||||
}
|
||||
|
||||
|
||||
cv::mulSpectrums( *src1, *src2, dst, flags, (flags & CV_DXT_MUL_CONJ) != 0 );
|
||||
}
|
||||
|
||||
@@ -806,7 +806,7 @@ void CxCore_MulSpectrumsTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
Mat& dst = test_mat[OUTPUT][0];
|
||||
Mat& dst0 = test_mat[REF_OUTPUT][0];
|
||||
int cn = src1->channels();
|
||||
|
||||
|
||||
if( cn == 1 )
|
||||
{
|
||||
cvtest::convertFromCCS( *src1, *src1, dst, flags );
|
||||
@@ -814,7 +814,7 @@ void CxCore_MulSpectrumsTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
src1 = &dst;
|
||||
src2 = &dst0;
|
||||
}
|
||||
|
||||
|
||||
cvtest::mulComplex( *src1, *src2, dst0, flags );
|
||||
if( cn == 1 )
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user