src/qvip/qvipp/qvippworkers.cpp

Go to the documentation of this file.
00001 /*
00002  *      Copyright (C) 2007, 2008. PARP Research Group.
00003  *      <http://perception.inf.um.es>
00004  *      University of Murcia, Spain.
00005  *
00006  *      This file is part of the QVision library.
00007  *
00008  *      QVision is free software: you can redistribute it and/or modify
00009  *      it under the terms of the GNU Lesser General Public License as
00010  *      published by the Free Software Foundation, version 3 of the License.
00011  *
00012  *      QVision is distributed in the hope that it will be useful,
00013  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *      GNU Lesser General Public License for more details.
00016  *
00017  *      You should have received a copy of the GNU Lesser General Public
00018  *      License along with QVision. If not, see <http://www.gnu.org/licenses/>.
00019  */
00020 
00024 
00025 #include <qvippworkers.h>
00026 #include <qvip/qvipp/macros.h>
00027 
00029 // Macros
00030 // IppiMaskSize
00031 #define ADD_IPPI_MASK_SIZE_PROPERTY(Name)               \
00032         QVIndexedStringList Name ## _choice;            \
00033         /*Name ## _choice.append("ippMskSize1x3");      \
00034         Name ## _choice.append("ippMskSize1x5");        \
00035         Name ## _choice.append("ippMskSize3x1");*/      \
00036         Name ## _choice.append("ippMskSize3x3");        \
00037         /*Name ## _choice.append("ippMskSize5x1");*/    \
00038         Name ## _choice.append("ippMskSize5x5");        \
00039         addProperty< QVIndexedStringList >("" # Name, inputFlag, Name ## _choice);
00040 
00041 #define GET_IPPI_MASK_SIZE_PROPERTY(Name)                                                               \
00042         const QString Name ## _indexedStringList =                                                      \
00043                                 getPropertyValue< QVIndexedStringList >("" #Name).getCurrent();         \
00044         const IppiMaskSize Name =                                                                       \
00045                                 (Name ## _indexedStringList == "ippMskSize1x3")? ippMskSize1x3:         \
00046                                 (Name ## _indexedStringList == "ippMskSize1x5")? ippMskSize1x5:         \
00047                                 (Name ## _indexedStringList == "ippMskSize3x1")? ippMskSize3x1:         \
00048                                 (Name ## _indexedStringList == "ippMskSize3x3")? ippMskSize3x3:         \
00049                                 (Name ## _indexedStringList == "ippMskSize5x1")? ippMskSize5x1:         \
00050                                 ippMskSize5x5;
00051 
00052 // IppCmpOp
00053 #define ADD_IPP_CMP_OP_PROPERTY(Name)                   \
00054         QVIndexedStringList Name ## _choice;            \
00055         Name ## _choice.append("ippCmpLessEq");         \
00056         Name ## _choice.append("ippCmpEq");             \
00057         Name ## _choice.append("ippCmpGreaterEq");      \
00058         Name ## _choice.append("ippCmpGreater");        \
00059         addProperty< QVIndexedStringList >("" # Name, inputFlag, Name ## _choice);
00060 
00061 #define GET_IPP_CMP_OP_PROPERTY(Name)                                                                   \
00062         const QString Name ## _indexedStringList =                                                      \
00063                                 getPropertyValue< QVIndexedStringList >("" #Name).getCurrent();         \
00064         const IppCmpOp Name =                                                                   \
00065                                 (Name ## _indexedStringList == "ippCmpLessEq")? ippCmpLessEq:           \
00066                                 (Name ## _indexedStringList == "ippCmpEq")? ippCmpEq:                   \
00067                                 (Name ## _indexedStringList == "ippCmpGreaterEq")? ippCmpGreaterEq:     \
00068                                 ippCmpGreater;
00069 
00070 #define CREATE_OUTPUT_IMAGE(Type, Channels, Dest, Src, DestROIOffset)   \
00071         QVImage<Type, Channels> Dest(Src.getROI().width() + DestROIOffset.x(), Src.getROI().height() + DestROIOffset.y());
00072 
00074 // qvippCopyP3C3Worker<uChar,1>
00075 template <> qvippCopyP3C3Worker<uChar>::qvippCopyP3C3Worker(QString name): QVWorker(name)
00076         {
00077         addProperty< QVImage<uChar,1> >("src1", inputFlag|outputFlag);
00078         addProperty< QVImage<uChar,1> >("src2", inputFlag|outputFlag);
00079         addProperty< QVImage<uChar,1> >("src3", inputFlag|outputFlag);
00080         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00081 
00082         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00083         }
00084 
00085 template <> void qvippCopyP3C3Worker<uChar>::iterate()
00086         {
00087         // Read input properties
00088         const QVImage<uChar,1>  src1 = getPropertyValue< QVImage<uChar,1> >("src1"),
00089                                 src2 = getPropertyValue< QVImage<uChar,1> >("src2"),
00090                                 src3 = getPropertyValue< QVImage<uChar,1> >("src3");
00091         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00092         timeFlag("Read input parameters");
00093 
00094         //CHECK_SAME_ROISIZE(src1, src2);
00095         //CHECK_SAME_ROISIZE(src2, src3);
00096 
00097         // Apply dilate 3x3 filter      
00098         CREATE_OUTPUT_IMAGE(uChar, 3, dest, src1, destROIOffset);
00099         Copy(src1, src2, src3, dest, destROIOffset);
00100 
00101         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00102         timeFlag("Write output parameters");
00103         }
00104 
00105 
00106 // qvippCopyC3P3Worker<uChar,1>
00107 template <> qvippCopyC3P3Worker<uChar>::qvippCopyC3P3Worker(QString name): QVWorker(name)
00108         {
00109         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00110 
00111         addProperty< QVImage<uChar,1> >("dest1", outputFlag);
00112         addProperty< QVImage<uChar,1> >("dest2", outputFlag);
00113         addProperty< QVImage<uChar,1> >("dest3", outputFlag);
00114         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00115         }
00116 
00117 template <> void qvippCopyC3P3Worker<uChar>::iterate()
00118         {
00119         // Read input properties
00120         const QVImage<uChar,3>  src = getPropertyValue< QVImage<uChar,3> >("src");
00121         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00122         timeFlag("Read input parameters");
00123 
00124         // Apply dilate 3x3 filter      
00125         CREATE_OUTPUT_IMAGE(uChar, 1, dest1, src, destROIOffset);
00126         CREATE_OUTPUT_IMAGE(uChar, 1, dest2, src, destROIOffset);
00127         CREATE_OUTPUT_IMAGE(uChar, 1, dest3, src, destROIOffset);
00128         Copy(src, dest1, dest2, dest3, destROIOffset);
00129 
00130         setPropertyValue< QVImage<uChar,1> >("dest1", dest1);
00131         setPropertyValue< QVImage<uChar,1> >("dest2", dest2);
00132         setPropertyValue< QVImage<uChar,1> >("dest3", dest3);
00133         timeFlag("Write output parameters");
00134         }
00135 
00136 // qvippDilate3x3Worker<uChar,1>
00137 template <> qvippDilate3x3Worker<uChar,1>::qvippDilate3x3Worker(QString name): QVWorker(name)
00138         {
00139         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00140         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00141 
00142         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00143         }
00144 
00145 template <> void qvippDilate3x3Worker<uChar,1>::iterate()
00146         {
00147         // Read input properties
00148         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00149         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00150         timeFlag("Read input parameters");
00151 
00152         // Apply dilate 3x3 filter      
00153         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00154         //QVImage<uChar,1> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00155         Dilate3x3(src, dest);
00156 
00157         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00158         timeFlag("Write output parameters");
00159         }
00160 
00161 // qvippErode3x3Worker<uChar,1>
00162 template <> qvippErode3x3Worker<uChar,1>::qvippErode3x3Worker(QString name): QVWorker(name)
00163         {
00164         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00165         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00166 
00167         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00168         }
00169 
00170 template <> void qvippErode3x3Worker<uChar,1>::iterate()
00171         {
00172         // Read input properties
00173         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00174         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00175         timeFlag("Read input parameters");
00176 
00177         // Apply dilate 3x3 filter      
00178         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00179         Erode3x3(src, dest);
00180 
00181         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00182         timeFlag("Write output parameters");
00183         }
00184 
00185 
00186 // qvippComputeThreshold_OtsuWorker<uChar,1>
00187 template <> qvippComputeThreshold_OtsuWorker<uChar,1>::qvippComputeThreshold_OtsuWorker(QString name): QVWorker(name)
00188         {
00189         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00190 
00191         addProperty< int >("Threshold Otsu", outputFlag);
00192         }
00193 
00194 template <> void qvippComputeThreshold_OtsuWorker<uChar,1>::iterate()
00195         {
00196         // Read input properties
00197         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00198         timeFlag("Read input parameters");
00199 
00200         // Apply random filter  
00201         uChar threshold;
00202         ComputeThreshold_Otsu(src, threshold);
00203 
00204         setPropertyValue< int >("Threshold Otsu", threshold);
00205         timeFlag("Write output parameters");
00206         }
00207 
00208 
00209 // qvippAddRandUniform_DirectWorker<uChar,1>
00210 template <> qvippAddRandUniform_DirectWorker<uChar,1>::qvippAddRandUniform_DirectWorker(QString name): QVWorker(name), seed(0)
00211         {
00212         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00213         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00214         addProperty< int >("Low", inputFlag, 10, "", 0, 255);
00215         addProperty< int >("High", inputFlag, 30, "", 0, 255);
00216 
00217         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00218         }
00219 
00220 template <> void qvippAddRandUniform_DirectWorker<uChar,1>::iterate()
00221         {
00222         // Read input properties
00223         QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00224         const uChar     low = getPropertyValue< uChar >("Low"),
00225                         high = getPropertyValue< uChar >("High");
00226         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00227         timeFlag("Read input parameters");
00228 
00229         // Apply random filter  
00230         AddRandUniform_Direct(src, low, high, seed);
00231 
00232         seed++;
00233 
00234         setPropertyValue< QVImage<uChar,1> >("dest", src);
00235         timeFlag("Write output parameters");
00236         }
00237 
00238 // qvippFilterBoxWorker<uChar,1>
00239 template <> qvippFilterBoxWorker<uChar,1>::qvippFilterBoxWorker(QString name): QVWorker(name)
00240         {
00241         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00242         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00243         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00244         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00245 
00246         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00247         }
00248 
00249 template <> void qvippFilterBoxWorker<uChar,1>::iterate()
00250         {
00251         // Read input properties
00252         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00253         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00254                         maskHeight = getPropertyValue< int >("Mask Height");
00255         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00256         timeFlag("Read input parameters");
00257 
00258         // Create output variables
00259         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00260 
00261         FilterBox(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00262         timeFlag("Call to ippiFilterBox_8u_C1R");
00263 
00264         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00265         timeFlag("Write output parameters");
00266         }
00267 
00268 // qvippFilterBoxWorker<uChar,3>
00269 template <> qvippFilterBoxWorker<uChar,3>::qvippFilterBoxWorker(QString name): QVWorker(name)
00270         {
00271         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00272         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00273         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00274         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00275 
00276         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00277         }
00278 
00279 template <> void qvippFilterBoxWorker<uChar,3>::iterate()
00280         {
00281         // Read input properties
00282         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00283         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00284                         maskHeight = getPropertyValue< int >("Mask Height");
00285         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00286         timeFlag("Read input parameters");
00287 
00288         // Create output variables
00289         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00290 
00291         FilterBox(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00292         timeFlag("Call to ippiFilterBox_8u_C1R");
00293 
00294         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00295         timeFlag("Write output parameters");
00296         }
00297 
00298 
00299 // qvippFilterMedianWorker<uChar,1>
00300 template <> qvippFilterMedianWorker<uChar,1>::qvippFilterMedianWorker(QString name): QVWorker(name)
00301         {
00302         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00303         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00304         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00305         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00306 
00307         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00308         }
00309 
00310 template <> void qvippFilterMedianWorker<uChar,1>::iterate()
00311         {
00312         // Read input properties
00313         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00314         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00315                         maskHeight = getPropertyValue< int >("Mask Height");
00316         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00317         timeFlag("Read input parameters");
00318 
00319         // Create output variables
00320         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00321 
00322         FilterMedian(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00323         timeFlag("Call to ippiFilterMedian_8u_C1R");
00324 
00325         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00326         timeFlag("Write output parameters");
00327         }
00328 
00329 // qvippFilterMedianWorker<uChar,3>
00330 template <> qvippFilterMedianWorker<uChar,3>::qvippFilterMedianWorker(QString name): QVWorker(name)
00331         {
00332         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00333         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00334         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00335         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00336 
00337         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00338         }
00339 
00340 template <> void qvippFilterMedianWorker<uChar,3>::iterate()
00341         {
00342         // Read input properties
00343         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00344         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00345                         maskHeight = getPropertyValue< int >("Mask Height");
00346         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00347         timeFlag("Read input parameters");
00348 
00349         // Create output variables
00350         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00351 
00352         FilterMedian(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00353         timeFlag("Call to ippiFilterMedian_8u_C1R");
00354 
00355         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00356         timeFlag("Write output parameters");
00357         }
00358 
00359 // qvippFilterMaxWorker<uChar,1>
00360 template <> qvippFilterMaxWorker<uChar,1>::qvippFilterMaxWorker(QString name): QVWorker(name)
00361         {
00362         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00363         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00364         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00365         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00366 
00367         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00368         }
00369 
00370 template <> void qvippFilterMaxWorker<uChar,1>::iterate()
00371         {
00372         // Read input properties
00373         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00374         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00375                         maskHeight = getPropertyValue< int >("Mask Height");
00376         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00377         timeFlag("Read input parameters");
00378 
00379         // Create output variables
00380         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00381 
00382         FilterMax(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00383         timeFlag("Call to ippiFilterMax_8u_C1R");
00384 
00385         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00386         timeFlag("Write output parameters");
00387         }
00388 
00389 // qvippFilterMaxWorker<uChar,3>
00390 template <> qvippFilterMaxWorker<uChar,3>::qvippFilterMaxWorker(QString name): QVWorker(name)
00391         {
00392         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00393         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00394         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00395         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00396 
00397         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00398         }
00399 
00400 template <> void qvippFilterMaxWorker<uChar,3>::iterate()
00401         {
00402         // Read input properties
00403         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00404         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00405                         maskHeight = getPropertyValue< int >("Mask Height");
00406         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00407         timeFlag("Read input parameters");
00408 
00409         // Create output variables
00410         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00411 
00412         FilterMax(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00413         timeFlag("Call to ippiFilterMax_8u_C1R");
00414 
00415         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00416         timeFlag("Write output parameters");
00417         }
00418 
00419 // qvippFilterMinWorker<uChar,1>
00420 template <> qvippFilterMinWorker<uChar,1>::qvippFilterMinWorker(QString name): QVWorker(name)
00421         {
00422         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00423         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00424         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00425         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00426 
00427         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00428         }
00429 
00430 template <> void qvippFilterMinWorker<uChar,1>::iterate()
00431         {
00432         // Read input properties
00433         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00434         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00435                         maskHeight = getPropertyValue< int >("Mask Height");
00436         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00437         timeFlag("Read input parameters");
00438 
00439         // Create output variables
00440         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00441 
00442         FilterMin(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00443         timeFlag("Call to ippiFilterMin_8u_C1R");
00444 
00445         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00446         timeFlag("Write output parameters");
00447         }
00448 
00449 // qvippFilterMinWorker<uChar,3>
00450 template <> qvippFilterMinWorker<uChar,3>::qvippFilterMinWorker(QString name): QVWorker(name)
00451         {
00452         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00453         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00454         addProperty< int >("Mask Width", inputFlag, 1, "", 1, 64);
00455         addProperty< int >("Mask Height", inputFlag, 1, "", 1, 64);
00456 
00457         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00458         }
00459 
00460 template <> void qvippFilterMinWorker<uChar,3>::iterate()
00461         {
00462         // Read input properties
00463         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00464         const int       maskWidth = getPropertyValue< int >("Mask Width"),
00465                         maskHeight = getPropertyValue< int >("Mask Height");
00466         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00467         timeFlag("Read input parameters");
00468 
00469         // Create output variables
00470         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00471 
00472         FilterMin(src, dest, QSize(maskWidth, maskHeight), QPoint(0,0), destROIOffset);
00473         timeFlag("Call to ippiFilterMin_8u_C1R");
00474 
00475         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00476         timeFlag("Write output parameters");
00477         }
00478 
00479 // qvippFilterGaussWorker<uChar,1>
00480 template <> qvippFilterGaussWorker<uChar,1>::qvippFilterGaussWorker(QString name): QVWorker(name)
00481         {
00482         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00483         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00484         ADD_IPPI_MASK_SIZE_PROPERTY(maskSize);
00485         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00486         }
00487 
00488 template <> void qvippFilterGaussWorker<uChar,1>::iterate()
00489         {
00490         // Read input properties
00491         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00492         GET_IPPI_MASK_SIZE_PROPERTY(maskSize);
00493         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00494         timeFlag("Read input parameters");
00495 
00496         // Create output variables
00497         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00498 
00499         FilterGauss(src, dest, maskSize, destROIOffset);
00500         timeFlag("Call to ippiFilterGauss_8u_C1R");
00501 
00502         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00503         timeFlag("Write output parameters");
00504         }
00505 
00506 // qvippFilterHipassWorker<uChar,1>
00507 template <> qvippFilterHipassWorker<uChar,1>::qvippFilterHipassWorker(QString name): QVWorker(name)
00508         {
00509         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00510         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00511         ADD_IPPI_MASK_SIZE_PROPERTY(maskSize);
00512         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00513         }
00514 
00515 template <> void qvippFilterHipassWorker<uChar,1>::iterate()
00516         {
00517         // Read input properties
00518         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00519         GET_IPPI_MASK_SIZE_PROPERTY(maskSize);
00520         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00521         timeFlag("Read input parameters");
00522 
00523         // Create output variables
00524         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00525 
00526         FilterHipass(src, dest, maskSize, destROIOffset);
00527         timeFlag("Call to ippiFilterHipass_8u_C1R");
00528 
00529         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00530         timeFlag("Write output parameters");
00531         }
00532 
00533 // qvippFilterGaussWorker<uChar,3>
00534 template <> qvippFilterGaussWorker<uChar,3>::qvippFilterGaussWorker(QString name): QVWorker(name)
00535         {
00536         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00537         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00538         ADD_IPPI_MASK_SIZE_PROPERTY(maskSize);
00539         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00540         }
00541 
00542 template <> void qvippFilterGaussWorker<uChar,3>::iterate()
00543         {
00544         // Read input properties
00545         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00546         GET_IPPI_MASK_SIZE_PROPERTY(maskSize);
00547         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00548         timeFlag("Read input parameters");
00549 
00550         // Create output variables
00551         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00552 
00553         FilterGauss(src, dest, maskSize, destROIOffset);
00554         timeFlag("Call to ippiFilterGauss_8u_C1R");
00555 
00556         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00557         timeFlag("Write output parameters");
00558         }
00559 
00560 // qvippFilterHipassWorker<uChar,3>
00561 template <> qvippFilterHipassWorker<uChar,3>::qvippFilterHipassWorker(QString name): QVWorker(name)
00562         {
00563         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00564         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00565         ADD_IPPI_MASK_SIZE_PROPERTY(maskSize);
00566         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00567         }
00568 
00569 template <> void qvippFilterHipassWorker<uChar,3>::iterate()
00570         {
00571         // Read input properties
00572         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00573         GET_IPPI_MASK_SIZE_PROPERTY(maskSize);
00574         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00575         timeFlag("Read input parameters");
00576 
00577         // Create output variables
00578         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00579 
00580         FilterHipass(src, dest, maskSize, destROIOffset);
00581         timeFlag("Call to ippiFilterHipass_8u_C1R");
00582 
00583         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00584         timeFlag("Write output parameters");
00585         }
00586 
00587 // qvippAddWorker<uChar,1>
00588 template <> qvippAddWorker<uChar,1>::qvippAddWorker(QString name): QVWorker(name)
00589         {
00590         addProperty< QVImage<uChar,1> >("src1", inputFlag|outputFlag);
00591         addProperty< QVImage<uChar,1> >("src2", inputFlag|outputFlag);
00592         addProperty< int >("scale", inputFlag, 1, "", 0, 16);
00593         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00594         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00595         }
00596 
00597 template <> void qvippAddWorker<uChar,1>::iterate()
00598         {
00599         // Read input properties
00600         const QVImage<uChar,1> src1 = getPropertyValue< QVImage<uChar,1> >("src1");
00601         const QVImage<uChar,1> src2 = getPropertyValue< QVImage<uChar,1> >("src2");
00602         const int scale = getPropertyValue< int >("scale");
00603         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00604         timeFlag("Read input parameters");
00605 
00606         // Create output variables
00607         QVImage<uChar,1> dest(src1.getCols() + destROIOffset.x(), src1.getRows() + destROIOffset.y());
00608 
00609         Add(src1, src2, dest, scale, destROIOffset);
00610         timeFlag("Call to ippiAdd_8u_C1R");
00611 
00612         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00613         timeFlag("Write output parameters");
00614         }
00615 
00616 // qvippAddWorker<uChar,3>
00617 template <> qvippAddWorker<uChar,3>::qvippAddWorker(QString name): QVWorker(name)
00618         {
00619         addProperty< QVImage<uChar,3> >("src1", inputFlag|outputFlag);
00620         addProperty< QVImage<uChar,3> >("src2", inputFlag|outputFlag);
00621         addProperty< int >("scale", inputFlag, 1, "", 0, 16);
00622         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00623         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00624         }
00625 
00626 template <> void qvippAddWorker<uChar,3>::iterate()
00627         {
00628         // Read input properties
00629         const QVImage<uChar,3> src1 = getPropertyValue< QVImage<uChar,3> >("src1");
00630         const QVImage<uChar,3> src2 = getPropertyValue< QVImage<uChar,3> >("src2");
00631         const int scale = getPropertyValue< int >("scale");
00632         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00633         timeFlag("Read input parameters");
00634 
00635         // Create output variables
00636         QVImage<uChar,3> dest(src1.getCols() + destROIOffset.x(), src1.getRows() + destROIOffset.y());
00637 
00638         Add(src1, src2, dest, scale, destROIOffset);
00639         timeFlag("Call to ippiAdd_8u_C3R");
00640 
00641         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00642         timeFlag("Write output parameters");
00643         }
00644 
00645 // qvippAddCWorker<uChar, 1>
00646 template <> qvippAddCWorker<uChar,1>::qvippAddCWorker(QString name): QVWorker(name)
00647         {
00648         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00649         addProperty< int >("summand for channel 1", inputFlag, 128, "", 0, 255);
00650         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00651 
00652         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00653         }
00654 
00655 template <> void qvippAddCWorker<uChar,1>::iterate()
00656         {
00657         // Read input properties
00658         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00659         const int channel1Summand = getPropertyValue< int >("summand for channel 1");
00660         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00661         timeFlag("Read input parameters");
00662 
00663         // Create output variables
00664         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00665 
00666         AddC(src, channel1Summand, dest, 1, destROIOffset);
00667         timeFlag("Call to ippiAddC_8u_C1R");
00668 
00669         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00670         timeFlag("Write output parameters");
00671         }
00672 
00673 // qvippAddCWorker<uChar, 3>
00674 template <> qvippAddCWorker<uChar,3>::qvippAddCWorker(QString name): QVWorker(name)
00675         {
00676         addProperty< QVImage<uChar,3> >("src", inputFlag|outputFlag);
00677         addProperty< int >("summand for channel 1", inputFlag, 128, "", 0, 255);
00678         addProperty< int >("summand for channel 2", inputFlag, 128, "", 0, 255);
00679         addProperty< int >("summand for channel 3", inputFlag, 128, "", 0, 255);
00680         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00681 
00682         addProperty< QVImage<uChar,3> >("dest", outputFlag);
00683         }
00684 
00685 template <> void qvippAddCWorker<uChar,3>::iterate()
00686         {
00687         // Read input properties
00688         const QVImage<uChar,3> src = getPropertyValue< QVImage<uChar,3> >("src");
00689         const int channel1Summand = getPropertyValue< int >("summand for channel 1");
00690         const int channel2Summand = getPropertyValue< int >("summand for channel 2");
00691         const int channel3Summand = getPropertyValue< int >("summand for channel 3");
00692         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00693         timeFlag("Read input parameters");
00694 
00695         // Create output variables
00696         QVImage<uChar,3> dest(src.getCols() + destROIOffset.x(), src.getRows() + destROIOffset.y());
00697 
00698         const uChar channelSummands[3] = {channel1Summand, channel2Summand, channel3Summand};
00699         AddC(src, channelSummands, dest, 1, destROIOffset);
00700         timeFlag("Call to ippiAddC_8u_C3R");
00701 
00702         setPropertyValue< QVImage<uChar,3> >("dest", dest);
00703         timeFlag("Write output parameters");
00704         }
00705 
00706 // qvippCompareCWorker<uChar, 1>
00707 template <> qvippCompareCWorker<uChar,1>::qvippCompareCWorker(QString name): QVWorker(name)
00708         {
00709         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00710         ADD_IPP_CMP_OP_PROPERTY(operation);
00711         addProperty< int >("operand for channel 1", inputFlag);
00712         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00713 
00714         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00715         }
00716 
00717 template <> void qvippCompareCWorker<uChar,1>::iterate()
00718         {
00719         // Read input properties
00720         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00721         GET_IPP_CMP_OP_PROPERTY(operation);
00722         const int channel1Operand = getPropertyValue< int >("operand for channel 1");
00723         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00724         timeFlag("Read input parameters");
00725 
00726         // Create output variables
00727         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00728 
00729         CompareC(src, channel1Operand, dest, operation, destROIOffset);
00730         timeFlag("Call to ippiCompareC_8u_C1R");
00731 
00732         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00733         timeFlag("Write output parameters");
00734         }
00735 
00736 const QStringList getQvippWorkersNames()
00737         {
00738         QStringList result;
00739 
00740         result.append("qvippCopyP3C3Worker<uChar>");
00741         result.append("qvippCopyC3P3Worker<uChar>");
00742         result.append("qvippErode3x3Worker<uChar,1>");
00743         result.append("qvippComputeThreshold_OtsuWorker<uChar,1>");
00744         result.append("qvippAddRandUniform_DirectWorker<uChar,1>");
00745         result.append("qvippFilterBoxWorker<uChar,1>");
00746         result.append("qvippFilterBoxWorker<uChar,3>");
00747         result.append("qvippFilterMedianWorker<uChar,1>");
00748         result.append("qvippFilterMedianWorker<uChar,3>");
00749         result.append("qvippFilterMaxWorker<uChar,1>");
00750         result.append("qvippFilterMaxWorker<uChar,1>");
00751         result.append("qvippFilterMinWorker<uChar,1>");
00752         result.append("qvippFilterMinWorker<uChar,3>");
00753         result.append("qvippFilterGaussWorker<uChar,1>");
00754         result.append("qvippFilterHipassWorker<uChar,1>");
00755         result.append("qvippFilterGaussWorker<uChar,3>");
00756         result.append("qvippFilterHipassWorker<uChar,3>");
00757         result.append("qvippAddWorker<uChar,1>");
00758         result.append("qvippAddCWorker<uChar, 1>");
00759         result.append("qvippAddCWorker<uChar, 3>");
00760         result.append("qvippCompareCWorker<uChar, 1>");
00761 
00762         return result;
00763         }
00764 
00765 QVPropertyContainer *newQvippWorker(QString type, QString name)
00766         {
00767         if (type == "qvippCopyP3C3Worker<uChar>")                       return new qvippCopyP3C3Worker<uChar>(name);
00768         else if (type == "qvippCopyC3P3Worker<uChar>")                  return new qvippCopyC3P3Worker<uChar>(name);
00769         else if (type == "qvippComputeThreshold_OtsuWorker<uChar,1>")   return new qvippComputeThreshold_OtsuWorker<uChar,1>(name);
00770         else if (type == "qvippAddRandUniform_DirectWorker<uChar,1>")   return new qvippAddRandUniform_DirectWorker<uChar,1>(name);
00771         else if (type == "qvippFilterBoxWorker<uChar,1>")               return new qvippFilterBoxWorker<uChar,1>(name);
00772         else if (type == "qvippFilterBoxWorker<uChar,3>")               return new qvippFilterBoxWorker<uChar,3>(name);
00773         else if (type == "qvippFilterMedianWorker<uChar,1>")            return new qvippFilterMedianWorker<uChar,1>(name);
00774         else if (type == "qvippFilterMedianWorker<uChar,3>")            return new qvippFilterMedianWorker<uChar,3>(name);
00775         else if (type == "qvippFilterMaxWorker<uChar,1>")               return new qvippFilterMaxWorker<uChar,1>(name);
00776         else if (type == "qvippFilterMaxWorker<uChar,3>")               return new qvippFilterMaxWorker<uChar,3>(name);
00777         else if (type == "qvippFilterMinWorker<uChar,1>")               return new qvippFilterMinWorker<uChar,1>(name);
00778         else if (type == "qvippFilterMinWorker<uChar,3>")               return new qvippFilterMinWorker<uChar,3>(name);
00779         else if (type == "qvippFilterGaussWorker<uChar,1>")             return new qvippFilterGaussWorker<uChar,1>(name);
00780         else if (type == "qvippFilterGaussWorker<uChar,3>")             return new qvippFilterGaussWorker<uChar,3>(name);
00781         else if (type == "qvippFilterHipassWorker<uChar,1>")            return new qvippFilterHipassWorker<uChar,1>(name);
00782         else if (type == "qvippFilterHipassWorker<uChar,3>")            return new qvippFilterHipassWorker<uChar,3>(name);
00783         else if (type == "qvippAddWorker<uChar,1>")                     return new qvippAddWorker<uChar,1>(name);
00784         else if (type == "qvippAddCWorker<uChar, 1>")                   return new qvippAddCWorker<uChar, 1>(name);
00785         else if (type == "qvippAddCWorker<uChar, 3>")                   return new qvippAddCWorker<uChar, 3>(name);
00786         else if (type == "qvippCompareCWorker<uChar, 1>")               return new qvippCompareCWorker<uChar, 1>(name);
00787         else return NULL;
00788         }
00789