PARP Research Group University of Murcia, Spain


src/qvip/qvipp/qvippfunctions.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 <qvip/qvipp/macros.h>
00026 #include <qvip/qvipp/qvippfunctions.h>
00027 
00028 // QVision wrapper function for IPP's ippiConvert_8u16u_C1R
00029 void Convert(
00030                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00031                 QVImage<Ipp16u, 1> & qvimage_pDst,
00032                 const QPoint &destROIOffset)
00033         {
00034         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00035 
00036         IPP_DEBUG(Convert, ippiConvert_8u16u_C1R,
00037                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00038                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00039                 IMAGE_ROISIZE(qvimage_pDst));
00040         }
00041 
00042 // QVision wrapper function for IPP's ippiConvert_8u16s_C1R
00043 void Convert(
00044                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00045                 QVImage<Ipp16s, 1> & qvimage_pDst,
00046                 const QPoint &destROIOffset)
00047         {
00048         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00049 
00050         IPP_DEBUG(Convert, ippiConvert_8u16s_C1R,
00051                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00052                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00053                 IMAGE_ROISIZE(qvimage_pDst));
00054         }
00055 
00056 // QVision wrapper function for IPP's ippiConvert_8u32s_C1R
00057 void Convert(
00058                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00059                 QVImage<Ipp32s, 1> & qvimage_pDst,
00060                 const QPoint &destROIOffset)
00061         {
00062         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00063 
00064         IPP_DEBUG(Convert, ippiConvert_8u32s_C1R,
00065                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00066                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00067                 IMAGE_ROISIZE(qvimage_pDst));
00068         }
00069 
00070 // QVision wrapper function for IPP's ippiConvert_8u32f_C1R
00071 void Convert(
00072                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00073                 QVImage<Ipp32f, 1> & qvimage_pDst,
00074                 const QPoint &destROIOffset)
00075         {
00076         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00077 
00078         IPP_DEBUG(Convert, ippiConvert_8u32f_C1R,
00079                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00080                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00081                 IMAGE_ROISIZE(qvimage_pDst));
00082         }
00083 
00084 // QVision wrapper function for IPP's ippiConvert_8u16u_C3R
00085 void Convert(
00086                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00087                 QVImage<Ipp16u, 3> & qvimage_pDst,
00088                 const QPoint &destROIOffset)
00089         {
00090         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00091 
00092         IPP_DEBUG(Convert, ippiConvert_8u16u_C3R,
00093                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00094                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00095                 IMAGE_ROISIZE(qvimage_pDst));
00096         }
00097 
00098 // QVision wrapper function for IPP's ippiConvert_8u16s_C3R
00099 void Convert(
00100                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00101                 QVImage<Ipp16s, 3> & qvimage_pDst,
00102                 const QPoint &destROIOffset)
00103         {
00104         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00105 
00106         IPP_DEBUG(Convert, ippiConvert_8u16s_C3R,
00107                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00108                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00109                 IMAGE_ROISIZE(qvimage_pDst));
00110         }
00111 
00112 // QVision wrapper function for IPP's ippiConvert_8u32s_C3R
00113 void Convert(
00114                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00115                 QVImage<Ipp32s, 3> & qvimage_pDst,
00116                 const QPoint &destROIOffset)
00117         {
00118         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00119 
00120         IPP_DEBUG(Convert, ippiConvert_8u32s_C3R,
00121                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00122                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00123                 IMAGE_ROISIZE(qvimage_pDst));
00124         }
00125 
00126 // QVision wrapper function for IPP's ippiConvert_8u32f_C3R
00127 void Convert(
00128                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00129                 QVImage<Ipp32f, 3> & qvimage_pDst,
00130                 const QPoint &destROIOffset)
00131         {
00132         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00133 
00134         IPP_DEBUG(Convert, ippiConvert_8u32f_C3R,
00135                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00136                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00137                 IMAGE_ROISIZE(qvimage_pDst));
00138         }
00139 
00140 // QVision wrapper function for IPP's ippiConvert_16u8u_C1R
00141 void Convert(
00142                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
00143                 QVImage<Ipp8u, 1> & qvimage_pDst,
00144                 const QPoint &destROIOffset)
00145         {
00146         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00147 
00148         IPP_DEBUG(Convert, ippiConvert_16u8u_C1R,
00149                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00150                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00151                 IMAGE_ROISIZE(qvimage_pDst));
00152         }
00153 
00154 // QVision wrapper function for IPP's ippiConvert_16u32s_C1R
00155 void Convert(
00156                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
00157                 QVImage<Ipp32s, 1> & qvimage_pDst,
00158                 const QPoint &destROIOffset)
00159         {
00160         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00161 
00162         IPP_DEBUG(Convert, ippiConvert_16u32s_C1R,
00163                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00164                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00165                 IMAGE_ROISIZE(qvimage_pDst));
00166         }
00167 
00168 // QVision wrapper function for IPP's ippiConvert_16u32f_C1R
00169 void Convert(
00170                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
00171                 QVImage<Ipp32f, 1> & qvimage_pDst,
00172                 const QPoint &destROIOffset)
00173         {
00174         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00175 
00176         IPP_DEBUG(Convert, ippiConvert_16u32f_C1R,
00177                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00178                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00179                 IMAGE_ROISIZE(qvimage_pDst));
00180         }
00181 
00182 // QVision wrapper function for IPP's ippiConvert_16u8u_C3R
00183 void Convert(
00184                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
00185                 QVImage<Ipp8u, 3> & qvimage_pDst,
00186                 const QPoint &destROIOffset)
00187         {
00188         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00189 
00190         IPP_DEBUG(Convert, ippiConvert_16u8u_C3R,
00191                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00192                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00193                 IMAGE_ROISIZE(qvimage_pDst));
00194         }
00195 
00196 // QVision wrapper function for IPP's ippiConvert_16u32s_C3R
00197 void Convert(
00198                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
00199                 QVImage<Ipp32s, 3> & qvimage_pDst,
00200                 const QPoint &destROIOffset)
00201         {
00202         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00203 
00204         IPP_DEBUG(Convert, ippiConvert_16u32s_C3R,
00205                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00206                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00207                 IMAGE_ROISIZE(qvimage_pDst));
00208         }
00209 
00210 // QVision wrapper function for IPP's ippiConvert_16u32f_C3R
00211 void Convert(
00212                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
00213                 QVImage<Ipp32f, 3> & qvimage_pDst,
00214                 const QPoint &destROIOffset)
00215         {
00216         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00217 
00218         IPP_DEBUG(Convert, ippiConvert_16u32f_C3R,
00219                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00220                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00221                 IMAGE_ROISIZE(qvimage_pDst));
00222         }
00223 
00224 // QVision wrapper function for IPP's ippiConvert_16s8u_C1R
00225 void Convert(
00226                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
00227                 QVImage<Ipp8u, 1> & qvimage_pDst,
00228                 const QPoint &destROIOffset)
00229         {
00230         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00231 
00232         IPP_DEBUG(Convert, ippiConvert_16s8u_C1R,
00233                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00234                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00235                 IMAGE_ROISIZE(qvimage_pDst));
00236         }
00237 
00238 // QVision wrapper function for IPP's ippiConvert_16s32s_C1R
00239 void Convert(
00240                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
00241                 QVImage<Ipp32s, 1> & qvimage_pDst,
00242                 const QPoint &destROIOffset)
00243         {
00244         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00245 
00246         IPP_DEBUG(Convert, ippiConvert_16s32s_C1R,
00247                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00248                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00249                 IMAGE_ROISIZE(qvimage_pDst));
00250         }
00251 
00252 // QVision wrapper function for IPP's ippiConvert_16s32f_C1R
00253 void Convert(
00254                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
00255                 QVImage<Ipp32f, 1> & qvimage_pDst,
00256                 const QPoint &destROIOffset)
00257         {
00258         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00259 
00260         IPP_DEBUG(Convert, ippiConvert_16s32f_C1R,
00261                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00262                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00263                 IMAGE_ROISIZE(qvimage_pDst));
00264         }
00265 
00266 // QVision wrapper function for IPP's ippiConvert_16s8u_C3R
00267 void Convert(
00268                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
00269                 QVImage<Ipp8u, 3> & qvimage_pDst,
00270                 const QPoint &destROIOffset)
00271         {
00272         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00273 
00274         IPP_DEBUG(Convert, ippiConvert_16s8u_C3R,
00275                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00276                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00277                 IMAGE_ROISIZE(qvimage_pDst));
00278         }
00279 
00280 // QVision wrapper function for IPP's ippiConvert_16s32s_C3R
00281 void Convert(
00282                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
00283                 QVImage<Ipp32s, 3> & qvimage_pDst,
00284                 const QPoint &destROIOffset)
00285         {
00286         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00287 
00288         IPP_DEBUG(Convert, ippiConvert_16s32s_C3R,
00289                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00290                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00291                 IMAGE_ROISIZE(qvimage_pDst));
00292         }
00293 
00294 // QVision wrapper function for IPP's ippiConvert_16s32f_C3R
00295 void Convert(
00296                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
00297                 QVImage<Ipp32f, 3> & qvimage_pDst,
00298                 const QPoint &destROIOffset)
00299         {
00300         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00301 
00302         IPP_DEBUG(Convert, ippiConvert_16s32f_C3R,
00303                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00304                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00305                 IMAGE_ROISIZE(qvimage_pDst));
00306         }
00307 
00308 // QVision wrapper function for IPP's ippiConvert_32s8u_C1R
00309 void Convert(
00310                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
00311                 QVImage<Ipp8u, 1> & qvimage_pDst,
00312                 const QPoint &destROIOffset)
00313         {
00314         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00315 
00316         IPP_DEBUG(Convert, ippiConvert_32s8u_C1R,
00317                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00318                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00319                 IMAGE_ROISIZE(qvimage_pDst));
00320         }
00321 
00322 // QVision wrapper function for IPP's ippiConvert_32s8u_C3R
00323 void Convert(
00324                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
00325                 QVImage<Ipp8u, 3> & qvimage_pDst,
00326                 const QPoint &destROIOffset)
00327         {
00328         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00329 
00330         IPP_DEBUG(Convert, ippiConvert_32s8u_C3R,
00331                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00332                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00333                 IMAGE_ROISIZE(qvimage_pDst));
00334         }
00335 
00336 // QVision wrapper function for IPP's ippiConvert_32f8u_C1R
00337 void Convert(
00338                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
00339                 QVImage<Ipp8u, 1> & qvimage_pDst,
00340                 const IppRoundMode roundMode,
00341                 const QPoint &destROIOffset)
00342         {
00343         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00344 
00345         IPP_DEBUG(Convert, ippiConvert_32f8u_C1R,
00346                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00347                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00348                 IMAGE_ROISIZE(qvimage_pDst),
00349                 roundMode);
00350         }
00351 
00352 // QVision wrapper function for IPP's ippiConvert_32f16u_C1R
00353 void Convert(
00354                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
00355                 QVImage<Ipp16u, 1> & qvimage_pDst,
00356                 const IppRoundMode roundMode,
00357                 const QPoint &destROIOffset)
00358         {
00359         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00360 
00361         IPP_DEBUG(Convert, ippiConvert_32f16u_C1R,
00362                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00363                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00364                 IMAGE_ROISIZE(qvimage_pDst),
00365                 roundMode);
00366         }
00367 
00368 // QVision wrapper function for IPP's ippiConvert_32f16s_C1R
00369 void Convert(
00370                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
00371                 QVImage<Ipp16s, 1> & qvimage_pDst,
00372                 const IppRoundMode roundMode,
00373                 const QPoint &destROIOffset)
00374         {
00375         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00376 
00377         IPP_DEBUG(Convert, ippiConvert_32f16s_C1R,
00378                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00379                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00380                 IMAGE_ROISIZE(qvimage_pDst),
00381                 roundMode);
00382         }
00383 
00384 // QVision wrapper function for IPP's ippiConvert_32f8u_C3R
00385 void Convert(
00386                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
00387                 QVImage<Ipp8u, 3> & qvimage_pDst,
00388                 const IppRoundMode roundMode,
00389                 const QPoint &destROIOffset)
00390         {
00391         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00392 
00393         IPP_DEBUG(Convert, ippiConvert_32f8u_C3R,
00394                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00395                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00396                 IMAGE_ROISIZE(qvimage_pDst),
00397                 roundMode);
00398         }
00399 
00400 // QVision wrapper function for IPP's ippiConvert_32f16u_C3R
00401 void Convert(
00402                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
00403                 QVImage<Ipp16u, 3> & qvimage_pDst,
00404                 const IppRoundMode roundMode,
00405                 const QPoint &destROIOffset)
00406         {
00407         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00408 
00409         IPP_DEBUG(Convert, ippiConvert_32f16u_C3R,
00410                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00411                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00412                 IMAGE_ROISIZE(qvimage_pDst),
00413                 roundMode);
00414         }
00415 
00416 // QVision wrapper function for IPP's ippiConvert_32f16s_C3R
00417 void Convert(
00418                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
00419                 QVImage<Ipp16s, 3> & qvimage_pDst,
00420                 const IppRoundMode roundMode,
00421                 const QPoint &destROIOffset)
00422         {
00423         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00424 
00425         IPP_DEBUG(Convert, ippiConvert_32f16s_C3R,
00426                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00427                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00428                 IMAGE_ROISIZE(qvimage_pDst),
00429                 roundMode);
00430         }
00431 
00432 // QVision wrapper function for IPP's ippiScale_8u16u_C1R
00433 void Scale(
00434                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00435                 QVImage<Ipp16u, 1> & qvimage_pDst,
00436                 const QPoint &destROIOffset)
00437         {
00438         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00439 
00440         IPP_DEBUG(Scale, ippiScale_8u16u_C1R,
00441                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00442                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00443                 IMAGE_ROISIZE(qvimage_pDst));
00444         }
00445 
00446 // QVision wrapper function for IPP's ippiScale_8u16s_C1R
00447 void Scale(
00448                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00449                 QVImage<Ipp16s, 1> & qvimage_pDst,
00450                 const QPoint &destROIOffset)
00451         {
00452         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00453 
00454         IPP_DEBUG(Scale, ippiScale_8u16s_C1R,
00455                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00456                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00457                 IMAGE_ROISIZE(qvimage_pDst));
00458         }
00459 
00460 // QVision wrapper function for IPP's ippiScale_8u32s_C1R
00461 void Scale(
00462                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00463                 QVImage<Ipp32s, 1> & qvimage_pDst,
00464                 const QPoint &destROIOffset)
00465         {
00466         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00467 
00468         IPP_DEBUG(Scale, ippiScale_8u32s_C1R,
00469                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00470                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00471                 IMAGE_ROISIZE(qvimage_pDst));
00472         }
00473 
00474 // QVision wrapper function for IPP's ippiScale_8u16u_C3R
00475 void Scale(
00476                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00477                 QVImage<Ipp16u, 3> & qvimage_pDst,
00478                 const QPoint &destROIOffset)
00479         {
00480         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00481 
00482         IPP_DEBUG(Scale, ippiScale_8u16u_C3R,
00483                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00484                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00485                 IMAGE_ROISIZE(qvimage_pDst));
00486         }
00487 
00488 // QVision wrapper function for IPP's ippiScale_8u16s_C3R
00489 void Scale(
00490                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00491                 QVImage<Ipp16s, 3> & qvimage_pDst,
00492                 const QPoint &destROIOffset)
00493         {
00494         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00495 
00496         IPP_DEBUG(Scale, ippiScale_8u16s_C3R,
00497                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00498                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00499                 IMAGE_ROISIZE(qvimage_pDst));
00500         }
00501 
00502 // QVision wrapper function for IPP's ippiScale_8u32s_C3R
00503 void Scale(
00504                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00505                 QVImage<Ipp32s, 3> & qvimage_pDst,
00506                 const QPoint &destROIOffset)
00507         {
00508         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00509 
00510         IPP_DEBUG(Scale, ippiScale_8u32s_C3R,
00511                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00512                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00513                 IMAGE_ROISIZE(qvimage_pDst));
00514         }
00515 
00516 // QVision wrapper function for IPP's ippiSet_8u_C1R
00517 void Set(
00518                 const Ipp8u value,
00519                 QVImage<Ipp8u, 1> & qvimage_pDst)
00520         {
00521         IPP_DEBUG(Set, ippiSet_8u_C1R,
00522                 value,
00523                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00524                 IMAGE_ROISIZE(qvimage_pDst));
00525         }
00526 
00527 // QVision wrapper function for IPP's ippiSet_16u_C1R
00528 void Set(
00529                 const Ipp16u value,
00530                 QVImage<Ipp16u, 1> & qvimage_pDst)
00531         {
00532         IPP_DEBUG(Set, ippiSet_16u_C1R,
00533                 value,
00534                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00535                 IMAGE_ROISIZE(qvimage_pDst));
00536         }
00537 
00538 // QVision wrapper function for IPP's ippiSet_16s_C1R
00539 void Set(
00540                 const Ipp16s value,
00541                 QVImage<Ipp16s, 1> & qvimage_pDst)
00542         {
00543         IPP_DEBUG(Set, ippiSet_16s_C1R,
00544                 value,
00545                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00546                 IMAGE_ROISIZE(qvimage_pDst));
00547         }
00548 
00549 // QVision wrapper function for IPP's ippiSet_32s_C1R
00550 void Set(
00551                 const Ipp32s value,
00552                 QVImage<Ipp32s, 1> & qvimage_pDst)
00553         {
00554         IPP_DEBUG(Set, ippiSet_32s_C1R,
00555                 value,
00556                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00557                 IMAGE_ROISIZE(qvimage_pDst));
00558         }
00559 
00560 // QVision wrapper function for IPP's ippiSet_32f_C1R
00561 void Set(
00562                 const Ipp32f value,
00563                 QVImage<Ipp32f, 1> & qvimage_pDst)
00564         {
00565         IPP_DEBUG(Set, ippiSet_32f_C1R,
00566                 value,
00567                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00568                 IMAGE_ROISIZE(qvimage_pDst));
00569         }
00570 
00571 // QVision wrapper function for IPP's ippiSet_8u_C3R
00572 void Set(
00573                 const  Ipp8u value[3],
00574                 QVImage<Ipp8u, 3> & qvimage_pDst)
00575         {
00576         IPP_DEBUG(Set, ippiSet_8u_C3R,
00577                 value,
00578                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00579                 IMAGE_ROISIZE(qvimage_pDst));
00580         }
00581 
00582 // QVision wrapper function for IPP's ippiSet_16u_C3R
00583 void Set(
00584                 const  Ipp16u value[3],
00585                 QVImage<Ipp16u, 3> & qvimage_pDst)
00586         {
00587         IPP_DEBUG(Set, ippiSet_16u_C3R,
00588                 value,
00589                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00590                 IMAGE_ROISIZE(qvimage_pDst));
00591         }
00592 
00593 // QVision wrapper function for IPP's ippiSet_16s_C3R
00594 void Set(
00595                 const  Ipp16s value[3],
00596                 QVImage<Ipp16s, 3> & qvimage_pDst)
00597         {
00598         IPP_DEBUG(Set, ippiSet_16s_C3R,
00599                 value,
00600                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00601                 IMAGE_ROISIZE(qvimage_pDst));
00602         }
00603 
00604 // QVision wrapper function for IPP's ippiSet_32s_C3R
00605 void Set(
00606                 const  Ipp32s value[3],
00607                 QVImage<Ipp32s, 3> & qvimage_pDst)
00608         {
00609         IPP_DEBUG(Set, ippiSet_32s_C3R,
00610                 value,
00611                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00612                 IMAGE_ROISIZE(qvimage_pDst));
00613         }
00614 
00615 // QVision wrapper function for IPP's ippiSet_32f_C3R
00616 void Set(
00617                 const  Ipp32f value[3],
00618                 QVImage<Ipp32f, 3> & qvimage_pDst)
00619         {
00620         IPP_DEBUG(Set, ippiSet_32f_C3R,
00621                 value,
00622                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00623                 IMAGE_ROISIZE(qvimage_pDst));
00624         }
00625 
00626 // QVision wrapper function for IPP's ippiCopy_8u_C1R
00627 void Copy(
00628                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
00629                 QVImage<Ipp8u, 1> & qvimage_pDst,
00630                 const QPoint &destROIOffset)
00631         {
00632         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00633 
00634         IPP_DEBUG(Copy, ippiCopy_8u_C1R,
00635                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00636                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00637                 IMAGE_ROISIZE(qvimage_pDst));
00638         }
00639 
00640 // QVision wrapper function for IPP's ippiCopy_8u_C3R
00641 void Copy(
00642                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
00643                 QVImage<Ipp8u, 3> & qvimage_pDst,
00644                 const QPoint &destROIOffset)
00645         {
00646         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00647 
00648         IPP_DEBUG(Copy, ippiCopy_8u_C3R,
00649                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00650                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00651                 IMAGE_ROISIZE(qvimage_pDst));
00652         }
00653 
00654 // QVision wrapper function for IPP's ippiCopy_16u_C1R
00655 void Copy(
00656                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
00657                 QVImage<Ipp16u, 1> & qvimage_pDst,
00658                 const QPoint &destROIOffset)
00659         {
00660         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00661 
00662         IPP_DEBUG(Copy, ippiCopy_16u_C1R,
00663                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00664                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00665                 IMAGE_ROISIZE(qvimage_pDst));
00666         }
00667 
00668 // QVision wrapper function for IPP's ippiCopy_16u_C3R
00669 void Copy(
00670                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
00671                 QVImage<Ipp16u, 3> & qvimage_pDst,
00672                 const QPoint &destROIOffset)
00673         {
00674         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00675 
00676         IPP_DEBUG(Copy, ippiCopy_16u_C3R,
00677                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00678                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00679                 IMAGE_ROISIZE(qvimage_pDst));
00680         }
00681 
00682 // QVision wrapper function for IPP's ippiCopy_16s_C1R
00683 void Copy(
00684                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
00685                 QVImage<Ipp16s, 1> & qvimage_pDst,
00686                 const QPoint &destROIOffset)
00687         {
00688         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00689 
00690         IPP_DEBUG(Copy, ippiCopy_16s_C1R,
00691                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00692                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00693                 IMAGE_ROISIZE(qvimage_pDst));
00694         }
00695 
00696 // QVision wrapper function for IPP's ippiCopy_16s_C3R
00697 void Copy(
00698                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
00699                 QVImage<Ipp16s, 3> & qvimage_pDst,
00700                 const QPoint &destROIOffset)
00701         {
00702         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00703 
00704         IPP_DEBUG(Copy, ippiCopy_16s_C3R,
00705                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00706                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00707                 IMAGE_ROISIZE(qvimage_pDst));
00708         }
00709 
00710 // QVision wrapper function for IPP's ippiCopy_32s_C1R
00711 void Copy(
00712                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
00713                 QVImage<Ipp32s, 1> & qvimage_pDst,
00714                 const QPoint &destROIOffset)
00715         {
00716         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00717 
00718         IPP_DEBUG(Copy, ippiCopy_32s_C1R,
00719                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00720                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00721                 IMAGE_ROISIZE(qvimage_pDst));
00722         }
00723 
00724 // QVision wrapper function for IPP's ippiCopy_32s_C3R
00725 void Copy(
00726                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
00727                 QVImage<Ipp32s, 3> & qvimage_pDst,
00728                 const QPoint &destROIOffset)
00729         {
00730         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00731 
00732         IPP_DEBUG(Copy, ippiCopy_32s_C3R,
00733                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00734                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00735                 IMAGE_ROISIZE(qvimage_pDst));
00736         }
00737 
00738 // QVision wrapper function for IPP's ippiCopy_32f_C1R
00739 void Copy(
00740                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
00741                 QVImage<Ipp32f, 1> & qvimage_pDst,
00742                 const QPoint &destROIOffset)
00743         {
00744         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00745 
00746         IPP_DEBUG(Copy, ippiCopy_32f_C1R,
00747                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00748                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00749                 IMAGE_ROISIZE(qvimage_pDst));
00750         }
00751 
00752 // QVision wrapper function for IPP's ippiCopy_32f_C3R
00753 void Copy(
00754                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
00755                 QVImage<Ipp32f, 3> & qvimage_pDst,
00756                 const QPoint &destROIOffset)
00757         {
00758         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
00759 
00760         IPP_DEBUG(Copy, ippiCopy_32f_C3R,
00761                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
00762                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00763                 IMAGE_ROISIZE(qvimage_pDst));
00764         }
00765 
00766 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_8u_C1IR
00767 void AddRandUniform_Direct(
00768                 QVImage<Ipp8u, 1> & qvimage_pSrcDst,
00769                 const Ipp8u low,
00770                 const Ipp8u high,
00771                  unsigned int & pSeed)
00772         {
00773         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_8u_C1IR,
00774                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00775                 IMAGE_ROISIZE(qvimage_pSrcDst),
00776                 low,
00777                 high,
00778                 & pSeed);
00779         }
00780 
00781 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_16u_C1IR
00782 void AddRandUniform_Direct(
00783                 QVImage<Ipp16u, 1> & qvimage_pSrcDst,
00784                 const Ipp16u low,
00785                 const Ipp16u high,
00786                  unsigned int & pSeed)
00787         {
00788         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_16u_C1IR,
00789                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00790                 IMAGE_ROISIZE(qvimage_pSrcDst),
00791                 low,
00792                 high,
00793                 & pSeed);
00794         }
00795 
00796 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_16s_C1IR
00797 void AddRandUniform_Direct(
00798                 QVImage<Ipp16s, 1> & qvimage_pSrcDst,
00799                 const Ipp16s low,
00800                 const Ipp16s high,
00801                  unsigned int & pSeed)
00802         {
00803         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_16s_C1IR,
00804                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00805                 IMAGE_ROISIZE(qvimage_pSrcDst),
00806                 low,
00807                 high,
00808                 & pSeed);
00809         }
00810 
00811 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_32f_C1IR
00812 void AddRandUniform_Direct(
00813                 QVImage<Ipp32f, 1> & qvimage_pSrcDst,
00814                 const Ipp32f low,
00815                 const Ipp32f high,
00816                  unsigned int & pSeed)
00817         {
00818         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_32f_C1IR,
00819                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00820                 IMAGE_ROISIZE(qvimage_pSrcDst),
00821                 low,
00822                 high,
00823                 & pSeed);
00824         }
00825 
00826 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_8u_C3IR
00827 void AddRandUniform_Direct(
00828                 QVImage<Ipp8u, 3> & qvimage_pSrcDst,
00829                 const Ipp8u low,
00830                 const Ipp8u high,
00831                  unsigned int & pSeed)
00832         {
00833         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_8u_C3IR,
00834                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00835                 IMAGE_ROISIZE(qvimage_pSrcDst),
00836                 low,
00837                 high,
00838                 & pSeed);
00839         }
00840 
00841 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_16u_C3IR
00842 void AddRandUniform_Direct(
00843                 QVImage<Ipp16u, 3> & qvimage_pSrcDst,
00844                 const Ipp16u low,
00845                 const Ipp16u high,
00846                  unsigned int & pSeed)
00847         {
00848         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_16u_C3IR,
00849                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00850                 IMAGE_ROISIZE(qvimage_pSrcDst),
00851                 low,
00852                 high,
00853                 & pSeed);
00854         }
00855 
00856 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_16s_C3IR
00857 void AddRandUniform_Direct(
00858                 QVImage<Ipp16s, 3> & qvimage_pSrcDst,
00859                 const Ipp16s low,
00860                 const Ipp16s high,
00861                  unsigned int & pSeed)
00862         {
00863         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_16s_C3IR,
00864                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00865                 IMAGE_ROISIZE(qvimage_pSrcDst),
00866                 low,
00867                 high,
00868                 & pSeed);
00869         }
00870 
00871 // QVision wrapper function for IPP's ippiAddRandUniform_Direct_32f_C3IR
00872 void AddRandUniform_Direct(
00873                 QVImage<Ipp32f, 3> & qvimage_pSrcDst,
00874                 const Ipp32f low,
00875                 const Ipp32f high,
00876                  unsigned int & pSeed)
00877         {
00878         IPP_DEBUG(AddRandUniform_Direct, ippiAddRandUniform_Direct_32f_C3IR,
00879                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
00880                 IMAGE_ROISIZE(qvimage_pSrcDst),
00881                 low,
00882                 high,
00883                 & pSeed);
00884         }
00885 
00886 // QVision wrapper function for IPP's ippiAdd_8u_C1RSfs
00887 void Add(
00888                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
00889                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
00890                 QVImage<Ipp8u, 1> & qvimage_pDst,
00891                 const int scaleFactor,
00892                 const QPoint &destROIOffset)
00893         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00894 
00895         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00896 
00897         IPP_DEBUG(Add, ippiAdd_8u_C1RSfs,
00898                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00899                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00900                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00901                 IMAGE_ROISIZE(qvimage_pDst),
00902                 scaleFactor);
00903         }
00904 
00905 // QVision wrapper function for IPP's ippiAdd_8u_C3RSfs
00906 void Add(
00907                 const QVImage<Ipp8u, 3> & qvimage_pSrc1,
00908                 const QVImage<Ipp8u, 3> & qvimage_pSrc2,
00909                 QVImage<Ipp8u, 3> & qvimage_pDst,
00910                 const int scaleFactor,
00911                 const QPoint &destROIOffset)
00912         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00913 
00914         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00915 
00916         IPP_DEBUG(Add, ippiAdd_8u_C3RSfs,
00917                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00918                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00919                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00920                 IMAGE_ROISIZE(qvimage_pDst),
00921                 scaleFactor);
00922         }
00923 
00924 // QVision wrapper function for IPP's ippiAdd_16u_C1RSfs
00925 void Add(
00926                 const QVImage<Ipp16u, 1> & qvimage_pSrc1,
00927                 const QVImage<Ipp16u, 1> & qvimage_pSrc2,
00928                 QVImage<Ipp16u, 1> & qvimage_pDst,
00929                 const int scaleFactor,
00930                 const QPoint &destROIOffset)
00931         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00932 
00933         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00934 
00935         IPP_DEBUG(Add, ippiAdd_16u_C1RSfs,
00936                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00937                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00938                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00939                 IMAGE_ROISIZE(qvimage_pDst),
00940                 scaleFactor);
00941         }
00942 
00943 // QVision wrapper function for IPP's ippiAdd_16u_C3RSfs
00944 void Add(
00945                 const QVImage<Ipp16u, 3> & qvimage_pSrc1,
00946                 const QVImage<Ipp16u, 3> & qvimage_pSrc2,
00947                 QVImage<Ipp16u, 3> & qvimage_pDst,
00948                 const int scaleFactor,
00949                 const QPoint &destROIOffset)
00950         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00951 
00952         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00953 
00954         IPP_DEBUG(Add, ippiAdd_16u_C3RSfs,
00955                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00956                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00957                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00958                 IMAGE_ROISIZE(qvimage_pDst),
00959                 scaleFactor);
00960         }
00961 
00962 // QVision wrapper function for IPP's ippiAdd_16s_C1RSfs
00963 void Add(
00964                 const QVImage<Ipp16s, 1> & qvimage_pSrc1,
00965                 const QVImage<Ipp16s, 1> & qvimage_pSrc2,
00966                 QVImage<Ipp16s, 1> & qvimage_pDst,
00967                 const int scaleFactor,
00968                 const QPoint &destROIOffset)
00969         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00970 
00971         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00972 
00973         IPP_DEBUG(Add, ippiAdd_16s_C1RSfs,
00974                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00975                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00976                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00977                 IMAGE_ROISIZE(qvimage_pDst),
00978                 scaleFactor);
00979         }
00980 
00981 // QVision wrapper function for IPP's ippiAdd_16s_C3RSfs
00982 void Add(
00983                 const QVImage<Ipp16s, 3> & qvimage_pSrc1,
00984                 const QVImage<Ipp16s, 3> & qvimage_pSrc2,
00985                 QVImage<Ipp16s, 3> & qvimage_pDst,
00986                 const int scaleFactor,
00987                 const QPoint &destROIOffset)
00988         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
00989 
00990         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
00991 
00992         IPP_DEBUG(Add, ippiAdd_16s_C3RSfs,
00993                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
00994                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
00995                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
00996                 IMAGE_ROISIZE(qvimage_pDst),
00997                 scaleFactor);
00998         }
00999 
01000 // QVision wrapper function for IPP's ippiAdd_32f_C1R
01001 void Add(
01002                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
01003                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
01004                 QVImage<Ipp32f, 1> & qvimage_pDst,
01005                 const QPoint &destROIOffset)
01006         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01007 
01008         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01009 
01010         IPP_DEBUG(Add, ippiAdd_32f_C1R,
01011                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01012                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01013                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01014                 IMAGE_ROISIZE(qvimage_pDst));
01015         }
01016 
01017 // QVision wrapper function for IPP's ippiAdd_32f_C3R
01018 void Add(
01019                 const QVImage<Ipp32f, 3> & qvimage_pSrc1,
01020                 const QVImage<Ipp32f, 3> & qvimage_pSrc2,
01021                 QVImage<Ipp32f, 3> & qvimage_pDst,
01022                 const QPoint &destROIOffset)
01023         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01024 
01025         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01026 
01027         IPP_DEBUG(Add, ippiAdd_32f_C3R,
01028                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01029                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01030                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01031                 IMAGE_ROISIZE(qvimage_pDst));
01032         }
01033 
01034 // QVision wrapper function for IPP's ippiAddC_8u_C1RSfs
01035 void AddC(
01036                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
01037                 const Ipp8u value,
01038                 QVImage<Ipp8u, 1> & qvimage_pDst,
01039                 const int scaleFactor,
01040                 const QPoint &destROIOffset)
01041         {
01042         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01043 
01044         IPP_DEBUG(AddC, ippiAddC_8u_C1RSfs,
01045                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01046                 value,
01047                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01048                 IMAGE_ROISIZE(qvimage_pDst),
01049                 scaleFactor);
01050         }
01051 
01052 // QVision wrapper function for IPP's ippiAddC_8u_C3RSfs
01053 void AddC(
01054                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
01055                 const  Ipp8u value[3],
01056                 QVImage<Ipp8u, 3> & qvimage_pDst,
01057                 const int scaleFactor,
01058                 const QPoint &destROIOffset)
01059         {
01060         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01061 
01062         IPP_DEBUG(AddC, ippiAddC_8u_C3RSfs,
01063                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01064                 value,
01065                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01066                 IMAGE_ROISIZE(qvimage_pDst),
01067                 scaleFactor);
01068         }
01069 
01070 // QVision wrapper function for IPP's ippiAddC_16u_C1RSfs
01071 void AddC(
01072                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
01073                 const Ipp16u value,
01074                 QVImage<Ipp16u, 1> & qvimage_pDst,
01075                 const int scaleFactor,
01076                 const QPoint &destROIOffset)
01077         {
01078         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01079 
01080         IPP_DEBUG(AddC, ippiAddC_16u_C1RSfs,
01081                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01082                 value,
01083                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01084                 IMAGE_ROISIZE(qvimage_pDst),
01085                 scaleFactor);
01086         }
01087 
01088 // QVision wrapper function for IPP's ippiAddC_16u_C3RSfs
01089 void AddC(
01090                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
01091                 const  Ipp16u value[3],
01092                 QVImage<Ipp16u, 3> & qvimage_pDst,
01093                 const int scaleFactor,
01094                 const QPoint &destROIOffset)
01095         {
01096         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01097 
01098         IPP_DEBUG(AddC, ippiAddC_16u_C3RSfs,
01099                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01100                 value,
01101                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01102                 IMAGE_ROISIZE(qvimage_pDst),
01103                 scaleFactor);
01104         }
01105 
01106 // QVision wrapper function for IPP's ippiAddC_16s_C1RSfs
01107 void AddC(
01108                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
01109                 const Ipp16s value,
01110                 QVImage<Ipp16s, 1> & qvimage_pDst,
01111                 const int scaleFactor,
01112                 const QPoint &destROIOffset)
01113         {
01114         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01115 
01116         IPP_DEBUG(AddC, ippiAddC_16s_C1RSfs,
01117                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01118                 value,
01119                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01120                 IMAGE_ROISIZE(qvimage_pDst),
01121                 scaleFactor);
01122         }
01123 
01124 // QVision wrapper function for IPP's ippiAddC_16s_C3RSfs
01125 void AddC(
01126                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
01127                 const  Ipp16s value[3],
01128                 QVImage<Ipp16s, 3> & qvimage_pDst,
01129                 const int scaleFactor,
01130                 const QPoint &destROIOffset)
01131         {
01132         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01133 
01134         IPP_DEBUG(AddC, ippiAddC_16s_C3RSfs,
01135                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01136                 value,
01137                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01138                 IMAGE_ROISIZE(qvimage_pDst),
01139                 scaleFactor);
01140         }
01141 
01142 // QVision wrapper function for IPP's ippiAddC_32f_C1R
01143 void AddC(
01144                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
01145                 const Ipp32f value,
01146                 QVImage<Ipp32f, 1> & qvimage_pDst,
01147                 const QPoint &destROIOffset)
01148         {
01149         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01150 
01151         IPP_DEBUG(AddC, ippiAddC_32f_C1R,
01152                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01153                 value,
01154                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01155                 IMAGE_ROISIZE(qvimage_pDst));
01156         }
01157 
01158 // QVision wrapper function for IPP's ippiAddC_32f_C3R
01159 void AddC(
01160                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
01161                 const  Ipp32f value[3],
01162                 QVImage<Ipp32f, 3> & qvimage_pDst,
01163                 const QPoint &destROIOffset)
01164         {
01165         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01166 
01167         IPP_DEBUG(AddC, ippiAddC_32f_C3R,
01168                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01169                 value,
01170                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01171                 IMAGE_ROISIZE(qvimage_pDst));
01172         }
01173 
01174 // QVision wrapper function for IPP's ippiMul_8u_C1RSfs
01175 void Mul(
01176                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
01177                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
01178                 QVImage<Ipp8u, 1> & qvimage_pDst,
01179                 const int scaleFactor,
01180                 const QPoint &destROIOffset)
01181         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01182 
01183         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01184 
01185         IPP_DEBUG(Mul, ippiMul_8u_C1RSfs,
01186                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01187                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01188                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01189                 IMAGE_ROISIZE(qvimage_pDst),
01190                 scaleFactor);
01191         }
01192 
01193 // QVision wrapper function for IPP's ippiMul_8u_C3RSfs
01194 void Mul(
01195                 const QVImage<Ipp8u, 3> & qvimage_pSrc1,
01196                 const QVImage<Ipp8u, 3> & qvimage_pSrc2,
01197                 QVImage<Ipp8u, 3> & qvimage_pDst,
01198                 const int scaleFactor,
01199                 const QPoint &destROIOffset)
01200         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01201 
01202         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01203 
01204         IPP_DEBUG(Mul, ippiMul_8u_C3RSfs,
01205                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01206                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01207                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01208                 IMAGE_ROISIZE(qvimage_pDst),
01209                 scaleFactor);
01210         }
01211 
01212 // QVision wrapper function for IPP's ippiMul_16u_C1RSfs
01213 void Mul(
01214                 const QVImage<Ipp16u, 1> & qvimage_pSrc1,
01215                 const QVImage<Ipp16u, 1> & qvimage_pSrc2,
01216                 QVImage<Ipp16u, 1> & qvimage_pDst,
01217                 const int scaleFactor,
01218                 const QPoint &destROIOffset)
01219         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01220 
01221         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01222 
01223         IPP_DEBUG(Mul, ippiMul_16u_C1RSfs,
01224                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01225                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01226                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01227                 IMAGE_ROISIZE(qvimage_pDst),
01228                 scaleFactor);
01229         }
01230 
01231 // QVision wrapper function for IPP's ippiMul_16u_C3RSfs
01232 void Mul(
01233                 const QVImage<Ipp16u, 3> & qvimage_pSrc1,
01234                 const QVImage<Ipp16u, 3> & qvimage_pSrc2,
01235                 QVImage<Ipp16u, 3> & qvimage_pDst,
01236                 const int scaleFactor,
01237                 const QPoint &destROIOffset)
01238         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01239 
01240         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01241 
01242         IPP_DEBUG(Mul, ippiMul_16u_C3RSfs,
01243                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01244                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01245                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01246                 IMAGE_ROISIZE(qvimage_pDst),
01247                 scaleFactor);
01248         }
01249 
01250 // QVision wrapper function for IPP's ippiMul_16s_C1RSfs
01251 void Mul(
01252                 const QVImage<Ipp16s, 1> & qvimage_pSrc1,
01253                 const QVImage<Ipp16s, 1> & qvimage_pSrc2,
01254                 QVImage<Ipp16s, 1> & qvimage_pDst,
01255                 const int scaleFactor,
01256                 const QPoint &destROIOffset)
01257         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01258 
01259         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01260 
01261         IPP_DEBUG(Mul, ippiMul_16s_C1RSfs,
01262                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01263                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01264                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01265                 IMAGE_ROISIZE(qvimage_pDst),
01266                 scaleFactor);
01267         }
01268 
01269 // QVision wrapper function for IPP's ippiMul_16s_C3RSfs
01270 void Mul(
01271                 const QVImage<Ipp16s, 3> & qvimage_pSrc1,
01272                 const QVImage<Ipp16s, 3> & qvimage_pSrc2,
01273                 QVImage<Ipp16s, 3> & qvimage_pDst,
01274                 const int scaleFactor,
01275                 const QPoint &destROIOffset)
01276         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01277 
01278         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01279 
01280         IPP_DEBUG(Mul, ippiMul_16s_C3RSfs,
01281                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01282                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01283                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01284                 IMAGE_ROISIZE(qvimage_pDst),
01285                 scaleFactor);
01286         }
01287 
01288 // QVision wrapper function for IPP's ippiMul_32f_C3R
01289 void Mul(
01290                 const QVImage<Ipp32f, 3> & qvimage_pSrc1,
01291                 const QVImage<Ipp32f, 3> & qvimage_pSrc2,
01292                 QVImage<Ipp32f, 3> & qvimage_pDst,
01293                 const QPoint &destROIOffset)
01294         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01295 
01296         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01297 
01298         IPP_DEBUG(Mul, ippiMul_32f_C3R,
01299                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01300                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01301                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01302                 IMAGE_ROISIZE(qvimage_pDst));
01303         }
01304 
01305 // QVision wrapper function for IPP's ippiMul_32f_C1R
01306 void Mul(
01307                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
01308                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
01309                 QVImage<Ipp32f, 1> & qvimage_pDst,
01310                 const QPoint &destROIOffset)
01311         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01312 
01313         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01314 
01315         IPP_DEBUG(Mul, ippiMul_32f_C1R,
01316                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01317                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01318                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01319                 IMAGE_ROISIZE(qvimage_pDst));
01320         }
01321 
01322 // QVision wrapper function for IPP's ippiMulC_8u_C1RSfs
01323 void MulC(
01324                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
01325                 const Ipp8u value,
01326                 QVImage<Ipp8u, 1> & qvimage_pDst,
01327                 const int scaleFactor,
01328                 const QPoint &destROIOffset)
01329         {
01330         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01331 
01332         IPP_DEBUG(MulC, ippiMulC_8u_C1RSfs,
01333                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01334                 value,
01335                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01336                 IMAGE_ROISIZE(qvimage_pDst),
01337                 scaleFactor);
01338         }
01339 
01340 // QVision wrapper function for IPP's ippiMulC_8u_C3RSfs
01341 void MulC(
01342                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
01343                 const  Ipp8u value[3],
01344                 QVImage<Ipp8u, 3> & qvimage_pDst,
01345                 const int scaleFactor,
01346                 const QPoint &destROIOffset)
01347         {
01348         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01349 
01350         IPP_DEBUG(MulC, ippiMulC_8u_C3RSfs,
01351                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01352                 value,
01353                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01354                 IMAGE_ROISIZE(qvimage_pDst),
01355                 scaleFactor);
01356         }
01357 
01358 // QVision wrapper function for IPP's ippiMulC_16u_C1RSfs
01359 void MulC(
01360                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
01361                 const Ipp16u value,
01362                 QVImage<Ipp16u, 1> & qvimage_pDst,
01363                 const int scaleFactor,
01364                 const QPoint &destROIOffset)
01365         {
01366         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01367 
01368         IPP_DEBUG(MulC, ippiMulC_16u_C1RSfs,
01369                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01370                 value,
01371                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01372                 IMAGE_ROISIZE(qvimage_pDst),
01373                 scaleFactor);
01374         }
01375 
01376 // QVision wrapper function for IPP's ippiMulC_16u_C3RSfs
01377 void MulC(
01378                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
01379                 const  Ipp16u value[3],
01380                 QVImage<Ipp16u, 3> & qvimage_pDst,
01381                 const int scaleFactor,
01382                 const QPoint &destROIOffset)
01383         {
01384         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01385 
01386         IPP_DEBUG(MulC, ippiMulC_16u_C3RSfs,
01387                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01388                 value,
01389                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01390                 IMAGE_ROISIZE(qvimage_pDst),
01391                 scaleFactor);
01392         }
01393 
01394 // QVision wrapper function for IPP's ippiMulC_16s_C1RSfs
01395 void MulC(
01396                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
01397                 const Ipp16s value,
01398                 QVImage<Ipp16s, 1> & qvimage_pDst,
01399                 const int scaleFactor,
01400                 const QPoint &destROIOffset)
01401         {
01402         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01403 
01404         IPP_DEBUG(MulC, ippiMulC_16s_C1RSfs,
01405                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01406                 value,
01407                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01408                 IMAGE_ROISIZE(qvimage_pDst),
01409                 scaleFactor);
01410         }
01411 
01412 // QVision wrapper function for IPP's ippiMulC_16s_C3RSfs
01413 void MulC(
01414                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
01415                 const  Ipp16s value[3],
01416                 QVImage<Ipp16s, 3> & qvimage_pDst,
01417                 const int scaleFactor,
01418                 const QPoint &destROIOffset)
01419         {
01420         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01421 
01422         IPP_DEBUG(MulC, ippiMulC_16s_C3RSfs,
01423                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01424                 value,
01425                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01426                 IMAGE_ROISIZE(qvimage_pDst),
01427                 scaleFactor);
01428         }
01429 
01430 // QVision wrapper function for IPP's ippiMulC_32f_C1R
01431 void MulC(
01432                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
01433                 const Ipp32f value,
01434                 QVImage<Ipp32f, 1> & qvimage_pDst,
01435                 const QPoint &destROIOffset)
01436         {
01437         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01438 
01439         IPP_DEBUG(MulC, ippiMulC_32f_C1R,
01440                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01441                 value,
01442                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01443                 IMAGE_ROISIZE(qvimage_pDst));
01444         }
01445 
01446 // QVision wrapper function for IPP's ippiMulC_32f_C3R
01447 void MulC(
01448                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
01449                 const  Ipp32f value[3],
01450                 QVImage<Ipp32f, 3> & qvimage_pDst,
01451                 const QPoint &destROIOffset)
01452         {
01453         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01454 
01455         IPP_DEBUG(MulC, ippiMulC_32f_C3R,
01456                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01457                 value,
01458                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01459                 IMAGE_ROISIZE(qvimage_pDst));
01460         }
01461 
01462 // QVision wrapper function for IPP's ippiMulScale_8u_C1R
01463 void MulScale(
01464                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
01465                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
01466                 QVImage<Ipp8u, 1> & qvimage_pDst,
01467                 const QPoint &destROIOffset)
01468         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01469 
01470         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01471 
01472         IPP_DEBUG(MulScale, ippiMulScale_8u_C1R,
01473                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01474                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01475                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01476                 IMAGE_ROISIZE(qvimage_pDst));
01477         }
01478 
01479 // QVision wrapper function for IPP's ippiMulScale_8u_C3R
01480 void MulScale(
01481                 const QVImage<Ipp8u, 3> & qvimage_pSrc1,
01482                 const QVImage<Ipp8u, 3> & qvimage_pSrc2,
01483                 QVImage<Ipp8u, 3> & qvimage_pDst,
01484                 const QPoint &destROIOffset)
01485         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01486 
01487         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01488 
01489         IPP_DEBUG(MulScale, ippiMulScale_8u_C3R,
01490                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01491                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01492                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01493                 IMAGE_ROISIZE(qvimage_pDst));
01494         }
01495 
01496 // QVision wrapper function for IPP's ippiSub_8u_C1RSfs
01497 void Sub(
01498                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
01499                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
01500                 QVImage<Ipp8u, 1> & qvimage_pDst,
01501                 const int scaleFactor,
01502                 const QPoint &destROIOffset)
01503         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01504 
01505         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01506 
01507         IPP_DEBUG(Sub, ippiSub_8u_C1RSfs,
01508                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01509                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01510                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01511                 IMAGE_ROISIZE(qvimage_pDst),
01512                 scaleFactor);
01513         }
01514 
01515 // QVision wrapper function for IPP's ippiSub_8u_C3RSfs
01516 void Sub(
01517                 const QVImage<Ipp8u, 3> & qvimage_pSrc1,
01518                 const QVImage<Ipp8u, 3> & qvimage_pSrc2,
01519                 QVImage<Ipp8u, 3> & qvimage_pDst,
01520                 const int scaleFactor,
01521                 const QPoint &destROIOffset)
01522         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01523 
01524         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01525 
01526         IPP_DEBUG(Sub, ippiSub_8u_C3RSfs,
01527                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01528                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01529                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01530                 IMAGE_ROISIZE(qvimage_pDst),
01531                 scaleFactor);
01532         }
01533 
01534 // QVision wrapper function for IPP's ippiSub_16u_C1RSfs
01535 void Sub(
01536                 const QVImage<Ipp16u, 1> & qvimage_pSrc1,
01537                 const QVImage<Ipp16u, 1> & qvimage_pSrc2,
01538                 QVImage<Ipp16u, 1> & qvimage_pDst,
01539                 const int scaleFactor,
01540                 const QPoint &destROIOffset)
01541         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01542 
01543         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01544 
01545         IPP_DEBUG(Sub, ippiSub_16u_C1RSfs,
01546                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01547                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01548                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01549                 IMAGE_ROISIZE(qvimage_pDst),
01550                 scaleFactor);
01551         }
01552 
01553 // QVision wrapper function for IPP's ippiSub_16u_C3RSfs
01554 void Sub(
01555                 const QVImage<Ipp16u, 3> & qvimage_pSrc1,
01556                 const QVImage<Ipp16u, 3> & qvimage_pSrc2,
01557                 QVImage<Ipp16u, 3> & qvimage_pDst,
01558                 const int scaleFactor,
01559                 const QPoint &destROIOffset)
01560         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01561 
01562         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01563 
01564         IPP_DEBUG(Sub, ippiSub_16u_C3RSfs,
01565                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01566                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01567                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01568                 IMAGE_ROISIZE(qvimage_pDst),
01569                 scaleFactor);
01570         }
01571 
01572 // QVision wrapper function for IPP's ippiSub_16s_C1RSfs
01573 void Sub(
01574                 const QVImage<Ipp16s, 1> & qvimage_pSrc1,
01575                 const QVImage<Ipp16s, 1> & qvimage_pSrc2,
01576                 QVImage<Ipp16s, 1> & qvimage_pDst,
01577                 const int scaleFactor,
01578                 const QPoint &destROIOffset)
01579         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01580 
01581         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01582 
01583         IPP_DEBUG(Sub, ippiSub_16s_C1RSfs,
01584                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01585                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01586                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01587                 IMAGE_ROISIZE(qvimage_pDst),
01588                 scaleFactor);
01589         }
01590 
01591 // QVision wrapper function for IPP's ippiSub_16s_C3RSfs
01592 void Sub(
01593                 const QVImage<Ipp16s, 3> & qvimage_pSrc1,
01594                 const QVImage<Ipp16s, 3> & qvimage_pSrc2,
01595                 QVImage<Ipp16s, 3> & qvimage_pDst,
01596                 const int scaleFactor,
01597                 const QPoint &destROIOffset)
01598         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01599 
01600         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01601 
01602         IPP_DEBUG(Sub, ippiSub_16s_C3RSfs,
01603                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01604                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01605                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01606                 IMAGE_ROISIZE(qvimage_pDst),
01607                 scaleFactor);
01608         }
01609 
01610 // QVision wrapper function for IPP's ippiSub_32f_C1R
01611 void Sub(
01612                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
01613                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
01614                 QVImage<Ipp32f, 1> & qvimage_pDst,
01615                 const QPoint &destROIOffset)
01616         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01617 
01618         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01619 
01620         IPP_DEBUG(Sub, ippiSub_32f_C1R,
01621                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01622                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01623                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01624                 IMAGE_ROISIZE(qvimage_pDst));
01625         }
01626 
01627 // QVision wrapper function for IPP's ippiSub_32f_C3R
01628 void Sub(
01629                 const QVImage<Ipp32f, 3> & qvimage_pSrc1,
01630                 const QVImage<Ipp32f, 3> & qvimage_pSrc2,
01631                 QVImage<Ipp32f, 3> & qvimage_pDst,
01632                 const QPoint &destROIOffset)
01633         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01634 
01635         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01636 
01637         IPP_DEBUG(Sub, ippiSub_32f_C3R,
01638                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01639                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01640                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01641                 IMAGE_ROISIZE(qvimage_pDst));
01642         }
01643 
01644 // QVision wrapper function for IPP's ippiSubC_8u_C1RSfs
01645 void SubC(
01646                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
01647                 const Ipp8u value,
01648                 QVImage<Ipp8u, 1> & qvimage_pDst,
01649                 const int scaleFactor,
01650                 const QPoint &destROIOffset)
01651         {
01652         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01653 
01654         IPP_DEBUG(SubC, ippiSubC_8u_C1RSfs,
01655                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01656                 value,
01657                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01658                 IMAGE_ROISIZE(qvimage_pDst),
01659                 scaleFactor);
01660         }
01661 
01662 // QVision wrapper function for IPP's ippiSubC_8u_C3RSfs
01663 void SubC(
01664                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
01665                 const  Ipp8u value[3],
01666                 QVImage<Ipp8u, 3> & qvimage_pDst,
01667                 const int scaleFactor,
01668                 const QPoint &destROIOffset)
01669         {
01670         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01671 
01672         IPP_DEBUG(SubC, ippiSubC_8u_C3RSfs,
01673                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01674                 value,
01675                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01676                 IMAGE_ROISIZE(qvimage_pDst),
01677                 scaleFactor);
01678         }
01679 
01680 // QVision wrapper function for IPP's ippiSubC_16u_C1RSfs
01681 void SubC(
01682                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
01683                 const Ipp16u value,
01684                 QVImage<Ipp16u, 1> & qvimage_pDst,
01685                 const int scaleFactor,
01686                 const QPoint &destROIOffset)
01687         {
01688         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01689 
01690         IPP_DEBUG(SubC, ippiSubC_16u_C1RSfs,
01691                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01692                 value,
01693                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01694                 IMAGE_ROISIZE(qvimage_pDst),
01695                 scaleFactor);
01696         }
01697 
01698 // QVision wrapper function for IPP's ippiSubC_16s_C1RSfs
01699 void SubC(
01700                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
01701                 const Ipp16s value,
01702                 QVImage<Ipp16s, 1> & qvimage_pDst,
01703                 const int scaleFactor,
01704                 const QPoint &destROIOffset)
01705         {
01706         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01707 
01708         IPP_DEBUG(SubC, ippiSubC_16s_C1RSfs,
01709                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01710                 value,
01711                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01712                 IMAGE_ROISIZE(qvimage_pDst),
01713                 scaleFactor);
01714         }
01715 
01716 // QVision wrapper function for IPP's ippiSubC_16u_C3RSfs
01717 void SubC(
01718                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
01719                 const  Ipp16u value[3],
01720                 QVImage<Ipp16u, 3> & qvimage_pDst,
01721                 const int scaleFactor,
01722                 const QPoint &destROIOffset)
01723         {
01724         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01725 
01726         IPP_DEBUG(SubC, ippiSubC_16u_C3RSfs,
01727                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01728                 value,
01729                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01730                 IMAGE_ROISIZE(qvimage_pDst),
01731                 scaleFactor);
01732         }
01733 
01734 // QVision wrapper function for IPP's ippiSubC_16s_C3RSfs
01735 void SubC(
01736                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
01737                 const  Ipp16s value[3],
01738                 QVImage<Ipp16s, 3> & qvimage_pDst,
01739                 const int scaleFactor,
01740                 const QPoint &destROIOffset)
01741         {
01742         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01743 
01744         IPP_DEBUG(SubC, ippiSubC_16s_C3RSfs,
01745                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01746                 value,
01747                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01748                 IMAGE_ROISIZE(qvimage_pDst),
01749                 scaleFactor);
01750         }
01751 
01752 // QVision wrapper function for IPP's ippiSubC_32f_C1R
01753 void SubC(
01754                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
01755                 const Ipp32f value,
01756                 QVImage<Ipp32f, 1> & qvimage_pDst,
01757                 const QPoint &destROIOffset)
01758         {
01759         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01760 
01761         IPP_DEBUG(SubC, ippiSubC_32f_C1R,
01762                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01763                 value,
01764                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01765                 IMAGE_ROISIZE(qvimage_pDst));
01766         }
01767 
01768 // QVision wrapper function for IPP's ippiSubC_32f_C3R
01769 void SubC(
01770                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
01771                 const  Ipp32f value[3],
01772                 QVImage<Ipp32f, 3> & qvimage_pDst,
01773                 const QPoint &destROIOffset)
01774         {
01775         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01776 
01777         IPP_DEBUG(SubC, ippiSubC_32f_C3R,
01778                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01779                 value,
01780                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01781                 IMAGE_ROISIZE(qvimage_pDst));
01782         }
01783 
01784 // QVision wrapper function for IPP's ippiDiv_8u_C1RSfs
01785 void Div(
01786                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
01787                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
01788                 QVImage<Ipp8u, 1> & qvimage_pDst,
01789                 const int scaleFactor,
01790                 const QPoint &destROIOffset)
01791         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01792 
01793         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01794 
01795         IPP_DEBUG(Div, ippiDiv_8u_C1RSfs,
01796                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01797                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01798                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01799                 IMAGE_ROISIZE(qvimage_pDst),
01800                 scaleFactor);
01801         }
01802 
01803 // QVision wrapper function for IPP's ippiDiv_8u_C3RSfs
01804 void Div(
01805                 const QVImage<Ipp8u, 3> & qvimage_pSrc1,
01806                 const QVImage<Ipp8u, 3> & qvimage_pSrc2,
01807                 QVImage<Ipp8u, 3> & qvimage_pDst,
01808                 const int scaleFactor,
01809                 const QPoint &destROIOffset)
01810         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01811 
01812         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01813 
01814         IPP_DEBUG(Div, ippiDiv_8u_C3RSfs,
01815                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01816                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01817                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01818                 IMAGE_ROISIZE(qvimage_pDst),
01819                 scaleFactor);
01820         }
01821 
01822 // QVision wrapper function for IPP's ippiDiv_16u_C1RSfs
01823 void Div(
01824                 const QVImage<Ipp16u, 1> & qvimage_pSrc1,
01825                 const QVImage<Ipp16u, 1> & qvimage_pSrc2,
01826                 QVImage<Ipp16u, 1> & qvimage_pDst,
01827                 const int scaleFactor,
01828                 const QPoint &destROIOffset)
01829         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01830 
01831         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01832 
01833         IPP_DEBUG(Div, ippiDiv_16u_C1RSfs,
01834                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01835                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01836                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01837                 IMAGE_ROISIZE(qvimage_pDst),
01838                 scaleFactor);
01839         }
01840 
01841 // QVision wrapper function for IPP's ippiDiv_16u_C3RSfs
01842 void Div(
01843                 const QVImage<Ipp16u, 3> & qvimage_pSrc1,
01844                 const QVImage<Ipp16u, 3> & qvimage_pSrc2,
01845                 QVImage<Ipp16u, 3> & qvimage_pDst,
01846                 const int scaleFactor,
01847                 const QPoint &destROIOffset)
01848         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01849 
01850         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01851 
01852         IPP_DEBUG(Div, ippiDiv_16u_C3RSfs,
01853                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01854                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01855                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01856                 IMAGE_ROISIZE(qvimage_pDst),
01857                 scaleFactor);
01858         }
01859 
01860 // QVision wrapper function for IPP's ippiDiv_16s_C1RSfs
01861 void Div(
01862                 const QVImage<Ipp16s, 1> & qvimage_pSrc1,
01863                 const QVImage<Ipp16s, 1> & qvimage_pSrc2,
01864                 QVImage<Ipp16s, 1> & qvimage_pDst,
01865                 const int scaleFactor,
01866                 const QPoint &destROIOffset)
01867         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01868 
01869         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01870 
01871         IPP_DEBUG(Div, ippiDiv_16s_C1RSfs,
01872                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01873                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01874                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01875                 IMAGE_ROISIZE(qvimage_pDst),
01876                 scaleFactor);
01877         }
01878 
01879 // QVision wrapper function for IPP's ippiDiv_16s_C3RSfs
01880 void Div(
01881                 const QVImage<Ipp16s, 3> & qvimage_pSrc1,
01882                 const QVImage<Ipp16s, 3> & qvimage_pSrc2,
01883                 QVImage<Ipp16s, 3> & qvimage_pDst,
01884                 const int scaleFactor,
01885                 const QPoint &destROIOffset)
01886         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01887 
01888         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01889 
01890         IPP_DEBUG(Div, ippiDiv_16s_C3RSfs,
01891                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01892                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01893                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01894                 IMAGE_ROISIZE(qvimage_pDst),
01895                 scaleFactor);
01896         }
01897 
01898 // QVision wrapper function for IPP's ippiDiv_32f_C3R
01899 void Div(
01900                 const QVImage<Ipp32f, 3> & qvimage_pSrc1,
01901                 const QVImage<Ipp32f, 3> & qvimage_pSrc2,
01902                 QVImage<Ipp32f, 3> & qvimage_pDst,
01903                 const QPoint &destROIOffset)
01904         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01905 
01906         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01907 
01908         IPP_DEBUG(Div, ippiDiv_32f_C3R,
01909                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01910                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01911                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01912                 IMAGE_ROISIZE(qvimage_pDst));
01913         }
01914 
01915 // QVision wrapper function for IPP's ippiDiv_32f_C1R
01916 void Div(
01917                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
01918                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
01919                 QVImage<Ipp32f, 1> & qvimage_pDst,
01920                 const QPoint &destROIOffset)
01921         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
01922 
01923         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
01924 
01925         IPP_DEBUG(Div, ippiDiv_32f_C1R,
01926                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
01927                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
01928                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01929                 IMAGE_ROISIZE(qvimage_pDst));
01930         }
01931 
01932 // QVision wrapper function for IPP's ippiDivC_8u_C1RSfs
01933 void DivC(
01934                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
01935                 const Ipp8u value,
01936                 QVImage<Ipp8u, 1> & qvimage_pDst,
01937                 const int scaleFactor,
01938                 const QPoint &destROIOffset)
01939         {
01940         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01941 
01942         IPP_DEBUG(DivC, ippiDivC_8u_C1RSfs,
01943                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01944                 value,
01945                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01946                 IMAGE_ROISIZE(qvimage_pDst),
01947                 scaleFactor);
01948         }
01949 
01950 // QVision wrapper function for IPP's ippiDivC_8u_C3RSfs
01951 void DivC(
01952                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
01953                 const  Ipp8u value[3],
01954                 QVImage<Ipp8u, 3> & qvimage_pDst,
01955                 const int scaleFactor,
01956                 const QPoint &destROIOffset)
01957         {
01958         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01959 
01960         IPP_DEBUG(DivC, ippiDivC_8u_C3RSfs,
01961                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01962                 value,
01963                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01964                 IMAGE_ROISIZE(qvimage_pDst),
01965                 scaleFactor);
01966         }
01967 
01968 // QVision wrapper function for IPP's ippiDivC_16u_C1RSfs
01969 void DivC(
01970                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
01971                 const Ipp16u value,
01972                 QVImage<Ipp16u, 1> & qvimage_pDst,
01973                 const int scaleFactor,
01974                 const QPoint &destROIOffset)
01975         {
01976         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01977 
01978         IPP_DEBUG(DivC, ippiDivC_16u_C1RSfs,
01979                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01980                 value,
01981                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
01982                 IMAGE_ROISIZE(qvimage_pDst),
01983                 scaleFactor);
01984         }
01985 
01986 // QVision wrapper function for IPP's ippiDivC_16u_C3RSfs
01987 void DivC(
01988                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
01989                 const  Ipp16u value[3],
01990                 QVImage<Ipp16u, 3> & qvimage_pDst,
01991                 const int scaleFactor,
01992                 const QPoint &destROIOffset)
01993         {
01994         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
01995 
01996         IPP_DEBUG(DivC, ippiDivC_16u_C3RSfs,
01997                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
01998                 value,
01999                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02000                 IMAGE_ROISIZE(qvimage_pDst),
02001                 scaleFactor);
02002         }
02003 
02004 // QVision wrapper function for IPP's ippiDivC_16s_C1RSfs
02005 void DivC(
02006                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
02007                 const Ipp16s value,
02008                 QVImage<Ipp16s, 1> & qvimage_pDst,
02009                 const int scaleFactor,
02010                 const QPoint &destROIOffset)
02011         {
02012         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02013 
02014         IPP_DEBUG(DivC, ippiDivC_16s_C1RSfs,
02015                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02016                 value,
02017                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02018                 IMAGE_ROISIZE(qvimage_pDst),
02019                 scaleFactor);
02020         }
02021 
02022 // QVision wrapper function for IPP's ippiDivC_16s_C3RSfs
02023 void DivC(
02024                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
02025                 const  Ipp16s value[3],
02026                 QVImage<Ipp16s, 3> & qvimage_pDst,
02027                 const int scaleFactor,
02028                 const QPoint &destROIOffset)
02029         {
02030         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02031 
02032         IPP_DEBUG(DivC, ippiDivC_16s_C3RSfs,
02033                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02034                 value,
02035                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02036                 IMAGE_ROISIZE(qvimage_pDst),
02037                 scaleFactor);
02038         }
02039 
02040 // QVision wrapper function for IPP's ippiDivC_32f_C1R
02041 void DivC(
02042                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02043                 const Ipp32f value,
02044                 QVImage<Ipp32f, 1> & qvimage_pDst,
02045                 const QPoint &destROIOffset)
02046         {
02047         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02048 
02049         IPP_DEBUG(DivC, ippiDivC_32f_C1R,
02050                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02051                 value,
02052                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02053                 IMAGE_ROISIZE(qvimage_pDst));
02054         }
02055 
02056 // QVision wrapper function for IPP's ippiDivC_32f_C3R
02057 void DivC(
02058                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
02059                 const  Ipp32f value[3],
02060                 QVImage<Ipp32f, 3> & qvimage_pDst,
02061                 const QPoint &destROIOffset)
02062         {
02063         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02064 
02065         IPP_DEBUG(DivC, ippiDivC_32f_C3R,
02066                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02067                 value,
02068                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02069                 IMAGE_ROISIZE(qvimage_pDst));
02070         }
02071 
02072 // QVision wrapper function for IPP's ippiAbs_16s_C1R
02073 void Abs(
02074                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
02075                 QVImage<Ipp16s, 1> & qvimage_pDst,
02076                 const QPoint &destROIOffset)
02077         {
02078         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02079 
02080         IPP_DEBUG(Abs, ippiAbs_16s_C1R,
02081                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02082                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02083                 IMAGE_ROISIZE(qvimage_pDst));
02084         }
02085 
02086 // QVision wrapper function for IPP's ippiAbs_32f_C1R
02087 void Abs(
02088                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02089                 QVImage<Ipp32f, 1> & qvimage_pDst,
02090                 const QPoint &destROIOffset)
02091         {
02092         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02093 
02094         IPP_DEBUG(Abs, ippiAbs_32f_C1R,
02095                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02096                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02097                 IMAGE_ROISIZE(qvimage_pDst));
02098         }
02099 
02100 // QVision wrapper function for IPP's ippiAbsDiff_8u_C1R
02101 void AbsDiff(
02102                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
02103                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
02104                 QVImage<Ipp8u, 1> & qvimage_pDst,
02105                 const QPoint &destROIOffset)
02106         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
02107 
02108         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
02109 
02110         IPP_DEBUG(AbsDiff, ippiAbsDiff_8u_C1R,
02111                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
02112                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
02113                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02114                 IMAGE_ROISIZE(qvimage_pDst));
02115         }
02116 
02117 // QVision wrapper function for IPP's ippiAbsDiff_32f_C1R
02118 // Calculate absolute difference between corresponding pixels of the two images or between image pixels and scalar.
02119 void AbsDiff(
02120                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
02121                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
02122                 QVImage<Ipp32f, 1> & qvimage_pDst,
02123                 const QPoint &destROIOffset)
02124         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
02125 
02126         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
02127 
02128         IPP_DEBUG(AbsDiff, ippiAbsDiff_32f_C1R,
02129                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
02130                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
02131                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02132                 IMAGE_ROISIZE(qvimage_pDst));
02133         }
02134 
02135 // QVision wrapper function for IPP's ippiSqr_32f_C1R
02136 void Sqr(
02137                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02138                 QVImage<Ipp32f, 1> & qvimage_pDst,
02139                 const QPoint &destROIOffset)
02140         {
02141         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02142 
02143         IPP_DEBUG(Sqr, ippiSqr_32f_C1R,
02144                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02145                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02146                 IMAGE_ROISIZE(qvimage_pDst));
02147         }
02148 
02149 // QVision wrapper function for IPP's ippiLn_32f_C1R
02150 void Ln(
02151                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02152                 QVImage<Ipp32f, 1> & qvimage_pDst,
02153                 const QPoint &destROIOffset)
02154         {
02155         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02156 
02157         IPP_DEBUG(Ln, ippiLn_32f_C1R,
02158                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02159                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02160                 IMAGE_ROISIZE(qvimage_pDst));
02161         }
02162 
02163 // QVision wrapper function for IPP's ippiLn_32f_C3R
02164 void Ln(
02165                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
02166                 QVImage<Ipp32f, 3> & qvimage_pDst,
02167                 const QPoint &destROIOffset)
02168         {
02169         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02170 
02171         IPP_DEBUG(Ln, ippiLn_32f_C3R,
02172                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02173                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02174                 IMAGE_ROISIZE(qvimage_pDst));
02175         }
02176 
02177 // QVision wrapper function for IPP's ippiAndC_8u_C1R
02178 void AndC(
02179                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02180                 const Ipp8u value,
02181                 QVImage<Ipp8u, 1> & qvimage_pDst,
02182                 const QPoint &destROIOffset)
02183         {
02184         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02185 
02186         IPP_DEBUG(AndC, ippiAndC_8u_C1R,
02187                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02188                 value,
02189                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02190                 IMAGE_ROISIZE(qvimage_pDst));
02191         }
02192 
02193 // QVision wrapper function for IPP's ippiAndC_8u_C3R
02194 void AndC(
02195                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02196                 const  Ipp8u value[3],
02197                 QVImage<Ipp8u, 3> & qvimage_pDst,
02198                 const QPoint &destROIOffset)
02199         {
02200         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02201 
02202         IPP_DEBUG(AndC, ippiAndC_8u_C3R,
02203                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02204                 value,
02205                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02206                 IMAGE_ROISIZE(qvimage_pDst));
02207         }
02208 
02209 // QVision wrapper function for IPP's ippiAndC_16u_C1R
02210 void AndC(
02211                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
02212                 const Ipp16u value,
02213                 QVImage<Ipp16u, 1> & qvimage_pDst,
02214                 const QPoint &destROIOffset)
02215         {
02216         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02217 
02218         IPP_DEBUG(AndC, ippiAndC_16u_C1R,
02219                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02220                 value,
02221                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02222                 IMAGE_ROISIZE(qvimage_pDst));
02223         }
02224 
02225 // QVision wrapper function for IPP's ippiAndC_16u_C3R
02226 void AndC(
02227                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02228                 const  Ipp16u value[3],
02229                 QVImage<Ipp16u, 3> & qvimage_pDst,
02230                 const QPoint &destROIOffset)
02231         {
02232         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02233 
02234         IPP_DEBUG(AndC, ippiAndC_16u_C3R,
02235                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02236                 value,
02237                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02238                 IMAGE_ROISIZE(qvimage_pDst));
02239         }
02240 
02241 // QVision wrapper function for IPP's ippiAndC_32s_C1R
02242 void AndC(
02243                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
02244                 const Ipp32s value,
02245                 QVImage<Ipp32s, 1> & qvimage_pDst,
02246                 const QPoint &destROIOffset)
02247         {
02248         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02249 
02250         IPP_DEBUG(AndC, ippiAndC_32s_C1R,
02251                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02252                 value,
02253                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02254                 IMAGE_ROISIZE(qvimage_pDst));
02255         }
02256 
02257 // QVision wrapper function for IPP's ippiAndC_32s_C3R
02258 void AndC(
02259                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
02260                 const  Ipp32s value[3],
02261                 QVImage<Ipp32s, 3> & qvimage_pDst,
02262                 const QPoint &destROIOffset)
02263         {
02264         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02265 
02266         IPP_DEBUG(AndC, ippiAndC_32s_C3R,
02267                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02268                 value,
02269                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02270                 IMAGE_ROISIZE(qvimage_pDst));
02271         }
02272 
02273 // QVision wrapper function for IPP's ippiNot_8u_C1R
02274 void Not(
02275                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02276                 QVImage<Ipp8u, 1> & qvimage_pDst,
02277                 const QPoint &destROIOffset)
02278         {
02279         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02280 
02281         IPP_DEBUG(Not, ippiNot_8u_C1R,
02282                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02283                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02284                 IMAGE_ROISIZE(qvimage_pDst));
02285         }
02286 
02287 // QVision wrapper function for IPP's ippiNot_8u_C3R
02288 void Not(
02289                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02290                 QVImage<Ipp8u, 3> & qvimage_pDst,
02291                 const QPoint &destROIOffset)
02292         {
02293         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02294 
02295         IPP_DEBUG(Not, ippiNot_8u_C3R,
02296                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02297                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02298                 IMAGE_ROISIZE(qvimage_pDst));
02299         }
02300 
02301 // QVision wrapper function for IPP's ippiOrC_8u_C1R
02302 void OrC(
02303                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02304                 const Ipp8u value,
02305                 QVImage<Ipp8u, 1> & qvimage_pDst,
02306                 const QPoint &destROIOffset)
02307         {
02308         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02309 
02310         IPP_DEBUG(OrC, ippiOrC_8u_C1R,
02311                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02312                 value,
02313                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02314                 IMAGE_ROISIZE(qvimage_pDst));
02315         }
02316 
02317 // QVision wrapper function for IPP's ippiOrC_8u_C3R
02318 void OrC(
02319                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02320                 const  Ipp8u value[3],
02321                 QVImage<Ipp8u, 3> & qvimage_pDst,
02322                 const QPoint &destROIOffset)
02323         {
02324         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02325 
02326         IPP_DEBUG(OrC, ippiOrC_8u_C3R,
02327                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02328                 value,
02329                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02330                 IMAGE_ROISIZE(qvimage_pDst));
02331         }
02332 
02333 // QVision wrapper function for IPP's ippiOrC_16u_C1R
02334 void OrC(
02335                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
02336                 const Ipp16u value,
02337                 QVImage<Ipp16u, 1> & qvimage_pDst,
02338                 const QPoint &destROIOffset)
02339         {
02340         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02341 
02342         IPP_DEBUG(OrC, ippiOrC_16u_C1R,
02343                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02344                 value,
02345                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02346                 IMAGE_ROISIZE(qvimage_pDst));
02347         }
02348 
02349 // QVision wrapper function for IPP's ippiOrC_16u_C3R
02350 void OrC(
02351                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02352                 const  Ipp16u value[3],
02353                 QVImage<Ipp16u, 3> & qvimage_pDst,
02354                 const QPoint &destROIOffset)
02355         {
02356         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02357 
02358         IPP_DEBUG(OrC, ippiOrC_16u_C3R,
02359                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02360                 value,
02361                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02362                 IMAGE_ROISIZE(qvimage_pDst));
02363         }
02364 
02365 // QVision wrapper function for IPP's ippiOrC_32s_C1R
02366 void OrC(
02367                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
02368                 const Ipp32s value,
02369                 QVImage<Ipp32s, 1> & qvimage_pDst,
02370                 const QPoint &destROIOffset)
02371         {
02372         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02373 
02374         IPP_DEBUG(OrC, ippiOrC_32s_C1R,
02375                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02376                 value,
02377                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02378                 IMAGE_ROISIZE(qvimage_pDst));
02379         }
02380 
02381 // QVision wrapper function for IPP's ippiOrC_32s_C3R
02382 void OrC(
02383                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
02384                 const  Ipp32s value[3],
02385                 QVImage<Ipp32s, 3> & qvimage_pDst,
02386                 const QPoint &destROIOffset)
02387         {
02388         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02389 
02390         IPP_DEBUG(OrC, ippiOrC_32s_C3R,
02391                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02392                 value,
02393                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02394                 IMAGE_ROISIZE(qvimage_pDst));
02395         }
02396 
02397 // QVision wrapper function for IPP's ippiXorC_8u_C1R
02398 void XorC(
02399                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02400                 const Ipp8u value,
02401                 QVImage<Ipp8u, 1> & qvimage_pDst,
02402                 const QPoint &destROIOffset)
02403         {
02404         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02405 
02406         IPP_DEBUG(XorC, ippiXorC_8u_C1R,
02407                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02408                 value,
02409                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02410                 IMAGE_ROISIZE(qvimage_pDst));
02411         }
02412 
02413 // QVision wrapper function for IPP's ippiXorC_8u_C3R
02414 void XorC(
02415                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02416                 const  Ipp8u value[3],
02417                 QVImage<Ipp8u, 3> & qvimage_pDst,
02418                 const QPoint &destROIOffset)
02419         {
02420         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02421 
02422         IPP_DEBUG(XorC, ippiXorC_8u_C3R,
02423                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02424                 value,
02425                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02426                 IMAGE_ROISIZE(qvimage_pDst));
02427         }
02428 
02429 // QVision wrapper function for IPP's ippiXorC_16u_C1R
02430 void XorC(
02431                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
02432                 const Ipp16u value,
02433                 QVImage<Ipp16u, 1> & qvimage_pDst,
02434                 const QPoint &destROIOffset)
02435         {
02436         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02437 
02438         IPP_DEBUG(XorC, ippiXorC_16u_C1R,
02439                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02440                 value,
02441                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02442                 IMAGE_ROISIZE(qvimage_pDst));
02443         }
02444 
02445 // QVision wrapper function for IPP's ippiXorC_16u_C3R
02446 void XorC(
02447                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02448                 const  Ipp16u value[3],
02449                 QVImage<Ipp16u, 3> & qvimage_pDst,
02450                 const QPoint &destROIOffset)
02451         {
02452         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02453 
02454         IPP_DEBUG(XorC, ippiXorC_16u_C3R,
02455                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02456                 value,
02457                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02458                 IMAGE_ROISIZE(qvimage_pDst));
02459         }
02460 
02461 // QVision wrapper function for IPP's ippiXorC_32s_C1R
02462 void XorC(
02463                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
02464                 const Ipp32s value,
02465                 QVImage<Ipp32s, 1> & qvimage_pDst,
02466                 const QPoint &destROIOffset)
02467         {
02468         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02469 
02470         IPP_DEBUG(XorC, ippiXorC_32s_C1R,
02471                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02472                 value,
02473                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02474                 IMAGE_ROISIZE(qvimage_pDst));
02475         }
02476 
02477 // QVision wrapper function for IPP's ippiXorC_32s_C3R
02478 void XorC(
02479                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
02480                 const  Ipp32s value[3],
02481                 QVImage<Ipp32s, 3> & qvimage_pDst,
02482                 const QPoint &destROIOffset)
02483         {
02484         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02485 
02486         IPP_DEBUG(XorC, ippiXorC_32s_C3R,
02487                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02488                 value,
02489                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02490                 IMAGE_ROISIZE(qvimage_pDst));
02491         }
02492 
02493 // QVision wrapper function for IPP's ippiLShiftC_8u_C1R
02494 void LShiftC(
02495                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02496                 const Ipp32u value,
02497                 QVImage<Ipp8u, 1> & qvimage_pDst,
02498                 const QPoint &destROIOffset)
02499         {
02500         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02501 
02502         IPP_DEBUG(LShiftC, ippiLShiftC_8u_C1R,
02503                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02504                 value,
02505                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02506                 IMAGE_ROISIZE(qvimage_pDst));
02507         }
02508 
02509 // QVision wrapper function for IPP's ippiLShiftC_8u_C3R
02510 void LShiftC(
02511                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02512                 const  Ipp32u value[3],
02513                 QVImage<Ipp8u, 3> & qvimage_pDst,
02514                 const QPoint &destROIOffset)
02515         {
02516         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02517 
02518         IPP_DEBUG(LShiftC, ippiLShiftC_8u_C3R,
02519                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02520                 value,
02521                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02522                 IMAGE_ROISIZE(qvimage_pDst));
02523         }
02524 
02525 // QVision wrapper function for IPP's ippiRShiftC_8u_C1R
02526 void RShiftC(
02527                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02528                 const Ipp32u value,
02529                 QVImage<Ipp8u, 1> & qvimage_pDst,
02530                 const QPoint &destROIOffset)
02531         {
02532         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02533 
02534         IPP_DEBUG(RShiftC, ippiRShiftC_8u_C1R,
02535                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02536                 value,
02537                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02538                 IMAGE_ROISIZE(qvimage_pDst));
02539         }
02540 
02541 // QVision wrapper function for IPP's ippiRShiftC_8u_C3R
02542 void RShiftC(
02543                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02544                 const  Ipp32u value[3],
02545                 QVImage<Ipp8u, 3> & qvimage_pDst,
02546                 const QPoint &destROIOffset)
02547         {
02548         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02549 
02550         IPP_DEBUG(RShiftC, ippiRShiftC_8u_C3R,
02551                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02552                 value,
02553                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02554                 IMAGE_ROISIZE(qvimage_pDst));
02555         }
02556 
02557 // QVision wrapper function for IPP's ippiLShiftC_16u_C1R
02558 void LShiftC(
02559                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
02560                 const Ipp32u value,
02561                 QVImage<Ipp16u, 1> & qvimage_pDst,
02562                 const QPoint &destROIOffset)
02563         {
02564         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02565 
02566         IPP_DEBUG(LShiftC, ippiLShiftC_16u_C1R,
02567                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02568                 value,
02569                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02570                 IMAGE_ROISIZE(qvimage_pDst));
02571         }
02572 
02573 // QVision wrapper function for IPP's ippiLShiftC_16u_C3R
02574 void LShiftC(
02575                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02576                 const  Ipp32u value[3],
02577                 QVImage<Ipp16u, 3> & qvimage_pDst,
02578                 const QPoint &destROIOffset)
02579         {
02580         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02581 
02582         IPP_DEBUG(LShiftC, ippiLShiftC_16u_C3R,
02583                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02584                 value,
02585                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02586                 IMAGE_ROISIZE(qvimage_pDst));
02587         }
02588 
02589 // QVision wrapper function for IPP's ippiRShiftC_16u_C1R
02590 void RShiftC(
02591                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
02592                 const Ipp32u value,
02593                 QVImage<Ipp16u, 1> & qvimage_pDst,
02594                 const QPoint &destROIOffset)
02595         {
02596         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02597 
02598         IPP_DEBUG(RShiftC, ippiRShiftC_16u_C1R,
02599                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02600                 value,
02601                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02602                 IMAGE_ROISIZE(qvimage_pDst));
02603         }
02604 
02605 // QVision wrapper function for IPP's ippiRShiftC_16u_C3R
02606 void RShiftC(
02607                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02608                 const  Ipp32u value[3],
02609                 QVImage<Ipp16u, 3> & qvimage_pDst,
02610                 const QPoint &destROIOffset)
02611         {
02612         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02613 
02614         IPP_DEBUG(RShiftC, ippiRShiftC_16u_C3R,
02615                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02616                 value,
02617                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02618                 IMAGE_ROISIZE(qvimage_pDst));
02619         }
02620 
02621 // QVision wrapper function for IPP's ippiLShiftC_32s_C1R
02622 void LShiftC(
02623                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
02624                 const Ipp32u value,
02625                 QVImage<Ipp32s, 1> & qvimage_pDst,
02626                 const QPoint &destROIOffset)
02627         {
02628         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02629 
02630         IPP_DEBUG(LShiftC, ippiLShiftC_32s_C1R,
02631                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02632                 value,
02633                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02634                 IMAGE_ROISIZE(qvimage_pDst));
02635         }
02636 
02637 // QVision wrapper function for IPP's ippiLShiftC_32s_C3R
02638 void LShiftC(
02639                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
02640                 const  Ipp32u value[3],
02641                 QVImage<Ipp32s, 3> & qvimage_pDst,
02642                 const QPoint &destROIOffset)
02643         {
02644         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02645 
02646         IPP_DEBUG(LShiftC, ippiLShiftC_32s_C3R,
02647                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02648                 value,
02649                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02650                 IMAGE_ROISIZE(qvimage_pDst));
02651         }
02652 
02653 // QVision wrapper function for IPP's ippiRShiftC_32s_C1R
02654 void RShiftC(
02655                 const QVImage<Ipp32s, 1> & qvimage_pSrc,
02656                 const Ipp32u value,
02657                 QVImage<Ipp32s, 1> & qvimage_pDst,
02658                 const QPoint &destROIOffset)
02659         {
02660         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02661 
02662         IPP_DEBUG(RShiftC, ippiRShiftC_32s_C1R,
02663                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02664                 value,
02665                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02666                 IMAGE_ROISIZE(qvimage_pDst));
02667         }
02668 
02669 // QVision wrapper function for IPP's ippiRShiftC_32s_C3R
02670 void RShiftC(
02671                 const QVImage<Ipp32s, 3> & qvimage_pSrc,
02672                 const  Ipp32u value[3],
02673                 QVImage<Ipp32s, 3> & qvimage_pDst,
02674                 const QPoint &destROIOffset)
02675         {
02676         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02677 
02678         IPP_DEBUG(RShiftC, ippiRShiftC_32s_C3R,
02679                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02680                 value,
02681                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02682                 IMAGE_ROISIZE(qvimage_pDst));
02683         }
02684 
02685 // QVision wrapper function for IPP's ippiRGBToGray_8u_C3C1R
02686 void RGBToGray(
02687                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
02688                 QVImage<Ipp8u, 1> & qvimage_pDst,
02689                 const QPoint &destROIOffset)
02690         {
02691         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02692 
02693         IPP_DEBUG(RGBToGray, ippiRGBToGray_8u_C3C1R,
02694                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02695                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02696                 IMAGE_ROISIZE(qvimage_pDst));
02697         }
02698 
02699 // QVision wrapper function for IPP's ippiRGBToGray_16u_C3C1R
02700 void RGBToGray(
02701                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
02702                 QVImage<Ipp16u, 1> & qvimage_pDst,
02703                 const QPoint &destROIOffset)
02704         {
02705         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02706 
02707         IPP_DEBUG(RGBToGray, ippiRGBToGray_16u_C3C1R,
02708                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02709                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02710                 IMAGE_ROISIZE(qvimage_pDst));
02711         }
02712 
02713 // QVision wrapper function for IPP's ippiRGBToGray_16s_C3C1R
02714 void RGBToGray(
02715                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
02716                 QVImage<Ipp16s, 1> & qvimage_pDst,
02717                 const QPoint &destROIOffset)
02718         {
02719         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02720 
02721         IPP_DEBUG(RGBToGray, ippiRGBToGray_16s_C3C1R,
02722                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02723                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02724                 IMAGE_ROISIZE(qvimage_pDst));
02725         }
02726 
02727 // QVision wrapper function for IPP's ippiRGBToGray_32f_C3C1R
02728 void RGBToGray(
02729                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
02730                 QVImage<Ipp32f, 1> & qvimage_pDst,
02731                 const QPoint &destROIOffset)
02732         {
02733         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02734 
02735         IPP_DEBUG(RGBToGray, ippiRGBToGray_32f_C3C1R,
02736                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02737                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02738                 IMAGE_ROISIZE(qvimage_pDst));
02739         }
02740 
02741 // QVision wrapper function for IPP's ippiThreshold_8u_C1R
02742 void Threshold(
02743                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02744                 QVImage<Ipp8u, 1> & qvimage_pDst,
02745                 const Ipp8u threshold,
02746                 const IppCmpOp ippCmpOp,
02747                 const QPoint &destROIOffset)
02748         {
02749         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02750 
02751         IPP_DEBUG(Threshold, ippiThreshold_8u_C1R,
02752                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02753                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02754                 IMAGE_ROISIZE(qvimage_pDst),
02755                 threshold,
02756                 ippCmpOp);
02757         }
02758 
02759 // QVision wrapper function for IPP's ippiThreshold_8u_C1IR
02760 void Threshold(
02761                 QVImage<Ipp8u, 1> & qvimage_pSrcDst,
02762                 const Ipp8u threshold,
02763                 const IppCmpOp ippCmpOp)
02764         {
02765         IPP_DEBUG(Threshold, ippiThreshold_8u_C1IR,
02766                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02767                 IMAGE_ROISIZE(qvimage_pSrcDst),
02768                 threshold,
02769                 ippCmpOp);
02770         }
02771 
02772 // QVision wrapper function for IPP's ippiThreshold_16s_C1R
02773 void Threshold(
02774                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
02775                 QVImage<Ipp16s, 1> & qvimage_pDst,
02776                 const Ipp16s threshold,
02777                 const IppCmpOp ippCmpOp,
02778                 const QPoint &destROIOffset)
02779         {
02780         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02781 
02782         IPP_DEBUG(Threshold, ippiThreshold_16s_C1R,
02783                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02784                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02785                 IMAGE_ROISIZE(qvimage_pDst),
02786                 threshold,
02787                 ippCmpOp);
02788         }
02789 
02790 // QVision wrapper function for IPP's ippiThreshold_16s_C1IR
02791 void Threshold(
02792                 QVImage<Ipp16s, 1> & qvimage_pSrcDst,
02793                 const Ipp16s threshold,
02794                 const IppCmpOp ippCmpOp)
02795         {
02796         IPP_DEBUG(Threshold, ippiThreshold_16s_C1IR,
02797                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02798                 IMAGE_ROISIZE(qvimage_pSrcDst),
02799                 threshold,
02800                 ippCmpOp);
02801         }
02802 
02803 // QVision wrapper function for IPP's ippiThreshold_32f_C1R
02804 void Threshold(
02805                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02806                 QVImage<Ipp32f, 1> & qvimage_pDst,
02807                 const Ipp32f threshold,
02808                 const IppCmpOp ippCmpOp,
02809                 const QPoint &destROIOffset)
02810         {
02811         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02812 
02813         IPP_DEBUG(Threshold, ippiThreshold_32f_C1R,
02814                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02815                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02816                 IMAGE_ROISIZE(qvimage_pDst),
02817                 threshold,
02818                 ippCmpOp);
02819         }
02820 
02821 // QVision wrapper function for IPP's ippiThreshold_32f_C1IR
02822 void Threshold(
02823                 QVImage<Ipp32f, 1> & qvimage_pSrcDst,
02824                 const Ipp32f threshold,
02825                 const IppCmpOp ippCmpOp)
02826         {
02827         IPP_DEBUG(Threshold, ippiThreshold_32f_C1IR,
02828                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02829                 IMAGE_ROISIZE(qvimage_pSrcDst),
02830                 threshold,
02831                 ippCmpOp);
02832         }
02833 
02834 // QVision wrapper function for IPP's ippiThreshold_Val_8u_C1R
02835 void Threshold_Val(
02836                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02837                 QVImage<Ipp8u, 1> & qvimage_pDst,
02838                 const Ipp8u threshold,
02839                 const Ipp8u value,
02840                 const IppCmpOp ippCmpOp,
02841                 const QPoint &destROIOffset)
02842         {
02843         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02844 
02845         IPP_DEBUG(Threshold_Val, ippiThreshold_Val_8u_C1R,
02846                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02847                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02848                 IMAGE_ROISIZE(qvimage_pDst),
02849                 threshold,
02850                 value,
02851                 ippCmpOp);
02852         }
02853 
02854 // QVision wrapper function for IPP's ippiThreshold_Val_8u_C1IR
02855 void Threshold_Val(
02856                 QVImage<Ipp8u, 1> & qvimage_pSrcDst,
02857                 const Ipp8u threshold,
02858                 const Ipp8u value,
02859                 const IppCmpOp ippCmpOp)
02860         {
02861         IPP_DEBUG(Threshold_Val, ippiThreshold_Val_8u_C1IR,
02862                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02863                 IMAGE_ROISIZE(qvimage_pSrcDst),
02864                 threshold,
02865                 value,
02866                 ippCmpOp);
02867         }
02868 
02869 // QVision wrapper function for IPP's ippiThreshold_Val_16s_C1IR
02870 void Threshold_Val(
02871                 QVImage<Ipp16s, 1> & qvimage_pSrcDst,
02872                 const Ipp16s threshold,
02873                 const Ipp16s value,
02874                 const IppCmpOp ippCmpOp)
02875         {
02876         IPP_DEBUG(Threshold_Val, ippiThreshold_Val_16s_C1IR,
02877                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02878                 IMAGE_ROISIZE(qvimage_pSrcDst),
02879                 threshold,
02880                 value,
02881                 ippCmpOp);
02882         }
02883 
02884 // QVision wrapper function for IPP's ippiThreshold_Val_32f_C1R
02885 void Threshold_Val(
02886                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02887                 QVImage<Ipp32f, 1> & qvimage_pDst,
02888                 const Ipp32f threshold,
02889                 const Ipp32f value,
02890                 const IppCmpOp ippCmpOp,
02891                 const QPoint &destROIOffset)
02892         {
02893         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02894 
02895         IPP_DEBUG(Threshold_Val, ippiThreshold_Val_32f_C1R,
02896                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02897                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02898                 IMAGE_ROISIZE(qvimage_pDst),
02899                 threshold,
02900                 value,
02901                 ippCmpOp);
02902         }
02903 
02904 // QVision wrapper function for IPP's ippiThreshold_Val_32f_C1IR
02905 void Threshold_Val(
02906                 QVImage<Ipp32f, 1> & qvimage_pSrcDst,
02907                 const Ipp32f threshold,
02908                 const Ipp32f value,
02909                 const IppCmpOp ippCmpOp)
02910         {
02911         IPP_DEBUG(Threshold_Val, ippiThreshold_Val_32f_C1IR,
02912                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
02913                 IMAGE_ROISIZE(qvimage_pSrcDst),
02914                 threshold,
02915                 value,
02916                 ippCmpOp);
02917         }
02918 
02919 // QVision wrapper function for IPP's ippiThreshold_LTValGTVal_8u_C1R
02920 void Threshold_LTValGTVal(
02921                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02922                 QVImage<Ipp8u, 1> & qvimage_pDst,
02923                 const Ipp8u thresholdLT,
02924                 const Ipp8u valueLT,
02925                 const Ipp8u thresholdGT,
02926                 const Ipp8u valueGT,
02927                 const QPoint &destROIOffset)
02928         {
02929         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02930 
02931         IPP_DEBUG(Threshold_LTValGTVal, ippiThreshold_LTValGTVal_8u_C1R,
02932                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02933                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02934                 IMAGE_ROISIZE(qvimage_pDst),
02935                 thresholdLT,
02936                 valueLT,
02937                 thresholdGT,
02938                 valueGT);
02939         }
02940 
02941 // QVision wrapper function for IPP's ippiThreshold_LTValGTVal_32f_C1R
02942 void Threshold_LTValGTVal(
02943                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
02944                 QVImage<Ipp32f, 1> & qvimage_pDst,
02945                 const Ipp32f thresholdLT,
02946                 const Ipp32f valueLT,
02947                 const Ipp32f thresholdGT,
02948                 const Ipp32f valueGT,
02949                 const QPoint &destROIOffset)
02950         {
02951         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
02952 
02953         IPP_DEBUG(Threshold_LTValGTVal, ippiThreshold_LTValGTVal_32f_C1R,
02954                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02955                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02956                 IMAGE_ROISIZE(qvimage_pDst),
02957                 thresholdLT,
02958                 valueLT,
02959                 thresholdGT,
02960                 valueGT);
02961         }
02962 
02963 // QVision wrapper function for IPP's ippiComputeThreshold_Otsu_8u_C1R
02964 // Calculate Otsu theshold value of images.
02965 void ComputeThreshold_Otsu(
02966                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
02967                  Ipp8u & pThreshold)
02968         {
02969         IPP_DEBUG(ComputeThreshold_Otsu, ippiComputeThreshold_Otsu_8u_C1R,
02970                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
02971                 IMAGE_ROISIZE(qvimage_pSrc),
02972                 & pThreshold);
02973         }
02974 
02975 // QVision wrapper function for IPP's ippiCompare_8u_C1R
02976 void Compare(
02977                 const QVImage<Ipp8u, 1> & qvimage_pSrc1,
02978                 const QVImage<Ipp8u, 1> & qvimage_pSrc2,
02979                 QVImage<Ipp8u, 1> & qvimage_pDst,
02980                 const IppCmpOp ippCmpOp,
02981                 const QPoint &destROIOffset)
02982         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
02983 
02984         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
02985 
02986         IPP_DEBUG(Compare, ippiCompare_8u_C1R,
02987                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
02988                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
02989                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
02990                 IMAGE_ROISIZE(qvimage_pDst),
02991                 ippCmpOp);
02992         }
02993 
02994 // QVision wrapper function for IPP's ippiCompare_16u_C1R
02995 void Compare(
02996                 const QVImage<Ipp16u, 1> & qvimage_pSrc1,
02997                 const QVImage<Ipp16u, 1> & qvimage_pSrc2,
02998                 QVImage<Ipp8u, 1> & qvimage_pDst,
02999                 const IppCmpOp ippCmpOp,
03000                 const QPoint &destROIOffset)
03001         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
03002 
03003         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
03004 
03005         IPP_DEBUG(Compare, ippiCompare_16u_C1R,
03006                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
03007                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
03008                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03009                 IMAGE_ROISIZE(qvimage_pDst),
03010                 ippCmpOp);
03011         }
03012 
03013 // QVision wrapper function for IPP's ippiCompare_16s_C1R
03014 void Compare(
03015                 const QVImage<Ipp16s, 1> & qvimage_pSrc1,
03016                 const QVImage<Ipp16s, 1> & qvimage_pSrc2,
03017                 QVImage<Ipp8u, 1> & qvimage_pDst,
03018                 const IppCmpOp ippCmpOp,
03019                 const QPoint &destROIOffset)
03020         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
03021 
03022         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
03023 
03024         IPP_DEBUG(Compare, ippiCompare_16s_C1R,
03025                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
03026                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
03027                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03028                 IMAGE_ROISIZE(qvimage_pDst),
03029                 ippCmpOp);
03030         }
03031 
03032 // QVision wrapper function for IPP's ippiCompare_32f_C1R
03033 void Compare(
03034                 const QVImage<Ipp32f, 1> & qvimage_pSrc1,
03035                 const QVImage<Ipp32f, 1> & qvimage_pSrc2,
03036                 QVImage<Ipp8u, 1> & qvimage_pDst,
03037                 const IppCmpOp ippCmpOp,
03038                 const QPoint &destROIOffset)
03039         {       CHECK_SAME_ROISIZE(qvimage_pSrc1, qvimage_pSrc2);
03040 
03041         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc1, destROIOffset, 0, 0);
03042 
03043         IPP_DEBUG(Compare, ippiCompare_32f_C1R,
03044                 PDATA_READ(qvimage_pSrc1), qvimage_pSrc1.getStep(),
03045                 PDATA_READ(qvimage_pSrc2), qvimage_pSrc2.getStep(),
03046                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03047                 IMAGE_ROISIZE(qvimage_pDst),
03048                 ippCmpOp);
03049         }
03050 
03051 // QVision wrapper function for IPP's ippiCompareC_8u_C1R
03052 void CompareC(
03053                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03054                 const Ipp8u value,
03055                 QVImage<Ipp8u, 1> & qvimage_pDst,
03056                 const IppCmpOp ippCmpOp,
03057                 const QPoint &destROIOffset)
03058         {
03059         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03060 
03061         IPP_DEBUG(CompareC, ippiCompareC_8u_C1R,
03062                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03063                 value,
03064                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03065                 IMAGE_ROISIZE(qvimage_pDst),
03066                 ippCmpOp);
03067         }
03068 
03069 // QVision wrapper function for IPP's ippiCompareC_32f_C1R
03070 void CompareC(
03071                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03072                 const Ipp32f value,
03073                 QVImage<Ipp8u, 1> & qvimage_pDst,
03074                 const IppCmpOp ippCmpOp,
03075                 const QPoint &destROIOffset)
03076         {
03077         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03078 
03079         IPP_DEBUG(CompareC, ippiCompareC_32f_C1R,
03080                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03081                 value,
03082                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03083                 IMAGE_ROISIZE(qvimage_pDst),
03084                 ippCmpOp);
03085         }
03086 
03087 // QVision wrapper function for IPP's ippiDilate3x3_8u_C1R
03088 void Dilate3x3(
03089                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03090                 QVImage<Ipp8u, 1> & qvimage_pDst,
03091                 const QPoint &destROIOffset)
03092         {
03093         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03094 
03095         IPP_DEBUG(Dilate3x3, ippiDilate3x3_8u_C1R,
03096                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03097                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03098                 IMAGE_ROISIZE(qvimage_pDst));
03099         }
03100 
03101 // QVision wrapper function for IPP's ippiDilate3x3_8u_C3R
03102 void Dilate3x3(
03103                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03104                 QVImage<Ipp8u, 3> & qvimage_pDst,
03105                 const QPoint &destROIOffset)
03106         {
03107         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03108 
03109         IPP_DEBUG(Dilate3x3, ippiDilate3x3_8u_C3R,
03110                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03111                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03112                 IMAGE_ROISIZE(qvimage_pDst));
03113         }
03114 
03115 // QVision wrapper function for IPP's ippiDilate3x3_8u_C1IR
03116 void Dilate3x3(
03117                 QVImage<Ipp8u, 1> & qvimage_pSrcDst)
03118         {
03119         IPP_DEBUG(Dilate3x3, ippiDilate3x3_8u_C1IR,
03120                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
03121                 IMAGE_ROISIZE(qvimage_pSrcDst));
03122         }
03123 
03124 // QVision wrapper function for IPP's ippiDilate3x3_16u_C1R
03125 void Dilate3x3(
03126                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03127                 QVImage<Ipp16u, 1> & qvimage_pDst,
03128                 const QPoint &destROIOffset)
03129         {
03130         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03131 
03132         IPP_DEBUG(Dilate3x3, ippiDilate3x3_16u_C1R,
03133                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03134                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03135                 IMAGE_ROISIZE(qvimage_pDst));
03136         }
03137 
03138 // QVision wrapper function for IPP's ippiDilate3x3_16u_C3R
03139 void Dilate3x3(
03140                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
03141                 QVImage<Ipp16u, 3> & qvimage_pDst,
03142                 const QPoint &destROIOffset)
03143         {
03144         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03145 
03146         IPP_DEBUG(Dilate3x3, ippiDilate3x3_16u_C3R,
03147                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03148                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03149                 IMAGE_ROISIZE(qvimage_pDst));
03150         }
03151 
03152 // QVision wrapper function for IPP's ippiDilate3x3_32f_C1R
03153 void Dilate3x3(
03154                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03155                 QVImage<Ipp32f, 1> & qvimage_pDst,
03156                 const QPoint &destROIOffset)
03157         {
03158         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03159 
03160         IPP_DEBUG(Dilate3x3, ippiDilate3x3_32f_C1R,
03161                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03162                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03163                 IMAGE_ROISIZE(qvimage_pDst));
03164         }
03165 
03166 // QVision wrapper function for IPP's ippiDilate3x3_32f_C3R
03167 void Dilate3x3(
03168                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
03169                 QVImage<Ipp32f, 3> & qvimage_pDst,
03170                 const QPoint &destROIOffset)
03171         {
03172         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03173 
03174         IPP_DEBUG(Dilate3x3, ippiDilate3x3_32f_C3R,
03175                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03176                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03177                 IMAGE_ROISIZE(qvimage_pDst));
03178         }
03179 
03180 // QVision wrapper function for IPP's ippiErode3x3_8u_C1R
03181 void Erode3x3(
03182                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03183                 QVImage<Ipp8u, 1> & qvimage_pDst,
03184                 const QPoint &destROIOffset)
03185         {
03186         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03187 
03188         IPP_DEBUG(Erode3x3, ippiErode3x3_8u_C1R,
03189                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03190                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03191                 IMAGE_ROISIZE(qvimage_pDst));
03192         }
03193 
03194 // QVision wrapper function for IPP's ippiErode3x3_8u_C3R
03195 void Erode3x3(
03196                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03197                 QVImage<Ipp8u, 3> & qvimage_pDst,
03198                 const QPoint &destROIOffset)
03199         {
03200         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03201 
03202         IPP_DEBUG(Erode3x3, ippiErode3x3_8u_C3R,
03203                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03204                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03205                 IMAGE_ROISIZE(qvimage_pDst));
03206         }
03207 
03208 // QVision wrapper function for IPP's ippiErode3x3_8u_C1IR
03209 void Erode3x3(
03210                 QVImage<Ipp8u, 1> & qvimage_pSrcDst)
03211         {
03212         IPP_DEBUG(Erode3x3, ippiErode3x3_8u_C1IR,
03213                 PDATA_WRITE(qvimage_pSrcDst), qvimage_pSrcDst.getStep(),
03214                 IMAGE_ROISIZE(qvimage_pSrcDst));
03215         }
03216 
03217 // QVision wrapper function for IPP's ippiErode3x3_16u_C1R
03218 void Erode3x3(
03219                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03220                 QVImage<Ipp16u, 1> & qvimage_pDst,
03221                 const QPoint &destROIOffset)
03222         {
03223         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03224 
03225         IPP_DEBUG(Erode3x3, ippiErode3x3_16u_C1R,
03226                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03227                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03228                 IMAGE_ROISIZE(qvimage_pDst));
03229         }
03230 
03231 // QVision wrapper function for IPP's ippiErode3x3_16u_C3R
03232 void Erode3x3(
03233                 const QVImage<Ipp16u, 3> & qvimage_pSrc,
03234                 QVImage<Ipp16u, 3> & qvimage_pDst,
03235                 const QPoint &destROIOffset)
03236         {
03237         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03238 
03239         IPP_DEBUG(Erode3x3, ippiErode3x3_16u_C3R,
03240                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03241                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03242                 IMAGE_ROISIZE(qvimage_pDst));
03243         }
03244 
03245 // QVision wrapper function for IPP's ippiErode3x3_32f_C1R
03246 void Erode3x3(
03247                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03248                 QVImage<Ipp32f, 1> & qvimage_pDst,
03249                 const QPoint &destROIOffset)
03250         {
03251         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03252 
03253         IPP_DEBUG(Erode3x3, ippiErode3x3_32f_C1R,
03254                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03255                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03256                 IMAGE_ROISIZE(qvimage_pDst));
03257         }
03258 
03259 // QVision wrapper function for IPP's ippiErode3x3_32f_C3R
03260 void Erode3x3(
03261                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
03262                 QVImage<Ipp32f, 3> & qvimage_pDst,
03263                 const QPoint &destROIOffset)
03264         {
03265         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03266 
03267         IPP_DEBUG(Erode3x3, ippiErode3x3_32f_C3R,
03268                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03269                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03270                 IMAGE_ROISIZE(qvimage_pDst));
03271         }
03272 
03273 // QVision wrapper function for IPP's ippiFilterBox_8u_C1R
03274 void FilterBox(
03275                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03276                 QVImage<Ipp8u, 1> & qvimage_pDst,
03277                 const QSize &maskSize,
03278                 const QPoint &anchor,
03279                 const QPoint &destROIOffset)
03280         {
03281         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03282         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03283 
03284         IPP_DEBUG(FilterBox, ippiFilterBox_8u_C1R,
03285                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03286                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03287                 IMAGE_ROISIZE(qvimage_pDst),
03288                 IPP_SIZE_FROM_QSIZE(maskSize),
03289                 IPP_POINT_FROM_QPOINT(anchor));
03290         }
03291 
03292 // QVision wrapper function for IPP's ippiFilterBox_8u_C3R
03293 void FilterBox(
03294                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03295                 QVImage<Ipp8u, 3> & qvimage_pDst,
03296                 const QSize &maskSize,
03297                 const QPoint &anchor,
03298                 const QPoint &destROIOffset)
03299         {
03300         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03301         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03302 
03303         IPP_DEBUG(FilterBox, ippiFilterBox_8u_C3R,
03304                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03305                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03306                 IMAGE_ROISIZE(qvimage_pDst),
03307                 IPP_SIZE_FROM_QSIZE(maskSize),
03308                 IPP_POINT_FROM_QPOINT(anchor));
03309         }
03310 
03311 // QVision wrapper function for IPP's ippiFilterBox_16u_C1R
03312 void FilterBox(
03313                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03314                 QVImage<Ipp16u, 1> & qvimage_pDst,
03315                 const QSize &maskSize,
03316                 const QPoint &anchor,
03317                 const QPoint &destROIOffset)
03318         {
03319         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03320         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03321 
03322         IPP_DEBUG(FilterBox, ippiFilterBox_16u_C1R,
03323                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03324                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03325                 IMAGE_ROISIZE(qvimage_pDst),
03326                 IPP_SIZE_FROM_QSIZE(maskSize),
03327                 IPP_POINT_FROM_QPOINT(anchor));
03328         }
03329 
03330 // QVision wrapper function for IPP's ippiFilterBox_32f_C1R
03331 void FilterBox(
03332                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03333                 QVImage<Ipp32f, 1> & qvimage_pDst,
03334                 const QSize &maskSize,
03335                 const QPoint &anchor,
03336                 const QPoint &destROIOffset)
03337         {
03338         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03339         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03340 
03341         IPP_DEBUG(FilterBox, ippiFilterBox_32f_C1R,
03342                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03343                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03344                 IMAGE_ROISIZE(qvimage_pDst),
03345                 IPP_SIZE_FROM_QSIZE(maskSize),
03346                 IPP_POINT_FROM_QPOINT(anchor));
03347         }
03348 
03349 // QVision wrapper function for IPP's ippiFilterMin_8u_C1R
03350 void FilterMin(
03351                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03352                 QVImage<Ipp8u, 1> & qvimage_pDst,
03353                 const QSize &maskSize,
03354                 const QPoint &anchor,
03355                 const QPoint &destROIOffset)
03356         {
03357         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03358         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03359 
03360         IPP_DEBUG(FilterMin, ippiFilterMin_8u_C1R,
03361                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03362                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03363                 IMAGE_ROISIZE(qvimage_pDst),
03364                 IPP_SIZE_FROM_QSIZE(maskSize),
03365                 IPP_POINT_FROM_QPOINT(anchor));
03366         }
03367 
03368 // QVision wrapper function for IPP's ippiFilterMin_8u_C3R
03369 void FilterMin(
03370                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03371                 QVImage<Ipp8u, 3> & qvimage_pDst,
03372                 const QSize &maskSize,
03373                 const QPoint &anchor,
03374                 const QPoint &destROIOffset)
03375         {
03376         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03377         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03378 
03379         IPP_DEBUG(FilterMin, ippiFilterMin_8u_C3R,
03380                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03381                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03382                 IMAGE_ROISIZE(qvimage_pDst),
03383                 IPP_SIZE_FROM_QSIZE(maskSize),
03384                 IPP_POINT_FROM_QPOINT(anchor));
03385         }
03386 
03387 // QVision wrapper function for IPP's ippiFilterMin_16u_C1R
03388 void FilterMin(
03389                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03390                 QVImage<Ipp16u, 1> & qvimage_pDst,
03391                 const QSize &maskSize,
03392                 const QPoint &anchor,
03393                 const QPoint &destROIOffset)
03394         {
03395         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03396         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03397 
03398         IPP_DEBUG(FilterMin, ippiFilterMin_16u_C1R,
03399                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03400                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03401                 IMAGE_ROISIZE(qvimage_pDst),
03402                 IPP_SIZE_FROM_QSIZE(maskSize),
03403                 IPP_POINT_FROM_QPOINT(anchor));
03404         }
03405 
03406 // QVision wrapper function for IPP's ippiFilterMin_32f_C1R
03407 void FilterMin(
03408                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03409                 QVImage<Ipp32f, 1> & qvimage_pDst,
03410                 const QSize &maskSize,
03411                 const QPoint &anchor,
03412                 const QPoint &destROIOffset)
03413         {
03414         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03415         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03416 
03417         IPP_DEBUG(FilterMin, ippiFilterMin_32f_C1R,
03418                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03419                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03420                 IMAGE_ROISIZE(qvimage_pDst),
03421                 IPP_SIZE_FROM_QSIZE(maskSize),
03422                 IPP_POINT_FROM_QPOINT(anchor));
03423         }
03424 
03425 // QVision wrapper function for IPP's ippiFilterMax_8u_C1R
03426 void FilterMax(
03427                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03428                 QVImage<Ipp8u, 1> & qvimage_pDst,
03429                 const QSize &maskSize,
03430                 const QPoint &anchor,
03431                 const QPoint &destROIOffset)
03432         {
03433         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03434         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03435 
03436         IPP_DEBUG(FilterMax, ippiFilterMax_8u_C1R,
03437                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03438                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03439                 IMAGE_ROISIZE(qvimage_pDst),
03440                 IPP_SIZE_FROM_QSIZE(maskSize),
03441                 IPP_POINT_FROM_QPOINT(anchor));
03442         }
03443 
03444 // QVision wrapper function for IPP's ippiFilterMax_8u_C3R
03445 void FilterMax(
03446                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03447                 QVImage<Ipp8u, 3> & qvimage_pDst,
03448                 const QSize &maskSize,
03449                 const QPoint &anchor,
03450                 const QPoint &destROIOffset)
03451         {
03452         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03453         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03454 
03455         IPP_DEBUG(FilterMax, ippiFilterMax_8u_C3R,
03456                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03457                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03458                 IMAGE_ROISIZE(qvimage_pDst),
03459                 IPP_SIZE_FROM_QSIZE(maskSize),
03460                 IPP_POINT_FROM_QPOINT(anchor));
03461         }
03462 
03463 // QVision wrapper function for IPP's ippiFilterMax_16u_C1R
03464 void FilterMax(
03465                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03466                 QVImage<Ipp16u, 1> & qvimage_pDst,
03467                 const QSize &maskSize,
03468                 const QPoint &anchor,
03469                 const QPoint &destROIOffset)
03470         {
03471         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03472         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03473 
03474         IPP_DEBUG(FilterMax, ippiFilterMax_16u_C1R,
03475                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03476                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03477                 IMAGE_ROISIZE(qvimage_pDst),
03478                 IPP_SIZE_FROM_QSIZE(maskSize),
03479                 IPP_POINT_FROM_QPOINT(anchor));
03480         }
03481 
03482 // QVision wrapper function for IPP's ippiFilterMax_32f_C1R
03483 void FilterMax(
03484                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03485                 QVImage<Ipp32f, 1> & qvimage_pDst,
03486                 const QSize &maskSize,
03487                 const QPoint &anchor,
03488                 const QPoint &destROIOffset)
03489         {
03490         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03491         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03492 
03493         IPP_DEBUG(FilterMax, ippiFilterMax_32f_C1R,
03494                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03495                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03496                 IMAGE_ROISIZE(qvimage_pDst),
03497                 IPP_SIZE_FROM_QSIZE(maskSize),
03498                 IPP_POINT_FROM_QPOINT(anchor));
03499         }
03500 
03501 // QVision wrapper function for IPP's ippiFilterMedian_8u_C1R
03502 void FilterMedian(
03503                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03504                 QVImage<Ipp8u, 1> & qvimage_pDst,
03505                 const QSize &maskSize,
03506                 const QPoint &anchor,
03507                 const QPoint &destROIOffset)
03508         {
03509         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03510         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03511 
03512         IPP_DEBUG(FilterMedian, ippiFilterMedian_8u_C1R,
03513                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03514                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03515                 IMAGE_ROISIZE(qvimage_pDst),
03516                 IPP_SIZE_FROM_QSIZE(maskSize),
03517                 IPP_POINT_FROM_QPOINT(anchor));
03518         }
03519 
03520 // QVision wrapper function for IPP's ippiFilterMedian_8u_C3R
03521 void FilterMedian(
03522                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03523                 QVImage<Ipp8u, 3> & qvimage_pDst,
03524                 const QSize &maskSize,
03525                 const QPoint &anchor,
03526                 const QPoint &destROIOffset)
03527         {
03528         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03529         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03530 
03531         IPP_DEBUG(FilterMedian, ippiFilterMedian_8u_C3R,
03532                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03533                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03534                 IMAGE_ROISIZE(qvimage_pDst),
03535                 IPP_SIZE_FROM_QSIZE(maskSize),
03536                 IPP_POINT_FROM_QPOINT(anchor));
03537         }
03538 
03539 // QVision wrapper function for IPP's ippiFilterMedian_16u_C1R
03540 void FilterMedian(
03541                 const QVImage<Ipp16u, 1> & qvimage_pSrc,
03542                 QVImage<Ipp16u, 1> & qvimage_pDst,
03543                 const QSize &maskSize,
03544                 const QPoint &anchor,
03545                 const QPoint &destROIOffset)
03546         {
03547         const int colMaskRadius = maskSize.width(), rowMaskRadius = maskSize.height();
03548         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, colMaskRadius-1, rowMaskRadius-1);
03549 
03550         IPP_DEBUG(FilterMedian, ippiFilterMedian_16u_C1R,
03551                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03552                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03553                 IMAGE_ROISIZE(qvimage_pDst),
03554                 IPP_SIZE_FROM_QSIZE(maskSize),
03555                 IPP_POINT_FROM_QPOINT(anchor));
03556         }
03557 
03558 // QVision wrapper function for IPP's ippiFilterMedianHoriz_8u_C1R
03559 void FilterMedianHoriz(
03560                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03561                 QVImage<Ipp8u, 1> & qvimage_pDst,
03562                 const IppiMaskSize mask,
03563                 const QPoint &destROIOffset)
03564         {
03565         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03566         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03567 
03568         IPP_DEBUG(FilterMedianHoriz, ippiFilterMedianHoriz_8u_C1R,
03569                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03570                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03571                 IMAGE_ROISIZE(qvimage_pDst),
03572                 mask);
03573         }
03574 
03575 // QVision wrapper function for IPP's ippiFilterMedianVert_8u_C1R
03576 void FilterMedianVert(
03577                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03578                 QVImage<Ipp8u, 1> & qvimage_pDst,
03579                 const IppiMaskSize mask,
03580                 const QPoint &destROIOffset)
03581         {
03582         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03583         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03584 
03585         IPP_DEBUG(FilterMedianVert, ippiFilterMedianVert_8u_C1R,
03586                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03587                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03588                 IMAGE_ROISIZE(qvimage_pDst),
03589                 mask);
03590         }
03591 
03592 // QVision wrapper function for IPP's ippiFilterMedianCross_8u_C1R
03593 void FilterMedianCross(
03594                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03595                 QVImage<Ipp8u, 1> & qvimage_pDst,
03596                 const IppiMaskSize mask,
03597                 const QPoint &destROIOffset)
03598         {
03599         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03600         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03601 
03602         IPP_DEBUG(FilterMedianCross, ippiFilterMedianCross_8u_C1R,
03603                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03604                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03605                 IMAGE_ROISIZE(qvimage_pDst),
03606                 mask);
03607         }
03608 
03609 // QVision wrapper function for IPP's ippiFilterMedianWeightedCenter3x3_8u_C1R
03610 // Filter an image using a median filter with kernal size 3x3 and enlarged weight of central pixel.
03611 void FilterMedianWeightedCenter3x3(
03612                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03613                 QVImage<Ipp8u, 1> & qvimage_pDst,
03614                 const int weight,
03615                 const QPoint &destROIOffset)
03616         {
03617         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03618 
03619         IPP_DEBUG(FilterMedianWeightedCenter3x3, ippiFilterMedianWeightedCenter3x3_8u_C1R,
03620                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03621                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03622                 IMAGE_ROISIZE(qvimage_pDst),
03623                 weight);
03624         }
03625 
03626 // QVision wrapper function for IPP's ippiFilterMedianColor_8u_C3R
03627 void FilterMedianColor(
03628                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03629                 QVImage<Ipp8u, 3> & qvimage_pDst,
03630                 const IppiMaskSize mask,
03631                 const QPoint &destROIOffset)
03632         {
03633         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03634         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03635 
03636         IPP_DEBUG(FilterMedianColor, ippiFilterMedianColor_8u_C3R,
03637                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03638                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03639                 IMAGE_ROISIZE(qvimage_pDst),
03640                 mask);
03641         }
03642 
03643 // QVision wrapper function for IPP's ippiFilterSobelHoriz_8u_C1R
03644 void FilterSobelHoriz(
03645                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03646                 QVImage<Ipp8u, 1> & qvimage_pDst,
03647                 const QPoint &destROIOffset)
03648         {
03649         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03650 
03651         IPP_DEBUG(FilterSobelHoriz, ippiFilterSobelHoriz_8u_C1R,
03652                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03653                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03654                 IMAGE_ROISIZE(qvimage_pDst));
03655         }
03656 
03657 // QVision wrapper function for IPP's ippiFilterSobelHoriz_16s_C1R
03658 void FilterSobelHoriz(
03659                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
03660                 QVImage<Ipp16s, 1> & qvimage_pDst,
03661                 const QPoint &destROIOffset)
03662         {
03663         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03664 
03665         IPP_DEBUG(FilterSobelHoriz, ippiFilterSobelHoriz_16s_C1R,
03666                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03667                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03668                 IMAGE_ROISIZE(qvimage_pDst));
03669         }
03670 
03671 // QVision wrapper function for IPP's ippiFilterSobelHoriz_32f_C1R
03672 void FilterSobelHoriz(
03673                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03674                 QVImage<Ipp32f, 1> & qvimage_pDst,
03675                 const QPoint &destROIOffset)
03676         {
03677         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03678 
03679         IPP_DEBUG(FilterSobelHoriz, ippiFilterSobelHoriz_32f_C1R,
03680                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03681                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03682                 IMAGE_ROISIZE(qvimage_pDst));
03683         }
03684 
03685 // QVision wrapper function for IPP's ippiFilterSobelHorizMask_32f_C1R
03686 void FilterSobelHorizMask(
03687                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03688                 QVImage<Ipp32f, 1> & qvimage_pDst,
03689                 const IppiMaskSize mask,
03690                 const QPoint &destROIOffset)
03691         {
03692         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03693         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03694 
03695         IPP_DEBUG(FilterSobelHorizMask, ippiFilterSobelHorizMask_32f_C1R,
03696                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03697                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03698                 IMAGE_ROISIZE(qvimage_pDst),
03699                 mask);
03700         }
03701 
03702 // QVision wrapper function for IPP's ippiFilterSobelVert_8u_C1R
03703 void FilterSobelVert(
03704                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03705                 QVImage<Ipp8u, 1> & qvimage_pDst,
03706                 const QPoint &destROIOffset)
03707         {
03708         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03709 
03710         IPP_DEBUG(FilterSobelVert, ippiFilterSobelVert_8u_C1R,
03711                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03712                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03713                 IMAGE_ROISIZE(qvimage_pDst));
03714         }
03715 
03716 // QVision wrapper function for IPP's ippiFilterSobelVert_16s_C1R
03717 void FilterSobelVert(
03718                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
03719                 QVImage<Ipp16s, 1> & qvimage_pDst,
03720                 const QPoint &destROIOffset)
03721         {
03722         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03723 
03724         IPP_DEBUG(FilterSobelVert, ippiFilterSobelVert_16s_C1R,
03725                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03726                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03727                 IMAGE_ROISIZE(qvimage_pDst));
03728         }
03729 
03730 // QVision wrapper function for IPP's ippiFilterSobelVert_32f_C1R
03731 void FilterSobelVert(
03732                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03733                 QVImage<Ipp32f, 1> & qvimage_pDst,
03734                 const QPoint &destROIOffset)
03735         {
03736         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
03737 
03738         IPP_DEBUG(FilterSobelVert, ippiFilterSobelVert_32f_C1R,
03739                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03740                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03741                 IMAGE_ROISIZE(qvimage_pDst));
03742         }
03743 
03744 // QVision wrapper function for IPP's ippiFilterSobelVertMask_32f_C1R
03745 void FilterSobelVertMask(
03746                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03747                 QVImage<Ipp32f, 1> & qvimage_pDst,
03748                 const IppiMaskSize mask,
03749                 const QPoint &destROIOffset)
03750         {
03751         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03752         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03753 
03754         IPP_DEBUG(FilterSobelVertMask, ippiFilterSobelVertMask_32f_C1R,
03755                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03756                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03757                 IMAGE_ROISIZE(qvimage_pDst),
03758                 mask);
03759         }
03760 
03761 // QVision wrapper function for IPP's ippiFilterLaplace_8u_C1R
03762 void FilterLaplace(
03763                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03764                 QVImage<Ipp8u, 1> & qvimage_pDst,
03765                 const IppiMaskSize mask,
03766                 const QPoint &destROIOffset)
03767         {
03768         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03769         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03770 
03771         IPP_DEBUG(FilterLaplace, ippiFilterLaplace_8u_C1R,
03772                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03773                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03774                 IMAGE_ROISIZE(qvimage_pDst),
03775                 mask);
03776         }
03777 
03778 // QVision wrapper function for IPP's ippiFilterLaplace_16s_C1R
03779 void FilterLaplace(
03780                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
03781                 QVImage<Ipp16s, 1> & qvimage_pDst,
03782                 const IppiMaskSize mask,
03783                 const QPoint &destROIOffset)
03784         {
03785         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03786         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03787 
03788         IPP_DEBUG(FilterLaplace, ippiFilterLaplace_16s_C1R,
03789                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03790                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03791                 IMAGE_ROISIZE(qvimage_pDst),
03792                 mask);
03793         }
03794 
03795 // QVision wrapper function for IPP's ippiFilterLaplace_32f_C1R
03796 void FilterLaplace(
03797                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03798                 QVImage<Ipp32f, 1> & qvimage_pDst,
03799                 const IppiMaskSize mask,
03800                 const QPoint &destROIOffset)
03801         {
03802         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03803         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03804 
03805         IPP_DEBUG(FilterLaplace, ippiFilterLaplace_32f_C1R,
03806                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03807                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03808                 IMAGE_ROISIZE(qvimage_pDst),
03809                 mask);
03810         }
03811 
03812 // QVision wrapper function for IPP's ippiFilterGauss_8u_C1R
03813 void FilterGauss(
03814                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03815                 QVImage<Ipp8u, 1> & qvimage_pDst,
03816                 const IppiMaskSize mask,
03817                 const QPoint &destROIOffset)
03818         {
03819         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03820         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03821 
03822         IPP_DEBUG(FilterGauss, ippiFilterGauss_8u_C1R,
03823                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03824                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03825                 IMAGE_ROISIZE(qvimage_pDst),
03826                 mask);
03827         }
03828 
03829 // QVision wrapper function for IPP's ippiFilterGauss_32f_C1R
03830 void FilterGauss(
03831                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03832                 QVImage<Ipp32f, 1> & qvimage_pDst,
03833                 const IppiMaskSize mask,
03834                 const QPoint &destROIOffset)
03835         {
03836         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03837         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03838 
03839         IPP_DEBUG(FilterGauss, ippiFilterGauss_32f_C1R,
03840                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03841                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03842                 IMAGE_ROISIZE(qvimage_pDst),
03843                 mask);
03844         }
03845 
03846 // QVision wrapper function for IPP's ippiFilterGauss_8u_C3R
03847 void FilterGauss(
03848                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03849                 QVImage<Ipp8u, 3> & qvimage_pDst,
03850                 const IppiMaskSize mask,
03851                 const QPoint &destROIOffset)
03852         {
03853         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03854         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03855 
03856         IPP_DEBUG(FilterGauss, ippiFilterGauss_8u_C3R,
03857                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03858                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03859                 IMAGE_ROISIZE(qvimage_pDst),
03860                 mask);
03861         }
03862 
03863 // QVision wrapper function for IPP's ippiFilterGauss_32f_C3R
03864 void FilterGauss(
03865                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
03866                 QVImage<Ipp32f, 3> & qvimage_pDst,
03867                 const IppiMaskSize mask,
03868                 const QPoint &destROIOffset)
03869         {
03870         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03871         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03872 
03873         IPP_DEBUG(FilterGauss, ippiFilterGauss_32f_C3R,
03874                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03875                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03876                 IMAGE_ROISIZE(qvimage_pDst),
03877                 mask);
03878         }
03879 
03880 // QVision wrapper function for IPP's ippiFilterHipass_8u_C1R
03881 void FilterHipass(
03882                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03883                 QVImage<Ipp8u, 1> & qvimage_pDst,
03884                 const IppiMaskSize mask,
03885                 const QPoint &destROIOffset)
03886         {
03887         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03888         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03889 
03890         IPP_DEBUG(FilterHipass, ippiFilterHipass_8u_C1R,
03891                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03892                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03893                 IMAGE_ROISIZE(qvimage_pDst),
03894                 mask);
03895         }
03896 
03897 // QVision wrapper function for IPP's ippiFilterHipass_8u_C3R
03898 void FilterHipass(
03899                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03900                 QVImage<Ipp8u, 3> & qvimage_pDst,
03901                 const IppiMaskSize mask,
03902                 const QPoint &destROIOffset)
03903         {
03904         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03905         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03906 
03907         IPP_DEBUG(FilterHipass, ippiFilterHipass_8u_C3R,
03908                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03909                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03910                 IMAGE_ROISIZE(qvimage_pDst),
03911                 mask);
03912         }
03913 
03914 // QVision wrapper function for IPP's ippiFilterHipass_32f_C1R
03915 void FilterHipass(
03916                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03917                 QVImage<Ipp32f, 1> & qvimage_pDst,
03918                 const IppiMaskSize mask,
03919                 const QPoint &destROIOffset)
03920         {
03921         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03922         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03923 
03924         IPP_DEBUG(FilterHipass, ippiFilterHipass_32f_C1R,
03925                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03926                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03927                 IMAGE_ROISIZE(qvimage_pDst),
03928                 mask);
03929         }
03930 
03931 // QVision wrapper function for IPP's ippiFilterHipass_32f_C3R
03932 void FilterHipass(
03933                 const QVImage<Ipp32f, 3> & qvimage_pSrc,
03934                 QVImage<Ipp32f, 3> & qvimage_pDst,
03935                 const IppiMaskSize mask,
03936                 const QPoint &destROIOffset)
03937         {
03938         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03939         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03940 
03941         IPP_DEBUG(FilterHipass, ippiFilterHipass_32f_C3R,
03942                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03943                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03944                 IMAGE_ROISIZE(qvimage_pDst),
03945                 mask);
03946         }
03947 
03948 // QVision wrapper function for IPP's ippiFilterLowpass_8u_C1R
03949 void FilterLowpass(
03950                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03951                 QVImage<Ipp8u, 1> & qvimage_pDst,
03952                 const IppiMaskSize mask,
03953                 const QPoint &destROIOffset)
03954         {
03955         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03956         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03957 
03958         IPP_DEBUG(FilterLowpass, ippiFilterLowpass_8u_C1R,
03959                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03960                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03961                 IMAGE_ROISIZE(qvimage_pDst),
03962                 mask);
03963         }
03964 
03965 // QVision wrapper function for IPP's ippiFilterLowpass_32f_C1R
03966 void FilterLowpass(
03967                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
03968                 QVImage<Ipp32f, 1> & qvimage_pDst,
03969                 const IppiMaskSize mask,
03970                 const QPoint &destROIOffset)
03971         {
03972         const int maskCols = IPP_MASK_SIZE_COLS(mask)-1, maskRows = IPP_MASK_SIZE_ROWS(mask)-1;
03973         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, maskCols, maskRows);
03974 
03975         IPP_DEBUG(FilterLowpass, ippiFilterLowpass_32f_C1R,
03976                 PDATA_READ_MARGIN(qvimage_pSrc, maskCols/2, maskRows/2), qvimage_pSrc.getStep(),
03977                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
03978                 IMAGE_ROISIZE(qvimage_pDst),
03979                 mask);
03980         }
03981 
03982 // QVision wrapper function for IPP's ippiSum_8u_C1R
03983 void Sum(
03984                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
03985                  Ipp64f & pSum)
03986         {
03987         IPP_DEBUG(Sum, ippiSum_8u_C1R,
03988                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
03989                 IMAGE_ROISIZE(qvimage_pSrc),
03990                 & pSum);
03991         }
03992 
03993 // QVision wrapper function for IPP's ippiSum_8u_C3R
03994 void Sum(
03995                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
03996                 Ipp64f sum[3])
03997         {
03998         IPP_DEBUG(Sum, ippiSum_8u_C3R,
03999                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04000                 IMAGE_ROISIZE(qvimage_pSrc),
04001                 sum);
04002         }
04003 
04004 // QVision wrapper function for IPP's ippiSum_16s_C1R
04005 void Sum(
04006                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
04007                  Ipp64f & pSum)
04008         {
04009         IPP_DEBUG(Sum, ippiSum_16s_C1R,
04010                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04011                 IMAGE_ROISIZE(qvimage_pSrc),
04012                 & pSum);
04013         }
04014 
04015 // QVision wrapper function for IPP's ippiSum_16s_C3R
04016 void Sum(
04017                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
04018                 Ipp64f sum[3])
04019         {
04020         IPP_DEBUG(Sum, ippiSum_16s_C3R,
04021                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04022                 IMAGE_ROISIZE(qvimage_pSrc),
04023                 sum);
04024         }
04025 
04026 // QVision wrapper function for IPP's ippiIntegral_8u32s_C1R
04027 void Integral(
04028                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04029                 QVImage<Ipp32s, 1> & qvimage_pDst,
04030                 const Ipp32s val,
04031                 const QPoint &destROIOffset)
04032         {
04033         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04034 
04035         IPP_DEBUG(Integral, ippiIntegral_8u32s_C1R,
04036                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04037                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04038                 IMAGE_ROISIZE(qvimage_pDst),
04039                 val);
04040         }
04041 
04042 // QVision wrapper function for IPP's ippiIntegral_8u32f_C1R
04043 void Integral(
04044                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04045                 QVImage<Ipp32f, 1> & qvimage_pDst,
04046                 const Ipp32f val,
04047                 const QPoint &destROIOffset)
04048         {
04049         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04050 
04051         IPP_DEBUG(Integral, ippiIntegral_8u32f_C1R,
04052                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04053                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04054                 IMAGE_ROISIZE(qvimage_pDst),
04055                 val);
04056         }
04057 
04058 // QVision wrapper function for IPP's ippiMean_8u_C1R
04059 void Mean(
04060                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04061                  Ipp64f & pMean)
04062         {
04063         IPP_DEBUG(Mean, ippiMean_8u_C1R,
04064                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04065                 IMAGE_ROISIZE(qvimage_pSrc),
04066                 & pMean);
04067         }
04068 
04069 // QVision wrapper function for IPP's ippiMean_8u_C3R
04070 void Mean(
04071                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
04072                 Ipp64f mean[3])
04073         {
04074         IPP_DEBUG(Mean, ippiMean_8u_C3R,
04075                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04076                 IMAGE_ROISIZE(qvimage_pSrc),
04077                 mean);
04078         }
04079 
04080 // QVision wrapper function for IPP's ippiMean_16s_C1R
04081 void Mean(
04082                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
04083                  Ipp64f & pMean)
04084         {
04085         IPP_DEBUG(Mean, ippiMean_16s_C1R,
04086                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04087                 IMAGE_ROISIZE(qvimage_pSrc),
04088                 & pMean);
04089         }
04090 
04091 // QVision wrapper function for IPP's ippiMean_16s_C3R
04092 void Mean(
04093                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
04094                 Ipp64f mean[3])
04095         {
04096         IPP_DEBUG(Mean, ippiMean_16s_C3R,
04097                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04098                 IMAGE_ROISIZE(qvimage_pSrc),
04099                 mean);
04100         }
04101 
04102 // QVision wrapper function for IPP's ippiMin_8u_C1R
04103 void Min(
04104                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04105                  Ipp8u & pMin)
04106         {
04107         IPP_DEBUG(Min, ippiMin_8u_C1R,
04108                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04109                 IMAGE_ROISIZE(qvimage_pSrc),
04110                 & pMin);
04111         }
04112 
04113 // QVision wrapper function for IPP's ippiMin_8u_C3R
04114 void Min(
04115                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
04116                 Ipp8u min[3])
04117         {
04118         IPP_DEBUG(Min, ippiMin_8u_C3R,
04119                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04120                 IMAGE_ROISIZE(qvimage_pSrc),
04121                 min);
04122         }
04123 
04124 // QVision wrapper function for IPP's ippiMin_16s_C1R
04125 void Min(
04126                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
04127                  Ipp16s & pMin)
04128         {
04129         IPP_DEBUG(Min, ippiMin_16s_C1R,
04130                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04131                 IMAGE_ROISIZE(qvimage_pSrc),
04132                 & pMin);
04133         }
04134 
04135 // QVision wrapper function for IPP's ippiMin_16s_C3R
04136 void Min(
04137                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
04138                 Ipp16s min[3])
04139         {
04140         IPP_DEBUG(Min, ippiMin_16s_C3R,
04141                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04142                 IMAGE_ROISIZE(qvimage_pSrc),
04143                 min);
04144         }
04145 
04146 // QVision wrapper function for IPP's ippiMin_32f_C1R
04147 void Min(
04148                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
04149                  Ipp32f & pMin)
04150         {
04151         IPP_DEBUG(Min, ippiMin_32f_C1R,
04152                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04153                 IMAGE_ROISIZE(qvimage_pSrc),
04154                 & pMin);
04155         }
04156 
04157 // QVision wrapper function for IPP's ippiMax_8u_C1R
04158 void Max(
04159                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04160                  Ipp8u & pMax)
04161         {
04162         IPP_DEBUG(Max, ippiMax_8u_C1R,
04163                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04164                 IMAGE_ROISIZE(qvimage_pSrc),
04165                 & pMax);
04166         }
04167 
04168 // QVision wrapper function for IPP's ippiMax_8u_C3R
04169 void Max(
04170                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
04171                 Ipp8u max[3])
04172         {
04173         IPP_DEBUG(Max, ippiMax_8u_C3R,
04174                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04175                 IMAGE_ROISIZE(qvimage_pSrc),
04176                 max);
04177         }
04178 
04179 // QVision wrapper function for IPP's ippiMax_16s_C1R
04180 void Max(
04181                 const QVImage<Ipp16s, 1> & qvimage_pSrc,
04182                  Ipp16s & pMax)
04183         {
04184         IPP_DEBUG(Max, ippiMax_16s_C1R,
04185                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04186                 IMAGE_ROISIZE(qvimage_pSrc),
04187                 & pMax);
04188         }
04189 
04190 // QVision wrapper function for IPP's ippiMax_16s_C3R
04191 void Max(
04192                 const QVImage<Ipp16s, 3> & qvimage_pSrc,
04193                 Ipp16s max[3])
04194         {
04195         IPP_DEBUG(Max, ippiMax_16s_C3R,
04196                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04197                 IMAGE_ROISIZE(qvimage_pSrc),
04198                 max);
04199         }
04200 
04201 // QVision wrapper function for IPP's ippiMax_32f_C1R
04202 void Max(
04203                 const QVImage<Ipp32f, 1> & qvimage_pSrc,
04204                  Ipp32f & pMax)
04205         {
04206         IPP_DEBUG(Max, ippiMax_32f_C1R,
04207                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04208                 IMAGE_ROISIZE(qvimage_pSrc),
04209                 & pMax);
04210         }
04211 
04212 // QVision wrapper function for IPP's ippiCanny_16s8u_C1R
04213 void Canny(
04214                 QVImage<Ipp16s, 1> & qvimage_pSrcDx,
04215                 QVImage<Ipp16s, 1> & qvimage_pSrcDy,
04216                 QVImage<Ipp8u, 1> & qvimage_pDstEdges,
04217                 const Ipp32f lowThresh,
04218                 const Ipp32f highThresh,
04219                 QVImage<uChar, 1> & qvimage_pBuffer)
04220         {
04221         IPP_DEBUG(Canny, ippiCanny_16s8u_C1R,
04222                 PDATA_WRITE(qvimage_pSrcDx), qvimage_pSrcDx.getStep(),
04223                 PDATA_WRITE(qvimage_pSrcDy), qvimage_pSrcDy.getStep(),
04224                 PDATA_WRITE(qvimage_pDstEdges), qvimage_pDstEdges.getStep(),
04225                 IMAGE_ROISIZE(qvimage_pDstEdges),
04226                 lowThresh,
04227                 highThresh,
04228                 qvimage_pBuffer.getWriteData());
04229         }
04230 
04231 // QVision wrapper function for IPP's ippiCanny_32f8u_C1R
04232 void Canny(
04233                 QVImage<Ipp32f, 1> & qvimage_pSrcDx,
04234                 QVImage<Ipp32f, 1> & qvimage_pSrcDy,
04235                 QVImage<Ipp8u, 1> & qvimage_pDstEdges,
04236                 const Ipp32f lowThresh,
04237                 const Ipp32f highThresh,
04238                 QVImage<uChar, 1> & qvimage_pBuffer)
04239         {
04240         IPP_DEBUG(Canny, ippiCanny_32f8u_C1R,
04241                 PDATA_WRITE(qvimage_pSrcDx), qvimage_pSrcDx.getStep(),
04242                 PDATA_WRITE(qvimage_pSrcDy), qvimage_pSrcDy.getStep(),
04243                 PDATA_WRITE(qvimage_pDstEdges), qvimage_pDstEdges.getStep(),
04244                 IMAGE_ROISIZE(qvimage_pDstEdges),
04245                 lowThresh,
04246                 highThresh,
04247                 qvimage_pBuffer.getWriteData());
04248         }
04249 
04250 // QVision wrapper function for IPP's ippiMinEigenVal_8u32f_C1R
04251 void MinEigenVal(
04252                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04253                 QVImage<Ipp32f, 1> & qvimage_pMinEigenVal,
04254                 const IppiKernelType kernType,
04255                 const int apertureSize,
04256                 const int avgWindow,
04257                 QVImage<uChar, 1> & qvimage_pBuffer,
04258                 const QPoint &destROIOffset)
04259         {
04260         COMPOSE_ROI(qvimage_pMinEigenVal, qvimage_pSrc, destROIOffset, 0, 0);
04261 
04262         IPP_DEBUG(MinEigenVal, ippiMinEigenVal_8u32f_C1R,
04263                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04264                 PDATA_WRITE(qvimage_pMinEigenVal), qvimage_pMinEigenVal.getStep(),
04265                 IMAGE_ROISIZE(qvimage_pMinEigenVal),
04266                 kernType,
04267                 apertureSize,
04268                 avgWindow,
04269                 qvimage_pBuffer.getWriteData());
04270         }
04271 
04272 // QVision wrapper function for IPP's ippiDistanceTransform_5x5_8u16u_C1R
04273 void DistanceTransform_5x5(
04274                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04275                 QVImage<Ipp16u, 1> & qvimage_pDst,
04276                  Ipp32s & pMetrics,
04277                 const QPoint &destROIOffset)
04278         {
04279         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04280 
04281         IPP_DEBUG(DistanceTransform_5x5, ippiDistanceTransform_5x5_8u16u_C1R,
04282                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04283                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04284                 IMAGE_ROISIZE(qvimage_pDst),
04285                 & pMetrics);
04286         }
04287 
04288 // QVision wrapper function for IPP's ippiFastMarching_8u32f_C1R
04289 // Calculate distance transform by fast marching method.
04290 void FastMarching(
04291                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04292                 QVImage<Ipp32f, 1> & qvimage_pDst,
04293                 const Ipp32f radius,
04294                 QVImage<uChar, 1> & qvimage_pBuffer,
04295                 const QPoint &destROIOffset)
04296         {
04297         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04298 
04299         IPP_DEBUG(FastMarching, ippiFastMarching_8u32f_C1R,
04300                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04301                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04302                 IMAGE_ROISIZE(qvimage_pDst),
04303                 radius,
04304                 qvimage_pBuffer.getWriteData());
04305         }
04306 
04307 // QVision wrapper function for IPP's ippiInpaint_8u_C1R
04308 void Inpaint(
04309                 const QVImage<Ipp8u, 1> & qvimage_pSrc,
04310                 QVImage<Ipp8u, 1> & qvimage_pDst,
04311                  IppiInpaintState_8u_C1R & pState,
04312                 const QPoint &destROIOffset)
04313         {
04314         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04315 
04316         IPP_DEBUG(Inpaint, ippiInpaint_8u_C1R,
04317                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04318                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04319                 IMAGE_ROISIZE(qvimage_pDst),
04320                 & pState);
04321         }
04322 
04323 // QVision wrapper function for IPP's ippiInpaint_8u_C3R
04324 // Restores damaged image area by direct inpainting.
04325 void Inpaint(
04326                 const QVImage<Ipp8u, 3> & qvimage_pSrc,
04327                 QVImage<Ipp8u, 3> & qvimage_pDst,
04328                  IppiInpaintState_8u_C1R & pState,
04329                 const QPoint &destROIOffset)
04330         {
04331         COMPOSE_ROI(qvimage_pDst, qvimage_pSrc, destROIOffset, 0, 0);
04332 
04333         IPP_DEBUG(Inpaint, ippiInpaint_8u_C3R,
04334                 PDATA_READ(qvimage_pSrc), qvimage_pSrc.getStep(),
04335                 PDATA_WRITE(qvimage_pDst), qvimage_pDst.getStep(),
04336                 IMAGE_ROISIZE(qvimage_pDst),
04337                 & pState);
04338         }
04339 



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