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

Generated on Fri Feb 22 18:26:55 2008 for QVision by  doxygen 1.5.3