src/qvip/qvipp/qvipp.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007. PARP Research Group.
00003  *      <http://perception.inf.um.es>
00004  *      University of Murcia, Spain.
00005  *
00006  *      This file is part of the QVision library.
00007  *
00008  *      QVision is free software: you can redistribute it and/or modify
00009  *      it under the terms of the GNU Lesser General Public License as
00010  *      published by the Free Software Foundation, version 3 of the License.
00011  *
00012  *      QVision is distributed in the hope that it will be useful,
00013  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *      GNU Lesser General Public License for more details.
00016  *
00017  *      You should have received a copy of the GNU Lesser General Public
00018  *      License along with QVision. If not, see <http://www.gnu.org/licenses/>.
00019  */
00020 
00024 
00025 #include <qvip/qvipp/qvipp.h>
00026 #include <qvmath/qvmatrix.h>
00027 
00028 // Macro to call IPP functions
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 // Reads a pointer to the image, counting the ROI
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 // Get the size of the image
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                                 /*((X) == 5 && (Y) == 5)?*/ 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 //DEFINE_IPP_FUNCTION_QVIMAGE_C3_QVIMAGE_C1(RGBToGray, sInt, _32s_C3C1R);
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 // MASK SIZED
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         /*const uInt max = (pPeakCount < maxPeakCount)?pPeakCount:maxPeakCount-1;*/     \
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 // END OF MACROS
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         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
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, // ippi ## NAME ## SUBFIX,
00928                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00929                                         pHist, pLevels, nLevels);
00930 
00932         // compute cumulative histogram
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         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
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, // ippi ## NAME ## SUBFIX,
00951                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00952                                         pHist, pLevels, nLevels);
00953 
00955         // compute cumulative histogram
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 // Flood fill
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         //OJO
01088         dst.resetROI();
01089 
01090 }

Generated on Thu Jul 17 17:23:28 2008 for QVision by  doxygen 1.5.3