generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored Tegra related macro usage

Browse Source
This commit is contained in:
Andrey Kamaev
2011-12-27 11:21:45 +00:00
parent 4fee5ef818
commit 95d659a3cf
2 changed files with 43 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
modules/imgproc/src/morph.cpp
View File

@@ -585,11 +585,11 @@ struct MorphNoVec
}; };
#ifdef HAVE_TEGRA_OPTIMIZATION #ifdef HAVE_TEGRA_OPTIMIZATION
typedef tegra::MorphRowIVec<tegra::VMin8u> ErodeRowVec8u; using tegra::ErodeRowVec8u;
typedef tegra::MorphRowIVec<tegra::VMax8u> DilateRowVec8u; using tegra::DilateRowVec8u;
typedef tegra::MorphColumnIVec<tegra::VMin8u> ErodeColumnVec8u; using tegra::ErodeColumnVec8u;
typedef tegra::MorphColumnIVec<tegra::VMax8u> DilateColumnVec8u; using tegra::DilateColumnVec8u;
#else #else
typedef MorphRowNoVec ErodeRowVec8u; typedef MorphRowNoVec ErodeRowVec8u;
typedef MorphRowNoVec DilateRowVec8u; typedef MorphRowNoVec DilateRowVec8u;
@@ -780,7 +780,7 @@ template<class Op, class VecOp> struct MorphFilter : BaseFilter
CV_Assert( _kernel.type() == CV_8U ); CV_Assert( _kernel.type() == CV_8U );
vector<uchar> coeffs; // we do not really the values of non-zero vector<uchar> coeffs; // we do not really the values of non-zero
// kernel elements, just their locations // kernel elements, just their locations
preprocess2DKernel( _kernel, coords, coeffs ); preprocess2DKernel( _kernel, coords, coeffs );
ptrs.resize( coords.size() ); ptrs.resize( coords.size() );
} }
@@ -832,7 +832,7 @@ template<class Op, class VecOp> struct MorphFilter : BaseFilter
vector<uchar*> ptrs; vector<uchar*> ptrs;
VecOp vecOp; VecOp vecOp;
}; };
} }
/////////////////////////////////// External Interface ///////////////////////////////////// /////////////////////////////////// External Interface /////////////////////////////////////
@@ -845,35 +845,35 @@ cv::Ptr<cv::BaseRowFilter> cv::getMorphologyRowFilter(int op, int type, int ksiz
CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE ); CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE );
if( op == MORPH_ERODE ) if( op == MORPH_ERODE )
{ {
if( depth == CV_8U ) if( depth == CV_8U )
return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<uchar>, return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<uchar>,
ErodeRowVec8u>(ksize, anchor)); ErodeRowVec8u>(ksize, anchor));
if( depth == CV_16U ) if( depth == CV_16U )
return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<ushort>, return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<ushort>,
ErodeRowVec16u>(ksize, anchor)); ErodeRowVec16u>(ksize, anchor));
if( depth == CV_16S ) if( depth == CV_16S )
return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<short>, return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<short>,
ErodeRowVec16s>(ksize, anchor)); ErodeRowVec16s>(ksize, anchor));
if( depth == CV_32F ) if( depth == CV_32F )
return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<float>, return Ptr<BaseRowFilter>(new MorphRowFilter<MinOp<float>,
ErodeRowVec32f>(ksize, anchor)); ErodeRowVec32f>(ksize, anchor));
} }
else else
{ {
if( depth == CV_8U ) if( depth == CV_8U )
return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<uchar>, return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<uchar>,
DilateRowVec8u>(ksize, anchor)); DilateRowVec8u>(ksize, anchor));
if( depth == CV_16U ) if( depth == CV_16U )
return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<ushort>, return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<ushort>,
DilateRowVec16u>(ksize, anchor)); DilateRowVec16u>(ksize, anchor));
if( depth == CV_16S ) if( depth == CV_16S )
return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<short>, return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<short>,
DilateRowVec16s>(ksize, anchor)); DilateRowVec16s>(ksize, anchor));
if( depth == CV_32F ) if( depth == CV_32F )
return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<float>, return Ptr<BaseRowFilter>(new MorphRowFilter<MaxOp<float>,
DilateRowVec32f>(ksize, anchor)); DilateRowVec32f>(ksize, anchor));
} }
CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type)); CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type));
return Ptr<BaseRowFilter>(0); return Ptr<BaseRowFilter>(0);
} }
@@ -886,33 +886,33 @@ cv::Ptr<cv::BaseColumnFilter> cv::getMorphologyColumnFilter(int op, int type, in
CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE ); CV_Assert( op == MORPH_ERODE || op == MORPH_DILATE );
if( op == MORPH_ERODE ) if( op == MORPH_ERODE )
{ {
if( depth == CV_8U ) if( depth == CV_8U )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<uchar>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<uchar>,
ErodeColumnVec8u>(ksize, anchor)); ErodeColumnVec8u>(ksize, anchor));
if( depth == CV_16U ) if( depth == CV_16U )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<ushort>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<ushort>,
ErodeColumnVec16u>(ksize, anchor)); ErodeColumnVec16u>(ksize, anchor));
if( depth == CV_16S ) if( depth == CV_16S )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<short>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<short>,
ErodeColumnVec16s>(ksize, anchor)); ErodeColumnVec16s>(ksize, anchor));
if( depth == CV_32F ) if( depth == CV_32F )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<float>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MinOp<float>,
ErodeColumnVec32f>(ksize, anchor)); ErodeColumnVec32f>(ksize, anchor));
} }
else else
{ {
if( depth == CV_8U ) if( depth == CV_8U )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<uchar>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<uchar>,
DilateColumnVec8u>(ksize, anchor)); DilateColumnVec8u>(ksize, anchor));
if( depth == CV_16U ) if( depth == CV_16U )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<ushort>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<ushort>,
DilateColumnVec16u>(ksize, anchor)); DilateColumnVec16u>(ksize, anchor));
if( depth == CV_16S ) if( depth == CV_16S )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<short>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<short>,
DilateColumnVec16s>(ksize, anchor)); DilateColumnVec16s>(ksize, anchor));
if( depth == CV_32F ) if( depth == CV_32F )
return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<float>, return Ptr<BaseColumnFilter>(new MorphColumnFilter<MaxOp<float>,
DilateColumnVec32f>(ksize, anchor)); DilateColumnVec32f>(ksize, anchor));
} }
CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type)); CV_Error_( CV_StsNotImplemented, ("Unsupported data type (=%d)", type));
@@ -955,8 +955,8 @@ cv::Ptr<cv::BaseFilter> cv::getMorphologyFilter(int op, int type, InputArray _ke
cv::Ptr<cv::FilterEngine> cv::createMorphologyFilter( int op, int type, InputArray _kernel, cv::Ptr<cv::FilterEngine> cv::createMorphologyFilter( int op, int type, InputArray _kernel,
Point anchor, int _rowBorderType, int _columnBorderType, Point anchor, int _rowBorderType, int _columnBorderType,
const Scalar& _borderValue ) const Scalar& _borderValue )
{ {
Mat kernel = _kernel.getMat(); Mat kernel = _kernel.getMat();
anchor = normalizeAnchor(anchor, kernel.size()); anchor = normalizeAnchor(anchor, kernel.size());
@@ -976,20 +976,20 @@ cv::Ptr<cv::FilterEngine> cv::createMorphologyFilter( int op, int type, InputArr
Scalar borderValue = _borderValue; Scalar borderValue = _borderValue;
if( (_rowBorderType == BORDER_CONSTANT || _columnBorderType == BORDER_CONSTANT) && if( (_rowBorderType == BORDER_CONSTANT || _columnBorderType == BORDER_CONSTANT) &&
borderValue == morphologyDefaultBorderValue() ) borderValue == morphologyDefaultBorderValue() )
{ {
int depth = CV_MAT_DEPTH(type); int depth = CV_MAT_DEPTH(type);
CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32F ); CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32F );
if( op == MORPH_ERODE ) if( op == MORPH_ERODE )
borderValue = Scalar::all( depth == CV_8U ? (double)UCHAR_MAX : borderValue = Scalar::all( depth == CV_8U ? (double)UCHAR_MAX :
depth == CV_16U ? (double)USHRT_MAX : (double)FLT_MAX ); depth == CV_16U ? (double)USHRT_MAX : (double)FLT_MAX );
else else
borderValue = Scalar::all( depth == CV_8U || depth == CV_16U ? borderValue = Scalar::all( depth == CV_8U || depth == CV_16U ?
0. : (double)-FLT_MAX ); 0. : (double)-FLT_MAX );
} }
return Ptr<FilterEngine>(new FilterEngine(filter2D, rowFilter, columnFilter, return Ptr<FilterEngine>(new FilterEngine(filter2D, rowFilter, columnFilter,
type, type, type, _rowBorderType, _columnBorderType, borderValue )); type, type, type, _rowBorderType, _columnBorderType, borderValue ));
} }
@@ -1079,20 +1079,20 @@ static void morphOp( int op, InputArray _src, OutputArray _dst,
{ {
anchor = Point(anchor.x*iterations, anchor.y*iterations); anchor = Point(anchor.x*iterations, anchor.y*iterations);
kernel = getStructuringElement(MORPH_RECT, kernel = getStructuringElement(MORPH_RECT,
Size(ksize.width + iterations*(ksize.width-1), Size(ksize.width + iterations*(ksize.width-1),
ksize.height + iterations*(ksize.height-1)), ksize.height + iterations*(ksize.height-1)),
anchor); anchor);
iterations = 1; iterations = 1;
} }
Ptr<FilterEngine> f = createMorphologyFilter(op, src.type(), Ptr<FilterEngine> f = createMorphologyFilter(op, src.type(),
kernel, anchor, borderType, borderType, borderValue ); kernel, anchor, borderType, borderType, borderValue );
f->apply( src, dst ); f->apply( src, dst );
for( int i = 1; i < iterations; i++ ) for( int i = 1; i < iterations; i++ )
f->apply( dst, dst ); f->apply( dst, dst );
} }
template<> void Ptr<IplConvKernel>::delete_obj() template<> void Ptr<IplConvKernel>::delete_obj()
{ cvReleaseStructuringElement(&obj); } { cvReleaseStructuringElement(&obj); }
@@ -1170,7 +1170,7 @@ cvCreateStructuringElementEx( int cols, int rows,
cv::Size ksize = cv::Size(cols, rows); cv::Size ksize = cv::Size(cols, rows);
cv::Point anchor = cv::Point(anchorX, anchorY); cv::Point anchor = cv::Point(anchorX, anchorY);
CV_Assert( cols > 0 && rows > 0 && anchor.inside(cv::Rect(0,0,cols,rows)) && CV_Assert( cols > 0 && rows > 0 && anchor.inside(cv::Rect(0,0,cols,rows)) &&
(shape != CV_SHAPE_CUSTOM || values != 0)); (shape != CV_SHAPE_CUSTOM || values != 0));
int i, size = rows * cols; int i, size = rows * cols;
int element_size = sizeof(IplConvKernel) + size*sizeof(int); int element_size = sizeof(IplConvKernel) + size*sizeof(int);
@@ -1254,7 +1254,7 @@ cvMorphologyEx( const void* srcarr, void* dstarr, void*,
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), kernel; cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), kernel;
CV_Assert( src.size() == dst.size() && src.type() == dst.type() ); CV_Assert( src.size() == dst.size() && src.type() == dst.type() );
cv::Point anchor; cv::Point anchor;
IplConvKernel* temp_element = NULL; IplConvKernel* temp_element = NULL;
if (!element) if (!element)
{ {
temp_element = cvCreateStructuringElementEx(3, 3, 1, 1, CV_SHAPE_RECT); temp_element = cvCreateStructuringElementEx(3, 3, 1, 1, CV_SHAPE_RECT);

14
modules/imgproc/src/sumpixels.cpp
View File

@@ -211,19 +211,7 @@ void integral_##suffix( T* src, size_t srcstep, ST* sum, size_t sumstep, QT* sqs
ST* tilted, size_t tiltedstep, Size size, int cn ) \ ST* tilted, size_t tiltedstep, Size size, int cn ) \
{ integral_(src, srcstep, sum, sumstep, sqsum, sqsumstep, tilted, tiltedstep, size, cn); } { integral_(src, srcstep, sum, sumstep, sqsum, sqsumstep, tilted, tiltedstep, size, cn); }
#ifdef HAVE_TEGRA_OPTIMIZATION
DEF_INTEGRAL_FUNC(8u32sOCV, uchar, int, double)
void integral_8u32s(uchar* src, size_t srcstep, int* sum, size_t sumstep, double* sqsum, size_t sqsumstep,
int* tilted, size_t tiltedstep, Size size, int cn )
{
if (tegra::integral_8u32s(src, srcstep, sum, sumstep, sqsum, sqsumstep, tilted, tiltedstep, size, cn))
return;
integral_8u32sOCV(src, srcstep, sum, sumstep, sqsum, sqsumstep, tilted, tiltedstep, size, cn);
}
#else
DEF_INTEGRAL_FUNC(8u32s, uchar, int, double) DEF_INTEGRAL_FUNC(8u32s, uchar, int, double)
#endif
DEF_INTEGRAL_FUNC(8u32f, uchar, float, double) DEF_INTEGRAL_FUNC(8u32f, uchar, float, double)
DEF_INTEGRAL_FUNC(8u64f, uchar, double, double) DEF_INTEGRAL_FUNC(8u64f, uchar, double, double)
DEF_INTEGRAL_FUNC(32f, float, float, double) DEF_INTEGRAL_FUNC(32f, float, float, double)
@@ -264,7 +252,7 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output
IntegralFunc func = 0; IntegralFunc func = 0;
if( depth == CV_8U && sdepth == CV_32S ) if( depth == CV_8U && sdepth == CV_32S )
func = (IntegralFunc)integral_8u32s; func = (IntegralFunc)GET_OPTIMIZED(integral_8u32s);
else if( depth == CV_8U && sdepth == CV_32F ) else if( depth == CV_8U && sdepth == CV_32F )
func = (IntegralFunc)integral_8u32f; func = (IntegralFunc)integral_8u32f;
else if( depth == CV_8U && sdepth == CV_64F ) else if( depth == CV_8U && sdepth == CV_64F )