00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00024
00025 #include <qvipp/qvipp.h>
00026
00027
00028 #define IPP_DEBUG(function, ipp_function, ...) \
00029 { \
00030 IppStatus status = ipp_function(__VA_ARGS__); \
00031 Q_ASSERT_X( status == ippStsNoErr, #ipp_function, \
00032 ippGetStatusString(status)); \
00033 } \
00034
00035
00036 #define PDATA_READ(Image) \
00037 (&Image.getReadData()[Image.getROI().y()*Image.getStep()/Image.getTypeSize() + Image.getChannels()*Image.getROI().x()])
00038 #define PDATA_WRITE(Image) \
00039 (&Image.getWriteData()[Image.getROI().y()*Image.getStep()/Image.getTypeSize() + Image.getChannels()*Image.getROI().x()])
00040
00041 #define PDATA_READ_MARGIN(Image, margin) \
00042 (&Image.getReadData()[ \
00043 (Image.getROI().y()+margin)*Image.getStep()/Image.getTypeSize() \
00044 + Image.getChannels()*(Image.getROI().x()+margin)] \
00045 )
00046
00047 #define PDATA_WRITE_MARGIN(Image, margin) \
00048 (&Image.getWriteData()[ \
00049 (Image.getROI().y()+margin)*Image.getStep()/Image.getTypeSize() \
00050 + Image.getChannels()*(Image.getROI().x()+margin)] \
00051 )
00052
00053
00054 #define IMAGE_ROISIZE(Image) ((IppiSize){ Image.getROI().width(), Image.getROI().height() })
00055 #define IMAGE_ROIRECT(Image) ((IppiRect){ Image.getROI().x(), Image.getROI().y(), Image.getROI().width(), Image.getROI().height() })
00056 #define IMAGE_SIZE(Image) ((IppiSize){ Image.getCols(), Image.getRows() })
00057 #define IPP_SIZE(X,Y) ( (IppiSize) { (X), (Y) })
00058 #define IPP_POINT(X,Y) ( (IppiPoint) { (X), (Y) })
00059 #define IPP_MASK_SIZE(X,Y) (((X) == 1 && (Y) == 3)? ippMskSize1x3: \
00060 ((X) == 1 && (Y) == 5)? ippMskSize1x5: \
00061 ((X) == 3 && (Y) == 1)? ippMskSize3x1: \
00062 ((X) == 5 && (Y) == 1)? ippMskSize5x1: \
00063 ((X) == 3 && (Y) == 3)? ippMskSize3x3: \
00064 ippMskSize5x5)
00065
00066 #define CHECK_COMPATIBLE_IMAGES(NAME, Image1, Image2) \
00067 Q_ASSERT_X(Image1.getROI().size() == Image2.getROI().size(),"qvipp::" #NAME, "different ROI sizes in source images"); \
00068
00069 namespace qvipp
00070 {
00072
00074
00075 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(NAME, TYPE, C, SUBFIX) \
00076 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest) \
00077 { \
00078 qDebug() << "qvipp::" # NAME << "()"; \
00079 qDebug() << "qvipp::" # NAME << ": calling ippi" # NAME # SUBFIX; \
00080 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00081 \
00082 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00083 PDATA_READ(src), src.getStep(), \
00084 PDATA_WRITE(dest), dest.getStep(), \
00085 IMAGE_ROISIZE(dest)); \
00086 qDebug() << "qvipp::" # NAME # SUBFIX << "() <~ return"; \
00087 }
00088
00089 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uChar, 1, _8u_C1R);
00090 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sShort, 1, _16s_C1R);
00091 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sFloat, 1, _32f_C1R);
00092 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uChar, 3, _8u_C3R);
00093 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sShort, 3, _16s_C3R);
00094 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sFloat, 3, _32f_C3R);
00095 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSharpen, uChar, 1, _8u_C1R);
00096 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSharpen, sFloat, 1, _32f_C1R);
00097 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, uChar, 1, _8u_C1R);
00098 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, sShort, 1, _16s_C1R);
00099 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, sFloat, 1, _32f_C1R);
00100 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, uChar, 1, _8u_C1R);
00101 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, sShort, 1, _16s_C1R);
00102 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, sFloat, 1, _32f_C1R);
00103 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Not, uChar, 1, _8u_C1R);
00104 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Not, uChar, 3, _8u_C3R);
00105 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Abs, sShort, 1, _16s_C1R);
00106 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Abs, sFloat, 1, _32f_C1R);
00107
00108 #define DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(NAME, TYPE, SUBFIX) \
00109 void NAME(const QVImage<TYPE, 1> &src, QVImage<TYPE, 3> &dest) \
00110 { \
00111 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00112 const TYPE * pSrc[3] = { PDATA_READ(src), PDATA_READ(src), PDATA_READ(src) }; \
00113 \
00114 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00115 pSrc, src.getStep(), \
00116 PDATA_WRITE(dest), dest.getStep(), \
00117 IMAGE_ROISIZE(dest)); \
00118 }
00119
00120 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, uChar, _8u_P3C3R);
00121 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, sShort, _16s_P3C3R);
00122 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, sFloat, _32f_P3C3R);
00123
00124 #define DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(NAME, TYPE1, TYPE2, C, SUBFIX) \
00125 void NAME(const QVImage<TYPE1, C> &src, QVImage<TYPE2, C> &dest) \
00126 { \
00127 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00128 \
00129 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00130 PDATA_READ(src), src.getStep(), \
00131 PDATA_WRITE(dest), dest.getStep(), \
00132 IMAGE_ROISIZE(dest)); \
00133 }
00134
00135 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sShort, 1, _8u16s_C1R);
00136 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sFloat, 1, _8u32f_C1R);
00137 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, uChar, 1, _16s8u_C1R);
00138 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sFloat, 1, _16s32f_C1R);
00139 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sShort, 3, _8u16s_C3R);
00140 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sFloat, 3, _8u32f_C3R);
00141 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, uChar, 3, _16s8u_C3R);
00142 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sFloat, 3, _16s32f_C3R);
00143
00144 #define DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(NAME, TYPE1, TYPE2, C, SUBFIX) \
00145 void NAME(const QVImage<TYPE1, C> &src, QVImage<TYPE2, C> &dest, IppRoundMode roundMode) \
00146 { \
00147 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00148 \
00149 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00150 PDATA_READ(src), src.getStep(), \
00151 PDATA_WRITE(dest), dest.getStep(), \
00152 IMAGE_ROISIZE(dest),roundMode); \
00153 }
00154
00155 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uChar, 1, _32f8u_C1R);
00156 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, sShort, 1, _32f16s_C1R);
00157 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uChar, 3, _32f8u_C3R);
00158 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, sShort, 3, _32f16s_C3R);
00159
00160 #define DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(NAME, TYPE, SUBFIX) \
00161 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 1> &dest) \
00162 { \
00163 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00164 \
00165 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00166 PDATA_READ(src), src.getStep(), \
00167 PDATA_WRITE(dest), dest.getStep(), \
00168 IMAGE_ROISIZE(dest)); \
00169 }
00170
00171 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, uChar, _8u_C3C1R);
00172 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, sShort, _16s_C3C1R);
00173 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, sFloat, _32f_C3C1R);
00174
00175
00176 #define DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(NAME, TYPE, SUBFIX) \
00177 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 1> &dest, uChar channel) \
00178 { \
00179 qDebug() << "qvipp::" # NAME << "()"; \
00180 qDebug() << "qvipp::" # NAME << ": calling ippi" # NAME # SUBFIX; \
00181 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00182 \
00183 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00184 PDATA_READ(src)+ channel, src.getStep(), \
00185 PDATA_WRITE(dest), dest.getStep(), \
00186 IMAGE_ROISIZE(dest)); \
00187 qDebug() << "qvipp::" # NAME # SUBFIX << "() <~ return"; \
00188 }
00189
00190 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, uChar, _8u_C3C1R);
00191 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, sShort, _16s_C3C1R);
00192 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, sFloat, _32f_C3C1R);
00193
00194 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(NAME, TYPE, C, SUBFIX) \
00195 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<uChar> &dest, IppCmpOp ippCmpOp) \
00196 { \
00197 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00198 \
00199 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src1.getROI().width(), src1.getROI().height()); \
00200 \
00201 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00202 PDATA_READ(src1), src1.getStep(), \
00203 PDATA_READ(src2), src2.getStep(), \
00204 PDATA_WRITE(dest), dest.getStep(), \
00205 IMAGE_ROISIZE(dest), \
00206 ippCmpOp); \
00207 }
00208
00209 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uChar, 1, _8u_C1R);
00210 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sShort, 1, _16s_C1R);
00211 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sFloat, 1, _32f_C1R);
00212 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uChar, 3, _8u_C3R);
00213 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sShort, 3, _16s_C3R);
00214 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sFloat, 3, _32f_C3R);
00215
00216 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(NAME, TYPE, SUBFIX) \
00217 void NAME(const QVImage<TYPE> &src, QVImage<uChar> &dest, TYPE constant, IppCmpOp ippCmpOp) \
00218 { \
00219 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00220 \
00221 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00222 PDATA_READ(src), src.getStep(), \
00223 constant, \
00224 PDATA_WRITE(dest), dest.getStep(), \
00225 IMAGE_ROISIZE(dest), \
00226 ippCmpOp); \
00227 }
00228
00229 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(CompareC, uChar, _8u_C1R);
00230 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(CompareC, sFloat, _32f_C1R);
00231
00232 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(NAME, TYPE, SUBFIX) \
00233 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant, IppCmpOp ippCmpOp) \
00234 { \
00235 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00236 \
00237 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00238 PDATA_READ(src), src.getStep(), \
00239 PDATA_WRITE(dest), dest.getStep(), \
00240 IMAGE_ROISIZE(dest), \
00241 constant, ippCmpOp); \
00242 }
00243
00244 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, uChar, _8u_C1R);
00245 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, sShort, _16s_C1R);
00246 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, sFloat, _32f_C1R);
00247
00248 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(NAME, TYPE, SUBFIX) \
00249 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, uInt colMaskRadius, uInt rowMaskRadius) \
00250 { \
00251 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), \
00252 src.getROI().width()-colMaskRadius+1, src.getROI().height()-rowMaskRadius+1); \
00253 \
00254 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00255 PDATA_READ(src), src.getStep(), \
00256 PDATA_WRITE(dest), dest.getStep(), \
00257 IMAGE_ROISIZE(dest), \
00258 IPP_SIZE(colMaskRadius, rowMaskRadius), \
00259 IPP_POINT(0,0)); \
00260 }
00261
00262 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMax, uChar, _8u_C1R);
00263 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMax, sFloat, _32f_C1R);
00264 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMin, uChar, _8u_C1R);
00265 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMin, sFloat, _32f_C1R);
00266 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterBox, uChar, _8u_C1R);
00267 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterBox, sFloat, _32f_C1R);
00268 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMedian, uChar, _8u_C1R);
00269 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMedian, sShort, _16s_C1R);
00270
00271
00272 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(NAME, TYPE, SUBFIX) \
00273 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, uInt maskSize) \
00274 { \
00275 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00276 "qvipp::" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00277 \
00278 Q_ASSERT_X(src.getROI().width()-maskSize+1 > 0,"qvipp::" #NAME, "dest ROI size < 1"); \
00279 Q_ASSERT_X(src.getROI().height()-maskSize+1 > 0,"qvipp::" #NAME, "dest ROI size < 1"); \
00280 \
00281 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), \
00282 src.getROI().width()-maskSize+1, src.getROI().height()-maskSize+1); \
00283 \
00284 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00285 PDATA_READ_MARGIN(src,(maskSize -1)/2), src.getStep(), \
00286 PDATA_WRITE(dest), dest.getStep(), \
00287 IMAGE_ROISIZE(dest), IPP_MASK_SIZE(maskSize, maskSize) \
00288 ); \
00289 }
00290
00291 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, uChar, _8u_C1R);
00292 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, sFloat, _32f_C1R);
00293 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterHipass, uChar, _8u_C1R);
00294 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterHipass, sFloat, _32f_C1R);
00295 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLowpass, uChar, _8u_C1R);
00296 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLowpass, sFloat, _32f_C1R);
00297 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterSobelHorizMask, sFloat, _32f_C1R);
00298 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterSobelVertMask, sFloat, _32f_C1R);
00299 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, uChar, _8u_C1R);
00300 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, sShort, _16s_C1R);
00301 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, sFloat, _32f_C1R);
00302
00303 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(NAME, TYPE1, TYPE2, SUBFIX) \
00304 void NAME(const QVImage<TYPE1> &src, QVImage<TYPE2> &dest, QVImage<TYPE1> &buffer, uInt maskSize) \
00305 { \
00306 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00307 "qvipp::" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00308 \
00309 Q_ASSERT_X(src.getROI().width()-maskSize+1 > 0,"qvipp::" #NAME, "dest ROI size < 1"); \
00310 Q_ASSERT_X(src.getROI().height()-maskSize+1 > 0,"qvipp::" #NAME, "dest ROI size < 1"); \
00311 \
00312 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), \
00313 src.getROI().width()-maskSize+1, src.getROI().height()-maskSize+1); \
00314 \
00315 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00316 PDATA_READ_MARGIN(src,(maskSize -1)/2), src.getStep(), \
00317 PDATA_WRITE(dest), dest.getStep(), \
00318 IMAGE_ROISIZE(dest), IPP_MASK_SIZE(maskSize, maskSize), \
00319 ippBorderRepl, 0, buffer.getWriteData()); \
00320 }
00321 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(FilterSobelNegVertBorder, uChar, sShort, _8u16s_C1R);
00322 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(FilterSobelHorizBorder, uChar, sShort, _8u16s_C1R);
00323
00324 #define DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(NAME, TYPE, SUBFIX) \
00325 void NAME(const QVGenericImage &src, QVImage<TYPE> &buffer, uInt maskSize) \
00326 { \
00327 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00328 "qvipp::" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00329 \
00330 int bufferSize; \
00331 \
00332 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, IMAGE_ROISIZE(src), \
00333 IPP_MASK_SIZE(maskSize, maskSize), &bufferSize); \
00334 buffer = QVImage<uChar>(bufferSize,1); \
00335 }
00336
00337 DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(FilterSobelNegVertGetBufferSize, uChar, _8u16s_C1R);
00338 DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(FilterSobelHorizGetBufferSize, uChar, _8u16s_C1R);
00339
00340 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(NAME, TYPE, C, SUBFIX) \
00341 void NAME(QVImage<TYPE, C> &img, TYPE constant) \
00342 { \
00343 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, constant, \
00344 PDATA_WRITE(img), img.getStep(), \
00345 IMAGE_ROISIZE(img)); \
00346 }
00347
00348 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, uChar, 1, _8u_C1R);
00349 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, sShort, 1, _16s_C1R);
00350 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, sFloat, 1, _32f_C1R);
00351
00352 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(NAME, TYPE, SUBFIX) \
00353 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant) \
00354 { \
00355 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00356 \
00357 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00358 PDATA_READ(src), src.getStep(), constant, \
00359 PDATA_WRITE(dest), dest.getStep(), \
00360 IMAGE_ROISIZE(dest)); \
00361 }
00362
00363 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(OrC, uChar, _8u_C1R);
00364 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AndC, uChar, _8u_C1R);
00365 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(XorC, uChar, _8u_C1R);
00366 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(LShiftC, uChar, _8u_C1R);
00367 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(RShiftC, uChar, _8u_C1R);
00368
00369
00370 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(MulC, sFloat, _32f_C1R);
00371 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AddC, sFloat, _32f_C1R);
00372 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(SubC, sFloat, _32f_C1R);
00373 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(DivC, sFloat, _32f_C1R);
00374
00375
00376 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(NAME, TYPE1, TYPE2, SUBFIX) \
00377 void NAME(const QVImage<TYPE1> &src, TYPE2 & value) \
00378 { \
00379 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00380 PDATA_READ(src), src.getStep(), \
00381 IMAGE_ROISIZE(src), &value); \
00382 }
00383
00384 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Sum, uChar, sDouble, _8u_C1R);
00385 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Sum, sShort, sDouble, _16s_C1R);
00386 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Mean, uChar, sDouble, _8u_C1R);
00387 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Mean, sShort, sDouble, _16s_C1R);
00388 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, uChar, uChar, _8u_C1R);
00389 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, sShort, sShort, _16s_C1R);
00390 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, sFloat, sFloat, _32f_C1R);
00391 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, uChar, uChar, _8u_C1R);
00392 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, sShort, sShort, _16s_C1R);
00393 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, sFloat, sFloat, _32f_C1R);
00394
00395 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(NAME, TYPE, C, SUBFIX) \
00396 void NAME(QVImage<TYPE, C> &img, TYPE red, TYPE green, TYPE blue) \
00397 { \
00398 TYPE constant[3] = { red, green, blue }; \
00399 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, constant, \
00400 PDATA_WRITE(img), img.getStep(), \
00401 IMAGE_ROISIZE(img)); \
00402 }
00403
00404 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, uChar, 3, _8u_C3R);
00405 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, sShort, 3, _16s_C3R);
00406 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, sFloat, 3, _32f_C3R);
00407
00408 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(NAME, TYPE1, TYPE2, SUBFIX) \
00409 void NAME(const QVImage<TYPE1,3> &src, TYPE2 & valueR, TYPE2 & valueG, TYPE2 & valueB) \
00410 { \
00411 TYPE2 values[3]; \
00412 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00413 PDATA_READ(src), src.getStep(), \
00414 IMAGE_ROISIZE(src), values); \
00415 \
00416 valueR = values[0]; valueG = values[1]; valueB = values[2]; \
00417 }
00418
00419 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Sum, uChar, sDouble, _8u_C1R);
00420 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Sum, sShort, sDouble, _16s_C1R);
00421 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Mean, uChar, sDouble, _8u_C1R);
00422 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Mean, sShort, sDouble, _16s_C1R);
00423 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Max, uChar, uChar, _8u_C1R);
00424 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Max, sShort, sShort, _16s_C1R);
00425 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Min, uChar, uChar, _8u_C1R);
00426 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Min, sShort, sShort, _16s_C1R);
00427
00428 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(NAME, TYPE, C, SUBFIX) \
00429 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<TYPE,C> &dest, int scale) \
00430 { \
00431 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00432 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src1.getROI().width(), src1.getROI().height()); \
00433 \
00434 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00435 PDATA_READ(src1), src1.getStep(), \
00436 PDATA_READ(src2), src2.getStep(), \
00437 PDATA_WRITE(dest), dest.getStep(), \
00438 IMAGE_ROISIZE(dest), scale); \
00439 }
00440
00441 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uChar, 1, _8u_C1RSfs);
00442 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uChar, 1, _8u_C1RSfs);
00443 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uChar, 1, _8u_C1RSfs);
00444 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uChar, 1, _8u_C1RSfs);
00445 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uChar, 3, _8u_C3RSfs);
00446 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uChar, 3, _8u_C3RSfs);
00447 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uChar, 3, _8u_C3RSfs);
00448 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uChar, 3, _8u_C3RSfs);
00449 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, sShort, 1, _16s_C1RSfs);
00450 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, sShort, 1, _16s_C1RSfs);
00451 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, sShort, 1, _16s_C1RSfs);
00452 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, sShort, 1, _16s_C1RSfs);
00453 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, sShort, 3, _16s_C3RSfs);
00454 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, sShort, 3, _16s_C3RSfs);
00455 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, sShort, 3, _16s_C3RSfs);
00456 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, sShort, 3, _16s_C3RSfs);
00457
00458 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(NAME, TYPE, C, SUBFIX) \
00459 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<TYPE,C> &dest) \
00460 { \
00461 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00462 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src1.getROI().width(), src1.getROI().height()); \
00463 \
00464 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00465 PDATA_READ(src1), src1.getStep(), \
00466 PDATA_READ(src2), src2.getStep(), \
00467 PDATA_WRITE(dest), dest.getStep(), \
00468 IMAGE_ROISIZE(dest)); \
00469 }
00470
00471 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Add, sFloat, 1, _32f_C1R);
00472 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Sub, sFloat, 1, _32f_C1R);
00473 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Mul, sFloat, 1, _32f_C1R);
00474 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Div, sFloat, 1, _32f_C1R);
00475 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Add, sFloat, 3, _32f_C3R);
00476 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Sub, sFloat, 3, _32f_C3R);
00477 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Mul, sFloat, 3, _32f_C3R);
00478 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Div, sFloat, 3, _32f_C3R);
00479 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(MulScale, uChar, 1, _8u_C1R);
00480 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(MulScale, uChar, 3, _8u_C3R);
00481 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(AbsDiff, uChar, 1, _8u_C1R);
00482 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(AbsDiff, sFloat, 1, _32f_C1R);
00483
00484 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(NAME, TYPE, SUBFIX) \
00485 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant, int scale) \
00486 { \
00487 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height()); \
00488 \
00489 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00490 PDATA_READ(src), src.getStep(), constant, \
00491 PDATA_WRITE(dest), dest.getStep(), \
00492 IMAGE_ROISIZE(dest),scale); \
00493 }
00494
00495 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, uChar, _8u_C1RSfs);
00496 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, uChar, _8u_C1RSfs);
00497 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, uChar, _8u_C1RSfs);
00498 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, uChar, _8u_C1RSfs);
00499 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, sShort, _16s_C1RSfs);
00500 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, sShort, _16s_C1RSfs);
00501 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, sShort, _16s_C1RSfs);
00502 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, sShort, _16s_C1RSfs);
00503
00504 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(NAME, TYPE, PLANES, SUBFIX) \
00505 void NAME(const QVImage<TYPE, PLANES> &src, QVImage<TYPE, PLANES> &dest, int interpolation) \
00506 { \
00507 double factorX = (double) dest.getROI().width() / (double) src.getROI().width(), \
00508 factorY = (double) dest.getROI().height() / (double) src.getROI().height(); \
00509 \
00510 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00511 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src), \
00512 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROISIZE(dest), \
00513 factorX, factorY, interpolation); \
00514 }
00515
00516 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uChar, 1, _8u_C1R);
00517 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, sFloat, 1, _32f_C1R);
00518
00519 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(NAME, TYPE, C, SUBFIX) \
00520 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, QVImage<uChar> &buffer, sInt kernelSize, sFloat sfloat, IppiBorderType borderType, sFloat borderValue) \
00521 { \
00522 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), \
00523 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1); \
00524 \
00525 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00526 PDATA_READ(src), src.getStep(), \
00527 PDATA_WRITE(dest), dest.getStep(), \
00528 IMAGE_ROISIZE(dest), \
00529 kernelSize, sfloat, borderType, borderValue, \
00530 buffer.getWriteData()); \
00531 }
00532
00533 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(FilterGaussBorder, sFloat, 1, _32f_C1R);
00534
00535 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(NAME, TYPE, C, SUBFIX) \
00536 void NAME(const QVImage<TYPE, C> &img, QVImage<uChar> &buffer, QList<QPoint> &points, TYPE threshold, IppiNorm norm, uInt border, uInt maxPeakCount) \
00537 { \
00538 int pPeakCount; \
00539 IppiPoint *pPeak = new IppiPoint[maxPeakCount](); \
00540 \
00541 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00542 PDATA_READ(img), img.getStep(), IMAGE_ROISIZE(img), \
00543 threshold, pPeak, maxPeakCount, &pPeakCount, \
00544 norm, border, buffer.getWriteData()); \
00545 \
00546 \
00547 for (int n = 0; n < maxPeakCount; n++) \
00548 points.append(QPoint(pPeak[n].x, pPeak[n].y)); \
00549 \
00550 delete pPeak; \
00551 }
00552
00553
00554 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sInt, 1, _32s_C1R);
00555 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sFloat, 1, _32f_C1R);
00556
00557 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(NAME, TYPE, C, SUBFIX) \
00558 void NAME(const QVImage<TYPE,C> &image, QVImage<uChar> &buffer) \
00559 { \
00560 int pBufferSize; \
00561 \
00562 IPP_DEBUG(Peaks3x3GetBufferSize, ippi ## NAME ## SUBFIX, image.getROI().width(), &pBufferSize); \
00563 buffer = QVImage<uChar>(pBufferSize,1); \
00564 }
00565
00566 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sInt, 1, _32s_C1R);
00567 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sFloat, 1, _32f_C1R);
00568
00570
00572
00573 void FilterGaussGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt kernelSize)
00574 {
00575 int pBufferSize;
00576 IPP_DEBUG(FilterGaussGetBufferSize, ippiFilterGaussGetBufferSize_32f_C1R, IMAGE_ROISIZE(image), kernelSize, &pBufferSize);
00577 buffer = QVImage<uChar>(pBufferSize,1);
00578 }
00579
00580 void MinEigenValGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt apertureSize, uInt avgWindow)
00581 {
00582 int pBufferSize;
00583 IPP_DEBUG(MinEigenVal, ippiMinEigenValGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image), apertureSize, avgWindow, &pBufferSize);
00584 buffer = QVImage<uChar>(pBufferSize,1);
00585 }
00586
00587 void CannyGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00588 {
00589 int cannyBufferSize;
00590 IPP_DEBUG(CannyGetSize, ippiCannyGetSize, IMAGE_ROISIZE(src),&cannyBufferSize);
00591 buffer = QVImage<uChar>(cannyBufferSize,1);
00592 }
00593
00594 void Canny(QVImage<sShort> &derivadaX, QVImage<sShort> &derivadaY,
00595 QVImage<uChar> &destino, QVImage<uChar> &buffer, double low, double high)
00596 {
00597 CHECK_COMPATIBLE_IMAGES(NAME,derivadaX, derivadaY);
00598 destino.setROI(destino.getAnchor().x(), destino.getAnchor().y(), derivadaX.getROI().width(), derivadaX.getROI().height());
00599
00600 IPP_DEBUG(Canny, ippiCanny_16s8u_C1R,
00601 PDATA_WRITE(derivadaX), derivadaX.getStep(),
00602 PDATA_WRITE(derivadaY), derivadaY.getStep(),
00603 PDATA_WRITE(destino), destino.getStep(),
00604 IMAGE_ROISIZE(derivadaX), low, high,
00605 buffer.getWriteData() );
00606 }
00607
00608 void Canny(QVImage<sFloat> &derivadaX, QVImage<sFloat> &derivadaY,
00609 QVImage<uChar> &destino, QVImage<uChar> &buffer, double low, double high)
00610 {
00611 CHECK_COMPATIBLE_IMAGES(NAME,derivadaX, derivadaY);
00612 destino.setROI(destino.getAnchor().x(), destino.getAnchor().y(), derivadaX.getROI().width(), derivadaX.getROI().height());
00613
00614 IPP_DEBUG(Canny, ippiCanny_32f8u_C1R,
00615 PDATA_WRITE(derivadaX), derivadaX.getStep(),
00616 PDATA_WRITE(derivadaY), derivadaY.getStep(),
00617 PDATA_WRITE(destino), destino.getStep(),
00618 IMAGE_ROISIZE(derivadaX), low, high,
00619 buffer.getWriteData() );
00620 }
00621
00622 void MinEigenVal(const QVImage<uChar> &src, QVImage<sFloat> &mineigval, QVImage<uChar> &buffer,
00623 uInt apertureSize, uInt avgWindow, IppiKernelType kernel)
00624 {
00625 Q_ASSERT_X( ( (kernel == ippKernelSobel) && (apertureSize == 3 || apertureSize == 5) ) ||
00626 ( (kernel == ippKernelSobel) && (apertureSize == 3) ),
00627 "MinEigenVal", "apertureSize value incorrect");
00628
00629 mineigval.setROI(mineigval.getAnchor().x(), mineigval.getAnchor().y(), src.getROI().width(), src.getROI().height());
00630
00631 IPP_DEBUG(MinEigenVal, ippiMinEigenVal_8u32f_C1R,
00632 PDATA_READ(src), src.getStep(),
00633 PDATA_WRITE(mineigval), mineigval.getStep(),
00634 IMAGE_ROISIZE(src), kernel, apertureSize, avgWindow, buffer.getWriteData());
00635 }
00636
00637 void FastMarchingGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer)
00638 {
00639 int bufferSize;
00640 IPP_DEBUG(CannyGetSize, ippiFastMarchingGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image),&bufferSize);
00641 buffer = QVImage<uChar>(bufferSize,1);
00642 }
00643
00644 void FastMarching(const QVImage<uChar> &mask, QVImage<sFloat> &distances, int radius, QVImage<uChar> &buffer)
00645 {
00646 distances.setROI(distances.getAnchor().x(), distances.getAnchor().y(), mask.getROI().width(), mask.getROI().height());
00647
00648 IPP_DEBUG(FastMarching, ippiFastMarching_8u32f_C1R,
00649 PDATA_READ(mask), mask.getStep(),
00650 PDATA_WRITE(distances), distances.getStep(),
00651 IMAGE_ROISIZE(mask), radius, buffer.getWriteData());
00652 }
00653
00654 void Inpaint(const QVImage<uChar> &src, const QVImage<uChar> &mask, const QVImage<sFloat> &distances,
00655 QVImage<uChar> &dest, int radius, IppiInpaintFlag flag)
00656 {
00657 IppiInpaintState_8u_C1R * pState;
00658
00659 IPP_DEBUG( Inpaint, ippiInpaintInitAlloc_8u_C1R, &pState, distances.getReadData(), distances.getStep(),
00660 mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00661
00662 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height());
00663
00664 IPP_DEBUG(Inpaint, ippiInpaint_8u_C1R,
00665 PDATA_READ(src), src.getStep(),
00666 PDATA_WRITE(dest), dest.getStep(),
00667 IMAGE_ROISIZE(src), pState);
00668
00669 IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C1R,pState);
00670 }
00671
00672 void Inpaint(const QVImage<uChar,3> &src, const QVImage<uChar> &mask, const QVImage<sFloat> &distances,
00673 QVImage<uChar,3> &dest, int radius, IppiInpaintFlag flag)
00674 {
00675 IppiInpaintState_8u_C3R * pState;
00676
00677 IPP_DEBUG( Inpaint, ippiInpaintInitAlloc_8u_C3R, &pState, distances.getReadData(), distances.getStep(),
00678 mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00679
00680 dest.setROI(dest.getAnchor().x(), dest.getAnchor().y(), src.getROI().width(), src.getROI().height());
00681
00682 IPP_DEBUG(Inpaint, ippiInpaint_8u_C3R,
00683 PDATA_READ(src), src.getStep(),
00684 PDATA_WRITE(dest), dest.getStep(),
00685 IMAGE_ROISIZE(src), pState);
00686
00687 IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C3R,pState);
00688 }
00689
00690 QVector<int> HistogramRange(const QVImage<uChar, 1> &src)
00691 {
00692
00693 int nLevels = 257;
00694 sInt pLevels[nLevels];
00695 int pHist[nLevels];
00696
00697 for(sInt i=0; i<nLevels; i++)
00698 pLevels[i] = i;
00699
00700 IPP_DEBUG(HistogramRange, ippiHistogramRange_8u_C1R,
00701 PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00702 pHist, pLevels, nLevels);
00703
00705
00706 QVector< int > result(256);
00707 for (int i=0; i<result.size(); i++)
00708 result[i] = pHist[i];
00709
00710 return result;
00711 }
00712
00713 QMap<sInt, int> HistogramRange(const QVImage<uChar, 1> &src, QList<uChar> values)
00714 {
00715
00716 int nLevels = values.size();
00717 sInt pLevels[nLevels];
00718 int pHist[nLevels];
00719
00720 Q_ASSERT_X(false, "QMap<sInt, int> HistogramRange(QVImage<uChar, 1> &src, QList<uChar> values)",
00721 "Tried an user defined values QList. Functionality not implemented yet.");
00722
00723 IPP_DEBUG(HistogramRange, ippiHistogramRange_8u_C1R,
00724 PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00725 pHist, pLevels, nLevels);
00726
00728
00729 QMap<sInt, int> histogram;
00730 for (int i=0; i<nLevels; i++)
00731 histogram.insert(pLevels[i], pHist[i]);
00732
00733 return histogram;
00734 }
00735
00736
00737 void FloodFillGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00738 {
00739 int floodFillBufferSize;
00740 IPP_DEBUG(CannyGetSize, ippiCannyGetSize, IMAGE_ROISIZE(src),&floodFillBufferSize);
00741 buffer = QVImage<uChar>(floodFillBufferSize,1);
00742 }
00743
00744 #define CREATE_IPP_FUNCTION_FLOOD_FILL_RANGE(CONNECTIVITY, SUBFIX, TYPE) \
00745 void FloodFillRange(QVImage<TYPE> &img, QVImage<uChar> &buffer, \
00746 uInt seedX, uInt seedY, TYPE newVal, TYPE minDelta, TYPE maxDelta) \
00747 { \
00748 IppiConnectedComp pRegion; \
00749 IPP_DEBUG(NAME, ippiFloodFill ## CONNECTIVITY ## SUBFIX, \
00750 PDATA_WRITE(img), img.getStep(), IMAGE_ROISIZE(img), \
00751 IPP_POINT(seedX, seedY), newVal, minDelta, maxDelta, \
00752 &pRegion, buffer.getWriteData()); \
00753 }
00754
00755 CREATE_IPP_FUNCTION_FLOOD_FILL_RANGE(_Range4Con, _8u_C1IR, uChar);
00756 }