src/qvip/qvipp/qvippfunctions.cpp

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