src/qvip/qvipp/qvipp.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008. 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 <iostream>
00026 #include <qvipp.h>
00027 #include <QVMatrix>
00028 #include <qvip/qvipp/macros.h>
00029 
00030 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Cj_ROIOFFSET_BORDER3x3(FilterSharpen, uChar, 1, _8u_C1R);
00031 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Cj_ROIOFFSET_BORDER3x3(FilterSharpen, sFloat, 1, _32f_C1R);
00032 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_DESTIMAGE_Ti_Cj_ROIOFFSET(Copy, uChar, 3, _8u_P3C3R);
00033 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_DESTIMAGE_Ti_Cj_ROIOFFSET(Copy, uShort, 3, _16u_P3C3R);
00034 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_DESTIMAGE_Ti_Cj_ROIOFFSET(Copy, sShort, 3, _16s_P3C3R);
00035 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_DESTIMAGE_Ti_Cj_ROIOFFSET(Copy, sInt, 3, _32s_P3C3R);
00036 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_SRCIMAGE_Ti_C1_DESTIMAGE_Ti_Cj_ROIOFFSET(Copy, sFloat, 3, _32f_P3C3R);
00037 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_ROIOFFSET(Copy, uChar, 3, _8u_C3P3R);
00038 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_ROIOFFSET(Copy, uShort, 3, _16u_C3P3R);
00039 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_ROIOFFSET(Copy, sShort, 3, _16s_C3P3R);
00040 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_ROIOFFSET(Copy, sInt, 3, _32s_C3P3R);
00041 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_DESTIMAGE_Ti_C1_ROIOFFSET(Copy, sFloat, 3, _32f_C3P3R);
00042 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Ck_CHANNELNUM_ROIOFFSET(Copy, uChar, 3, 1, _8u_C3C1R);
00043 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Ck_CHANNELNUM_ROIOFFSET(Copy, uShort, 3, 1, _16u_C3C1R);
00044 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Ck_CHANNELNUM_ROIOFFSET(Copy, sShort, 3, 1, _16s_C3C1R);
00045 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Ck_CHANNELNUM_ROIOFFSET(Copy, sInt, 3, 1, _32s_C3C1R);
00046 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Ck_CHANNELNUM_ROIOFFSET(Copy, sFloat, 3, 1, _32f_C3C1R);
00047 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_SRCIMAGE_Ti_Cj_DESTIMAGE_C1_Tuchar_IPPCMPOP_ROIOFFSET(Compare, uChar, 3, _8u_C3R);
00048 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_SRCIMAGE_Ti_Cj_DESTIMAGE_C1_Tuchar_IPPCMPOP_ROIOFFSET(Compare, uShort, 3, _16u_C3R);
00049 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_SRCIMAGE_Ti_Cj_DESTIMAGE_C1_Tuchar_IPPCMPOP_ROIOFFSET(Compare, sShort, 3, _16s_C3R);
00050 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_SRCIMAGE_Ti_Cj_DESTIMAGE_C1_Tuchar_IPPCMPOP_ROIOFFSET(Compare, sFloat, 3, _32f_C3R);
00051 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Cj_BUFFERIMAGE_Ti_Cj_IPPMASKSIZE__ROIOFFSET(FilterSobelNegVertBorder, uChar, sShort, 1, _8u16s_C1R);
00052 DEFINE_IPP_FUNCTION_SRCIMAGE_Ti_Cj_DESTIMAGE_Ti_Cj_BUFFERIMAGE_Ti_Cj_IPPMASKSIZE__ROIOFFSET(FilterSobelHorizBorder, uChar, sShort, 1, _8u16s_C1R);
00053 DEFINE_IPP_FUNCTION_SRCGENERICIMAGE_DESTBUFFERIMAGE_Ti_Cj_IPPMASKSIZE__ROIOFFSET(FilterSobelNegVertGetBufferSize, uChar, sShort, 1, _8u16s_C1R);
00054 DEFINE_IPP_FUNCTION_SRCGENERICIMAGE_DESTBUFFERIMAGE_Ti_Cj_IPPMASKSIZE__ROIOFFSET(FilterSobelHorizGetBufferSize, uChar, sShort, 1, _8u16s_C1R);
00055 
00056 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(NAME, TYPE, PLANES, SUBFIX)     \
00057 void NAME(const QVImage<TYPE, PLANES> &src, QVImage<TYPE, PLANES> &dest, int interpolation)             \
00058         {                                                                                               \
00059         double  factorX = (double) dest.getROI().width() / (double) src.getROI().width(),               \
00060                 factorY = (double) dest.getROI().height() / (double) src.getROI().height();             \
00061                                                                                                         \
00062         IPP_DEBUG(NAME,         ippi ## NAME ## SUBFIX,                                                 \
00063                                 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src),  \
00064                                 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROISIZE(dest),                 \
00065                                 factorX, factorY, interpolation);                                       \
00066         }
00067 
00068 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uChar, 1, _8u_C1R);
00069 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uChar, 3, _8u_C3R);
00070 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, uShort, 1, _16u_C1R);
00071 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_DOUBLE_DOUBLE_INTERPOLATION(Resize, sFloat, 1, _32f_C1R);
00072 
00073 #define DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(NAME, TYPE, C, SUBFIX)      \
00074 void NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, QVImage<uChar> &buffer, sInt kernelSize,                 \
00075         sFloat sfloat, IppiBorderType borderType, sFloat borderValue, const QPoint &destROIOffset)                      \
00076         {                                                                                                               \
00077         dest.setROI(destROIOffset.x(), destROIOffset.y(),                                       \
00078                 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1);         \
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                                 kernelSize, sfloat, borderType, borderValue,                    \
00085                                 buffer.getWriteData());                                         \
00086         }
00087 
00088 DEFINE_IPP_FUNCTION_QVIMAGE_QVIMAGE_BUFFER_KERNELSIZE_SFLOAT_BORDERTYPE_BORDERVALUE(FilterGaussBorder, sFloat, 1, _32f_C1R);
00089 
00090 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(NAME, TYPE, C, SUBFIX)                                       \
00091 void NAME(const QVImage<TYPE, C> &img, QVImage<uChar> &buffer, QList<QPoint> &points, TYPE threshold, IppiNorm norm, uInt border, uInt maxPeakCount)    \
00092         {                                                                                                                                               \
00093         int pPeakCount;                                                                 \
00094         IppiPoint *pPeak = new IppiPoint[maxPeakCount]();                               \
00095                                                                                         \
00096         IPP_DEBUG(NAME,         ippi ## NAME ## SUBFIX,                                 \
00097                                 PDATA_READ(img), img.getStep(), IMAGE_ROISIZE(img),     \
00098                                 threshold, pPeak, maxPeakCount, &pPeakCount,            \
00099                                 norm, border, buffer.getWriteData());                   \
00100                                                                                         \
00101         /*const uInt max = (pPeakCount < maxPeakCount)?pPeakCount:maxPeakCount-1;*/     \
00102         for (int n = 0; n < maxPeakCount; n++)                                          \
00103                 points.append(QPoint(pPeak[n].x, pPeak[n].y));                          \
00104                                                                                         \
00105         delete pPeak;                                                                   \
00106         }
00107 
00108 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sInt, 1, _32s_C1R);
00109 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_THRESHOLD_PIPPIPOINT_UINT_PUINT_IPPINORM_BORDER(FindPeaks3x3, sFloat, 1, _32f_C1R);
00110 
00111 #define DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(NAME, TYPE, C, SUBFIX)                      \
00112 void NAME(const QVImage<TYPE,C> &image, QVImage<uChar> &buffer, const QPoint &destROIOffset)    \
00113         {                                                                                       \
00114         int pBufferSize;                                                                        \
00115                                                                                                 \
00116         IPP_DEBUG(Peaks3x3GetBufferSize,        ippi ## NAME ## SUBFIX,                         \
00117                                                 image.getROI().width(), &pBufferSize);          \
00118         buffer = QVImage<uChar>(pBufferSize,1);                                                 \
00119         }
00120 
00121 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sInt, 1, _32s_C1R);
00122 DEFINE_IPP_FUNCTION_QVIMAGE_BUFFER_ROIWIDTH(FindPeaks3x3GetBufferSize, sFloat, 1, _32f_C1R);
00123 
00125 void YUV420ToRGB(const QVImage<uChar, 1> &src1, const QVImage<uChar, 1> &src2, const QVImage<uChar, 1> &src3,
00126         QVImage<uChar, 3> &dest, const QPoint &destROIOffset)
00127         {
00128         const uChar * const pSrc[3] = { PDATA_READ(src1), PDATA_READ(src2), PDATA_READ(src3) };
00129         int srcStep[3] = { src1.getStep(), src2.getStep(), src3.getStep() };
00130 
00131         dest.setROI(destROIOffset.x(), destROIOffset.y(), src1.getROI().width(), src1.getROI().height());
00132 
00133         IPP_DEBUG("TUV420ToRGB",        ippiYUV420ToRGB_8u_P3C3R,
00134                                         pSrc, srcStep,
00135                                         PDATA_WRITE(dest), dest.getStep(),
00136                                         IMAGE_ROISIZE(dest));
00137         }
00138 
00139 void FilterGaussGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt kernelSize)
00140         {
00141         int pBufferSize;
00142         IPP_DEBUG(FilterGaussGetBufferSize,     ippiFilterGaussGetBufferSize_32f_C1R, IMAGE_ROISIZE(image), kernelSize, &pBufferSize);
00143         buffer = QVImage<uChar>(pBufferSize,1);
00144         }
00145 
00146 void MinEigenValGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt apertureSize, uInt avgWindow)
00147         {
00148         int pBufferSize;
00149         IPP_DEBUG(MinEigenVal,  ippiMinEigenValGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image), apertureSize, avgWindow, &pBufferSize);
00150         buffer = QVImage<uChar>(pBufferSize,1);
00151         }
00152 
00153 void CannyGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00154         {
00155         int cannyBufferSize;
00156         IPP_DEBUG(CannyGetSize, ippiCannyGetSize, IMAGE_ROISIZE(src),&cannyBufferSize);
00157         buffer = QVImage<uChar>(cannyBufferSize,1);
00158         }
00159 
00160 void FastMarchingGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer)
00161         {
00162         int bufferSize;
00163         IPP_DEBUG(CannyGetSize, ippiFastMarchingGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image),&bufferSize);
00164         buffer = QVImage<uChar>(bufferSize,1);
00165         }
00166 
00167 // Inpainting C3
00168 void InpaintInitAllocC3(IppiInpaintState_8u_C3R **pState, const QVImage<sFloat> &distances, const QVImage<uChar> &mask,
00169         const sFloat radius, const IppiInpaintFlag flag)
00170         {
00171         IPP_DEBUG(      Inpaint, ippiInpaintInitAlloc_8u_C3R, pState, distances.getReadData(), distances.getStep(),
00172                         mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00173         }
00174 
00175 void InpaintFreeC3(IppiInpaintState_8u_C3R *pState)
00176         {
00177         IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C3R,pState);
00178         }
00179 
00180 void InpaintInitAllocC1(IppiInpaintState_8u_C1R **pState, const QVImage<sFloat> &distances, const QVImage<uChar> &mask,
00181         const sFloat radius, const IppiInpaintFlag flag)
00182         {
00183         IPP_DEBUG(      Inpaint, ippiInpaintInitAlloc_8u_C1R, pState, distances.getReadData(), distances.getStep(),
00184                         mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00185         }
00186 
00187 void InpaintFreeC1(IppiInpaintState_8u_C1R *pState)
00188         {
00189         IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C1R,pState);
00190         }
00191 
00192 // Histogram
00193 QVector<int> HistogramRange(const QVImage<uChar, 1> &src)
00194         {
00195         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
00196         int nLevels = 257;
00197         sInt pLevels[nLevels];
00198         int pHist[nLevels];
00199         
00200         for(sInt i=0; i<nLevels; i++)
00201                 pLevels[i] = i;
00202 
00203         IPP_DEBUG(HistogramRange,       ippiHistogramRange_8u_C1R, // ippi ## NAME ## SUBFIX,
00204                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00205                                         pHist, pLevels, nLevels);
00206 
00208         // compute cumulative histogram
00209         QVector< int > result(256);
00210         for (int i=0; i<result.size(); i++)
00211                 result[i] = pHist[i];
00212 
00213         return result;
00214         }
00215 
00216 QMap<sInt, int> HistogramRange(const QVImage<uChar, 1> &src, QList<uChar> values)
00217         {
00218         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
00219         int nLevels = values.size();
00220         sInt pLevels[nLevels];
00221         int pHist[nLevels];
00222         
00223         Q_ASSERT_X(false, "QMap<sInt, int> HistogramRange(QVImage<uChar, 1> &src, QList<uChar> values)",
00224                         "Tried an user defined values QList. Functionality not implemented yet.");
00225 
00226         IPP_DEBUG(HistogramRange,       ippiHistogramRange_8u_C1R, // ippi ## NAME ## SUBFIX,
00227                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00228                                         pHist, pLevels, nLevels);
00229 
00231         // compute cumulative histogram
00232         QMap<sInt, int> histogram;
00233         for (int i=0; i<nLevels; i++)
00234                 histogram.insert(pLevels[i], pHist[i]);
00235 
00236         return histogram;
00237         }
00238 
00239 // Flood fill
00240 void    FloodFillGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00241         {
00242         int floodFillBufferSize;
00243         IPP_DEBUG(FloodFillGetSize, ippiFloodFillGetSize, IMAGE_ROISIZE(src),&floodFillBufferSize);
00244         buffer = QVImage<uChar>(floodFillBufferSize,1);
00245         }
00246 
00247 #define CREATE_IPP_FUNCTION_FLOOD_FILL(NAME, CONNECTIVITY, SUBFIX, TYPE)                \
00248 void NAME(QVImage<TYPE> &img, QVImage<uChar> &buffer,                                   \
00249         uInt seedX, uInt seedY, TYPE newVal, TYPE minDelta, TYPE maxDelta)              \
00250         {                                                                               \
00251         IppiConnectedComp pRegion;                                                      \
00252         IPP_DEBUG(NAME,         ippiFloodFill ## CONNECTIVITY ## SUBFIX,                \
00253                                 PDATA_WRITE(img), img.getStep(), IMAGE_ROISIZE(img),    \
00254                                 IPP_POINT(seedX, seedY), newVal, minDelta, maxDelta,    \
00255                                 &pRegion, buffer.getWriteData());                       \
00256         }
00257 
00258 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillRange4Connected, _Range4Con, _8u_C1IR, uChar);
00259 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillGradient4Connected, _Grad4Con, _8u_C1IR, uChar);
00260 
00261 #define CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(NAME, SUBFIX, C, TYPE)                                                                     \
00262 void    NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, const QVMatrix &rectifyingHomography, int interpolation, const QPoint &destROIOffset) \
00263         {                                                                                                                                               \
00264         double coeffs[3][3];                                                                                                                            \
00265         for (int i = 0; i < 3; i++)                                                                                                                     \
00266                 for (int j = 0; j < 3; j++)                                                                                                             \
00267                         coeffs[i][j] = rectifyingHomography(i,j);                                                                                       \
00268                                                                                                                                                         \
00269         IPP_DEBUG(NAME,         ippi ## NAME ## SUBFIX,                                                                                                 \
00270                                 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src),                                                  \
00271                                 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROIRECT(dest),                                                                 \
00272                                 coeffs, interpolation);                                                                                                 \
00273         }
00274 
00275 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C1R, 1, uChar);
00276 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C3R, 3, uChar);
00277 
00278 #include <qvmath/qvmatrix.h>
00279 void    Filter(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVMatrix kernel, const QPoint &destROIOffset)
00280         {
00281         Q_ASSERT(kernel.getCols() == kernel.getRows());
00282 
00283         const int kernelSize = kernel.getCols();
00284         sFloat kernelValues[kernelSize*kernelSize];
00285         for(int i = 0; i < kernelSize; i++)
00286                 for(int j = 0; j < kernelSize; j++)
00287                         kernelValues[i+ kernelSize*j] = kernel(i,j);
00288 
00289         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00290                 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1);
00291 
00294         IPP_DEBUG(NAME,         ippiFilter_32f_C1R,
00295                                 PDATA_READ(src), src.getStep(),
00296                                 PDATA_WRITE(dest), dest.getStep(),
00297                                 IMAGE_ROISIZE(dest),
00298                                 kernelValues, IPP_SIZE(kernelSize, kernelSize), IPP_POINT(0,0)
00299                                 );
00300         }
00301 
00303 void    FilterColumn(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint &destROIOffset)
00304         {
00305         const int kernelSize = kernel.size();
00306         sFloat kernelValues[kernelSize];
00307         for(int i = 0; i < kernelSize; i++)
00308                         kernelValues[i] = kernel[i];
00309 
00310         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00311                 src.getROI().width(), src.getROI().height()-kernelSize+1);
00312 
00313         IPP_DEBUG(NAME,         ippiFilterColumn_32f_C1R,
00314                                 PDATA_READ(src), src.getStep(),
00315                                 PDATA_WRITE(dest), dest.getStep(),
00316                                 IMAGE_ROISIZE(dest),
00317                                 kernelValues, kernelSize, kernelSize
00318                                 );
00319         }
00320 
00322 void    FilterRow(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint &destROIOffset)
00323         {
00324         const int kernelSize = kernel.size();
00325         sFloat kernelValues[kernelSize];
00326         for(int i = 0; i < kernelSize; i++)
00327                         kernelValues[i] = kernel[i];
00328 
00329         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00330                 src.getROI().width()-kernelSize+1, src.getROI().height());
00331 
00332         IPP_DEBUG(NAME,         ippiFilterRow_32f_C1R,
00333                                 PDATA_READ(src), src.getStep(),
00334                                 PDATA_WRITE(dest), dest.getStep(),
00335                                 IMAGE_ROISIZE(dest),
00336                                 kernelValues, kernelSize, kernelSize
00337                                 );
00338         }
00339