PARP Research Group University of Murcia, Spain


src/qvip/qvipp/qvipp.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008, 2009. 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(), 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                                 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 < (int)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 * 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("YUV420ToRGB",        ippiYUV420ToRGB_8u_P3C3R,
00134                                         pSrc, srcStep,
00135                                         PDATA_WRITE(dest), dest.getStep(),
00136                                         IMAGE_ROISIZE(dest));
00137         }
00138 
00140 void RGBToYUV420(const QVImage<uChar, 3> &src, QVImage<uChar, 1> &dst1, QVImage<uChar, 1> &dst2, QVImage<uChar, 1> &dst3, const QPoint &destROIOffset)
00141         {
00142         uChar * pDst[3] = { PDATA_WRITE(dst1), PDATA_WRITE(dst2), PDATA_WRITE(dst3) };
00143         int dstStep[3] = { dst1.getStep(), dst2.getStep(), dst3.getStep() };
00144 
00145         dst1.setROI(destROIOffset.x(), destROIOffset.y(), src.getROI().width(), src.getROI().height());
00146         dst2.setROI(destROIOffset.x()/2, destROIOffset.y()/2, src.getROI().width()/2, src.getROI().height()/2);
00147         dst3.setROI(destROIOffset.x()/2, destROIOffset.y()/2, src.getROI().width()/2, src.getROI().height()/2);
00148 
00149         IPP_DEBUG("RGBToTUV420",        ippiRGBToYUV420_8u_C3P3R,
00150                                         PDATA_READ(src), src.getStep(),
00151                                         pDst, dstStep,
00152                                         IMAGE_ROISIZE(dst1));
00153         }
00154 
00155 void FilterGaussGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt kernelSize)
00156         {
00157         int pBufferSize;
00158         IPP_DEBUG(FilterGaussGetBufferSize,     ippiFilterGaussGetBufferSize_32f_C1R, IMAGE_ROISIZE(image), kernelSize, &pBufferSize);
00159         buffer = QVImage<uChar>(pBufferSize,1);
00160         }
00161 
00162 void MinEigenValGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer, uInt apertureSize, uInt avgWindow)
00163         {
00164         int pBufferSize;
00165         IPP_DEBUG(MinEigenVal,  ippiMinEigenValGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image), apertureSize, avgWindow, &pBufferSize);
00166         buffer = QVImage<uChar>(pBufferSize,1);
00167         }
00168 
00169 void CannyGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00170         {
00171         int cannyBufferSize;
00172         IPP_DEBUG(CannyGetSize, ippiCannyGetSize, IMAGE_ROISIZE(src),&cannyBufferSize);
00173         buffer = QVImage<uChar>(cannyBufferSize,1);
00174         }
00175 
00176 void FastMarchingGetBufferSize(const QVGenericImage &image, QVImage<uChar> &buffer)
00177         {
00178         int bufferSize;
00179         IPP_DEBUG(CannyGetSize, ippiFastMarchingGetBufferSize_8u32f_C1R, IMAGE_ROISIZE(image),&bufferSize);
00180         buffer = QVImage<uChar>(bufferSize,1);
00181         }
00182 
00183 // Inpainting C3
00184 void InpaintInitAllocC3(IppiInpaintState_8u_C3R **pState, const QVImage<sFloat> &distances, const QVImage<uChar> &mask,
00185         const sFloat radius, const IppiInpaintFlag flag)
00186         {
00187         IPP_DEBUG(      Inpaint, ippiInpaintInitAlloc_8u_C3R, pState, distances.getReadData(), distances.getStep(),
00188                         mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00189         }
00190 
00191 void InpaintFreeC3(IppiInpaintState_8u_C3R *pState)
00192         {
00193         IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C3R,pState);
00194         }
00195 
00196 void InpaintInitAllocC1(IppiInpaintState_8u_C1R **pState, const QVImage<sFloat> &distances, const QVImage<uChar> &mask,
00197         const sFloat radius, const IppiInpaintFlag flag)
00198         {
00199         IPP_DEBUG(      Inpaint, ippiInpaintInitAlloc_8u_C1R, pState, distances.getReadData(), distances.getStep(),
00200                         mask.getReadData(), mask.getStep(), IMAGE_ROISIZE(mask), radius, flag);
00201         }
00202 
00203 void InpaintFreeC1(IppiInpaintState_8u_C1R *pState)
00204         {
00205         IPP_DEBUG(Inpaint, ippiInpaintFree_8u_C1R,pState);
00206         }
00207 
00208 // Histogram
00209 QVector<int> HistogramRange(const QVImage<uChar, 1> &src)
00210         {
00211         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
00212         int nLevels = 257;
00213         sInt pLevels[nLevels];
00214         int pHist[nLevels];
00215         
00216         for(sInt i=0; i<nLevels; i++)
00217                 pLevels[i] = i;
00218 
00219         IPP_DEBUG(HistogramRange,       ippiHistogramRange_8u_C1R, // ippi ## NAME ## SUBFIX,
00220                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00221                                         pHist, pLevels, nLevels);
00222 
00224         // compute cumulative histogram
00225         QVector< int > result(256);
00226         for (int i=0; i<result.size(); i++)
00227                 result[i] = pHist[i];
00228 
00229         return result;
00230         }
00231 
00232 QMap<sInt, int> HistogramRange(const QVImage<uChar, 1> &src, QList<uChar> values)
00233         {
00234         // Bug: always coputes last value wrong. So we use one more value, 257, instead of 256.
00235         int nLevels = values.size();
00236         sInt pLevels[nLevels];
00237         int pHist[nLevels];
00238         
00239         Q_ASSERT_X(false, "QMap<sInt, int> HistogramRange(QVImage<uChar, 1> &src, QList<uChar> values)",
00240                         "Tried an user defined values QList. Functionality not implemented yet.");
00241 
00242         IPP_DEBUG(HistogramRange,       ippiHistogramRange_8u_C1R, // ippi ## NAME ## SUBFIX,
00243                                         PDATA_READ(src), src.getStep(), IMAGE_ROISIZE(src),
00244                                         pHist, pLevels, nLevels);
00245 
00247         // compute cumulative histogram
00248         QMap<sInt, int> histogram;
00249         for (int i=0; i<nLevels; i++)
00250                 histogram.insert(pLevels[i], pHist[i]);
00251 
00252         return histogram;
00253         }
00254 
00255 // Flood fill
00256 void    FloodFillGetSize(const QVGenericImage &src, QVImage<uChar> &buffer)
00257         {
00258         int floodFillBufferSize;
00259         IPP_DEBUG(FloodFillGetSize, ippiFloodFillGetSize, IMAGE_ROISIZE(src),&floodFillBufferSize);
00260         buffer = QVImage<uChar>(floodFillBufferSize,1);
00261         }
00262 
00263 #define CREATE_IPP_FUNCTION_FLOOD_FILL(NAME, CONNECTIVITY, SUBFIX, TYPE)                \
00264 void NAME(QVImage<TYPE> &img, QVImage<uChar> &buffer,                                   \
00265         uInt seedX, uInt seedY, TYPE newVal, TYPE minDelta, TYPE maxDelta)              \
00266         {                                                                               \
00267         IppiConnectedComp pRegion;                                                      \
00268         IPP_DEBUG(NAME,         ippiFloodFill ## CONNECTIVITY ## SUBFIX,                \
00269                                 PDATA_WRITE(img), img.getStep(), IMAGE_ROISIZE(img),    \
00270                                 IPP_POINT(seedX, seedY), newVal, minDelta, maxDelta,    \
00271                                 &pRegion, buffer.getWriteData());                       \
00272         }
00273 
00274 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillRange4Connected, _Range4Con, _8u_C1IR, uChar);
00275 CREATE_IPP_FUNCTION_FLOOD_FILL(FloodFillGradient4Connected, _Grad4Con, _8u_C1IR, uChar);
00276 
00277 #define CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(NAME, SUBFIX, C, TYPE)                                                                     \
00278 void    NAME(const QVImage<TYPE, C> &src, QVImage<TYPE, C> &dest, const QVMatrix &rectifyingHomography, int interpolation, const QPoint &/*destROIOffset*/)     \
00279         {                                                                                                                                               \
00280         double coeffs[3][3];                                                                                                                            \
00281         for (int i = 0; i < 3; i++)                                                                                                                     \
00282                 for (int j = 0; j < 3; j++)                                                                                                             \
00283                         coeffs[i][j] = rectifyingHomography(i,j);                                                                                       \
00284                                                                                                                                                         \
00285         IPP_DEBUG(NAME,         ippi ## NAME ## SUBFIX,                                                                                                 \
00286                                 src.getReadData(), IMAGE_SIZE(src), src.getStep(), IMAGE_ROIRECT(src),                                                  \
00287                                 PDATA_WRITE(dest), dest.getStep(), IMAGE_ROIRECT(dest),                                                                 \
00288                                 coeffs, interpolation);                                                                                                 \
00289         }
00290 
00291 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C1R, 1, uChar);
00292 CREATE_IPP_FUNCTION_WARP_PERSPECTIVE(WarpPerspective, _8u_C3R, 3, uChar);
00293 
00294 #include <qvmath/qvmatrix.h>
00295 void    Filter(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVMatrix kernel, const QPoint &destROIOffset)
00296         {
00297         Q_ASSERT(kernel.getCols() == kernel.getRows());
00298 
00299         const int kernelSize = kernel.getCols();
00300         sFloat kernelValues[kernelSize*kernelSize];
00301         for(int i = 0; i < kernelSize; i++)
00302                 for(int j = 0; j < kernelSize; j++)
00303                         kernelValues[i+ kernelSize*j] = kernel(i,j);
00304 
00305         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00306                 src.getROI().width()-kernelSize+1, src.getROI().height()-kernelSize+1);
00307 
00310         IPP_DEBUG(NAME,         ippiFilter_32f_C1R,
00311                                 PDATA_READ(src), src.getStep(),
00312                                 PDATA_WRITE(dest), dest.getStep(),
00313                                 IMAGE_ROISIZE(dest),
00314                                 kernelValues, IPP_SIZE(kernelSize, kernelSize), IPP_POINT(0,0)
00315                                 );
00316         }
00317 
00319 void    FilterColumn(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint &destROIOffset)
00320         {
00321         const int kernelSize = kernel.size();
00322         sFloat kernelValues[kernelSize];
00323         for(int i = 0; i < kernelSize; i++)
00324                         kernelValues[i] = kernel[i];
00325 
00326         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00327                 src.getROI().width(), src.getROI().height()-kernelSize+1);
00328 
00329         IPP_DEBUG(NAME,         ippiFilterColumn_32f_C1R,
00330                                 PDATA_READ(src), src.getStep(),
00331                                 PDATA_WRITE(dest), dest.getStep(),
00332                                 IMAGE_ROISIZE(dest),
00333                                 kernelValues, kernelSize, kernelSize-1
00334                                 );
00335         }
00336 
00338 void    FilterRow(const QVImage<sFloat> &src, QVImage<sFloat> &dest, const QVVector kernel, const QPoint &destROIOffset)
00339         {
00340         const int kernelSize = kernel.size();
00341 
00342         sFloat kernelValues[kernelSize];
00343         for(int i = 0; i < kernelSize; i++)
00344                         kernelValues[i] = kernel[i];
00345 
00346         dest.setROI(destROIOffset.x(), destROIOffset.y(),
00347                 src.getROI().width()-kernelSize+1, src.getROI().height());
00348 
00349         IPP_DEBUG(NAME,         ippiFilterRow_32f_C1R,
00350                                 PDATA_READ(src), src.getStep(),
00351                                 PDATA_WRITE(dest), dest.getStep(),
00352                                 IMAGE_ROISIZE(dest),
00353                                 kernelValues, kernelSize, kernelSize-1
00354                                 );
00355         }



QVision framework. PARP research group, copyright 2007, 2008.