PARP Research Group University of Murcia, Spain


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_C3R");
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 // QVIPPAbsDiffWorker<uChar,1>
00707 template <> QVIPPAbsDiffWorker<uChar,1>::QVIPPAbsDiffWorker(QString name): QVWorker(name)
00708         {
00709         addProperty< QVImage<uChar,1> >("src1", inputFlag|outputFlag);
00710         addProperty< QVImage<uChar,1> >("src2", inputFlag|outputFlag);
00711         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00712         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00713         }
00714 
00715 template <> void QVIPPAbsDiffWorker<uChar,1>::iterate()
00716         {
00717         // Read input properties
00718         const QVImage<uChar,1> src1 = getPropertyValue< QVImage<uChar,1> >("src1");
00719         const QVImage<uChar,1> src2 = getPropertyValue< QVImage<uChar,1> >("src2");
00720         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00721         timeFlag("Read input parameters");
00722 
00723         // Create output variables
00724         QVImage<uChar,1> dest(src1.getCols() + destROIOffset.x(), src1.getRows() + destROIOffset.y());
00725 
00726         AbsDiff(src1, src2, dest, destROIOffset);
00727         timeFlag("Call to ippiAdbsDiff_8u_C1R");
00728 
00729         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00730         timeFlag("Write output parameters");
00731         }
00732 
00733 
00734 // QVIPPCompareCWorker<uChar, 1>
00735 template <> QVIPPCompareCWorker<uChar,1>::QVIPPCompareCWorker(QString name): QVWorker(name)
00736         {
00737         addProperty< QVImage<uChar,1> >("src", inputFlag|outputFlag);
00738         ADD_IPP_CMP_OP_PROPERTY(operation);
00739         addProperty< int >("operand for channel 1", inputFlag);
00740         addProperty< QPoint >("destROIOffset", inputFlag, QPoint(0,0));
00741 
00742         addProperty< QVImage<uChar,1> >("dest", outputFlag);
00743         }
00744 
00745 template <> void QVIPPCompareCWorker<uChar,1>::iterate()
00746         {
00747         // Read input properties
00748         const QVImage<uChar,1> src = getPropertyValue< QVImage<uChar,1> >("src");
00749         GET_IPP_CMP_OP_PROPERTY(operation);
00750         const int channel1Operand = getPropertyValue< int >("operand for channel 1");
00751         const QPoint destROIOffset = getPropertyValue< QPoint >("destROIOffset");
00752         timeFlag("Read input parameters");
00753 
00754         // Create output variables
00755         CREATE_OUTPUT_IMAGE(uChar, 1, dest, src, destROIOffset);
00756 
00757         CompareC(src, channel1Operand, dest, operation, destROIOffset);
00758         timeFlag("Call to ippiCompareC_8u_C1R");
00759 
00760         setPropertyValue< QVImage<uChar,1> >("dest", dest);
00761         timeFlag("Write output parameters");
00762         }
00763 
00764 const QStringList getQVIPPWorkersNames()
00765         {
00766         QStringList result;
00767 
00768         result.append("QVIPPCopyP3C3Worker<uChar>");
00769         result.append("QVIPPCopyC3P3Worker<uChar>");
00770         result.append("QVIPPErode3x3Worker<uChar,1>");
00771         result.append("QVIPPComputeThreshold_OtsuWorker<uChar,1>");
00772         result.append("QVIPPAddRandUniform_DirectWorker<uChar,1>");
00773         result.append("QVIPPFilterBoxWorker<uChar,1>");
00774         result.append("QVIPPFilterBoxWorker<uChar,3>");
00775         result.append("QVIPPFilterMedianWorker<uChar,1>");
00776         result.append("QVIPPFilterMedianWorker<uChar,3>");
00777         result.append("QVIPPFilterMaxWorker<uChar,1>");
00778         result.append("QVIPPFilterMaxWorker<uChar,1>");
00779         result.append("QVIPPFilterMinWorker<uChar,1>");
00780         result.append("QVIPPFilterMinWorker<uChar,3>");
00781         result.append("QVIPPFilterGaussWorker<uChar,1>");
00782         result.append("QVIPPFilterHipassWorker<uChar,1>");
00783         result.append("QVIPPFilterGaussWorker<uChar,3>");
00784         result.append("QVIPPFilterHipassWorker<uChar,3>");
00785         result.append("QVIPPAddWorker<uChar,1>");
00786         result.append("QVIPPAddCWorker<uChar, 1>");
00787         result.append("QVIPPAddCWorker<uChar, 3>");
00788         result.append("QVIPPAbsDiffWorker<uChar, 1>");
00789         result.append("QVIPPCompareCWorker<uChar, 1>");
00790 
00791         return result;
00792         }
00793 
00794 QVPropertyContainer *newQVIPPWorker(QString type, QString name)
00795         {
00796         if (type == "QVIPPCopyP3C3Worker<uChar>")                       return new QVIPPCopyP3C3Worker<uChar>(name);
00797         else if (type == "QVIPPCopyC3P3Worker<uChar>")                  return new QVIPPCopyC3P3Worker<uChar>(name);
00798         else if (type == "QVIPPComputeThreshold_OtsuWorker<uChar,1>")   return new QVIPPComputeThreshold_OtsuWorker<uChar,1>(name);
00799         else if (type == "QVIPPAddRandUniform_DirectWorker<uChar,1>")   return new QVIPPAddRandUniform_DirectWorker<uChar,1>(name);
00800         else if (type == "QVIPPFilterBoxWorker<uChar,1>")               return new QVIPPFilterBoxWorker<uChar,1>(name);
00801         else if (type == "QVIPPFilterBoxWorker<uChar,3>")               return new QVIPPFilterBoxWorker<uChar,3>(name);
00802         else if (type == "QVIPPFilterMedianWorker<uChar,1>")            return new QVIPPFilterMedianWorker<uChar,1>(name);
00803         else if (type == "QVIPPFilterMedianWorker<uChar,3>")            return new QVIPPFilterMedianWorker<uChar,3>(name);
00804         else if (type == "QVIPPFilterMaxWorker<uChar,1>")               return new QVIPPFilterMaxWorker<uChar,1>(name);
00805         else if (type == "QVIPPFilterMaxWorker<uChar,3>")               return new QVIPPFilterMaxWorker<uChar,3>(name);
00806         else if (type == "QVIPPFilterMinWorker<uChar,1>")               return new QVIPPFilterMinWorker<uChar,1>(name);
00807         else if (type == "QVIPPFilterMinWorker<uChar,3>")               return new QVIPPFilterMinWorker<uChar,3>(name);
00808         else if (type == "QVIPPFilterGaussWorker<uChar,1>")             return new QVIPPFilterGaussWorker<uChar,1>(name);
00809         else if (type == "QVIPPFilterGaussWorker<uChar,3>")             return new QVIPPFilterGaussWorker<uChar,3>(name);
00810         else if (type == "QVIPPFilterHipassWorker<uChar,1>")            return new QVIPPFilterHipassWorker<uChar,1>(name);
00811         else if (type == "QVIPPFilterHipassWorker<uChar,3>")            return new QVIPPFilterHipassWorker<uChar,3>(name);
00812         else if (type == "QVIPPAddWorker<uChar,1>")                     return new QVIPPAddWorker<uChar,1>(name);
00813         else if (type == "QVIPPAddCWorker<uChar, 1>")                   return new QVIPPAddCWorker<uChar, 1>(name);
00814         else if (type == "QVIPPAddCWorker<uChar, 3>")                   return new QVIPPAddCWorker<uChar, 3>(name);
00815         else if (type == "QVIPPAbsDiffWorker<uChar, 1>")                return new QVIPPAbsDiffWorker<uChar, 1>(name);
00816         else if (type == "QVIPPCompareCWorker<uChar, 1>")               return new QVIPPCompareCWorker<uChar, 1>(name);
00817         else return NULL;
00818         }
00819 
00820 char *QVIPPWorkerName(QVPropertyContainer *cont)
00821         {
00822         if(dynamic_cast<QVIPPCopyP3C3Worker<uChar>*>(cont) != NULL) return "QVIPPCopyP3C3Worker<uChar>";
00823         else if(dynamic_cast<QVIPPCopyC3P3Worker<uChar>*>(cont) != NULL) return "QVIPPCopyC3P3Worker<uChar>";
00824         else if(dynamic_cast<QVIPPComputeThreshold_OtsuWorker<uChar,1>*>(cont) != NULL) return "QVIPPComputeThreshold_OtsuWorker<uChar,1>";
00825         else if(dynamic_cast<QVIPPAddRandUniform_DirectWorker<uChar,1>*>(cont) != NULL) return "QVIPPAddRandUniform_DirectWorker<uChar,1>";
00826         else if(dynamic_cast<QVIPPFilterBoxWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterBoxWorker<uChar,1>";
00827         else if(dynamic_cast<QVIPPFilterBoxWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterBoxWorker<uChar,3>";
00828         else if(dynamic_cast<QVIPPFilterMedianWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterMedianWorker<uChar,1>";
00829         else if(dynamic_cast<QVIPPFilterMedianWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterMedianWorker<uChar,3>";
00830         else if(dynamic_cast<QVIPPFilterMaxWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterMaxWorker<uChar,1>";
00831         else if(dynamic_cast<QVIPPFilterMedianWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterMedianWorker<uChar,3>";
00832         else if(dynamic_cast<QVIPPFilterMaxWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterMaxWorker<uChar,1>";
00833         else if(dynamic_cast<QVIPPFilterMaxWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterMaxWorker<uChar,3>";
00834         else if(dynamic_cast<QVIPPFilterMinWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterMinWorker<uChar,1>";
00835         else if(dynamic_cast<QVIPPFilterMinWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterMinWorker<uChar,3>";
00836         else if(dynamic_cast<QVIPPFilterGaussWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterGaussWorker<uChar,1>";
00837         else if(dynamic_cast<QVIPPFilterGaussWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterGaussWorker<uChar,3>";
00838         else if(dynamic_cast<QVIPPFilterHipassWorker<uChar,1>*>(cont) != NULL) return "QVIPPFilterHipassWorker<uChar,1>";
00839         else if(dynamic_cast<QVIPPFilterHipassWorker<uChar,3>*>(cont) != NULL) return "QVIPPFilterHipassWorker<uChar,3>";
00840         else if(dynamic_cast<QVIPPAddWorker<uChar,1>*>(cont) != NULL) return "QVIPPAddWorker<uChar,1>";
00841         else if(dynamic_cast<QVIPPAddCWorker<uChar, 1>*>(cont) != NULL) return "QVIPPAddCWorker<uChar, 1>";
00842         else if(dynamic_cast<QVIPPAddCWorker<uChar, 3>*>(cont) != NULL) return "QVIPPAddCWorker<uChar, 3>";
00843         else if(dynamic_cast<QVIPPAbsDiffWorker<uChar, 1>*>(cont) != NULL) return "QVIPPAbsDiffWorker<uChar, 1>";
00844         else if(dynamic_cast<QVIPPCompareCWorker<uChar, 1>*>(cont) != NULL) return "QVIPPCompareCWorker<uChar, 1>";
00845         else return NULL;
00846         }
00847 



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