PARP Research Group University of Murcia, Spain


src/qvworkers/qvippworkers.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008, 2009. PARP Research Group.
00003  *      <http://perception.inf.um.es>
00004  *      University of Murcia, Spain.
00005  *
00006  *      This file is part of the QVision library.
00007  *
00008  *      QVision is free software: you can redistribute it and/or modify
00009  *      it under the terms of the GNU Lesser General Public License as
00010  *      published by the Free Software Foundation, version 3 of the License.
00011  *
00012  *      QVision is distributed in the hope that it will be useful,
00013  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *      GNU Lesser General Public License for more details.
00016  *
00017  *      You should have received a copy of the GNU Lesser General Public
00018  *      License along with QVision. If not, see <http://www.gnu.org/licenses/>.
00019  */
00020 
00024 
00025 #include <qvworkers/qvippworkers.h>
00026 
00027 const QMap<QString, QString> getQVIPPWorkersNames()
00028         {
00029         QMap<QString, QString> result;
00030 
00031         result.insertMulti("IPP: Image Data Exchange and Initialization Functions", "QVConvert_uCharsFloatC1Worker");
00032         result.insertMulti("IPP: Image Data Exchange and Initialization Functions", "QVConvert_uCharsFloatC3Worker");
00033         result.insertMulti("IPP: Image Data Exchange and Initialization Functions", "QVConvert_sFloatuCharC1Worker");
00034         result.insertMulti("IPP: Image Data Exchange and Initialization Functions", "QVConvert_sFloatuCharC3Worker");
00035         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAdd_uCharC1Worker");
00036         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAdd_uCharC3Worker");
00037         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAdd_sFloatC1Worker");
00038         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAdd_sFloatC3Worker");
00039         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAddC_uCharC1Worker");
00040         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAddC_sFloatC1Worker");
00041         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMul_uCharC1Worker");
00042         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMul_uCharC3Worker");
00043         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMul_sFloatC3Worker");
00044         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMul_sFloatC1Worker");
00045         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMulC_uCharC1Worker");
00046         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMulC_sFloatC1Worker");
00047         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMulScale_uCharC1Worker");
00048         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVMulScale_uCharC3Worker");
00049         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSub_uCharC1Worker");
00050         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSub_uCharC3Worker");
00051         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSub_sFloatC1Worker");
00052         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSub_sFloatC3Worker");
00053         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSubC_uCharC1Worker");
00054         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSubC_sFloatC1Worker");
00055         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDiv_uCharC1Worker");
00056         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDiv_uCharC3Worker");
00057         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDiv_sFloatC3Worker");
00058         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDiv_sFloatC1Worker");
00059         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDivC_uCharC1Worker");
00060         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVDivC_sFloatC1Worker");
00061         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAbs_sShortC1Worker");
00062         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAbs_sFloatC1Worker");
00063         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAbsDiff_uCharC1Worker");
00064         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAbsDiff_sFloatC1Worker");
00065         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVSqr_sFloatC1Worker");
00066         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVLn_sFloatC1Worker");
00067         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVLn_sFloatC3Worker");
00068         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVAndC_uCharC1Worker");
00069         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVNot_uCharC1Worker");
00070         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVNot_uCharC3Worker");
00071         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVOrC_uCharC1Worker");
00072         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVXorC_uCharC1Worker");
00073         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVLShiftC_uCharC1Worker");
00074         result.insertMulti("IPP: Image Arithmetic and Logical Operations", "QVRShiftC_uCharC1Worker");
00075         result.insertMulti("IPP: Image Color Conversion", "QVRGBToGray_uCharC3C1Worker");
00076         result.insertMulti("IPP: Image Color Conversion", "QVRGBToGray_sFloatC3C1Worker");
00077         result.insertMulti("IPP: Threshold and Compare Operations", "QVThreshold_uCharC1Worker");
00078         result.insertMulti("IPP: Threshold and Compare Operations", "QVThreshold_sFloatC1Worker");
00079         result.insertMulti("IPP: Threshold and Compare Operations", "QVComputeThreshold_Otsu_uCharC1Worker");
00080         result.insertMulti("IPP: Threshold and Compare Operations", "QVCompare_uCharC1Worker");
00081         result.insertMulti("IPP: Threshold and Compare Operations", "QVCompare_sFloatC1Worker");
00082         result.insertMulti("IPP: Threshold and Compare Operations", "QVCompareC_uCharC1Worker");
00083         result.insertMulti("IPP: Threshold and Compare Operations", "QVCompareC_sFloatC1Worker");
00084         result.insertMulti("IPP: Filtering Functions", "QVFilterBox_uCharC1Worker");
00085         result.insertMulti("IPP: Filtering Functions", "QVFilterBox_uCharC3Worker");
00086         result.insertMulti("IPP: Filtering Functions", "QVFilterBox_sFloatC1Worker");
00087         result.insertMulti("IPP: Filtering Functions", "QVFilterMin_uCharC1Worker");
00088         result.insertMulti("IPP: Filtering Functions", "QVFilterMin_uCharC3Worker");
00089         result.insertMulti("IPP: Filtering Functions", "QVFilterMin_sFloatC1Worker");
00090         result.insertMulti("IPP: Filtering Functions", "QVFilterMax_uCharC1Worker");
00091         result.insertMulti("IPP: Filtering Functions", "QVFilterMax_uCharC3Worker");
00092         result.insertMulti("IPP: Filtering Functions", "QVFilterMax_sFloatC1Worker");
00093         result.insertMulti("IPP: Filtering Functions", "QVFilterMedian_uCharC1Worker");
00094         result.insertMulti("IPP: Filtering Functions", "QVFilterMedian_uCharC3Worker");
00095         result.insertMulti("IPP: Filtering Functions", "QVFilterMedianHoriz_uCharC1Worker");
00096         result.insertMulti("IPP: Filtering Functions", "QVFilterSobelHorizMask_sFloatC1Worker");
00097         result.insertMulti("IPP: Filtering Functions", "QVFilterSobelVertMask_sFloatC1Worker");
00098         result.insertMulti("IPP: Filtering Functions", "QVFilterLaplace_uCharC1Worker");
00099         result.insertMulti("IPP: Filtering Functions", "QVFilterLaplace_sFloatC1Worker");
00100         result.insertMulti("IPP: Filtering Functions", "QVFilterGauss_uCharC1Worker");
00101         result.insertMulti("IPP: Filtering Functions", "QVFilterGauss_sFloatC1Worker");
00102         result.insertMulti("IPP: Filtering Functions", "QVFilterGauss_uCharC3Worker");
00103         result.insertMulti("IPP: Filtering Functions", "QVFilterGauss_sFloatC3Worker");
00104         result.insertMulti("IPP: Filtering Functions", "QVFilterHipass_uCharC1Worker");
00105         result.insertMulti("IPP: Filtering Functions", "QVFilterHipass_uCharC3Worker");
00106         result.insertMulti("IPP: Filtering Functions", "QVFilterHipass_sFloatC1Worker");
00107         result.insertMulti("IPP: Filtering Functions", "QVFilterHipass_sFloatC3Worker");
00108         result.insertMulti("IPP: Filtering Functions", "QVFilterLowpass_uCharC1Worker");
00109         result.insertMulti("IPP: Filtering Functions", "QVFilterLowpass_sFloatC1Worker");
00110         result.insertMulti("IPP: Image Statistics Functions", "QVSum_uCharC1Worker");
00111         result.insertMulti("IPP: Image Statistics Functions", "QVMean_uCharC1Worker");
00112         result.insertMulti("IPP: Image Statistics Functions", "QVMin_uCharC1Worker");
00113         result.insertMulti("IPP: Image Statistics Functions", "QVMin_sFloatC1Worker");
00114         result.insertMulti("IPP: Image Statistics Functions", "QVMax_uCharC1Worker");
00115         result.insertMulti("IPP: Image Statistics Functions", "QVMax_sFloatC1Worker");
00116 
00117         return result;
00118         }
00119 
00120 QVPropertyContainer *newQVIPPWorker(QString type, QString name)
00121         {
00122         if (type == "QVConvert_uCharsFloatC1Worker")                    return new QVConvert_uCharsFloatC1Worker(name);
00123         else if (type == "QVConvert_uCharsFloatC3Worker")                       return new QVConvert_uCharsFloatC3Worker(name);
00124         else if (type == "QVConvert_sFloatuCharC1Worker")                       return new QVConvert_sFloatuCharC1Worker(name);
00125         else if (type == "QVConvert_sFloatuCharC3Worker")                       return new QVConvert_sFloatuCharC3Worker(name);
00126         else if (type == "QVAdd_uCharC1Worker")                 return new QVAdd_uCharC1Worker(name);
00127         else if (type == "QVAdd_uCharC3Worker")                 return new QVAdd_uCharC3Worker(name);
00128         else if (type == "QVAdd_sFloatC1Worker")                        return new QVAdd_sFloatC1Worker(name);
00129         else if (type == "QVAdd_sFloatC3Worker")                        return new QVAdd_sFloatC3Worker(name);
00130         else if (type == "QVAddC_uCharC1Worker")                        return new QVAddC_uCharC1Worker(name);
00131         else if (type == "QVAddC_sFloatC1Worker")                       return new QVAddC_sFloatC1Worker(name);
00132         else if (type == "QVMul_uCharC1Worker")                 return new QVMul_uCharC1Worker(name);
00133         else if (type == "QVMul_uCharC3Worker")                 return new QVMul_uCharC3Worker(name);
00134         else if (type == "QVMul_sFloatC3Worker")                        return new QVMul_sFloatC3Worker(name);
00135         else if (type == "QVMul_sFloatC1Worker")                        return new QVMul_sFloatC1Worker(name);
00136         else if (type == "QVMulC_uCharC1Worker")                        return new QVMulC_uCharC1Worker(name);
00137         else if (type == "QVMulC_sFloatC1Worker")                       return new QVMulC_sFloatC1Worker(name);
00138         else if (type == "QVMulScale_uCharC1Worker")                    return new QVMulScale_uCharC1Worker(name);
00139         else if (type == "QVMulScale_uCharC3Worker")                    return new QVMulScale_uCharC3Worker(name);
00140         else if (type == "QVSub_uCharC1Worker")                 return new QVSub_uCharC1Worker(name);
00141         else if (type == "QVSub_uCharC3Worker")                 return new QVSub_uCharC3Worker(name);
00142         else if (type == "QVSub_sFloatC1Worker")                        return new QVSub_sFloatC1Worker(name);
00143         else if (type == "QVSub_sFloatC3Worker")                        return new QVSub_sFloatC3Worker(name);
00144         else if (type == "QVSubC_uCharC1Worker")                        return new QVSubC_uCharC1Worker(name);
00145         else if (type == "QVSubC_sFloatC1Worker")                       return new QVSubC_sFloatC1Worker(name);
00146         else if (type == "QVDiv_uCharC1Worker")                 return new QVDiv_uCharC1Worker(name);
00147         else if (type == "QVDiv_uCharC3Worker")                 return new QVDiv_uCharC3Worker(name);
00148         else if (type == "QVDiv_sFloatC3Worker")                        return new QVDiv_sFloatC3Worker(name);
00149         else if (type == "QVDiv_sFloatC1Worker")                        return new QVDiv_sFloatC1Worker(name);
00150         else if (type == "QVDivC_uCharC1Worker")                        return new QVDivC_uCharC1Worker(name);
00151         else if (type == "QVDivC_sFloatC1Worker")                       return new QVDivC_sFloatC1Worker(name);
00152         else if (type == "QVAbs_sShortC1Worker")                        return new QVAbs_sShortC1Worker(name);
00153         else if (type == "QVAbs_sFloatC1Worker")                        return new QVAbs_sFloatC1Worker(name);
00154         else if (type == "QVAbsDiff_uCharC1Worker")                     return new QVAbsDiff_uCharC1Worker(name);
00155         else if (type == "QVAbsDiff_sFloatC1Worker")                    return new QVAbsDiff_sFloatC1Worker(name);
00156         else if (type == "QVSqr_sFloatC1Worker")                        return new QVSqr_sFloatC1Worker(name);
00157         else if (type == "QVLn_sFloatC1Worker")                 return new QVLn_sFloatC1Worker(name);
00158         else if (type == "QVLn_sFloatC3Worker")                 return new QVLn_sFloatC3Worker(name);
00159         else if (type == "QVAndC_uCharC1Worker")                        return new QVAndC_uCharC1Worker(name);
00160         else if (type == "QVNot_uCharC1Worker")                 return new QVNot_uCharC1Worker(name);
00161         else if (type == "QVNot_uCharC3Worker")                 return new QVNot_uCharC3Worker(name);
00162         else if (type == "QVOrC_uCharC1Worker")                 return new QVOrC_uCharC1Worker(name);
00163         else if (type == "QVXorC_uCharC1Worker")                        return new QVXorC_uCharC1Worker(name);
00164         else if (type == "QVLShiftC_uCharC1Worker")                     return new QVLShiftC_uCharC1Worker(name);
00165         else if (type == "QVRShiftC_uCharC1Worker")                     return new QVRShiftC_uCharC1Worker(name);
00166         else if (type == "QVRGBToGray_uCharC3C1Worker")                 return new QVRGBToGray_uCharC3C1Worker(name);
00167         else if (type == "QVRGBToGray_sFloatC3C1Worker")                        return new QVRGBToGray_sFloatC3C1Worker(name);
00168         else if (type == "QVThreshold_uCharC1Worker")                   return new QVThreshold_uCharC1Worker(name);
00169         else if (type == "QVThreshold_sFloatC1Worker")                  return new QVThreshold_sFloatC1Worker(name);
00170         else if (type == "QVComputeThreshold_Otsu_uCharC1Worker")                       return new QVComputeThreshold_Otsu_uCharC1Worker(name);
00171         else if (type == "QVCompare_uCharC1Worker")                     return new QVCompare_uCharC1Worker(name);
00172         else if (type == "QVCompare_sFloatC1Worker")                    return new QVCompare_sFloatC1Worker(name);
00173         else if (type == "QVCompareC_uCharC1Worker")                    return new QVCompareC_uCharC1Worker(name);
00174         else if (type == "QVCompareC_sFloatC1Worker")                   return new QVCompareC_sFloatC1Worker(name);
00175         else if (type == "QVFilterBox_uCharC1Worker")                   return new QVFilterBox_uCharC1Worker(name);
00176         else if (type == "QVFilterBox_uCharC3Worker")                   return new QVFilterBox_uCharC3Worker(name);
00177         else if (type == "QVFilterBox_sFloatC1Worker")                  return new QVFilterBox_sFloatC1Worker(name);
00178         else if (type == "QVFilterMin_uCharC1Worker")                   return new QVFilterMin_uCharC1Worker(name);
00179         else if (type == "QVFilterMin_uCharC3Worker")                   return new QVFilterMin_uCharC3Worker(name);
00180         else if (type == "QVFilterMin_sFloatC1Worker")                  return new QVFilterMin_sFloatC1Worker(name);
00181         else if (type == "QVFilterMax_uCharC1Worker")                   return new QVFilterMax_uCharC1Worker(name);
00182         else if (type == "QVFilterMax_uCharC3Worker")                   return new QVFilterMax_uCharC3Worker(name);
00183         else if (type == "QVFilterMax_sFloatC1Worker")                  return new QVFilterMax_sFloatC1Worker(name);
00184         else if (type == "QVFilterMedian_uCharC1Worker")                        return new QVFilterMedian_uCharC1Worker(name);
00185         else if (type == "QVFilterMedian_uCharC3Worker")                        return new QVFilterMedian_uCharC3Worker(name);
00186         else if (type == "QVFilterMedianHoriz_uCharC1Worker")                   return new QVFilterMedianHoriz_uCharC1Worker(name);
00187         else if (type == "QVFilterSobelHorizMask_sFloatC1Worker")                       return new QVFilterSobelHorizMask_sFloatC1Worker(name);
00188         else if (type == "QVFilterSobelVertMask_sFloatC1Worker")                        return new QVFilterSobelVertMask_sFloatC1Worker(name);
00189         else if (type == "QVFilterLaplace_uCharC1Worker")                       return new QVFilterLaplace_uCharC1Worker(name);
00190         else if (type == "QVFilterLaplace_sFloatC1Worker")                      return new QVFilterLaplace_sFloatC1Worker(name);
00191         else if (type == "QVFilterGauss_uCharC1Worker")                 return new QVFilterGauss_uCharC1Worker(name);
00192         else if (type == "QVFilterGauss_sFloatC1Worker")                        return new QVFilterGauss_sFloatC1Worker(name);
00193         else if (type == "QVFilterGauss_uCharC3Worker")                 return new QVFilterGauss_uCharC3Worker(name);
00194         else if (type == "QVFilterGauss_sFloatC3Worker")                        return new QVFilterGauss_sFloatC3Worker(name);
00195         else if (type == "QVFilterHipass_uCharC1Worker")                        return new QVFilterHipass_uCharC1Worker(name);
00196         else if (type == "QVFilterHipass_uCharC3Worker")                        return new QVFilterHipass_uCharC3Worker(name);
00197         else if (type == "QVFilterHipass_sFloatC1Worker")                       return new QVFilterHipass_sFloatC1Worker(name);
00198         else if (type == "QVFilterHipass_sFloatC3Worker")                       return new QVFilterHipass_sFloatC3Worker(name);
00199         else if (type == "QVFilterLowpass_uCharC1Worker")                       return new QVFilterLowpass_uCharC1Worker(name);
00200         else if (type == "QVFilterLowpass_sFloatC1Worker")                      return new QVFilterLowpass_sFloatC1Worker(name);
00201         else if (type == "QVSum_uCharC1Worker")                 return new QVSum_uCharC1Worker(name);
00202         else if (type == "QVMean_uCharC1Worker")                        return new QVMean_uCharC1Worker(name);
00203         else if (type == "QVMin_uCharC1Worker")                 return new QVMin_uCharC1Worker(name);
00204         else if (type == "QVMin_sFloatC1Worker")                        return new QVMin_sFloatC1Worker(name);
00205         else if (type == "QVMax_uCharC1Worker")                 return new QVMax_uCharC1Worker(name);
00206         else if (type == "QVMax_sFloatC1Worker")                        return new QVMax_sFloatC1Worker(name);
00207         else return NULL;
00208         }
00209 
00210 // Worker QVConvert_uCharsFloatC1Worker for IPP function ippiConvert_8u32f_C1R
00211 QVConvert_uCharsFloatC1Worker::QVConvert_uCharsFloatC1Worker(QString name): QVWorker(name)
00212         {
00213         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
00214         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00215         addProperty< QPoint >("destROIOffset", inputFlag);
00216         }
00217 
00218 void QVConvert_uCharsFloatC1Worker::iterate()
00219         {
00220         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
00221         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00222 
00223         QVImage<sFloat, 1> qvimage_pDst;
00224 
00225         Convert(qvimage_pSrc, qvimage_pDst, destROIOffset);
00226 
00227         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00228         }
00229 
00230 // Worker QVConvert_uCharsFloatC3Worker for IPP function ippiConvert_8u32f_C3R
00231 QVConvert_uCharsFloatC3Worker::QVConvert_uCharsFloatC3Worker(QString name): QVWorker(name)
00232         {
00233         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
00234         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
00235         addProperty< QPoint >("destROIOffset", inputFlag);
00236         }
00237 
00238 void QVConvert_uCharsFloatC3Worker::iterate()
00239         {
00240         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
00241         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00242 
00243         QVImage<sFloat, 3> qvimage_pDst;
00244 
00245         Convert(qvimage_pSrc, qvimage_pDst, destROIOffset);
00246 
00247         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
00248         }
00249 
00250 // Worker QVConvert_sFloatuCharC1Worker for IPP function ippiConvert_32f8u_C1R
00251 QVConvert_sFloatuCharC1Worker::QVConvert_sFloatuCharC1Worker(QString name): QVWorker(name)
00252         {
00253         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00254         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00255         addProperty< IppRoundMode >("roundMode", inputFlag);
00256         addProperty< QPoint >("destROIOffset", inputFlag);
00257         }
00258 
00259 void QVConvert_sFloatuCharC1Worker::iterate()
00260         {
00261         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00262         const IppRoundMode roundMode = getPropertyValue< IppRoundMode > ("roundMode");
00263         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00264 
00265         QVImage<uChar, 1> qvimage_pDst;
00266 
00267         Convert(qvimage_pSrc, qvimage_pDst, roundMode, destROIOffset);
00268 
00269         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00270         }
00271 
00272 // Worker QVConvert_sFloatuCharC3Worker for IPP function ippiConvert_32f8u_C3R
00273 QVConvert_sFloatuCharC3Worker::QVConvert_sFloatuCharC3Worker(QString name): QVWorker(name)
00274         {
00275         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc", inputFlag);
00276         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00277         addProperty< IppRoundMode >("roundMode", inputFlag);
00278         addProperty< QPoint >("destROIOffset", inputFlag);
00279         }
00280 
00281 void QVConvert_sFloatuCharC3Worker::iterate()
00282         {
00283         const QVImage<sFloat, 3> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc");
00284         const IppRoundMode roundMode = getPropertyValue< IppRoundMode > ("roundMode");
00285         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00286 
00287         QVImage<uChar, 3> qvimage_pDst;
00288 
00289         Convert(qvimage_pSrc, qvimage_pDst, roundMode, destROIOffset);
00290 
00291         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00292         }
00293 
00294 // Worker QVAdd_uCharC1Worker for IPP function ippiAdd_8u_C1RSfs
00295 QVAdd_uCharC1Worker::QVAdd_uCharC1Worker(QString name): QVWorker(name)
00296         {
00297         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00298         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00299         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00300         addProperty< int >("scaleFactor", inputFlag);
00301         addProperty< QPoint >("destROIOffset", inputFlag);
00302         }
00303 
00304 void QVAdd_uCharC1Worker::iterate()
00305         {
00306         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00307         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00308         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00309         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00310 
00311         QVImage<uChar, 1> qvimage_pDst;
00312 
00313         Add(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00314 
00315         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00316         }
00317 
00318 // Worker QVAdd_uCharC3Worker for IPP function ippiAdd_8u_C3RSfs
00319 QVAdd_uCharC3Worker::QVAdd_uCharC3Worker(QString name): QVWorker(name)
00320         {
00321         addProperty< QVImage<uChar, 3> >("qvimage_pSrc1", inputFlag);
00322         addProperty< QVImage<uChar, 3> >("qvimage_pSrc2", inputFlag);
00323         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00324         addProperty< int >("scaleFactor", inputFlag);
00325         addProperty< QPoint >("destROIOffset", inputFlag);
00326         }
00327 
00328 void QVAdd_uCharC3Worker::iterate()
00329         {
00330         const QVImage<uChar, 3> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc1");
00331         const QVImage<uChar, 3> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc2");
00332         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00333         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00334 
00335         QVImage<uChar, 3> qvimage_pDst;
00336 
00337         Add(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00338 
00339         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00340         }
00341 
00342 // Worker QVAdd_sFloatC1Worker for IPP function ippiAdd_32f_C1R
00343 QVAdd_sFloatC1Worker::QVAdd_sFloatC1Worker(QString name): QVWorker(name)
00344         {
00345         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
00346         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
00347         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00348         addProperty< QPoint >("destROIOffset", inputFlag);
00349         }
00350 
00351 void QVAdd_sFloatC1Worker::iterate()
00352         {
00353         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
00354         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
00355         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00356 
00357         QVImage<sFloat, 1> qvimage_pDst;
00358 
00359         Add(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00360 
00361         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00362         }
00363 
00364 // Worker QVAdd_sFloatC3Worker for IPP function ippiAdd_32f_C3R
00365 QVAdd_sFloatC3Worker::QVAdd_sFloatC3Worker(QString name): QVWorker(name)
00366         {
00367         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc1", inputFlag);
00368         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc2", inputFlag);
00369         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
00370         addProperty< QPoint >("destROIOffset", inputFlag);
00371         }
00372 
00373 void QVAdd_sFloatC3Worker::iterate()
00374         {
00375         const QVImage<sFloat, 3> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc1");
00376         const QVImage<sFloat, 3> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc2");
00377         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00378 
00379         QVImage<sFloat, 3> qvimage_pDst;
00380 
00381         Add(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00382 
00383         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
00384         }
00385 
00386 // Worker QVAddC_uCharC1Worker for IPP function ippiAddC_8u_C1RSfs
00387 QVAddC_uCharC1Worker::QVAddC_uCharC1Worker(QString name): QVWorker(name)
00388         {
00389         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
00390         addProperty< uChar >("value", inputFlag);
00391         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00392         addProperty< int >("scaleFactor", inputFlag);
00393         addProperty< QPoint >("destROIOffset", inputFlag);
00394         }
00395 
00396 void QVAddC_uCharC1Worker::iterate()
00397         {
00398         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
00399         const uChar value = getPropertyValue< uChar > ("value");
00400         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00401         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00402 
00403         QVImage<uChar, 1> qvimage_pDst;
00404 
00405         AddC(qvimage_pSrc, value, qvimage_pDst, scaleFactor, destROIOffset);
00406 
00407         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00408         }
00409 
00410 // Worker QVAddC_sFloatC1Worker for IPP function ippiAddC_32f_C1R
00411 QVAddC_sFloatC1Worker::QVAddC_sFloatC1Worker(QString name): QVWorker(name)
00412         {
00413         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00414         addProperty< sFloat >("value", inputFlag);
00415         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00416         addProperty< QPoint >("destROIOffset", inputFlag);
00417         }
00418 
00419 void QVAddC_sFloatC1Worker::iterate()
00420         {
00421         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00422         const sFloat value = getPropertyValue< sFloat > ("value");
00423         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00424 
00425         QVImage<sFloat, 1> qvimage_pDst;
00426 
00427         AddC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
00428 
00429         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00430         }
00431 
00432 // Worker QVMul_uCharC1Worker for IPP function ippiMul_8u_C1RSfs
00433 QVMul_uCharC1Worker::QVMul_uCharC1Worker(QString name): QVWorker(name)
00434         {
00435         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00436         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00437         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00438         addProperty< int >("scaleFactor", inputFlag);
00439         addProperty< QPoint >("destROIOffset", inputFlag);
00440         }
00441 
00442 void QVMul_uCharC1Worker::iterate()
00443         {
00444         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00445         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00446         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00447         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00448 
00449         QVImage<uChar, 1> qvimage_pDst;
00450 
00451         Mul(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00452 
00453         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00454         }
00455 
00456 // Worker QVMul_uCharC3Worker for IPP function ippiMul_8u_C3RSfs
00457 QVMul_uCharC3Worker::QVMul_uCharC3Worker(QString name): QVWorker(name)
00458         {
00459         addProperty< QVImage<uChar, 3> >("qvimage_pSrc1", inputFlag);
00460         addProperty< QVImage<uChar, 3> >("qvimage_pSrc2", inputFlag);
00461         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00462         addProperty< int >("scaleFactor", inputFlag);
00463         addProperty< QPoint >("destROIOffset", inputFlag);
00464         }
00465 
00466 void QVMul_uCharC3Worker::iterate()
00467         {
00468         const QVImage<uChar, 3> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc1");
00469         const QVImage<uChar, 3> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc2");
00470         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00471         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00472 
00473         QVImage<uChar, 3> qvimage_pDst;
00474 
00475         Mul(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00476 
00477         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00478         }
00479 
00480 // Worker QVMul_sFloatC3Worker for IPP function ippiMul_32f_C3R
00481 QVMul_sFloatC3Worker::QVMul_sFloatC3Worker(QString name): QVWorker(name)
00482         {
00483         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc1", inputFlag);
00484         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc2", inputFlag);
00485         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
00486         addProperty< QPoint >("destROIOffset", inputFlag);
00487         }
00488 
00489 void QVMul_sFloatC3Worker::iterate()
00490         {
00491         const QVImage<sFloat, 3> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc1");
00492         const QVImage<sFloat, 3> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc2");
00493         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00494 
00495         QVImage<sFloat, 3> qvimage_pDst;
00496 
00497         Mul(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00498 
00499         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
00500         }
00501 
00502 // Worker QVMul_sFloatC1Worker for IPP function ippiMul_32f_C1R
00503 QVMul_sFloatC1Worker::QVMul_sFloatC1Worker(QString name): QVWorker(name)
00504         {
00505         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
00506         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
00507         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00508         addProperty< QPoint >("destROIOffset", inputFlag);
00509         }
00510 
00511 void QVMul_sFloatC1Worker::iterate()
00512         {
00513         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
00514         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
00515         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00516 
00517         QVImage<sFloat, 1> qvimage_pDst;
00518 
00519         Mul(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00520 
00521         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00522         }
00523 
00524 // Worker QVMulC_uCharC1Worker for IPP function ippiMulC_8u_C1RSfs
00525 QVMulC_uCharC1Worker::QVMulC_uCharC1Worker(QString name): QVWorker(name)
00526         {
00527         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
00528         addProperty< uChar >("value", inputFlag);
00529         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00530         addProperty< int >("scaleFactor", inputFlag);
00531         addProperty< QPoint >("destROIOffset", inputFlag);
00532         }
00533 
00534 void QVMulC_uCharC1Worker::iterate()
00535         {
00536         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
00537         const uChar value = getPropertyValue< uChar > ("value");
00538         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00539         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00540 
00541         QVImage<uChar, 1> qvimage_pDst;
00542 
00543         MulC(qvimage_pSrc, value, qvimage_pDst, scaleFactor, destROIOffset);
00544 
00545         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00546         }
00547 
00548 // Worker QVMulC_sFloatC1Worker for IPP function ippiMulC_32f_C1R
00549 QVMulC_sFloatC1Worker::QVMulC_sFloatC1Worker(QString name): QVWorker(name)
00550         {
00551         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00552         addProperty< sFloat >("value", inputFlag);
00553         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00554         addProperty< QPoint >("destROIOffset", inputFlag);
00555         }
00556 
00557 void QVMulC_sFloatC1Worker::iterate()
00558         {
00559         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00560         const sFloat value = getPropertyValue< sFloat > ("value");
00561         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00562 
00563         QVImage<sFloat, 1> qvimage_pDst;
00564 
00565         MulC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
00566 
00567         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00568         }
00569 
00570 // Worker QVMulScale_uCharC1Worker for IPP function ippiMulScale_8u_C1R
00571 QVMulScale_uCharC1Worker::QVMulScale_uCharC1Worker(QString name): QVWorker(name)
00572         {
00573         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00574         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00575         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00576         addProperty< QPoint >("destROIOffset", inputFlag);
00577         }
00578 
00579 void QVMulScale_uCharC1Worker::iterate()
00580         {
00581         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00582         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00583         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00584 
00585         QVImage<uChar, 1> qvimage_pDst;
00586 
00587         MulScale(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00588 
00589         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00590         }
00591 
00592 // Worker QVMulScale_uCharC3Worker for IPP function ippiMulScale_8u_C3R
00593 QVMulScale_uCharC3Worker::QVMulScale_uCharC3Worker(QString name): QVWorker(name)
00594         {
00595         addProperty< QVImage<uChar, 3> >("qvimage_pSrc1", inputFlag);
00596         addProperty< QVImage<uChar, 3> >("qvimage_pSrc2", inputFlag);
00597         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00598         addProperty< QPoint >("destROIOffset", inputFlag);
00599         }
00600 
00601 void QVMulScale_uCharC3Worker::iterate()
00602         {
00603         const QVImage<uChar, 3> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc1");
00604         const QVImage<uChar, 3> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc2");
00605         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00606 
00607         QVImage<uChar, 3> qvimage_pDst;
00608 
00609         MulScale(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00610 
00611         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00612         }
00613 
00614 // Worker QVSub_uCharC1Worker for IPP function ippiSub_8u_C1RSfs
00615 QVSub_uCharC1Worker::QVSub_uCharC1Worker(QString name): QVWorker(name)
00616         {
00617         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00618         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00619         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00620         addProperty< int >("scaleFactor", inputFlag);
00621         addProperty< QPoint >("destROIOffset", inputFlag);
00622         }
00623 
00624 void QVSub_uCharC1Worker::iterate()
00625         {
00626         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00627         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00628         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00629         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00630 
00631         QVImage<uChar, 1> qvimage_pDst;
00632 
00633         Sub(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00634 
00635         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00636         }
00637 
00638 // Worker QVSub_uCharC3Worker for IPP function ippiSub_8u_C3RSfs
00639 QVSub_uCharC3Worker::QVSub_uCharC3Worker(QString name): QVWorker(name)
00640         {
00641         addProperty< QVImage<uChar, 3> >("qvimage_pSrc1", inputFlag);
00642         addProperty< QVImage<uChar, 3> >("qvimage_pSrc2", inputFlag);
00643         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00644         addProperty< int >("scaleFactor", inputFlag);
00645         addProperty< QPoint >("destROIOffset", inputFlag);
00646         }
00647 
00648 void QVSub_uCharC3Worker::iterate()
00649         {
00650         const QVImage<uChar, 3> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc1");
00651         const QVImage<uChar, 3> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc2");
00652         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00653         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00654 
00655         QVImage<uChar, 3> qvimage_pDst;
00656 
00657         Sub(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00658 
00659         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00660         }
00661 
00662 // Worker QVSub_sFloatC1Worker for IPP function ippiSub_32f_C1R
00663 QVSub_sFloatC1Worker::QVSub_sFloatC1Worker(QString name): QVWorker(name)
00664         {
00665         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
00666         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
00667         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00668         addProperty< QPoint >("destROIOffset", inputFlag);
00669         }
00670 
00671 void QVSub_sFloatC1Worker::iterate()
00672         {
00673         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
00674         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
00675         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00676 
00677         QVImage<sFloat, 1> qvimage_pDst;
00678 
00679         Sub(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00680 
00681         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00682         }
00683 
00684 // Worker QVSub_sFloatC3Worker for IPP function ippiSub_32f_C3R
00685 QVSub_sFloatC3Worker::QVSub_sFloatC3Worker(QString name): QVWorker(name)
00686         {
00687         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc1", inputFlag);
00688         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc2", inputFlag);
00689         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
00690         addProperty< QPoint >("destROIOffset", inputFlag);
00691         }
00692 
00693 void QVSub_sFloatC3Worker::iterate()
00694         {
00695         const QVImage<sFloat, 3> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc1");
00696         const QVImage<sFloat, 3> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc2");
00697         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00698 
00699         QVImage<sFloat, 3> qvimage_pDst;
00700 
00701         Sub(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00702 
00703         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
00704         }
00705 
00706 // Worker QVSubC_uCharC1Worker for IPP function ippiSubC_8u_C1RSfs
00707 QVSubC_uCharC1Worker::QVSubC_uCharC1Worker(QString name): QVWorker(name)
00708         {
00709         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
00710         addProperty< uChar >("value", inputFlag);
00711         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00712         addProperty< int >("scaleFactor", inputFlag);
00713         addProperty< QPoint >("destROIOffset", inputFlag);
00714         }
00715 
00716 void QVSubC_uCharC1Worker::iterate()
00717         {
00718         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
00719         const uChar value = getPropertyValue< uChar > ("value");
00720         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00721         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00722 
00723         QVImage<uChar, 1> qvimage_pDst;
00724 
00725         SubC(qvimage_pSrc, value, qvimage_pDst, scaleFactor, destROIOffset);
00726 
00727         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00728         }
00729 
00730 // Worker QVSubC_sFloatC1Worker for IPP function ippiSubC_32f_C1R
00731 QVSubC_sFloatC1Worker::QVSubC_sFloatC1Worker(QString name): QVWorker(name)
00732         {
00733         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00734         addProperty< sFloat >("value", inputFlag);
00735         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00736         addProperty< QPoint >("destROIOffset", inputFlag);
00737         }
00738 
00739 void QVSubC_sFloatC1Worker::iterate()
00740         {
00741         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00742         const sFloat value = getPropertyValue< sFloat > ("value");
00743         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00744 
00745         QVImage<sFloat, 1> qvimage_pDst;
00746 
00747         SubC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
00748 
00749         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00750         }
00751 
00752 // Worker QVDiv_uCharC1Worker for IPP function ippiDiv_8u_C1RSfs
00753 QVDiv_uCharC1Worker::QVDiv_uCharC1Worker(QString name): QVWorker(name)
00754         {
00755         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00756         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00757         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00758         addProperty< int >("scaleFactor", inputFlag);
00759         addProperty< QPoint >("destROIOffset", inputFlag);
00760         }
00761 
00762 void QVDiv_uCharC1Worker::iterate()
00763         {
00764         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00765         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00766         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00767         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00768 
00769         QVImage<uChar, 1> qvimage_pDst;
00770 
00771         Div(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00772 
00773         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00774         }
00775 
00776 // Worker QVDiv_uCharC3Worker for IPP function ippiDiv_8u_C3RSfs
00777 QVDiv_uCharC3Worker::QVDiv_uCharC3Worker(QString name): QVWorker(name)
00778         {
00779         addProperty< QVImage<uChar, 3> >("qvimage_pSrc1", inputFlag);
00780         addProperty< QVImage<uChar, 3> >("qvimage_pSrc2", inputFlag);
00781         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
00782         addProperty< int >("scaleFactor", inputFlag);
00783         addProperty< QPoint >("destROIOffset", inputFlag);
00784         }
00785 
00786 void QVDiv_uCharC3Worker::iterate()
00787         {
00788         const QVImage<uChar, 3> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc1");
00789         const QVImage<uChar, 3> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc2");
00790         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00791         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00792 
00793         QVImage<uChar, 3> qvimage_pDst;
00794 
00795         Div(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, scaleFactor, destROIOffset);
00796 
00797         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
00798         }
00799 
00800 // Worker QVDiv_sFloatC3Worker for IPP function ippiDiv_32f_C3R
00801 QVDiv_sFloatC3Worker::QVDiv_sFloatC3Worker(QString name): QVWorker(name)
00802         {
00803         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc1", inputFlag);
00804         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc2", inputFlag);
00805         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
00806         addProperty< QPoint >("destROIOffset", inputFlag);
00807         }
00808 
00809 void QVDiv_sFloatC3Worker::iterate()
00810         {
00811         const QVImage<sFloat, 3> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc1");
00812         const QVImage<sFloat, 3> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc2");
00813         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00814 
00815         QVImage<sFloat, 3> qvimage_pDst;
00816 
00817         Div(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00818 
00819         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
00820         }
00821 
00822 // Worker QVDiv_sFloatC1Worker for IPP function ippiDiv_32f_C1R
00823 QVDiv_sFloatC1Worker::QVDiv_sFloatC1Worker(QString name): QVWorker(name)
00824         {
00825         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
00826         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
00827         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00828         addProperty< QPoint >("destROIOffset", inputFlag);
00829         }
00830 
00831 void QVDiv_sFloatC1Worker::iterate()
00832         {
00833         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
00834         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
00835         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00836 
00837         QVImage<sFloat, 1> qvimage_pDst;
00838 
00839         Div(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00840 
00841         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00842         }
00843 
00844 // Worker QVDivC_uCharC1Worker for IPP function ippiDivC_8u_C1RSfs
00845 QVDivC_uCharC1Worker::QVDivC_uCharC1Worker(QString name): QVWorker(name)
00846         {
00847         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
00848         addProperty< uChar >("value", inputFlag);
00849         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00850         addProperty< int >("scaleFactor", inputFlag);
00851         addProperty< QPoint >("destROIOffset", inputFlag);
00852         }
00853 
00854 void QVDivC_uCharC1Worker::iterate()
00855         {
00856         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
00857         const uChar value = getPropertyValue< uChar > ("value");
00858         const int scaleFactor = getPropertyValue< int > ("scaleFactor");
00859         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00860 
00861         QVImage<uChar, 1> qvimage_pDst;
00862 
00863         DivC(qvimage_pSrc, value, qvimage_pDst, scaleFactor, destROIOffset);
00864 
00865         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00866         }
00867 
00868 // Worker QVDivC_sFloatC1Worker for IPP function ippiDivC_32f_C1R
00869 QVDivC_sFloatC1Worker::QVDivC_sFloatC1Worker(QString name): QVWorker(name)
00870         {
00871         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00872         addProperty< sFloat >("value", inputFlag);
00873         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00874         addProperty< QPoint >("destROIOffset", inputFlag);
00875         }
00876 
00877 void QVDivC_sFloatC1Worker::iterate()
00878         {
00879         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00880         const sFloat value = getPropertyValue< sFloat > ("value");
00881         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00882 
00883         QVImage<sFloat, 1> qvimage_pDst;
00884 
00885         DivC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
00886 
00887         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00888         }
00889 
00890 // Worker QVAbs_sShortC1Worker for IPP function ippiAbs_16s_C1R
00891 QVAbs_sShortC1Worker::QVAbs_sShortC1Worker(QString name): QVWorker(name)
00892         {
00893         addProperty< QVImage<sShort, 1> >("qvimage_pSrc", inputFlag);
00894         addProperty< QVImage<sShort, 1> >("qvimage_pDst", outputFlag);
00895         addProperty< QPoint >("destROIOffset", inputFlag);
00896         }
00897 
00898 void QVAbs_sShortC1Worker::iterate()
00899         {
00900         const QVImage<sShort, 1> qvimage_pSrc = getPropertyValue< QVImage<sShort, 1> > ("qvimage_pSrc");
00901         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00902 
00903         QVImage<sShort, 1> qvimage_pDst;
00904 
00905         Abs(qvimage_pSrc, qvimage_pDst, destROIOffset);
00906 
00907         setPropertyValue< QVImage<sShort, 1> >("qvimage_pDst", qvimage_pDst);
00908         }
00909 
00910 // Worker QVAbs_sFloatC1Worker for IPP function ippiAbs_32f_C1R
00911 QVAbs_sFloatC1Worker::QVAbs_sFloatC1Worker(QString name): QVWorker(name)
00912         {
00913         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00914         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00915         addProperty< QPoint >("destROIOffset", inputFlag);
00916         }
00917 
00918 void QVAbs_sFloatC1Worker::iterate()
00919         {
00920         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00921         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00922 
00923         QVImage<sFloat, 1> qvimage_pDst;
00924 
00925         Abs(qvimage_pSrc, qvimage_pDst, destROIOffset);
00926 
00927         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00928         }
00929 
00930 // Worker QVAbsDiff_uCharC1Worker for IPP function ippiAbsDiff_8u_C1R
00931 QVAbsDiff_uCharC1Worker::QVAbsDiff_uCharC1Worker(QString name): QVWorker(name)
00932         {
00933         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
00934         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
00935         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
00936         addProperty< QPoint >("destROIOffset", inputFlag);
00937         }
00938 
00939 void QVAbsDiff_uCharC1Worker::iterate()
00940         {
00941         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
00942         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
00943         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00944 
00945         QVImage<uChar, 1> qvimage_pDst;
00946 
00947         AbsDiff(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00948 
00949         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
00950         }
00951 
00952 // Worker QVAbsDiff_sFloatC1Worker for IPP function ippiAbsDiff_32f_C1R
00953 QVAbsDiff_sFloatC1Worker::QVAbsDiff_sFloatC1Worker(QString name): QVWorker(name)
00954         {
00955         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
00956         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
00957         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00958         addProperty< QPoint >("destROIOffset", inputFlag);
00959         }
00960 
00961 void QVAbsDiff_sFloatC1Worker::iterate()
00962         {
00963         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
00964         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
00965         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00966 
00967         QVImage<sFloat, 1> qvimage_pDst;
00968 
00969         AbsDiff(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, destROIOffset);
00970 
00971         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00972         }
00973 
00974 // Worker QVSqr_sFloatC1Worker for IPP function ippiSqr_32f_C1R
00975 QVSqr_sFloatC1Worker::QVSqr_sFloatC1Worker(QString name): QVWorker(name)
00976         {
00977         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00978         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00979         addProperty< QPoint >("destROIOffset", inputFlag);
00980         }
00981 
00982 void QVSqr_sFloatC1Worker::iterate()
00983         {
00984         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
00985         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
00986 
00987         QVImage<sFloat, 1> qvimage_pDst;
00988 
00989         Sqr(qvimage_pSrc, qvimage_pDst, destROIOffset);
00990 
00991         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
00992         }
00993 
00994 // Worker QVLn_sFloatC1Worker for IPP function ippiLn_32f_C1R
00995 QVLn_sFloatC1Worker::QVLn_sFloatC1Worker(QString name): QVWorker(name)
00996         {
00997         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
00998         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
00999         addProperty< QPoint >("destROIOffset", inputFlag);
01000         }
01001 
01002 void QVLn_sFloatC1Worker::iterate()
01003         {
01004         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01005         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01006 
01007         QVImage<sFloat, 1> qvimage_pDst;
01008 
01009         Ln(qvimage_pSrc, qvimage_pDst, destROIOffset);
01010 
01011         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01012         }
01013 
01014 // Worker QVLn_sFloatC3Worker for IPP function ippiLn_32f_C3R
01015 QVLn_sFloatC3Worker::QVLn_sFloatC3Worker(QString name): QVWorker(name)
01016         {
01017         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc", inputFlag);
01018         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
01019         addProperty< QPoint >("destROIOffset", inputFlag);
01020         }
01021 
01022 void QVLn_sFloatC3Worker::iterate()
01023         {
01024         const QVImage<sFloat, 3> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc");
01025         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01026 
01027         QVImage<sFloat, 3> qvimage_pDst;
01028 
01029         Ln(qvimage_pSrc, qvimage_pDst, destROIOffset);
01030 
01031         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
01032         }
01033 
01034 // Worker QVAndC_uCharC1Worker for IPP function ippiAndC_8u_C1R
01035 QVAndC_uCharC1Worker::QVAndC_uCharC1Worker(QString name): QVWorker(name)
01036         {
01037         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01038         addProperty< uChar >("value", inputFlag);
01039         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01040         addProperty< QPoint >("destROIOffset", inputFlag);
01041         }
01042 
01043 void QVAndC_uCharC1Worker::iterate()
01044         {
01045         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01046         const uChar value = getPropertyValue< uChar > ("value");
01047         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01048 
01049         QVImage<uChar, 1> qvimage_pDst;
01050 
01051         AndC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
01052 
01053         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01054         }
01055 
01056 // Worker QVNot_uCharC1Worker for IPP function ippiNot_8u_C1R
01057 QVNot_uCharC1Worker::QVNot_uCharC1Worker(QString name): QVWorker(name)
01058         {
01059         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01060         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01061         addProperty< QPoint >("destROIOffset", inputFlag);
01062         }
01063 
01064 void QVNot_uCharC1Worker::iterate()
01065         {
01066         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01067         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01068 
01069         QVImage<uChar, 1> qvimage_pDst;
01070 
01071         Not(qvimage_pSrc, qvimage_pDst, destROIOffset);
01072 
01073         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01074         }
01075 
01076 // Worker QVNot_uCharC3Worker for IPP function ippiNot_8u_C3R
01077 QVNot_uCharC3Worker::QVNot_uCharC3Worker(QString name): QVWorker(name)
01078         {
01079         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01080         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01081         addProperty< QPoint >("destROIOffset", inputFlag);
01082         }
01083 
01084 void QVNot_uCharC3Worker::iterate()
01085         {
01086         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01087         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01088 
01089         QVImage<uChar, 3> qvimage_pDst;
01090 
01091         Not(qvimage_pSrc, qvimage_pDst, destROIOffset);
01092 
01093         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01094         }
01095 
01096 // Worker QVOrC_uCharC1Worker for IPP function ippiOrC_8u_C1R
01097 QVOrC_uCharC1Worker::QVOrC_uCharC1Worker(QString name): QVWorker(name)
01098         {
01099         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01100         addProperty< uChar >("value", inputFlag);
01101         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01102         addProperty< QPoint >("destROIOffset", inputFlag);
01103         }
01104 
01105 void QVOrC_uCharC1Worker::iterate()
01106         {
01107         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01108         const uChar value = getPropertyValue< uChar > ("value");
01109         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01110 
01111         QVImage<uChar, 1> qvimage_pDst;
01112 
01113         OrC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
01114 
01115         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01116         }
01117 
01118 // Worker QVXorC_uCharC1Worker for IPP function ippiXorC_8u_C1R
01119 QVXorC_uCharC1Worker::QVXorC_uCharC1Worker(QString name): QVWorker(name)
01120         {
01121         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01122         addProperty< uChar >("value", inputFlag);
01123         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01124         addProperty< QPoint >("destROIOffset", inputFlag);
01125         }
01126 
01127 void QVXorC_uCharC1Worker::iterate()
01128         {
01129         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01130         const uChar value = getPropertyValue< uChar > ("value");
01131         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01132 
01133         QVImage<uChar, 1> qvimage_pDst;
01134 
01135         XorC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
01136 
01137         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01138         }
01139 
01140 // Worker QVLShiftC_uCharC1Worker for IPP function ippiLShiftC_8u_C1R
01141 QVLShiftC_uCharC1Worker::QVLShiftC_uCharC1Worker(QString name): QVWorker(name)
01142         {
01143         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01144         addProperty< uInt >("value", inputFlag);
01145         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01146         addProperty< QPoint >("destROIOffset", inputFlag);
01147         }
01148 
01149 void QVLShiftC_uCharC1Worker::iterate()
01150         {
01151         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01152         const uInt value = getPropertyValue< uInt > ("value");
01153         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01154 
01155         QVImage<uChar, 1> qvimage_pDst;
01156 
01157         LShiftC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
01158 
01159         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01160         }
01161 
01162 // Worker QVRShiftC_uCharC1Worker for IPP function ippiRShiftC_8u_C1R
01163 QVRShiftC_uCharC1Worker::QVRShiftC_uCharC1Worker(QString name): QVWorker(name)
01164         {
01165         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01166         addProperty< uInt >("value", inputFlag);
01167         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01168         addProperty< QPoint >("destROIOffset", inputFlag);
01169         }
01170 
01171 void QVRShiftC_uCharC1Worker::iterate()
01172         {
01173         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01174         const uInt value = getPropertyValue< uInt > ("value");
01175         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01176 
01177         QVImage<uChar, 1> qvimage_pDst;
01178 
01179         RShiftC(qvimage_pSrc, value, qvimage_pDst, destROIOffset);
01180 
01181         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01182         }
01183 
01184 // Worker QVRGBToGray_uCharC3C1Worker for IPP function ippiRGBToGray_8u_C3C1R
01185 QVRGBToGray_uCharC3C1Worker::QVRGBToGray_uCharC3C1Worker(QString name): QVWorker(name)
01186         {
01187         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01188         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01189         addProperty< QPoint >("destROIOffset", inputFlag);
01190         }
01191 
01192 void QVRGBToGray_uCharC3C1Worker::iterate()
01193         {
01194         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01195         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01196 
01197         QVImage<uChar, 1> qvimage_pDst;
01198 
01199         RGBToGray(qvimage_pSrc, qvimage_pDst, destROIOffset);
01200 
01201         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01202         }
01203 
01204 // Worker QVRGBToGray_sFloatC3C1Worker for IPP function ippiRGBToGray_32f_C3C1R
01205 QVRGBToGray_sFloatC3C1Worker::QVRGBToGray_sFloatC3C1Worker(QString name): QVWorker(name)
01206         {
01207         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc", inputFlag);
01208         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01209         addProperty< QPoint >("destROIOffset", inputFlag);
01210         }
01211 
01212 void QVRGBToGray_sFloatC3C1Worker::iterate()
01213         {
01214         const QVImage<sFloat, 3> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc");
01215         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01216 
01217         QVImage<sFloat, 1> qvimage_pDst;
01218 
01219         RGBToGray(qvimage_pSrc, qvimage_pDst, destROIOffset);
01220 
01221         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01222         }
01223 
01224 // Worker QVThreshold_uCharC1Worker for IPP function ippiThreshold_8u_C1R
01225 QVThreshold_uCharC1Worker::QVThreshold_uCharC1Worker(QString name): QVWorker(name)
01226         {
01227         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01228         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01229         addProperty< uChar >("threshold", inputFlag);
01230         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01231         addProperty< QPoint >("destROIOffset", inputFlag);
01232         }
01233 
01234 void QVThreshold_uCharC1Worker::iterate()
01235         {
01236         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01237         const uChar threshold = getPropertyValue< uChar > ("threshold");
01238         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01239         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01240 
01241         QVImage<uChar, 1> qvimage_pDst;
01242 
01243         Threshold(qvimage_pSrc, qvimage_pDst, threshold, ippCmpOp, destROIOffset);
01244 
01245         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01246         }
01247 
01248 // Worker QVThreshold_sFloatC1Worker for IPP function ippiThreshold_32f_C1R
01249 QVThreshold_sFloatC1Worker::QVThreshold_sFloatC1Worker(QString name): QVWorker(name)
01250         {
01251         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01252         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01253         addProperty< sFloat >("threshold", inputFlag);
01254         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01255         addProperty< QPoint >("destROIOffset", inputFlag);
01256         }
01257 
01258 void QVThreshold_sFloatC1Worker::iterate()
01259         {
01260         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01261         const sFloat threshold = getPropertyValue< sFloat > ("threshold");
01262         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01263         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01264 
01265         QVImage<sFloat, 1> qvimage_pDst;
01266 
01267         Threshold(qvimage_pSrc, qvimage_pDst, threshold, ippCmpOp, destROIOffset);
01268 
01269         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01270         }
01271 
01272 // Worker QVComputeThreshold_Otsu_uCharC1Worker for IPP function ippiComputeThreshold_Otsu_8u_C1R
01273 QVComputeThreshold_Otsu_uCharC1Worker::QVComputeThreshold_Otsu_uCharC1Worker(QString name): QVWorker(name)
01274         {
01275         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01276         addProperty< uChar >("pThreshold", outputFlag);
01277         }
01278 
01279 void QVComputeThreshold_Otsu_uCharC1Worker::iterate()
01280         {
01281         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01282 
01283         uChar pThreshold;
01284 
01285         ComputeThreshold_Otsu(qvimage_pSrc, pThreshold);
01286 
01287         setPropertyValue< uChar >("pThreshold", pThreshold);
01288         }
01289 
01290 // Worker QVCompare_uCharC1Worker for IPP function ippiCompare_8u_C1R
01291 QVCompare_uCharC1Worker::QVCompare_uCharC1Worker(QString name): QVWorker(name)
01292         {
01293         addProperty< QVImage<uChar, 1> >("qvimage_pSrc1", inputFlag);
01294         addProperty< QVImage<uChar, 1> >("qvimage_pSrc2", inputFlag);
01295         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01296         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01297         addProperty< QPoint >("destROIOffset", inputFlag);
01298         }
01299 
01300 void QVCompare_uCharC1Worker::iterate()
01301         {
01302         const QVImage<uChar, 1> qvimage_pSrc1 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc1");
01303         const QVImage<uChar, 1> qvimage_pSrc2 = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc2");
01304         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01305         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01306 
01307         QVImage<uChar, 1> qvimage_pDst;
01308 
01309         Compare(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, ippCmpOp, destROIOffset);
01310 
01311         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01312         }
01313 
01314 // Worker QVCompare_sFloatC1Worker for IPP function ippiCompare_32f_C1R
01315 QVCompare_sFloatC1Worker::QVCompare_sFloatC1Worker(QString name): QVWorker(name)
01316         {
01317         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc1", inputFlag);
01318         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc2", inputFlag);
01319         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01320         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01321         addProperty< QPoint >("destROIOffset", inputFlag);
01322         }
01323 
01324 void QVCompare_sFloatC1Worker::iterate()
01325         {
01326         const QVImage<sFloat, 1> qvimage_pSrc1 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc1");
01327         const QVImage<sFloat, 1> qvimage_pSrc2 = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc2");
01328         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01329         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01330 
01331         QVImage<uChar, 1> qvimage_pDst;
01332 
01333         Compare(qvimage_pSrc1, qvimage_pSrc2, qvimage_pDst, ippCmpOp, destROIOffset);
01334 
01335         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01336         }
01337 
01338 // Worker QVCompareC_uCharC1Worker for IPP function ippiCompareC_8u_C1R
01339 QVCompareC_uCharC1Worker::QVCompareC_uCharC1Worker(QString name): QVWorker(name)
01340         {
01341         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01342         addProperty< uChar >("value", inputFlag);
01343         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01344         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01345         addProperty< QPoint >("destROIOffset", inputFlag);
01346         }
01347 
01348 void QVCompareC_uCharC1Worker::iterate()
01349         {
01350         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01351         const uChar value = getPropertyValue< uChar > ("value");
01352         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01353         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01354 
01355         QVImage<uChar, 1> qvimage_pDst;
01356 
01357         CompareC(qvimage_pSrc, value, qvimage_pDst, ippCmpOp, destROIOffset);
01358 
01359         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01360         }
01361 
01362 // Worker QVCompareC_sFloatC1Worker for IPP function ippiCompareC_32f_C1R
01363 QVCompareC_sFloatC1Worker::QVCompareC_sFloatC1Worker(QString name): QVWorker(name)
01364         {
01365         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01366         addProperty< sFloat >("value", inputFlag);
01367         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01368         addProperty< IppCmpOp >("ippCmpOp", inputFlag);
01369         addProperty< QPoint >("destROIOffset", inputFlag);
01370         }
01371 
01372 void QVCompareC_sFloatC1Worker::iterate()
01373         {
01374         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01375         const sFloat value = getPropertyValue< sFloat > ("value");
01376         const IppCmpOp ippCmpOp = getPropertyValue< IppCmpOp > ("ippCmpOp");
01377         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01378 
01379         QVImage<uChar, 1> qvimage_pDst;
01380 
01381         CompareC(qvimage_pSrc, value, qvimage_pDst, ippCmpOp, destROIOffset);
01382 
01383         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01384         }
01385 
01386 // Worker QVFilterBox_uCharC1Worker for IPP function ippiFilterBox_8u_C1R
01387 QVFilterBox_uCharC1Worker::QVFilterBox_uCharC1Worker(QString name): QVWorker(name)
01388         {
01389         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01390         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01391         addProperty< QSize >("maskSize", inputFlag);
01392         addProperty< QPoint >("anchor", inputFlag);
01393         addProperty< QPoint >("destROIOffset", inputFlag);
01394         }
01395 
01396 void QVFilterBox_uCharC1Worker::iterate()
01397         {
01398         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01399         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01400         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01401         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01402 
01403         QVImage<uChar, 1> qvimage_pDst;
01404 
01405         FilterBox(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01406 
01407         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01408         }
01409 
01410 // Worker QVFilterBox_uCharC3Worker for IPP function ippiFilterBox_8u_C3R
01411 QVFilterBox_uCharC3Worker::QVFilterBox_uCharC3Worker(QString name): QVWorker(name)
01412         {
01413         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01414         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01415         addProperty< QSize >("maskSize", inputFlag);
01416         addProperty< QPoint >("anchor", inputFlag);
01417         addProperty< QPoint >("destROIOffset", inputFlag);
01418         }
01419 
01420 void QVFilterBox_uCharC3Worker::iterate()
01421         {
01422         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01423         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01424         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01425         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01426 
01427         QVImage<uChar, 3> qvimage_pDst;
01428 
01429         FilterBox(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01430 
01431         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01432         }
01433 
01434 // Worker QVFilterBox_sFloatC1Worker for IPP function ippiFilterBox_32f_C1R
01435 QVFilterBox_sFloatC1Worker::QVFilterBox_sFloatC1Worker(QString name): QVWorker(name)
01436         {
01437         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01438         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01439         addProperty< QSize >("maskSize", inputFlag);
01440         addProperty< QPoint >("anchor", inputFlag);
01441         addProperty< QPoint >("destROIOffset", inputFlag);
01442         }
01443 
01444 void QVFilterBox_sFloatC1Worker::iterate()
01445         {
01446         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01447         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01448         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01449         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01450 
01451         QVImage<sFloat, 1> qvimage_pDst;
01452 
01453         FilterBox(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01454 
01455         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01456         }
01457 
01458 // Worker QVFilterMin_uCharC1Worker for IPP function ippiFilterMin_8u_C1R
01459 QVFilterMin_uCharC1Worker::QVFilterMin_uCharC1Worker(QString name): QVWorker(name)
01460         {
01461         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01462         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01463         addProperty< QSize >("maskSize", inputFlag);
01464         addProperty< QPoint >("anchor", inputFlag);
01465         addProperty< QPoint >("destROIOffset", inputFlag);
01466         }
01467 
01468 void QVFilterMin_uCharC1Worker::iterate()
01469         {
01470         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01471         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01472         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01473         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01474 
01475         QVImage<uChar, 1> qvimage_pDst;
01476 
01477         FilterMin(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01478 
01479         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01480         }
01481 
01482 // Worker QVFilterMin_uCharC3Worker for IPP function ippiFilterMin_8u_C3R
01483 QVFilterMin_uCharC3Worker::QVFilterMin_uCharC3Worker(QString name): QVWorker(name)
01484         {
01485         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01486         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01487         addProperty< QSize >("maskSize", inputFlag);
01488         addProperty< QPoint >("anchor", inputFlag);
01489         addProperty< QPoint >("destROIOffset", inputFlag);
01490         }
01491 
01492 void QVFilterMin_uCharC3Worker::iterate()
01493         {
01494         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01495         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01496         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01497         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01498 
01499         QVImage<uChar, 3> qvimage_pDst;
01500 
01501         FilterMin(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01502 
01503         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01504         }
01505 
01506 // Worker QVFilterMin_sFloatC1Worker for IPP function ippiFilterMin_32f_C1R
01507 QVFilterMin_sFloatC1Worker::QVFilterMin_sFloatC1Worker(QString name): QVWorker(name)
01508         {
01509         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01510         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01511         addProperty< QSize >("maskSize", inputFlag);
01512         addProperty< QPoint >("anchor", inputFlag);
01513         addProperty< QPoint >("destROIOffset", inputFlag);
01514         }
01515 
01516 void QVFilterMin_sFloatC1Worker::iterate()
01517         {
01518         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01519         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01520         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01521         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01522 
01523         QVImage<sFloat, 1> qvimage_pDst;
01524 
01525         FilterMin(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01526 
01527         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01528         }
01529 
01530 // Worker QVFilterMax_uCharC1Worker for IPP function ippiFilterMax_8u_C1R
01531 QVFilterMax_uCharC1Worker::QVFilterMax_uCharC1Worker(QString name): QVWorker(name)
01532         {
01533         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01534         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01535         addProperty< QSize >("maskSize", inputFlag);
01536         addProperty< QPoint >("anchor", inputFlag);
01537         addProperty< QPoint >("destROIOffset", inputFlag);
01538         }
01539 
01540 void QVFilterMax_uCharC1Worker::iterate()
01541         {
01542         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01543         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01544         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01545         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01546 
01547         QVImage<uChar, 1> qvimage_pDst;
01548 
01549         FilterMax(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01550 
01551         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01552         }
01553 
01554 // Worker QVFilterMax_uCharC3Worker for IPP function ippiFilterMax_8u_C3R
01555 QVFilterMax_uCharC3Worker::QVFilterMax_uCharC3Worker(QString name): QVWorker(name)
01556         {
01557         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01558         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01559         addProperty< QSize >("maskSize", inputFlag);
01560         addProperty< QPoint >("anchor", inputFlag);
01561         addProperty< QPoint >("destROIOffset", inputFlag);
01562         }
01563 
01564 void QVFilterMax_uCharC3Worker::iterate()
01565         {
01566         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01567         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01568         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01569         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01570 
01571         QVImage<uChar, 3> qvimage_pDst;
01572 
01573         FilterMax(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01574 
01575         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01576         }
01577 
01578 // Worker QVFilterMax_sFloatC1Worker for IPP function ippiFilterMax_32f_C1R
01579 QVFilterMax_sFloatC1Worker::QVFilterMax_sFloatC1Worker(QString name): QVWorker(name)
01580         {
01581         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01582         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01583         addProperty< QSize >("maskSize", inputFlag);
01584         addProperty< QPoint >("anchor", inputFlag);
01585         addProperty< QPoint >("destROIOffset", inputFlag);
01586         }
01587 
01588 void QVFilterMax_sFloatC1Worker::iterate()
01589         {
01590         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01591         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01592         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01593         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01594 
01595         QVImage<sFloat, 1> qvimage_pDst;
01596 
01597         FilterMax(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01598 
01599         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01600         }
01601 
01602 // Worker QVFilterMedian_uCharC1Worker for IPP function ippiFilterMedian_8u_C1R
01603 QVFilterMedian_uCharC1Worker::QVFilterMedian_uCharC1Worker(QString name): QVWorker(name)
01604         {
01605         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01606         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01607         addProperty< QSize >("maskSize", inputFlag);
01608         addProperty< QPoint >("anchor", inputFlag);
01609         addProperty< QPoint >("destROIOffset", inputFlag);
01610         }
01611 
01612 void QVFilterMedian_uCharC1Worker::iterate()
01613         {
01614         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01615         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01616         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01617         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01618 
01619         QVImage<uChar, 1> qvimage_pDst;
01620 
01621         FilterMedian(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01622 
01623         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01624         }
01625 
01626 // Worker QVFilterMedian_uCharC3Worker for IPP function ippiFilterMedian_8u_C3R
01627 QVFilterMedian_uCharC3Worker::QVFilterMedian_uCharC3Worker(QString name): QVWorker(name)
01628         {
01629         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01630         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01631         addProperty< QSize >("maskSize", inputFlag);
01632         addProperty< QPoint >("anchor", inputFlag);
01633         addProperty< QPoint >("destROIOffset", inputFlag);
01634         }
01635 
01636 void QVFilterMedian_uCharC3Worker::iterate()
01637         {
01638         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01639         const QSize maskSize = getPropertyValue< QSize > ("maskSize");
01640         const QPoint anchor = getPropertyValue< QPoint > ("anchor");
01641         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01642 
01643         QVImage<uChar, 3> qvimage_pDst;
01644 
01645         FilterMedian(qvimage_pSrc, qvimage_pDst, maskSize, anchor, destROIOffset);
01646 
01647         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01648         }
01649 
01650 // Worker QVFilterMedianHoriz_uCharC1Worker for IPP function ippiFilterMedianHoriz_8u_C1R
01651 QVFilterMedianHoriz_uCharC1Worker::QVFilterMedianHoriz_uCharC1Worker(QString name): QVWorker(name)
01652         {
01653         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01654         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01655         addProperty< IppiMaskSize >("mask", inputFlag);
01656         addProperty< QPoint >("destROIOffset", inputFlag);
01657         }
01658 
01659 void QVFilterMedianHoriz_uCharC1Worker::iterate()
01660         {
01661         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01662         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01663         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01664 
01665         QVImage<uChar, 1> qvimage_pDst;
01666 
01667         FilterMedianHoriz(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01668 
01669         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01670         }
01671 
01672 // Worker QVFilterSobelHorizMask_sFloatC1Worker for IPP function ippiFilterSobelHorizMask_32f_C1R
01673 QVFilterSobelHorizMask_sFloatC1Worker::QVFilterSobelHorizMask_sFloatC1Worker(QString name): QVWorker(name)
01674         {
01675         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01676         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01677         addProperty< IppiMaskSize >("mask", inputFlag);
01678         addProperty< QPoint >("destROIOffset", inputFlag);
01679         }
01680 
01681 void QVFilterSobelHorizMask_sFloatC1Worker::iterate()
01682         {
01683         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01684         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01685         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01686 
01687         QVImage<sFloat, 1> qvimage_pDst;
01688 
01689         FilterSobelHorizMask(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01690 
01691         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01692         }
01693 
01694 // Worker QVFilterSobelVertMask_sFloatC1Worker for IPP function ippiFilterSobelVertMask_32f_C1R
01695 QVFilterSobelVertMask_sFloatC1Worker::QVFilterSobelVertMask_sFloatC1Worker(QString name): QVWorker(name)
01696         {
01697         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01698         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01699         addProperty< IppiMaskSize >("mask", inputFlag);
01700         addProperty< QPoint >("destROIOffset", inputFlag);
01701         }
01702 
01703 void QVFilterSobelVertMask_sFloatC1Worker::iterate()
01704         {
01705         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01706         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01707         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01708 
01709         QVImage<sFloat, 1> qvimage_pDst;
01710 
01711         FilterSobelVertMask(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01712 
01713         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01714         }
01715 
01716 // Worker QVFilterLaplace_uCharC1Worker for IPP function ippiFilterLaplace_8u_C1R
01717 QVFilterLaplace_uCharC1Worker::QVFilterLaplace_uCharC1Worker(QString name): QVWorker(name)
01718         {
01719         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01720         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01721         addProperty< IppiMaskSize >("mask", inputFlag);
01722         addProperty< QPoint >("destROIOffset", inputFlag);
01723         }
01724 
01725 void QVFilterLaplace_uCharC1Worker::iterate()
01726         {
01727         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01728         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01729         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01730 
01731         QVImage<uChar, 1> qvimage_pDst;
01732 
01733         FilterLaplace(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01734 
01735         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01736         }
01737 
01738 // Worker QVFilterLaplace_sFloatC1Worker for IPP function ippiFilterLaplace_32f_C1R
01739 QVFilterLaplace_sFloatC1Worker::QVFilterLaplace_sFloatC1Worker(QString name): QVWorker(name)
01740         {
01741         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01742         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01743         addProperty< IppiMaskSize >("mask", inputFlag);
01744         addProperty< QPoint >("destROIOffset", inputFlag);
01745         }
01746 
01747 void QVFilterLaplace_sFloatC1Worker::iterate()
01748         {
01749         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01750         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01751         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01752 
01753         QVImage<sFloat, 1> qvimage_pDst;
01754 
01755         FilterLaplace(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01756 
01757         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01758         }
01759 
01760 // Worker QVFilterGauss_uCharC1Worker for IPP function ippiFilterGauss_8u_C1R
01761 QVFilterGauss_uCharC1Worker::QVFilterGauss_uCharC1Worker(QString name): QVWorker(name)
01762         {
01763         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01764         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01765         addProperty< IppiMaskSize >("mask", inputFlag);
01766         addProperty< QPoint >("destROIOffset", inputFlag);
01767         }
01768 
01769 void QVFilterGauss_uCharC1Worker::iterate()
01770         {
01771         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01772         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01773         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01774 
01775         QVImage<uChar, 1> qvimage_pDst;
01776 
01777         FilterGauss(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01778 
01779         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01780         }
01781 
01782 // Worker QVFilterGauss_sFloatC1Worker for IPP function ippiFilterGauss_32f_C1R
01783 QVFilterGauss_sFloatC1Worker::QVFilterGauss_sFloatC1Worker(QString name): QVWorker(name)
01784         {
01785         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01786         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01787         addProperty< IppiMaskSize >("mask", inputFlag);
01788         addProperty< QPoint >("destROIOffset", inputFlag);
01789         }
01790 
01791 void QVFilterGauss_sFloatC1Worker::iterate()
01792         {
01793         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01794         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01795         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01796 
01797         QVImage<sFloat, 1> qvimage_pDst;
01798 
01799         FilterGauss(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01800 
01801         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01802         }
01803 
01804 // Worker QVFilterGauss_uCharC3Worker for IPP function ippiFilterGauss_8u_C3R
01805 QVFilterGauss_uCharC3Worker::QVFilterGauss_uCharC3Worker(QString name): QVWorker(name)
01806         {
01807         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01808         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01809         addProperty< IppiMaskSize >("mask", inputFlag);
01810         addProperty< QPoint >("destROIOffset", inputFlag);
01811         }
01812 
01813 void QVFilterGauss_uCharC3Worker::iterate()
01814         {
01815         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01816         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01817         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01818 
01819         QVImage<uChar, 3> qvimage_pDst;
01820 
01821         FilterGauss(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01822 
01823         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01824         }
01825 
01826 // Worker QVFilterGauss_sFloatC3Worker for IPP function ippiFilterGauss_32f_C3R
01827 QVFilterGauss_sFloatC3Worker::QVFilterGauss_sFloatC3Worker(QString name): QVWorker(name)
01828         {
01829         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc", inputFlag);
01830         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
01831         addProperty< IppiMaskSize >("mask", inputFlag);
01832         addProperty< QPoint >("destROIOffset", inputFlag);
01833         }
01834 
01835 void QVFilterGauss_sFloatC3Worker::iterate()
01836         {
01837         const QVImage<sFloat, 3> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc");
01838         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01839         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01840 
01841         QVImage<sFloat, 3> qvimage_pDst;
01842 
01843         FilterGauss(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01844 
01845         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
01846         }
01847 
01848 // Worker QVFilterHipass_uCharC1Worker for IPP function ippiFilterHipass_8u_C1R
01849 QVFilterHipass_uCharC1Worker::QVFilterHipass_uCharC1Worker(QString name): QVWorker(name)
01850         {
01851         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01852         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01853         addProperty< IppiMaskSize >("mask", inputFlag);
01854         addProperty< QPoint >("destROIOffset", inputFlag);
01855         }
01856 
01857 void QVFilterHipass_uCharC1Worker::iterate()
01858         {
01859         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01860         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01861         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01862 
01863         QVImage<uChar, 1> qvimage_pDst;
01864 
01865         FilterHipass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01866 
01867         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01868         }
01869 
01870 // Worker QVFilterHipass_uCharC3Worker for IPP function ippiFilterHipass_8u_C3R
01871 QVFilterHipass_uCharC3Worker::QVFilterHipass_uCharC3Worker(QString name): QVWorker(name)
01872         {
01873         addProperty< QVImage<uChar, 3> >("qvimage_pSrc", inputFlag);
01874         addProperty< QVImage<uChar, 3> >("qvimage_pDst", outputFlag);
01875         addProperty< IppiMaskSize >("mask", inputFlag);
01876         addProperty< QPoint >("destROIOffset", inputFlag);
01877         }
01878 
01879 void QVFilterHipass_uCharC3Worker::iterate()
01880         {
01881         const QVImage<uChar, 3> qvimage_pSrc = getPropertyValue< QVImage<uChar, 3> > ("qvimage_pSrc");
01882         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01883         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01884 
01885         QVImage<uChar, 3> qvimage_pDst;
01886 
01887         FilterHipass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01888 
01889         setPropertyValue< QVImage<uChar, 3> >("qvimage_pDst", qvimage_pDst);
01890         }
01891 
01892 // Worker QVFilterHipass_sFloatC1Worker for IPP function ippiFilterHipass_32f_C1R
01893 QVFilterHipass_sFloatC1Worker::QVFilterHipass_sFloatC1Worker(QString name): QVWorker(name)
01894         {
01895         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01896         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01897         addProperty< IppiMaskSize >("mask", inputFlag);
01898         addProperty< QPoint >("destROIOffset", inputFlag);
01899         }
01900 
01901 void QVFilterHipass_sFloatC1Worker::iterate()
01902         {
01903         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01904         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01905         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01906 
01907         QVImage<sFloat, 1> qvimage_pDst;
01908 
01909         FilterHipass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01910 
01911         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01912         }
01913 
01914 // Worker QVFilterHipass_sFloatC3Worker for IPP function ippiFilterHipass_32f_C3R
01915 QVFilterHipass_sFloatC3Worker::QVFilterHipass_sFloatC3Worker(QString name): QVWorker(name)
01916         {
01917         addProperty< QVImage<sFloat, 3> >("qvimage_pSrc", inputFlag);
01918         addProperty< QVImage<sFloat, 3> >("qvimage_pDst", outputFlag);
01919         addProperty< IppiMaskSize >("mask", inputFlag);
01920         addProperty< QPoint >("destROIOffset", inputFlag);
01921         }
01922 
01923 void QVFilterHipass_sFloatC3Worker::iterate()
01924         {
01925         const QVImage<sFloat, 3> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 3> > ("qvimage_pSrc");
01926         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01927         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01928 
01929         QVImage<sFloat, 3> qvimage_pDst;
01930 
01931         FilterHipass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01932 
01933         setPropertyValue< QVImage<sFloat, 3> >("qvimage_pDst", qvimage_pDst);
01934         }
01935 
01936 // Worker QVFilterLowpass_uCharC1Worker for IPP function ippiFilterLowpass_8u_C1R
01937 QVFilterLowpass_uCharC1Worker::QVFilterLowpass_uCharC1Worker(QString name): QVWorker(name)
01938         {
01939         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01940         addProperty< QVImage<uChar, 1> >("qvimage_pDst", outputFlag);
01941         addProperty< IppiMaskSize >("mask", inputFlag);
01942         addProperty< QPoint >("destROIOffset", inputFlag);
01943         }
01944 
01945 void QVFilterLowpass_uCharC1Worker::iterate()
01946         {
01947         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01948         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01949         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01950 
01951         QVImage<uChar, 1> qvimage_pDst;
01952 
01953         FilterLowpass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01954 
01955         setPropertyValue< QVImage<uChar, 1> >("qvimage_pDst", qvimage_pDst);
01956         }
01957 
01958 // Worker QVFilterLowpass_sFloatC1Worker for IPP function ippiFilterLowpass_32f_C1R
01959 QVFilterLowpass_sFloatC1Worker::QVFilterLowpass_sFloatC1Worker(QString name): QVWorker(name)
01960         {
01961         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
01962         addProperty< QVImage<sFloat, 1> >("qvimage_pDst", outputFlag);
01963         addProperty< IppiMaskSize >("mask", inputFlag);
01964         addProperty< QPoint >("destROIOffset", inputFlag);
01965         }
01966 
01967 void QVFilterLowpass_sFloatC1Worker::iterate()
01968         {
01969         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
01970         const IppiMaskSize mask = getPropertyValue< IppiMaskSize > ("mask");
01971         const QPoint destROIOffset = getPropertyValue< QPoint > ("destROIOffset");
01972 
01973         QVImage<sFloat, 1> qvimage_pDst;
01974 
01975         FilterLowpass(qvimage_pSrc, qvimage_pDst, mask, destROIOffset);
01976 
01977         setPropertyValue< QVImage<sFloat, 1> >("qvimage_pDst", qvimage_pDst);
01978         }
01979 
01980 // Worker QVSum_uCharC1Worker for IPP function ippiSum_8u_C1R
01981 QVSum_uCharC1Worker::QVSum_uCharC1Worker(QString name): QVWorker(name)
01982         {
01983         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
01984         addProperty< sDouble >("pSum", outputFlag);
01985         }
01986 
01987 void QVSum_uCharC1Worker::iterate()
01988         {
01989         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
01990 
01991         sDouble pSum;
01992 
01993         Sum(qvimage_pSrc, pSum);
01994 
01995         setPropertyValue< sDouble >("pSum", pSum);
01996         }
01997 
01998 // Worker QVMean_uCharC1Worker for IPP function ippiMean_8u_C1R
01999 QVMean_uCharC1Worker::QVMean_uCharC1Worker(QString name): QVWorker(name)
02000         {
02001         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
02002         addProperty< sDouble >("pMean", outputFlag);
02003         }
02004 
02005 void QVMean_uCharC1Worker::iterate()
02006         {
02007         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
02008 
02009         sDouble pMean;
02010 
02011         Mean(qvimage_pSrc, pMean);
02012 
02013         setPropertyValue< sDouble >("pMean", pMean);
02014         }
02015 
02016 // Worker QVMin_uCharC1Worker for IPP function ippiMin_8u_C1R
02017 QVMin_uCharC1Worker::QVMin_uCharC1Worker(QString name): QVWorker(name)
02018         {
02019         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
02020         addProperty< uChar >("pMin", outputFlag);
02021         }
02022 
02023 void QVMin_uCharC1Worker::iterate()
02024         {
02025         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
02026 
02027         uChar pMin;
02028 
02029         Min(qvimage_pSrc, pMin);
02030 
02031         setPropertyValue< uChar >("pMin", pMin);
02032         }
02033 
02034 // Worker QVMin_sFloatC1Worker for IPP function ippiMin_32f_C1R
02035 QVMin_sFloatC1Worker::QVMin_sFloatC1Worker(QString name): QVWorker(name)
02036         {
02037         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
02038         addProperty< sFloat >("pMin", outputFlag);
02039         }
02040 
02041 void QVMin_sFloatC1Worker::iterate()
02042         {
02043         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
02044 
02045         sFloat pMin;
02046 
02047         Min(qvimage_pSrc, pMin);
02048 
02049         setPropertyValue< sFloat >("pMin", pMin);
02050         }
02051 
02052 // Worker QVMax_uCharC1Worker for IPP function ippiMax_8u_C1R
02053 QVMax_uCharC1Worker::QVMax_uCharC1Worker(QString name): QVWorker(name)
02054         {
02055         addProperty< QVImage<uChar, 1> >("qvimage_pSrc", inputFlag);
02056         addProperty< uChar >("pMax", outputFlag);
02057         }
02058 
02059 void QVMax_uCharC1Worker::iterate()
02060         {
02061         const QVImage<uChar, 1> qvimage_pSrc = getPropertyValue< QVImage<uChar, 1> > ("qvimage_pSrc");
02062 
02063         uChar pMax;
02064 
02065         Max(qvimage_pSrc, pMax);
02066 
02067         setPropertyValue< uChar >("pMax", pMax);
02068         }
02069 
02070 // Worker QVMax_sFloatC1Worker for IPP function ippiMax_32f_C1R
02071 QVMax_sFloatC1Worker::QVMax_sFloatC1Worker(QString name): QVWorker(name)
02072         {
02073         addProperty< QVImage<sFloat, 1> >("qvimage_pSrc", inputFlag);
02074         addProperty< sFloat >("pMax", outputFlag);
02075         }
02076 
02077 void QVMax_sFloatC1Worker::iterate()
02078         {
02079         const QVImage<sFloat, 1> qvimage_pSrc = getPropertyValue< QVImage<sFloat, 1> > ("qvimage_pSrc");
02080 
02081         sFloat pMax;
02082 
02083         Max(qvimage_pSrc, pMax);
02084 
02085         setPropertyValue< sFloat >("pMax", pMax);
02086         }
02087 
02088 



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