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