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

Generated on Fri Dec 7 12:20:59 2007 for QVision by  doxygen 1.5.3