Developer documentation | Axl-2.5.1

axlDataDynamicReader.cpp
Go to the documentation of this file.
1 /* axlDataDynamicReader.cpp ---
2  *
3  * Author: Anais Ducoffe
4  * Copyright (C) 2013 - Anais Ducoffe, Inria.
5  */
6 
7 /* Commentary:
8  *
9  */
10 
11 /* Change log:
12  *
13  */
14 
15 #include "axlDataDynamicReader.h"
16 #include "axlReader.h"
17 
18 #include <axlCore/axlDataDynamic.h>
19 #include <axlCore/axlInteger.h>
20 #include <axlCore/axlDouble.h>
21 #include <axlCore/axlAbstractField.h>
22 #include <axlCore/axlAbstractProcess.h>
23 
24 #include <dtkCoreSupport/dtkAbstractData.h>
25 #include <dtkCoreSupport/dtkAbstractProcess>
26 #include <dtkCoreSupport/dtkAbstractDataFactory.h>
27 #include <dtkCoreSupport/dtkAbstractProcessFactory.h>
28 #include <axlCore/axlAbstractDataReader.h>
29 #include <axlCore/axlFieldReadersFactory.h>
30 
31 //#include <axlGui/axlInspectorToolFactory.h>
32 
33 // /////////////////////////////////////////////////////////////////
34 // axlDataDynamicReader
35 // /////////////////////////////////////////////////////////////////
36 
37 axlDataDynamicReader::axlDataDynamicReader(void)
38 {
39  this->setObjectName(this->description());
40 }
41 
42 axlDataDynamicReader::~axlDataDynamicReader(void)
43 {
44 
45 }
46 
47 QString axlDataDynamicReader::identifier(void) const
48 {
49  return "axlDataDynamicReader";
50 }
51 
52 QString axlDataDynamicReader::description(void) const
53 {
54  return "axlDataDynamicReader";
55 }
56 
57 QStringList axlDataDynamicReader::handled(void) const
58 {
59  return QStringList() << "axlDataDynamic";
60 }
61 
62 bool axlDataDynamicReader::registered(void)
63 {
64  return dtkAbstractDataFactory::instance()->registerDataReaderType("axlDataDynamicReader", QStringList(), createaxlDataDynamicReader);
65 }
66 
67 bool axlDataDynamicReader::accept(const QDomNode& node)
68 {
69  QDomElement element = node.toElement();
70 
71  if(element.tagName() != "process")
72  return false;
73 
74  return true;
75 }
76 
77 bool axlDataDynamicReader::reject(const QDomNode& node)
78 {
79  return !this->accept(node);
80 }
81 
82 axlAbstractData *axlDataDynamicReader::read(const QDomNode& node)
83 {
84 
85 
86  QDomElement element = node.toElement();
87  QString typeElement = element.attribute("status");
88 
89 
90  // if(typeElement == "dynamic")
91  axlDataDynamic *currentData = new axlDataDynamic();
92 
93  QString status = element.attribute("status");
94  if(!status.isEmpty()){
95  if(status == "static"){
96  currentData->setType(axlDataDynamic::Static);
97  }
98  }
99 
100  QString name = element.attribute("name");
101  if(!name.isEmpty())
102  {
103  currentData->setObjectName(name);
104  }
105 
106  QString color = element.attribute("color");
107  if(!color.isEmpty())
108  {
109  QStringList colorList = color.split(" ");
110  if(colorList.size() == 3) // rgb components
111  currentData->setColor(QColor(colorList.at(0).toInt(), colorList.at(1).toInt(), colorList.at(2).toInt()));
112 
113  }
114 
115  QString size = element.attribute("size");
116  if(!size.isEmpty())
117  {
118  currentData->setSize(size.toDouble());
119  }
120 
121  //Read Process
122  QString processName = element.attribute("type");
123  if(!processName.isEmpty())
124  {
125  currentData->setProcess(processName);
126 
127  }
128  // //return the name of the data
129  // QString name_data = element.attribute("name");
130  // currentData->setObjectName(name_data);
131  // return currentData;
132 
133  /* }else{
134 
135  axlAbstractData *currentData = new axlAbstractData();
136  return currentData;
137  }*/
138 
139 
140  //if there are some field, read them thanks to the factory.
141  QDomNodeList nodeListField = element.elementsByTagName("field");
142  if(!nodeListField.isEmpty()){
143  for(int i =0; i < nodeListField.size(); i++){
144  QDomElement fieldElement = nodeListField.at(i).toElement();
145  QString fieldType = fieldElement.attribute("type");
146  if(!fieldType.isEmpty()){
147  axlAbstractDataReader *field_reader = dynamic_cast<axlAbstractDataReader *>(axlFieldReadersFactory::instance()->create(fieldType));
148  axlAbstractField * fieldToAdd = dynamic_cast<axlAbstractField *>(field_reader->read(fieldElement));
149  if(fieldToAdd){
150  currentData->addField(fieldToAdd);
151  }
152  }
153  }
154  }
155  return currentData;
156 
157 
158 }
159 
206 axlAbstractData *axlDataDynamicReader::readInputs(axlDataDynamic *data, const QDomNode& node, const QList<axlAbstractData *>& list)
207 {
208  dtkWarn() << Q_FUNC_INFO<<list.size();
209  QDomElement element = node.toElement();
210 
211  QDomNodeList nextChild = element.childNodes();
212 
213  QDomNodeList nodelistinput = element.elementsByTagName("input") ;
214 
215  // Read inputs
216  for (int i = 0; i < nodelistinput.size(); i++) {
217  QDomElement childElement = nodelistinput.at(i).toElement();
218 // qDebug()<<"-- input"<<i;
219  int channel = 0;
220  // if(several_inputs) {
221  // channel = num_inputs;
222  // }
223  if (!childElement.attribute("channel").isEmpty()) {
224  channel=childElement.attribute("channel").toInt();
225  // several_inputs = true;
226  }
227 
228  QString typeChild = childElement.attribute("type");
229 // qDebug()<<"--"<<typeChild;
230 
231  if (typeChild == "data") {
232  QString nameInput = childElement.attribute("name");
233 
234 
235  if (!list.isEmpty()) {
236  bool input_found = false;
237  for (int j = 0; j < list.size(); j++) {
238 // qDebug()<<"--"<<list.at(j)->name();
239  if (list.at(j)->name() == nameInput) {
240  dynamic_cast<axlDataDynamic *>(data)->setInput(list.at(j), channel); // append the input to the data dynamic
241 
242  input_found=true;
243 
244  } else if (axlDataDynamic *ddata = dynamic_cast<axlDataDynamic *>(list.at(j))) {
245 
246  for (int i = 0; i < ddata->numberOfChannels(); i++) {
247  if(ddata->outputs(i)->name() == nameInput){
248  // if(isDynamicData)
249  dynamic_cast<axlDataDynamic *>(data)->setInput(ddata->outputs(i));
250  // else
251  // if(several_inputs)
252  // process->setInput(ddata->outputs(i), channel);
253  // else
254  // process->setInput(ddata->outputs(i));
255  input_found=true;
256  }
257  }
258  }
259  }
260 
261  if(!input_found){
262  dtkWarn()<< "Input" << nameInput << "not found";
263  }
264  }
265  } else if(typeChild == "double"){
266  QString valueDouble = childElement.attribute("value");
267  axlDouble *value = new axlDouble(valueDouble.toDouble());
268  // if(isDynamicData){
269  dynamic_cast<axlDataDynamic *>(data)->setInput(value);
270  // }else{
271  // if(childElement.attribute("channel").isEmpty()){
272  // process->setParameter(value->value());
273  // }else{
274  // process->setParameter(value->value(), channel);
275  // }
276  // }
277  }
278  }
279 
280  // Read parameters
281  QDomNodeList nodelistparam = element.elementsByTagName("parameter") ;
282  bool several_params = (nodelistparam.size()>0);
283 
284  int num_params=0;
285  for(int i = 0; i< nodelistparam.size();i++){
286 
287  QDomElement childElement = nodelistparam.at(i).toElement();
288  int channel = 0;
289  if(several_params) {
290  channel = num_params;
291  }
292  if (!childElement.attribute("channel").isEmpty()) {
293  channel=childElement.attribute("channel").toInt();
294  several_params=true;
295  }
296 
297  QString typeChild = childElement.attribute("type");
298 
299  /*if(typeChild == "data") {
300  QString nameParam = childElement.attribute("name");
301  if(!list.isEmpty()){
302  for (int j = 0;j < list.size();j++){
303  if(list.at(j)->name() == nameParam){
304  if(several_params)
305  process->setParameter(list.at(j),channel);
306  else
307  process->setParameter(list.at(j));
308  }
309  }
310  }
311  } else*/ if(typeChild == "double") {
312  QString valueDouble = childElement.attribute("value");
313  axlDouble *value = new axlDouble(valueDouble.toDouble());
314  // if(isDynamicData){
315  dtkWarn() << Q_FUNC_INFO << 2;
316  if(several_params)
317  dynamic_cast<axlDataDynamic *>(data)->setParameter(valueDouble.toDouble(),channel);
318  else
319  dynamic_cast<axlDataDynamic *>(data)->setParameter(valueDouble.toDouble());
320  dynamic_cast<axlDataDynamic *>(data)->setInput(value);
321 
322  // } else {
323  // if(several_params)
324  // process->setParameter(value->value(), channel);
325  // else
326  // process->setParameter(value->value());
327  // }
328  } else if(typeChild == "int") {
329  QString valueInt = childElement.attribute("value");
330  axlInteger *value = new axlInteger(valueInt.toInt());
331  // if(isDynamicData){
332  dtkWarn()<<"Set parameter"<<valueInt<<num_params<<several_params;
333  if(several_params)
334  dynamic_cast<axlDataDynamic *>(data)->setParameter(valueInt.toInt(),channel);
335  else
336  dynamic_cast<axlDataDynamic *>(data)->setParameter(valueInt.toInt());
337 
338  dynamic_cast<axlDataDynamic *>(data)->setInput(value);
339  // } else {
340  // if(several_params)
341  // process->setParameter(value->value(), channel);
342  // else
343  // process->setParameter(value->value());
344  // }
345  // }
346  num_params++;
347  }
348  }
349 
350 
351  // if(isDynamicData){
352 
353  // Compute the output
354  QDomNodeList nodelistoutputs = element.elementsByTagName("output") ;
355 
356  QString typeProcess = element.attribute("type");
357 
358  dtkWarn() << Q_FUNC_INFO << typeProcess;
359 
360  if (!typeProcess.isEmpty()) {
361  dynamic_cast<axlDataDynamic *>(data)->update();
362  dtkWarn() << Q_FUNC_INFO << "update dynamic data";
363  // on attribut le bon nom a chaque output
364  //int num_inputs = dynamic_cast<axlDataDynamic *>(data)->inputs().size();
365 
366  for(int i = 0; i < dynamic_cast<axlDataDynamic *>(data)->numberOfChannels(); i++){
367  //QDomElement childElement = nextChild.at(i+num_inputs).toElement();
368  QDomElement childElement = nodelistoutputs.at(i).toElement();
369 
370  // QString nameOutput = childElement.attribute("name");
371  // qDebug() << nameOutput;
372  // dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setObjectName(nameOutput);
373 
374  QString color = childElement.attribute("color");
375  if (!color.isEmpty()) {
376  dtkWarn() << Q_FUNC_INFO << "color";
377  QStringList colorList = color.split(" ");
378  if (colorList.size() > 2) { // rgb components
379  dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setColor(QColor(colorList.at(0).toInt(), colorList.at(1).toInt(), colorList.at(2).toInt()));
380  //dynamic_cast<axlDataDynamic *>(data)->setColor(QColor(colorList.at(0).toInt(), colorList.at(1).toInt(), colorList.at(2).toInt()));
381  } else if(colorList.size() == 4) {
382  dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setOpacity(colorList.at(3).toFloat());
383  //dynamic_cast<axlDataDynamic *>(data)->setOpacity(colorList.at(3).toFloat());
384  }
385  }
386 
387  QString shader = childElement.attribute("shader");
388  QString dirShader;
389  if (!shader.isEmpty()) {
390  // try to read from axelShader.qrc
391  dirShader = ":axlShader/shader/"+shader;
392  if (!QFile::exists(dirShader)) {
393  QSettings settings("inria", "dtk");
394  QString defaultPath;
395  settings.beginGroup("shader");
396  dirShader = settings.value("path", defaultPath).toString();
397  // dirShader = this->file().left(this->file().lastIndexOf("axel-data") + 9); // to Remove later
398  dirShader.append("/"+shader);
399  }
400  dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setShader(dirShader);
401  //dynamic_cast<axlDataDynamic *>(data)->setShader(dirShader);
402  }
403 
404  QString size = childElement.attribute("size");
405  if (!size.isEmpty()) {
406  dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setSize(size.toFloat());
407  //dynamic_cast<axlDataDynamic *>(data)->setSize(size.toFloat());
408  }
409 
410  QString nameO = childElement.attribute("name");
411  //qDebug() << nameO;
412 
413  if (!nameO.isEmpty()) {
414  dynamic_cast<axlDataDynamic *>(data)->outputs(i)->setObjectName(nameO);
415  }
416  }
417  }
418 
419  return data;
420 }
421 
422 axlAbstractData *axlDataDynamicReader::dataByReader(axlAbstractDataReader *axl_reader, const QDomNode& node)
423 {
424  if(!axl_reader)
425  return NULL;
426 
427  if(!axl_reader->accept(node))
428  return NULL;
429 
430  axl_reader->dtkAbstractDataReader::read(this->file());
431 
432  if(axlAbstractData *data = axl_reader->read(node))
433  return data;
434 
435  return NULL;
436 }
437 
438 dtkAbstractDataReader *createaxlDataDynamicReader(void)
439 {
440  return new axlDataDynamicReader;
441 }
axlDataDynamicReader::accept
bool accept(const QDomNode &node)
Definition: axlDataDynamicReader.cpp:67
axlDataDynamicReader::registered
static bool registered(void)
Definition: axlDataDynamicReader.cpp:62
axlDataDynamic::setProcess
int setProcess(QString processName)
Create the dynamic object process only with the name of its latter.
Definition: axlDataDynamic.cpp:285
axlDataDynamic::setType
void setType(axlDataDynamic::Type type)
Sets the type of the object. Type could be dynamic or static.
Definition: axlDataDynamic.cpp:123
axlDataDynamicReader::handled
QStringList handled(void) const
Definition: axlDataDynamicReader.cpp:57
axlDouble
Class axlDouble defines a double.
Definition: axlDouble.h:29
axlAbstractData::setShader
void setShader(const QString &shader)
Definition: axlAbstractData.cpp:127
axlFieldReadersFactory::create
dtkAbstractDataReader * create(const QString &interface_name)
Definition: axlFieldReadersFactory.cpp:98
axlDataDynamicReader::reject
bool reject(const QDomNode &node)
Definition: axlDataDynamicReader.cpp:77
axlDataDynamicReader::description
QString description(void) const
Definition: axlDataDynamicReader.cpp:52
axlDataDynamic
Class axlDataDynamic defines a dynamic object.
Definition: axlDataDynamic.h:33
axlAbstractDataReader::read
virtual axlAbstractData * read(const QDomNode &node)=0
axlAbstractField
Class axlAbstractField defines an API for arrays of numeric data.
Definition: axlAbstractField.h:29
axlInteger
Class axlInteger defines an integer.
Definition: axlInteger.h:28
axlDataDynamicReader::dataByReader
axlAbstractData * dataByReader(axlAbstractDataReader *axl_reader, const QDomNode &node)
Definition: axlDataDynamicReader.cpp:422
axlAbstractData::setOpacity
void setOpacity(const double &opacity)
Definition: axlAbstractData.cpp:92
axlDataDynamicReader::identifier
QString identifier(void) const
Definition: axlDataDynamicReader.cpp:47
axlDataDynamicReader::readInputs
axlAbstractData * readInputs(axlDataDynamic *data, const QDomNode &node, const QList< axlAbstractData * > &list)
Construct an axlAbstractData from a node and a list of data.
Definition: axlDataDynamicReader.cpp:206
axlDataDynamicReader::read
axlAbstractData * read(const QDomNode &node)
Definition: axlDataDynamicReader.cpp:82
axlAbstractDataReader::accept
virtual bool accept(const QDomNode &node)=0
createaxlDataDynamicReader
dtkAbstractDataReader * createaxlDataDynamicReader(void)
Definition: axlDataDynamicReader.cpp:438
axlFieldReadersFactory::instance
static axlFieldReadersFactory * instance(void)
Definition: axlFieldReadersFactory.cpp:65
axlAbstractData::addField
void addField(axlAbstractField *field)
Add a field to the field list of the object.
Definition: axlAbstractData.cpp:160
axlAbstractData::setSize
void setSize(const double &size)
Definition: axlAbstractData.cpp:102
axlAbstractData::setColor
void setColor(double r, double g, double b)
Definition: axlAbstractData.cpp:82
axlAbstractData
Class axlAbstractData defines an API for all type of axel data.
Definition: axlAbstractData.h:33
Generated on Sun Dec 2 2018 20:28:09 for Axl-2.5.1 by 1.8.9.1