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