00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00024
00025 #include <qvip/qvipp/qvipp.h>
00026 #include <qvmath/qvmatrix.h>
00027
00028
00029 #define IPP_DEBUG(function, ipp_function, ...) \
00030 { \
00031 IppStatus status = ipp_function(__VA_ARGS__); \
00032 Q_ASSERT_X( status == ippStsNoErr, #ipp_function, \
00033 ippGetStatusString(status)); \
00034 Q_UNUSED(status); \
00035 } \
00036
00037
00038 #define PDATA_READ(Image) \
00039 (&Image.getReadData()[Image.getROI().y()*Image.getStep()/Image.getTypeSize() + Image.getChannels()*Image.getROI().x()])
00040 #define PDATA_WRITE(Image) \
00041 (&Image.getWriteData()[Image.getROI().y()*Image.getStep()/Image.getTypeSize() + Image.getChannels()*Image.getROI().x()])
00042
00043 #define PDATA_READ_MARGIN(Image, margin) \
00044 (&Image.getReadData()[ \
00045 (Image.getROI().y()+margin)*Image.getStep()/Image.getTypeSize() \
00046 + Image.getChannels()*(Image.getROI().x()+margin)] \
00047 )
00048
00049 #define PDATA_WRITE_MARGIN(Image, margin) \
00050 (&Image.getWriteData()[ \
00051 (Image.getROI().y()+margin)*Image.getStep()/Image.getTypeSize() \
00052 + Image.getChannels()*(Image.getROI().x()+margin)] \
00053 )
00054
00055
00056 #define IMAGE_ROISIZE(Image) ((IppiSize){ Image.getROI().width(), Image.getROI().height() })
00057 #define IMAGE_ROIRECT(Image) ((IppiRect){ Image.getROI().x(), Image.getROI().y(), Image.getROI().width(), Image.getROI().height() })
00058 #define IMAGE_SIZE(Image) ((IppiSize){ Image.getCols(), Image.getRows() })
00059 #define IPP_SIZE(X,Y) ( (IppiSize) { (X), (Y) })
00060 #define IPP_POINT(X,Y) ( (IppiPoint) { (X), (Y) })
00061 #define IPP_MASK_SIZE(X,Y) (((X) == 1 && (Y) == 3)? ippMskSize1x3: \
00062 ((X) == 1 && (Y) == 5)? ippMskSize1x5: \
00063 ((X) == 3 && (Y) == 1)? ippMskSize3x1: \
00064 ((X) == 5 && (Y) == 1)? ippMskSize5x1: \
00065 ((X) == 3 && (Y) == 3)? ippMskSize3x3: \
00066 ippMskSize5x5)
00067
00068 #define CHECK_COMPATIBLE_IMAGES(NAME, Image1, Image2) \
00069 Q_ASSERT_X(Image1.getROI().size() == Image2.getROI().size(), "" # NAME, "different ROI sizes in source images"); \
00070
00072 // START OF MACROS
00074
00075 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(NAME, TYPE, C, SUBFIX) \
00076 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, QPoint destROIOffset) \
00077 { \
00078 qDebug() << "" # NAME << "()"; \
00079 qDebug() << "" # NAME << ": calling ippi" # NAME # SUBFIX; \
00080 dest.setROI(dest.getAnchor().x(), destROIOffset.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() << "" # NAME # SUBFIX << "() <~ return"; \
00087 }
00088
00089 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uChar, 1, _8u_C1R);
00090 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uChar, 3, _8u_C3R);
00091 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uShort, 1, _16u_C1R);
00092 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, uShort, 3, _16u_C3R);
00093 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sShort, 1, _16s_C1R);
00094 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sShort, 3, _16s_C3R);
00095 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sInt, 1, _32s_C1R);
00096 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sInt, 3, _32s_C3R);
00097 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sFloat, 1, _32f_C1R);
00098 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Copy, sFloat, 3, _32f_C3R);
00099
00100 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSharpen, uChar, 1, _8u_C1R);
00101 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSharpen, sFloat, 1, _32f_C1R);
00102 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, uChar, 1, _8u_C1R);
00103 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, sShort, 1, _16s_C1R);
00104 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelHoriz, sFloat, 1, _32f_C1R);
00105 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, uChar, 1, _8u_C1R);
00106 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, sShort, 1, _16s_C1R);
00107 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(FilterSobelVert, sFloat, 1, _32f_C1R);
00108 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Not, uChar, 1, _8u_C1R);
00109 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Not, uChar, 3, _8u_C3R);
00110 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Abs, sShort, 1, _16s_C1R);
00111 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Abs, sFloat, 1, _32f_C1R);
00112 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Ln, sFloat, 1, _32f_C1R);
00113 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Ln, sFloat, 3, _32f_C3R);
00114 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE(Sqr, sFloat, 1, _32f_C1R);
00115
00116
00118 #define DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(NAME, TYPE, SUBFIX) \
00119 void NAME(const QVImage<TYPE, 1> &src1, const QVImage<TYPE, 1> &src2, const QVImage<TYPE, 1> &src3, QVImage<TYPE, 3> &dest, QPoint destROIOffset) \
00120 { \
00121 dest.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width(), src1.getROI().height()); \
00122 const TYPE * pSrc[3] = { PDATA_READ(src1), PDATA_READ(src2), PDATA_READ(src3) }; \
00123 \
00124 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00125 pSrc, src1.getStep(), \
00126 PDATA_WRITE(dest), dest.getStep(), \
00127 IMAGE_ROISIZE(dest)); \
00128 }
00129
00130 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(Copy, uChar, _8u_P3C3R);
00131 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(Copy, uShort, _16u_P3C3R);
00132 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(Copy, sShort, _16s_P3C3R);
00133 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(Copy, sInt, _32s_P3C3R);
00134 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C1_QVIMAGE_C3(Copy, sFloat, _32f_P3C3R);
00135
00136 #define DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(NAME, TYPE, SUBFIX) \
00137 void NAME(const QVImage<TYPE, 1> &src, QVImage<TYPE, 3> &dest, QPoint destROIOffset) \
00138 { \
00139 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00140 const TYPE * pSrc[3] = { PDATA_READ(src), PDATA_READ(src), PDATA_READ(src) }; \
00141 \
00142 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00143 pSrc, src.getStep(), \
00144 PDATA_WRITE(dest), dest.getStep(), \
00145 IMAGE_ROISIZE(dest)); \
00146 }
00147
00148 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, uChar, _8u_P3C3R);
00149 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, uShort, _16u_P3C3R);
00150 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, sShort, _16s_P3C3R);
00151 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, sInt, _32s_P3C3R);
00152 DEFINE_IPP_FUNCTION_QVIMAGE_C1_QVIMAGE_C3(Copy, sFloat, _32f_P3C3R);
00153
00154 #define DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(NAME, TYPE1, TYPE2, C, SUBFIX) \
00155 void NAME(const QVImage<TYPE1, C> &src, QVImage<TYPE2, C> &dest, QPoint destROIOffset) \
00156 { \
00157 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00158 \
00159 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00160 PDATA_READ(src), src.getStep(), \
00161 PDATA_WRITE(dest), dest.getStep(), \
00162 IMAGE_ROISIZE(dest)); \
00163 }
00164
00165 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, uShort, 1, _8u16u_C1R);
00166 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sShort, 1, _8u16s_C1R);
00167 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sInt, 1, _8u32s_C1R);
00168 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sFloat, 1, _8u32f_C1R);
00169 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, uShort, 3, _8u16u_C3R);
00170 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sShort, 3, _8u16s_C3R);
00171 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sInt, 3, _8u32s_C3R);
00172 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uChar, sFloat, 3, _8u32f_C3R);
00173
00174 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, uChar, 1, _16u8u_C1R);
00175 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, sInt, 1, _16u32s_C1R);
00176 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, sFloat, 1, _16u32f_C1R);
00177 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, uChar, 3, _16u8u_C3R);
00178 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, sInt, 3, _16u32s_C3R);
00179 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, uShort, sFloat, 3, _16u32f_C3R);
00180
00181 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, uChar, 1, _16s8u_C1R);
00182 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sInt, 1, _16s32s_C1R);
00183 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sFloat, 1, _16s32f_C1R);
00184 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, uChar, 3, _16s8u_C3R);
00185 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sInt, 3, _16s32s_C3R);
00186 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sShort, sFloat, 3, _16s32f_C3R);
00187
00188 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sInt, uChar, 1, _32s8u_C1R);
00189 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2(Convert, sInt, uChar, 3, _32s8u_C3R);
00190
00191 #define DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_PLUSVALUE(NAME, TYPE1, TYPE2, C, SUBFIX) \
00192 void NAME(const QVImage<TYPE1, C> &src, QVImage<TYPE2, C> &dest, TYPE2 val, QPoint destROIOffset) \
00193 { \
00194 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00195 \
00196 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00197 PDATA_READ(src), src.getStep(), \
00198 PDATA_WRITE(dest), dest.getStep(), \
00199 IMAGE_ROISIZE(dest), val); \
00200 }
00201
00202 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_PLUSVALUE(Integral, uChar, sInt, 1, _8u32s_C1R);
00203 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_PLUSVALUE(Integral, uChar, sFloat, 1, _8u32f_C1R);
00204
00205
00206 #define DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(NAME, TYPE1, TYPE2, C, SUBFIX) \
00207 void NAME(const QVImage<TYPE1, C> &src, QVImage<TYPE2, C> &dest, IppRoundMode roundMode, QPoint destROIOffset) \
00208 { \
00209 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00210 \
00211 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00212 PDATA_READ(src), src.getStep(), \
00213 PDATA_WRITE(dest), dest.getStep(), \
00214 IMAGE_ROISIZE(dest),roundMode); \
00215 }
00216
00217 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uChar, 1, _32f8u_C1R);
00218 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uShort, 1, _32f16u_C1R);
00219 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, sShort, 1, _32f16s_C1R);
00220 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uChar, 3, _32f8u_C3R);
00221 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, uShort, 3, _32f16u_C3R);
00222 DEFINE_IPP_FUNCTION_QVIMAGE_T1_QVIMAGE_T2_IPPROUNDMODE(Convert, sFloat, sShort, 3, _32f16s_C3R);
00223
00224 #define DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(NAME, TYPE, SUBFIX) \
00225 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 1> &dest, QPoint destROIOffset) \
00226 { \
00227 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00228 \
00229 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00230 PDATA_READ(src), src.getStep(), \
00231 PDATA_WRITE(dest), dest.getStep(), \
00232 IMAGE_ROISIZE(dest)); \
00233 }
00234
00235 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, uChar, _8u_C3C1R);
00236 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, uShort, _16u_C3C1R);
00237 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, sShort, _16s_C3C1R);
00238
00239 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, sFloat, _32f_C3C1R);
00240
00241 #define DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(NAME, TYPE, SUBFIX) \
00242 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 1> &dest, uChar channel, QPoint destROIOffset) \
00243 { \
00244 qDebug() << "" # NAME << "()"; \
00245 qDebug() << "" # NAME << ": calling ippi" # NAME # SUBFIX; \
00246 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00247 \
00248 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00249 PDATA_READ(src) + channel, src.getStep(), \
00250 PDATA_WRITE(dest), dest.getStep(), \
00251 IMAGE_ROISIZE(dest)); \
00252 qDebug() << "" # NAME # SUBFIX << "() <~ return"; \
00253 }
00254
00255 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, uChar, _8u_C3C1R);
00256 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, uShort, _16u_C3C1R);
00257 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, sShort, _16s_C3C1R);
00258 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, sInt, _32s_C3C1R);
00259 DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1_BIS(Copy, sFloat, _32f_C3C1R);
00260
00261 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(NAME, TYPE, C, SUBFIX) \
00262 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<uChar> &dest, IppCmpOp ippCmpOp, QPoint destROIOffset) \
00263 { \
00264 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00265 \
00266 dest.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width(), src1.getROI().height()); \
00267 \
00268 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00269 PDATA_READ(src1), src1.getStep(), \
00270 PDATA_READ(src2), src2.getStep(), \
00271 PDATA_WRITE(dest), dest.getStep(), \
00272 IMAGE_ROISIZE(dest), \
00273 ippCmpOp); \
00274 }
00275
00276 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uChar, 1, _8u_C1R);
00277 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uShort, 1, _16u_C1R);
00278 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sShort, 1, _16s_C1R);
00279 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sFloat, 1, _32f_C1R);
00280 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uChar, 3, _8u_C3R);
00281 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, uShort, 3, _16u_C3R);
00282 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sShort, 3, _16s_C3R);
00283 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_UCHAR_C1_IPPCMPOP(Compare, sFloat, 3, _32f_C3R);
00284
00285 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(NAME, TYPE, SUBFIX) \
00286 void NAME(const QVImage<TYPE> &src, QVImage<uChar> &dest, TYPE constant, IppCmpOp ippCmpOp, QPoint destROIOffset) \
00287 { \
00288 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00289 \
00290 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00291 PDATA_READ(src), src.getStep(), \
00292 constant, \
00293 PDATA_WRITE(dest), dest.getStep(), \
00294 IMAGE_ROISIZE(dest), \
00295 ippCmpOp); \
00296 }
00297
00298 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(CompareC, uChar, _8u_C1R);
00299 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP(CompareC, sFloat, _32f_C1R);
00300
00301 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(NAME, TYPE, SUBFIX) \
00302 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant, IppCmpOp ippCmpOp, QPoint destROIOffset) \
00303 { \
00304 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00305 \
00306 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00307 PDATA_READ(src), src.getStep(), \
00308 PDATA_WRITE(dest), dest.getStep(), \
00309 IMAGE_ROISIZE(dest), \
00310 constant, ippCmpOp); \
00311 }
00312
00313 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, uChar, _8u_C1R);
00314 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, sShort, _16s_C1R);
00315 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_IPPCMPOP_2(Threshold, sFloat, _32f_C1R);
00316
00317 #define DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_IPPCMPOP(NAME, TYPE, SUBFIX) \
00318 void NAME(QVImage<TYPE> &src_dest, TYPE constant, IppCmpOp ippCmpOp) \
00319 { \
00320 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00321 PDATA_WRITE(src_dest), src_dest.getStep(), \
00322 IMAGE_ROISIZE(src_dest), \
00323 constant, ippCmpOp); \
00324 }
00325 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_IPPCMPOP(Threshold, uChar, _8u_C1IR);
00326 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_IPPCMPOP(Threshold, sShort, _16s_C1IR);
00327 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_IPPCMPOP(Threshold, sFloat, _32f_C1IR);
00328
00329 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_IPPCMPOP(NAME, TYPE, SUBFIX) \
00330 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant1, TYPE constant2, IppCmpOp ippCmpOp, QPoint destROIOffset) \
00331 { \
00332 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00333 \
00334 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00335 PDATA_READ(src), src.getStep(), \
00336 PDATA_WRITE(dest), dest.getStep(), \
00337 IMAGE_ROISIZE(dest), \
00338 constant1, constant2, ippCmpOp); \
00339 }
00340
00341 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_IPPCMPOP(Threshold_Val, uChar, _8u_C1R);
00342 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_IPPCMPOP(Threshold_Val, sFloat, _32f_C1R);
00343
00344 #define DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_SCALAR_IPPCMPOP(NAME, TYPE, SUBFIX) \
00345 void NAME(QVImage<TYPE> &src_dest, TYPE constant1, TYPE constant2, IppCmpOp ippCmpOp) \
00346 { \
00347 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00348 PDATA_WRITE(src_dest), src_dest.getStep(), \
00349 IMAGE_ROISIZE(src_dest), \
00350 constant1, constant2, ippCmpOp); \
00351 }
00352 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_SCALAR_IPPCMPOP(Threshold_Val, uChar, _8u_C1IR);
00353 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_SCALAR_IPPCMPOP(Threshold_Val, sShort, _16s_C1IR);
00354 DEFINE_IPP_FUNCTION_INPLACE_QVIMAGE_SCALAR_SCALAR_IPPCMPOP(Threshold_Val, sFloat, _32f_C1IR);
00355
00356 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_SCALAR_SCALAR(NAME, TYPE, SUBFIX) \
00357 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant1, TYPE constant2, TYPE constant3, TYPE constant4, QPoint destROIOffset) \
00358 { \
00359 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00360 \
00361 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00362 PDATA_READ(src), src.getStep(), \
00363 PDATA_WRITE(dest), dest.getStep(), \
00364 IMAGE_ROISIZE(dest), \
00365 constant1, constant2, constant3, constant4); \
00366 }
00367
00368 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_SCALAR_SCALAR(Threshold_LTValGTVal, uChar, _8u_C1R);
00369 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_UCHAR_C1_SCALAR_SCALAR_SCALAR_SCALAR(Threshold_LTValGTVal, sFloat, _32f_C1R);
00370
00371 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(NAME, TYPE, SUBFIX) \
00372 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, uInt colMaskRadius, uInt rowMaskRadius, QPoint destROIOffset) \
00373 { \
00374 dest.setROI(destROIOffset.x(), destROIOffset.y(), \
00375 src.getROI().width()-colMaskRadius+1, src.getROI().height()-rowMaskRadius+1); \
00376 \
00377 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00378 PDATA_READ(src), src.getStep(), \
00379 PDATA_WRITE(dest), dest.getStep(), \
00380 IMAGE_ROISIZE(dest), \
00381 IPP_SIZE(colMaskRadius, rowMaskRadius), \
00382 IPP_POINT(0,0)); \
00383 }
00384
00385 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMax, uChar, _8u_C1R);
00386 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMax, uShort, _16u_C1R);
00387 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMax, sFloat, _32f_C1R);
00388 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMin, uChar, _8u_C1R);
00389 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMin, uShort, _16u_C1R);
00390 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMin, sFloat, _32f_C1R);
00391 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterBox, uChar, _8u_C1R);
00392 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterBox, uShort, _16u_C1R);
00393 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterBox, sFloat, _32f_C1R);
00394 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMedian, uChar, _8u_C1R);
00395 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_INT_INT(FilterMedian, uShort, _16u_C1R);
00396
00397
00398 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(NAME, TYPE, C, SUBFIX) \
00399 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, uInt maskSize, QPoint destROIOffset) \
00400 { \
00401 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00402 "" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00403 \
00404 Q_ASSERT_X(src.getROI().width()-maskSize+1 > 0,"" #NAME, "dest ROI size < 1"); \
00405 Q_ASSERT_X(src.getROI().height()-maskSize+1 > 0,"" #NAME, "dest ROI size < 1"); \
00406 \
00407 dest.setROI(destROIOffset.x(), destROIOffset.y(), \
00408 src.getROI().width()-maskSize+1, src.getROI().height()-maskSize+1); \
00409 \
00410 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00411 PDATA_READ_MARGIN(src,(maskSize -1)/2), src.getStep(), \
00412 PDATA_WRITE(dest), dest.getStep(), \
00413 IMAGE_ROISIZE(dest), IPP_MASK_SIZE(maskSize, maskSize) \
00414 ); \
00415 }
00416
00417 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, uChar, 1, _8u_C1R);
00418 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, sFloat, 1, _32f_C1R);
00419 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, uChar, 3, _8u_C3R);
00420 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterGauss, sFloat, 3, _32f_C3R);
00421 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterHipass, uChar, 1, _8u_C1R);
00422 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterHipass, sFloat, 1, _32f_C1R);
00423 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLowpass, uChar, 1, _8u_C1R);
00424 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLowpass, sFloat, 1, _32f_C1R);
00425 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterSobelHorizMask, sFloat, 1, _32f_C1R);
00426 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterSobelVertMask, sFloat, 1, _32f_C1R);
00427 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, uChar, 1, _8u_C1R);
00428 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, sShort, 1, _16s_C1R);
00429 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_IPPMSKSIZE(FilterLaplace, sFloat, 1, _32f_C1R);
00430
00431 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(NAME, TYPE1, TYPE2, SUBFIX) \
00432 void NAME(const QVImage<TYPE1> &src, QVImage<TYPE2> &dest, QVImage<TYPE1> &buffer, uInt maskSize, QPoint destROIOffset) \
00433 { \
00434 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00435 "" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00436 \
00437 Q_ASSERT_X(src.getROI().width()-maskSize+1 > 0,"" #NAME, "dest ROI size < 1"); \
00438 Q_ASSERT_X(src.getROI().height()-maskSize+1 > 0,"" #NAME, "dest ROI size < 1"); \
00439 \
00440 dest.setROI(destROIOffset.x(), destROIOffset.y(), \
00441 src.getROI().width()-maskSize+1, src.getROI().height()-maskSize+1); \
00442 \
00443 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00444 PDATA_READ_MARGIN(src,(maskSize -1)/2), src.getStep(), \
00445 PDATA_WRITE(dest), dest.getStep(), \
00446 IMAGE_ROISIZE(dest), IPP_MASK_SIZE(maskSize, maskSize), \
00447 ippBorderRepl, 0, buffer.getWriteData()); \
00448 }
00449 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(FilterSobelNegVertBorder, uChar, sShort, _8u16s_C1R);
00450 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_IPPMSKSIZE(FilterSobelHorizBorder, uChar, sShort, _8u16s_C1R);
00451
00452 #define DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(NAME, TYPE, SUBFIX) \
00453 void NAME(const QVGenericImage &src, QVImage<TYPE> &buffer, uInt maskSize) \
00454 { \
00455 Q_ASSERT_X( (maskSize == 3) || (maskSize == 5), \
00456 "" #NAME, "Mask size incorrect. Allowed sizes: 3 and 5, for 3x3 and 5x5 mask sizes"); \
00457 \
00458 int bufferSize; \
00459 \
00460 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, IMAGE_ROISIZE(src), \
00461 IPP_MASK_SIZE(maskSize, maskSize), &bufferSize); \
00462 buffer = QVImage<uChar>(bufferSize,1); \
00463 }
00464
00465 DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(FilterSobelNegVertGetBufferSize, uChar, _8u16s_C1R);
00466 DEFINE_IPP_FUNCTION_QVGENERICIMAGE_BUFFER_IPPMSKSIZE(FilterSobelHorizGetBufferSize, uChar, _8u16s_C1R);
00467
00468 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(NAME, TYPE, C, SUBFIX) \
00469 void NAME(QVImage<TYPE, C> &img, TYPE constant) \
00470 { \
00471 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, constant, \
00472 PDATA_WRITE(img), img.getStep(), \
00473 IMAGE_ROISIZE(img)); \
00474 }
00475
00476 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, uChar, 1, _8u_C1R);
00477 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, uShort, 1, _16u_C1R);
00478 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, sShort, 1, _16s_C1R);
00479 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, sInt, 1, _32s_C1R);
00480 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR(Set, sFloat, 1, _32f_C1R);
00481
00482 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(NAME, TYPE, SUBFIX) \
00483 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant, QPoint destROIOffset) \
00484 { \
00485 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00486 \
00487 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00488 PDATA_READ(src), src.getStep(), constant, \
00489 PDATA_WRITE(dest), dest.getStep(), \
00490 IMAGE_ROISIZE(dest)); \
00491 }
00492
00493 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(OrC, uChar, _8u_C1R);
00494 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AndC, uChar, _8u_C1R);
00495 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(XorC, uChar, _8u_C1R);
00496 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(OrC, uShort, _16u_C1R);
00497 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AndC, uShort, _16u_C1R);
00498 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(XorC, uShort, _16u_C1R);
00499 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(OrC, sInt, _32s_C1R);
00500 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AndC, sInt, _32s_C1R);
00501 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(XorC, sInt, _32s_C1R);
00502 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(LShiftC, uChar, _8u_C1R);
00503 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(RShiftC, uChar, _8u_C1R);
00504 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(LShiftC, uShort, _16u_C1R);
00505 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(RShiftC, uShort, _16u_C1R);
00506 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(LShiftC, sInt, _32s_C1R);
00507 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(RShiftC, sInt, _32s_C1R);
00508 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(MulC, sFloat, _32f_C1R);
00509 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(AddC, sFloat, _32f_C1R);
00510 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(SubC, sFloat, _32f_C1R);
00511 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR(DivC, sFloat, _32f_C1R);
00512
00513 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(NAME, TYPE, SUBFIX) \
00514 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 3> &dest, TYPE constant, QPoint destROIOffset) \
00515 { \
00516 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00517 TYPE value[3] = {constant, constant, constant}; \
00518 \
00519 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00520 PDATA_READ(src), src.getStep(), value, \
00521 PDATA_WRITE(dest), dest.getStep(), \
00522 IMAGE_ROISIZE(dest)); \
00523 }
00524
00525 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(OrC, uChar, _8u_C3R);
00526 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(AndC, uChar, _8u_C3R);
00527 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(XorC, uChar, _8u_C3R);
00528 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(OrC, uShort, _16u_C3R);
00529 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(AndC, uShort, _16u_C3R);
00530 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(XorC, uShort, _16u_C3R);
00531 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(OrC, sInt, _32s_C3R);
00532 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(AndC, sInt, _32s_C3R);
00533 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(XorC, sInt, _32s_C3R);
00534 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(MulC, sFloat, _32f_C3R);
00535 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(AddC, sFloat, _32f_C3R);
00536 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(SubC, sFloat, _32f_C3R);
00537 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3(DivC, sFloat, _32f_C3R);
00538
00539 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(NAME, TYPE, SUBFIX) \
00540 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 3> &dest, TYPE constant, QPoint destROIOffset) \
00541 { \
00542 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00543 Ipp32u value[3] = {constant, constant, constant}; \
00544 \
00545 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00546 PDATA_READ(src), src.getStep(), value, \
00547 PDATA_WRITE(dest), dest.getStep(), \
00548 IMAGE_ROISIZE(dest)); \
00549 }
00550
00551 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(LShiftC, uChar, _8u_C3R);
00552 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(RShiftC, uChar, _8u_C3R);
00553 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(LShiftC, uShort, _16u_C3R);
00554 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(RShiftC, uShort, _16u_C3R);
00555 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(LShiftC, sInt, _32s_C3R);
00556 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_C3_SHIFT(RShiftC, sInt, _32s_C3R);
00557
00558 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(NAME, TYPE1, TYPE2, SUBFIX) \
00559 void NAME(const QVImage<TYPE1> &src, TYPE2 & value) \
00560 { \
00561 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00562 PDATA_READ(src), src.getStep(), \
00563 IMAGE_ROISIZE(src), &value); \
00564 }
00565
00566 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Sum, uChar, sDouble, _8u_C1R);
00567 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Sum, sShort, sDouble, _16s_C1R);
00568 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Mean, uChar, sDouble, _8u_C1R);
00569 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Mean, sShort, sDouble, _16s_C1R);
00570 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, uChar, uChar, _8u_C1R);
00571 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, sShort, sShort, _16s_C1R);
00572 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Max, sFloat, sFloat, _32f_C1R);
00573 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, uChar, uChar, _8u_C1R);
00574 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, sShort, sShort, _16s_C1R);
00575 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_2(Min, sFloat, sFloat, _32f_C1R);
00576
00577 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(NAME, TYPE, C, SUBFIX) \
00578 void NAME(QVImage<TYPE, C> &img, TYPE red, TYPE green, TYPE blue) \
00579 { \
00580 TYPE constant[3] = { red, green, blue }; \
00581 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, constant, \
00582 PDATA_WRITE(img), img.getStep(), \
00583 IMAGE_ROISIZE(img)); \
00584 }
00585
00586 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, uChar, 3, _8u_C3R);
00587 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, uShort, 3, _16u_C3R);
00588 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, sShort, 3, _16s_C3R);
00589 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, sInt, 3, _32s_C3R);
00590 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR(Set, sFloat, 3, _32f_C3R);
00591
00592 #define DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(NAME, TYPE1, TYPE2, SUBFIX) \
00593 void NAME(const QVImage<TYPE1,3> &src, TYPE2 & valueR, TYPE2 & valueG, TYPE2 & valueB) \
00594 { \
00595 TYPE2 values[3]; \
00596 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00597 PDATA_READ(src), src.getStep(), \
00598 IMAGE_ROISIZE(src), values); \
00599 \
00600 valueR = values[0]; valueG = values[1]; valueB = values[2]; \
00601 }
00602
00603 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Sum, uChar, sDouble, _8u_C1R);
00604 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Sum, sShort, sDouble, _16s_C1R);
00605 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Mean, uChar, sDouble, _8u_C1R);
00606 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Mean, sShort, sDouble, _16s_C1R);
00607 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Max, uChar, uChar, _8u_C1R);
00608 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Max, sShort, sShort, _16s_C1R);
00609 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Min, uChar, uChar, _8u_C1R);
00610 DEFINE_IPP_FUNCTION_QVIMAGE_SCALAR_SCALAR_SCALAR_2(Min, sShort, sShort, _16s_C1R);
00611
00612 #include <iostream>
00613 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(NAME, TYPE, C, SUBFIX) \
00614 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<TYPE,C> &dest, int scale, QPoint destROIOffset) \
00615 { \
00616 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00617 dest.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width(), src1.getROI().height()); \
00618 \
00619 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00620 PDATA_READ(src1), src1.getStep(), \
00621 PDATA_READ(src2), src2.getStep(), \
00622 PDATA_WRITE(dest), dest.getStep(), \
00623 IMAGE_ROISIZE(dest), scale); \
00624 }
00625
00626 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uChar, 1, _8u_C1RSfs);
00627 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uChar, 1, _8u_C1RSfs);
00628 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uChar, 1, _8u_C1RSfs);
00629 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uChar, 1, _8u_C1RSfs);
00630 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uChar, 3, _8u_C3RSfs);
00631 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uChar, 3, _8u_C3RSfs);
00632 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uChar, 3, _8u_C3RSfs);
00633 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uChar, 3, _8u_C3RSfs);
00634 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uShort, 1, _16u_C1RSfs);
00635 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uShort, 1, _16u_C1RSfs);
00636 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uShort, 1, _16u_C1RSfs);
00637 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uShort, 1, _16u_C1RSfs);
00638 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, uShort, 3, _16u_C3RSfs);
00639 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, uShort, 3, _16u_C3RSfs);
00640 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, uShort, 3, _16u_C3RSfs);
00641 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, uShort, 3, _16u_C3RSfs);
00642 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, sShort, 1, _16s_C1RSfs);
00643 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, sShort, 1, _16s_C1RSfs);
00644 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, sShort, 1, _16s_C1RSfs);
00645 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, sShort, 1, _16s_C1RSfs);
00646 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Add, sShort, 3, _16s_C3RSfs);
00647 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Sub, sShort, 3, _16s_C3RSfs);
00648 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Mul, sShort, 3, _16s_C3RSfs);
00649 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR(Div, sShort, 3, _16s_C3RSfs);
00650
00651
00652 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(NAME, TYPE, C, SUBFIX) \
00653 void NAME(const QVImage<TYPE,C> &src1, const QVImage<TYPE,C> &src2, QVImage<TYPE,C> &dest, QPoint destROIOffset) \
00654 { \
00655 CHECK_COMPATIBLE_IMAGES(NAME, src1, src2); \
00656 dest.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width(), src1.getROI().height()); \
00657 \
00658 \
00659 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00660 PDATA_READ(src1), src1.getStep(), \
00661 PDATA_READ(src2), src2.getStep(), \
00662 PDATA_WRITE(dest), dest.getStep(), \
00663 IMAGE_ROISIZE(dest)); \
00664 }
00665
00666 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Add, sFloat, 1, _32f_C1R);
00667 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Sub, sFloat, 1, _32f_C1R);
00668 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Mul, sFloat, 1, _32f_C1R);
00669 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Div, sFloat, 1, _32f_C1R);
00670 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Add, sFloat, 3, _32f_C3R);
00671 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Sub, sFloat, 3, _32f_C3R);
00672 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Mul, sFloat, 3, _32f_C3R);
00673 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(Div, sFloat, 3, _32f_C3R);
00674 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(MulScale, uChar, 1, _8u_C1R);
00675 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(MulScale, uChar, 3, _8u_C3R);
00676 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(AbsDiff, uChar, 1, _8u_C1R);
00677 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE(AbsDiff, sFloat, 1, _32f_C1R);
00678
00679 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(NAME, TYPE, SUBFIX) \
00680 void NAME(const QVImage<TYPE> &src, QVImage<TYPE> &dest, TYPE constant, int scale, QPoint destROIOffset) \
00681 { \
00682 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00683 \
00684 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00685 PDATA_READ(src), src.getStep(), constant, \
00686 PDATA_WRITE(dest), dest.getStep(), \
00687 IMAGE_ROISIZE(dest),scale); \
00688 }
00689
00690 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, uChar, _8u_C1RSfs);
00691 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, uChar, _8u_C1RSfs);
00692 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, uChar, _8u_C1RSfs);
00693 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, uChar, _8u_C1RSfs);
00694 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, uShort, _16u_C1RSfs);
00695 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, uShort, _16u_C1RSfs);
00696 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, uShort, _16u_C1RSfs);
00697 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, uShort, _16u_C1RSfs);
00698 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, sShort, _16s_C1RSfs);
00699 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, sShort, _16s_C1RSfs);
00700 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, sShort, _16s_C1RSfs);
00701 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, sShort, _16s_C1RSfs);
00702
00703 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(NAME, TYPE, SUBFIX) \
00704 void NAME(const QVImage<TYPE, 3> &src, QVImage<TYPE, 3> &dest, TYPE constant, int scale, QPoint destROIOffset) \
00705 { \
00706 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height()); \
00707 TYPE value[3] = {constant, constant, constant}; \
00708 \
00709 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00710 PDATA_READ(src), src.getStep(), value, \
00711 PDATA_WRITE(dest), dest.getStep(), \
00712 IMAGE_ROISIZE(dest),scale); \
00713 }
00714
00715 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, uChar, _8u_C3RSfs);
00716 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, uChar, _8u_C3RSfs);
00717 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, uChar, _8u_C3RSfs);
00718 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, uChar, _8u_C3RSfs);
00719 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, uShort, _16u_C3RSfs);
00720 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, uShort, _16u_C3RSfs);
00721 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, uShort, _16u_C3RSfs);
00722 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, uShort, _16u_C3RSfs);
00723 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(MulC, sShort, _16s_C3RSfs);
00724 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(AddC, sShort, _16s_C3RSfs);
00725 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(SubC, sShort, _16s_C3RSfs);
00726 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_QVIMAGE_SCALAR_SCALE(DivC, sShort, _16s_C3RSfs);
00727
00728
00729 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(NAME, TYPE, PLANES, SUBFIX) \
00730 void NAME(const QVImage<TYPE, PLANES> &src, QVImage<TYPE, PLANES> &dest, int interpolation) \
00731 { \
00732 double factorX = (double) dest.getROI().width() / (double) src.getROI().width(), \
00733 factorY = (double) dest.getROI().height() / (double) src.getROI().height(); \
00734 \
00735 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00736 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src), \
00737 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROISIZE(dest), \
00738 factorX, factorY, interpolation); \
00739 }
00740
00741 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uChar, 1, _8u_C1R);
00742 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uChar, 3, _8u_C3R);
00743 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uShort, 1, _16u_C1R);
00744 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, sFloat, 1, _32f_C1R);
00745
00746 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(NAME, TYPE, C, SUBFIX) \
00747 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, QVImage<uChar> &buffer, sInt kernelSize, sFloat sfloat, IppiBorderType borderType, sFloat borderValue, QPoint destROIOffset) \
00748 { \
00749 dest.setROI(destROIOffset.x(), destROIOffset.y(), \
00750 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1); \
00751 \
00752 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00753 PDATA_READ(src), src.getStep(), \
00754 PDATA_WRITE(dest), dest.getStep(), \
00755 IMAGE_ROISIZE(dest), \
00756 kernelSize, sfloat, borderType, borderValue, \
00757 buffer.getWriteData()); \
00758 }
00759
00760 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(FilterGaussBorder, sFloat, 1, _32f_C1R);
00761
00762 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(NAME, TYPE, C, SUBFIX) \
00763 void NAME(const QVImage<TYPE, C> &img, QVImage<uChar> &buffer, QList<QPoint> &points, TYPE threshold, IppiNorm norm, uInt border, uInt maxPeakCount) \
00764 { \
00765 int pPeakCount; \
00766 IppiPoint *pPeak = new IppiPoint[maxPeakCount](); \
00767 \
00768 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00769 PDATA_READ(img), img.getStep(), IMAGE_ROISIZE(img), \
00770 threshold, pPeak, maxPeakCount, &pPeakCount, \
00771 norm, border, buffer.getWriteData()); \
00772 \
00773 \
00774 for (int n = 0; n < maxPeakCount; n++) \
00775 points.append(QPoint(pPeak[n].x, pPeak[n].y)); \
00776 \
00777 delete pPeak; \
00778 }
00779
00780
00781 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sInt, 1, _32s_C1R);
00782 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sFloat, 1, _32f_C1R);
00783
00784 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(NAME, TYPE, C, SUBFIX) \
00785 void NAME(const QVImage<TYPE,C> &image, QVImage<uChar> &buffer, QPoint destROIOffset) \
00786 { \
00787 int pBufferSize; \
00788 \
00789 IPP_DEBUG(Peaks3x3GetBufferSize, ippi ## NAME ## SUBFIX, image.getROI().width(), &pBufferSize); \
00790 buffer = QVImage<uChar>(pBufferSize,1); \
00791 }
00792
00793 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sInt, 1, _32s_C1R);
00794 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sFloat, 1, _32f_C1R);
00795
00797
00799
00800 void FilterGaussGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt kernelSize)
00801 {
00802 int pBufferSize;
00803 IPP_DEBUG(FilterGaussGetBufferSize, ippiFilterGaussGetBufferSize_32f_C1R, IMAGE_ROISIZE(image), kernelSize, &pBufferSize);
00804 buffer = QVImage<uChar>(pBufferSize,1);
00805 }
00806
00807 void MinEigenValGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt apertureSize, uInt avgWindow)
00808 {
00809 int pBufferSize;
00810 IPP_DEBUG(MinEigenVal, ippiMinEigenValGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image), apertureSize, avgWindow, &pBufferSize);
00811 buffer = QVImage<uChar>(pBufferSize,1);
00812 }
00813
00814 void CannyGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00815 {
00816 int cannyBufferSize;
00817 IPP_DEBUG(CannyGetSize, ippiCannyGetSize, IMAGE_ROISIZE(src),&cannyBufferSize);
00818 buffer = QVImage<uChar>(cannyBufferSize,1);
00819 }
00820
00821 void Canny(QVImage<sShort> &derivadaX, QVImage<sShort> &derivadaY,
00822 QVImage<uChar> &destino, QVImage<uChar> &buffer, double low, double high, QPoint destROIOffset)
00823 {
00824 CHECK_COMPATIBLE_IMAGES(NAME,derivadaX, derivadaY);
00825 destino.setROI(destROIOffset.x(), destROIOffset.y(), derivadaX.getROI().width(), derivadaX.getROI().height());
00826
00827 IPP_DEBUG(Canny, ippiCanny_16s8u_C1R,
00828 PDATA_WRITE(derivadaX), derivadaX.getStep(),
00829 PDATA_WRITE(derivadaY), derivadaY.getStep(),
00830 PDATA_WRITE(destino), destino.getStep(),
00831 IMAGE_ROISIZE(derivadaX), low, high,
00832 buffer.getWriteData() );
00833 }
00834
00835 void Canny(QVImage<sFloat> &derivadaX, QVImage<sFloat> &derivadaY,
00836 QVImage<uChar> &destino, QVImage<uChar> &buffer, double low, double high, QPoint destROIOffset)
00837 {
00838 CHECK_COMPATIBLE_IMAGES(NAME,derivadaX, derivadaY);
00839 destino.setROI(destROIOffset.x(), destROIOffset.y(), derivadaX.getROI().width(), derivadaX.getROI().height());
00840
00841 IPP_DEBUG(Canny, ippiCanny_32f8u_C1R,
00842 PDATA_WRITE(derivadaX), derivadaX.getStep(),
00843 PDATA_WRITE(derivadaY), derivadaY.getStep(),
00844 PDATA_WRITE(destino), destino.getStep(),
00845 IMAGE_ROISIZE(derivadaX), low, high,
00846 buffer.getWriteData() );
00847 }
00848
00849 void MinEigenVal(const QVImage<uChar> &src, QVImage<sFloat> &mineigval, QVImage<uChar> &buffer,
00850 uInt apertureSize, uInt avgWindow, IppiKernelType kernel, QPoint destROIOffset)
00851 {
00852 Q_ASSERT_X( ( (kernel == ippKernelSobel) && (apertureSize == 3 || apertureSize == 5) ) ||
00853 ( (kernel == ippKernelSobel) && (apertureSize == 3) ),
00854 "MinEigenVal", "apertureSize value incorrect");
00855
00856 mineigval.setROI(mineigval.getAnchor().x(), mineigval.getAnchor().y(), src.getROI().width(), src.getROI().height());
00857
00858 IPP_DEBUG(MinEigenVal, ippiMinEigenVal_8u32f_C1R,
00859 PDATA_READ(src), src.getStep(),
00860 PDATA_WRITE(mineigval), mineigval.getStep(),
00861 IMAGE_ROISIZE(src), kernel, apertureSize, avgWindow, buffer.getWriteData());
00862 }
00863
00864 void FastMarchingGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer)
00865 {
00866 int bufferSize;
00867 IPP_DEBUG(CannyGetSize, ippiFastMarchingGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image),&bufferSize);
00868 buffer = QVImage<uChar>(bufferSize,1);
00869 }
00870
00871 void FastMarching(const QVImage<uChar> &mask, QVImage<sFloat> &distances, int radius, QVImage<uChar> &buffer, QPoint destROIOffset)
00872 {
00873 distances.setROI(distances.getAnchor().x(), distances.getAnchor().y(), mask.getROI().width(), mask.getROI().height());
00874
00875 IPP_DEBUG(FastMarching, ippiFastMarching_8u32f_C1R,
00876 PDATA_READ(mask), mask.getStep(),
00877 PDATA_WRITE(distances), distances.getStep(),
00878 IMAGE_ROISIZE(mask), radius, buffer.getWriteData());
00879 }
00880
00881 void Inpaint(const QVImage<uChar> &src, const QVImage<uChar> &mask, const QVImage<sFloat> &distances,
00882 QVImage<uChar> &dest, int radius, IppiInpaintFlag flag, QPoint destROIOffset)
00883 {
00884 IppiInpaintState_8u_C1R * pState;
00885
00886 IPP_DEBUG( Inpaint, ippiInpaintInitAlloc_8u_C1R, &pState, distances.getReadData(), distances.getStep(),
00887 mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00888
00889 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height());
00890
00891 IPP_DEBUG(Inpaint, ippiInpaint_8u_C1R,
00892 PDATA_READ(src), src.getStep(),
00893 PDATA_WRITE(dest), dest.getStep(),
00894 IMAGE_ROISIZE(src), pState);
00895
00896 IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C1R,pState);
00897 }
00898
00899 void Inpaint(const QVImage<uChar,3> &src, const QVImage<uChar> &mask, const QVImage<sFloat> &distances,
00900 QVImage<uChar,3> &dest, int radius, IppiInpaintFlag flag, QPoint destROIOffset)
00901 {
00902 IppiInpaintState_8u_C3R * pState;
00903
00904 IPP_DEBUG( Inpaint, ippiInpaintInitAlloc_8u_C3R, &pState, distances.getReadData(), distances.getStep(),
00905 mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00906
00907 dest.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height());
00908
00909 IPP_DEBUG(Inpaint, ippiInpaint_8u_C3R,
00910 PDATA_READ(src), src.getStep(),
00911 PDATA_WRITE(dest), dest.getStep(),
00912 IMAGE_ROISIZE(src), pState);
00913
00914 IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C3R,pState);
00915 }
00916
00917 QVector<int> HistogramRange(const QVImage<uChar, 1> &src)
00918 {
00919
00920 int nLevels = 257;
00921 sInt pLevels[nLevels];
00922 int pHist[nLevels];
00923
00924 for(sInt i=0; i<nLevels; i++)
00925 pLevels[i] = i;
00926
00927 IPP_DEBUG(HistogramRange, ippiHistogramRange_8u_C1R,
00928 PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00929 pHist, pLevels, nLevels);
00930
00932
00933 QVector< int > result(256);
00934 for (int i=0; i<result.size(); i++)
00935 result[i] = pHist[i];
00936
00937 return result;
00938 }
00939
00940 QMap<sInt, int> HistogramRange(const QVImage<uChar, 1> &src, QList<uChar> values)
00941 {
00942
00943 int nLevels = values.size();
00944 sInt pLevels[nLevels];
00945 int pHist[nLevels];
00946
00947 Q_ASSERT_X(false, "QMap<sInt, int> HistogramRange(QVImage<uChar, 1> &src, QList<uChar> values)",
00948 "Tried an user defined values QList. Functionality not implemented yet.");
00949
00950 IPP_DEBUG(HistogramRange, ippiHistogramRange_8u_C1R,
00951 PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00952 pHist, pLevels, nLevels);
00953
00955
00956 QMap<sInt, int> histogram;
00957 for (int i=0; i<nLevels; i++)
00958 histogram.insert(pLevels[i], pHist[i]);
00959
00960 return histogram;
00961 }
00962
00963
00964 void FloodFillGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00965 {
00966 int floodFillBufferSize;
00967 IPP_DEBUG(FloodFillGetSize, ippiFloodFillGetSize, IMAGE_ROISIZE(src),&floodFillBufferSize);
00968 buffer = QVImage<uChar>(floodFillBufferSize,1);
00969 }
00970
00971 #define CREATE_IPP_FUNCTION_FLOOD_FILL(NAME, CONNECTIVITY, SUBFIX, TYPE) \
00972 void NAME(QVImage<TYPE> &img, QVImage<uChar> &buffer, \
00973 uInt seedX, uInt seedY, TYPE newVal, TYPE minDelta, TYPE maxDelta) \
00974 { \
00975 IppiConnectedComp pRegion; \
00976 IPP_DEBUG(NAME, ippiFloodFill ## CONNECTIVITY ## SUBFIX, \
00977 PDATA_WRITE(img), img.getStep(), IMAGE_ROISIZE(img), \
00978 IPP_POINT(seedX, seedY), newVal, minDelta, maxDelta, \
00979 &pRegion, buffer.getWriteData()); \
00980 }
00981
00982 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillRange4Connected, _Range4Con, _8u_C1IR, uChar);
00983 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillGradient4Connected, _Grad4Con, _8u_C1IR, uChar);
00984
00985 #define CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(NAME, SUBFIX, C, TYPE) \
00986 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, const QVMatrix &rectifyingHomography, int interpolation, QPoint destROIOffset) \
00987 { \
00988 double coeffs[3][3]; \
00989 for (int i = 0; i < 3; i++) \
00990 for (int j = 0; j < 3; j++) \
00991 coeffs[i][j] = rectifyingHomography(i,j); \
00992 \
00993 IPP_DEBUG(NAME, ippi ## NAME ## SUBFIX, \
00994 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src), \
00995 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROIRECT(dest), \
00996 coeffs, interpolation); \
00997 }
00998
00999 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C1R, 1, uChar);
01000 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C3R, 3, uChar);
01001
01002 #include <qvmath/qvmatrix.h>
01003 void Filter(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVMatrix kernel, const QPoint destROIOffset)
01004 {
01005 Q_ASSERT(kernel.getCols() == kernel.getRows());
01006
01007 const int kernelSize = kernel.getCols();
01008 sFloat kernelValues[kernelSize*kernelSize];
01009 for(int i = 0; i < kernelSize; i++)
01010 for(int j = 0; j < kernelSize; j++)
01011 kernelValues[i+ kernelSize*j] = kernel(i,j);
01012
01013 dest.setROI(destROIOffset.x(), destROIOffset.y(),
01014 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1);
01015
01018 IPP_DEBUG(NAME, ippiFilter_32f_C1R,
01019 PDATA_READ(src), src.getStep(),
01020 PDATA_WRITE(dest), dest.getStep(),
01021 IMAGE_ROISIZE(dest),
01022 kernelValues, IPP_SIZE(kernelSize, kernelSize), IPP_POINT(0,0)
01023 );
01024 }
01025
01027 void FilterColumn(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint destROIOffset)
01028 {
01029 const int kernelSize = kernel.size();
01030 sFloat kernelValues[kernelSize];
01031 for(int i = 0; i < kernelSize; i++)
01032 kernelValues[i] = kernel[i];
01033
01034 dest.setROI(destROIOffset.x(), destROIOffset.y()+kernelSize,
01035 src.getROI().width(), src.getROI().height()-kernelSize+1);
01036
01037 IPP_DEBUG(NAME, ippiFilterColumn_32f_C1R,
01038 PDATA_READ(src), src.getStep(),
01039 PDATA_WRITE(dest), dest.getStep(),
01040 IMAGE_ROISIZE(dest),
01041 kernelValues, kernelSize, kernelSize
01042 );
01043 }
01044
01046 void FilterRow(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint destROIOffset)
01047 {
01048 const int kernelSize = kernel.size();
01049 sFloat kernelValues[kernelSize];
01050 for(int i = 0; i < kernelSize; i++)
01051 kernelValues[i] = kernel[i];
01052
01053 dest.setROI(destROIOffset.x()+kernelSize, destROIOffset.y(),
01054 src.getROI().width()-kernelSize+1, src.getROI().height());
01055
01056 IPP_DEBUG(NAME, ippiFilterRow_32f_C1R,
01057 PDATA_READ(src), src.getStep(),
01058 PDATA_WRITE(dest), dest.getStep(),
01059 IMAGE_ROISIZE(dest),
01060 kernelValues, kernelSize, kernelSize
01061 );
01062 }
01063
01064 void SqrIntegral(const QVImage<uChar,1> &src, QVImage<sFloat,1> &dst1, QVImageBuffer<sDouble,1> &dst2, sFloat val, sDouble valSqr, QPoint destROIOffset)
01065 {
01066 dst1.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width()+1, src.getROI().height()+1);
01067
01068 IPP_DEBUG(SqrIntegral,ippiSqrIntegral_8u32f64f_C1R,
01069 PDATA_READ(src), src.getStep(),
01070 PDATA_WRITE(dst1), dst1.getStep(),
01071 dst2.getWriteData(), dst2.getStep(),
01072 IMAGE_ROISIZE(src), val,valSqr);
01073
01074 }
01075
01076
01077 void RectStdDev(const QVImage<sFloat,1> &src1, const QVImageBuffer<sDouble,1> &src2, QVImage<sFloat,1> &dst, IppiRect rect, QPoint destROIOffset)
01078 {
01079 dst.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width()-rect.width, src1.getROI().height()-rect.height);
01080
01081 IPP_DEBUG(RectStdDev,ippiRectStdDev_32f_C1R,
01082 PDATA_READ(src1), src1.getStep(),
01083 src2.getReadData(), src2.getStep(),
01084 PDATA_WRITE(dst), dst.getStep(),
01085 IMAGE_ROISIZE(dst), rect);
01086
01087
01088 dst.resetROI();
01089
01090 }