PARP Research Group University of Murcia, Spain


src/qvgui/qvdesigner/facade/itemfactory.cpp

00001 /*
00002  *      Copyright (C) 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 
00021 
00022 #include "itemfactory.h"
00023 
00024 #include <QVApplication>
00025 #include <QVMPlayerCamera>
00026 #include <QVMPlayerCameraWorker>
00027 #include <QVWorker>
00028 #include "qvworkers/qvfilterselectorworker.h"
00029 #include "qvworkers/qvimageretarderworker.h"
00030 #include "qvworkers/qvimagemeansworker.h"
00031 #include "qvworkers/qvgraphsworker.h"
00032 #include "qvworkers/qvpointworker.h"
00033 #include <QVImageCanvas>
00034 #include <QVNumericPlot>
00035 #include <QVHistogramPlot>
00036 #include <QVCPUPlot>
00037 #include <QVYUV4MPEG2Recorder>
00038 #include <QVYUV4MPEG2CameraWorker>
00039 #include <QVSynchronizerWorker>
00040 
00042 ItemFactory::ItemFactory(): QObject()
00043 {
00044         inputItems.insert("Input node", QList<QString>());
00045         inputItems["Input node"].append("QVMPlayerCamera");
00046         inputItems["Input node"].append("QVMPlayerCameraWorker");
00047         inputItems["Input node"].append("QVYUV4MPEG2CameraWorker");
00048         inputItems["Input node"].append("QVPointWorker");
00049         inputItems["Input node"].append("QVYUV4MPEG2Camera");
00050 
00051         outputItems.insert("Output node", QList<QString>());
00052         outputItems["Output node"].append("QVImageCanvas");
00053         outputItems["Output node"].append("QVNumericPlot");
00054         outputItems["Output node"].append("QVHistogramPlot");
00055         outputItems["Output node"].append("QVCPUPlot");
00056         outputItems["Output node"].append("QVYUV4MPEG2Recorder");
00057         outputItems["Output node"].append("QVSynchronizer");
00058 
00059         middleItems.insert("QVision worker", QList<QString>());
00060         middleItems["QVision worker"].append("QVGraphsWorker");
00061         middleItems["QVision worker"].append("QVFilterSelectorWorker<uchar,1>");
00062         middleItems["QVision worker"].append("QVFilterSelectorWorker<uchar,3>");
00063         middleItems["QVision worker"].append("QVImageRetarderWorker<uchar,3>");
00064         middleItems["QVision worker"].append("QVImageRetarderWorker<uchar,1>");
00065         middleItems["QVision worker"].append("QVImageMeans<uChar,1>");
00066         middleItems["QVision worker"].append("QVImageMeans<uChar,3>");
00067 
00068         // Añadimos los tipos de las IPP.
00069         QMap<QString, QString> ippWorkers = getQVIPPWorkersNames();
00070         foreach(QString ippGroup, ippWorkers.keys())
00071                 {
00072                 middleItems.insert(ippGroup, QList<QString>());
00073                 foreach(QString qvippWorkerName, ippWorkers.values(ippGroup))
00074                         middleItems[ippGroup].append(qvippWorkerName);
00075                 }
00076 
00077         // Añadimos los tipos creados por el usuario.
00078 /*      foreach(QVPropertyContainer* qvp, qvApp->getQVPropertyContainers()) {
00079                 QVWorker* worker;
00080                 if((worker = dynamic_cast<QVWorker*>(qvp)) != NULL)
00081                         middleItems.append(worker.getName());
00082                 }*/
00083 }
00084 
00085 QMap<QString, QList<QString> > ItemFactory::getItemTypes() const
00086 {
00087         QMap<QString, QList<QString> > items = inputItems;
00088 
00089         foreach(QString group, middleItems.keys()) {
00090                 if (items.contains(group))
00091                         items[group] = items.value(group) + middleItems.value(group);
00092                 else
00093                         items.insert(group, middleItems.value(group));
00094         }
00095 
00096         foreach(QString group, outputItems.keys()) {
00097                 if (items.contains(group))
00098                         items[group] = items.value(group) + outputItems.value(group);
00099                 else
00100                         items.insert(group, outputItems.value(group));
00101         }
00102 
00103         return items;
00104 }
00105 
00106 QMap<QString, QList<QString> > ItemFactory::getInputItemTypes() const
00107 {
00108         return inputItems;
00109 }
00110 
00111 QMap<QString, QList<QString> > ItemFactory::getMiddleItemTypes() const
00112 {
00113         return middleItems;
00114 }
00115 
00116 QMap<QString, QList<QString> > ItemFactory::getOutputItemTypes() const
00117 {
00118         return outputItems;
00119 }
00120 
00121 QVPropertyContainer *ItemFactory::createContainer(QString type, QString name) const
00122 {
00123         QVPropertyContainer *qvippWorker = newQVIPPWorker(type, name);
00124         if (qvippWorker != NULL)
00125                 return qvippWorker;
00126         else if (type == "QVMPlayerCamera") {
00127                 QVMPlayerCamera* mpc = new QVMPlayerCamera(name);
00128                 if (mpc->getPropertyValue<QString>("URL").isEmpty())
00129                         mpc->setPropertyValue("URL", QString("http://perception.inf.um.es/public_data/videos/misc/penguin.dv"));
00130                 return mpc;
00131         }
00132         else if (type == "QVMPlayerCameraWorker") {
00133                 QVMPlayerCameraWorker* mpc = new QVMPlayerCameraWorker(name);
00134                 if (mpc->getPropertyValue<QString>("URL").isEmpty())
00135                         mpc->setPropertyValue("URL", QString("http://perception.inf.um.es/public_data/videos/misc/penguin.dv"));
00136                 return mpc;
00137         }
00138         else if (type == "QVYUV4MPEG2CameraWorker") {
00139                 QVYUV4MPEG2CameraWorker* mpc = new QVYUV4MPEG2CameraWorker(name);
00140                 if (mpc->getPropertyValue<QString>("URL").isEmpty())
00141                         mpc->setPropertyValue("URL", QString("http://perception.inf.um.es/public_data/videos/misc/penguin.dv"));
00142                 return mpc;
00143         }
00144         else if (type == "QVYUV4MPEG2Camera") return new QVYUV4MPEG2CameraWorker(name);
00145         else if (type == "QVYUV4MPEG2Recorder") return new QVYUV4MPEG2Recorder(name);
00146         else if (type == "QVImageCanvas") return new QVImageCanvas(name);
00147         else if (type == "QVNumericPlot") return new QVNumericPlot(name);
00148         else if (type == "QVHistogramPlot") return new QVHistogramPlot(name);
00149         else if (type == "QVCPUPlot") return new QVCPUPlot(name);
00150         else if (type == "QVGraphsWorker") return new QVGraphsWorker(name);
00151         else if (type == "QVFilterSelectorWorker<uchar,1>") return new QVFilterSelectorWorker<uchar, 1>(name);
00152         else if (type == "QVFilterSelectorWorker<uchar,3>") return new QVFilterSelectorWorker<uchar, 3>(name);
00153         else if (type == "QVImageRetarderWorker<uchar,3>") return new QVImageRetarderWorker<uchar, 3>(name);
00154         else if (type == "QVImageRetarderWorker<uchar,1>") return new QVImageRetarderWorker<uchar, 1>(name);
00155         else if (type == "QVImageMeans<uChar,1>") return new QVImageMeans<uChar, 1>(name);
00156         //else if (type == "QVAdd_uCharC1Worker") return new QVAdd_uCharC1Worker(name);
00157         else if (type == "QVPointWorker") return new QVPointWorker(name);
00158         else if (type == "QVSynchronizer") return new QVSynchronizer(name);
00159         else if (type == "QVCPUPlot") return new QVCPUPlot(name);
00160         else if (userWorkers.contains(type)) {
00161                 QVWorker * newWorker = (QVWorker *)QMetaType::construct(userWorkers.value(type), (void *)0);
00162                 newWorker->setName(name);
00163                 return newWorker;
00164         }
00165         return 0;
00166 }
00167 
00168 bool ItemFactory::deleteContainer(QVPropertyContainer *cont) const
00169 {
00170         // obtiene el nombre y el valor del tipo de la subclase concreta
00171         QString type = typeName(cont);
00172 
00173 /*      // lo destruye dependiendo de como se ha creado
00174         if (isUserType(type))
00175                 QMetaType::destroy(userWorkers.value(type), (void *)cont);
00176         else
00177                 delete cont;*/
00178 
00179         delete cont;
00180 
00181         return TRUE;
00182 }
00183 
00184 QString ItemFactory::containerType(QVPropertyContainer *cont) const
00185 {
00186         // obtiene el nombre y el valor del tipo de la subclase concreta
00187         return QString(typeName(cont));
00188 }
00189 
00190 const QString ItemFactory::registerUserWorker(QVWorker * worker)
00191 {
00192         const char * choptypeidname = typeName(worker);
00193 
00194         // obtiene el nombre y el valor del tipo de la subclase concreta
00195         QString typeString(choptypeidname);
00196         int type = QMetaType::type(choptypeidname);
00197 
00198         // almacena el subtipo concreto del objeto, si no existía ya y si estaba registrado en el sistema con qRegisterMetaType<Type>("Type")
00199         bool middleItemsContainsType = false;
00200         foreach(QList<QString> groupItems, middleItems.values())
00201                 if (groupItems.contains(typeString)) {
00202                         middleItemsContainsType = true;
00203                         break;
00204                 }
00205         if ( (type != 0) && (!middleItemsContainsType) ) {
00206                 if (!middleItems.contains("User worker")) middleItems.insert("User worker", QList<QString>());
00207                 middleItems["User worker"].append(typeString);
00208                 userWorkers.insert(typeString, type);
00209                 return typeString;
00210         }
00211         return QString();
00212 }
00213 
00214 bool ItemFactory::isUserType(QString type) const
00215 {
00216         return userWorkers.contains(type);
00217 }
00218 
00219 const char *ItemFactory::typeName(QVPropertyContainer *cont) const
00220 {
00221         char *qvippWorkerName = NULL; //QVIPPWorkerName(cont);
00222         if (qvippWorkerName != NULL)
00223                 return qvippWorkerName;
00224 
00225         if(dynamic_cast<QVYUV4MPEG2CameraWorker*>(cont) != NULL) return "QVYUV4MPEG2Camera";
00226         else if(dynamic_cast<QVYUV4MPEG2Recorder*>(cont) != NULL) return "QVYUV4MPEG2Recorder";
00227         else if(dynamic_cast<QVImageCanvas*>(cont) != NULL) return "QVImageCanvas";
00228         else if(dynamic_cast<QVNumericPlot*>(cont) != NULL) return "QVNumericPlot";
00229         else if(dynamic_cast<QVHistogramPlot*>(cont) != NULL) return "QVHistogramPlot";
00230         else if(dynamic_cast<QVCPUPlot*>(cont) != NULL) return "QVCPUPlot";
00231         else if(dynamic_cast<QVGraphsWorker*>(cont) != NULL) return "QVGraphsWorker";
00232         else if(dynamic_cast<QVFilterSelectorWorker<uchar,1>*>(cont) != NULL) return "QVFilterSelectorWorker<uchar,1>";
00233         else if(dynamic_cast<QVFilterSelectorWorker<uchar,3>*>(cont) != NULL) return "QVFilterSelectorWorker<uchar,3>";
00234         else if(dynamic_cast<QVImageRetarderWorker<uchar,3>*>(cont) != NULL) return "QVImageRetarderWorker<uchar,3>";
00235         else if(dynamic_cast<QVImageRetarderWorker<uchar,1>*>(cont) != NULL) return "QVImageRetarderWorker<uchar,1>";
00236         else if(dynamic_cast<QVImageMeans<uChar,1>*>(cont) != NULL) return "QVImageMeans<uChar,1>";
00237         else if(dynamic_cast<QVImageMeans<uChar,3>*>(cont) != NULL) return "QVImageMeans<uChar,3>";
00238         else if(dynamic_cast<QVPointWorker*>(cont) != NULL) return "QVPointWorker";
00239         else if(dynamic_cast<QVSynchronizer*>(cont) != NULL) return "QVSynchronizer";
00240 
00241         // obtiene el tipo real del objeto (la sunclase concreta de worker) en un formato char * de longitud+nombre (ejemplo: 8MyWorker)
00242         const char * typeidname = typeid(*cont).name();
00243 
00244         // se salta la pirmera parte de la cadena, la que contiene el número de caracteres del tipo
00245         int i = 0;
00246         while ( (typeidname[i] != '\0') && ((typeidname[i] == '0') || (typeidname[i] == '1') || (typeidname[i] == '2') || (typeidname[i] == '3') ||
00247                 (typeidname[i] == '4') || (typeidname[i] == '5') || (typeidname[i] == '6') || (typeidname[i] == '7') || (typeidname[i] == '8') ||
00248                 (typeidname[i] == '9')) ) {
00249                 i++;
00250         }
00251         return (typeidname + i*(sizeof(char)));
00252 }
00253 
00254 



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