stdr_robot_creator_connector.cpp
Go to the documentation of this file.
1 /******************************************************************************
2  STDR Simulator - Simple Two DImensional Robot Simulator
3  Copyright (C) 2013 STDR Simulator
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; either version 3 of the License, or
7  (at your option) any later version.
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  GNU General Public License for more details.
12  You should have received a copy of the GNU General Public License
13  along with this program; if not, write to the Free Software Foundation,
14  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15 
16  Authors :
17  * Manos Tsardoulias, etsardou@gmail.com
18  * Aris Thallas, aris.thallas@gmail.com
19  * Chris Zalidis, zalidis@gmail.com
20 ******************************************************************************/
21 
22 #include "stdr_gui/stdr_robot_creator/stdr_robot_creator_connector.h"
23 
24 namespace stdr_gui
25 {
26 
27  int CRobotCreatorConnector::laser_number = -1;
28  int CRobotCreatorConnector::sonar_number = -1;
29  int CRobotCreatorConnector::rfid_number = -1;
30  int CRobotCreatorConnector::co2_sensors_number = -1;
31  int CRobotCreatorConnector::thermal_sensors_number = -1;
32  int CRobotCreatorConnector::sound_sensors_number = -1;
33 
40  CRobotCreatorConnector::CRobotCreatorConnector(int argc, char **argv):
41  QObject(),
42  loader_(argc,argv),
43  argc_(argc),
44  argv_(argv)
45  {
46  QObject::connect(
47  loader_.robotTreeWidget,SIGNAL(itemClicked(QTreeWidgetItem *, int)),
48  this,SLOT(treeItemClicked(QTreeWidgetItem *, int)));
49 
50  QObject::connect(
51  loader_.laserPropLoader.laserUpdateButton,SIGNAL(clicked(bool)),
52  this,SLOT(updateLaser()));
53  QObject::connect(
54  loader_.laserPropLoader.refresh_laser,SIGNAL(clicked(bool)),
55  this,SLOT(updateLaserOpen()));
56 
57  QObject::connect(
58  loader_.robotPropLoader.updateButton,SIGNAL(clicked(bool)),
59  this,SLOT(updateRobot()));
60  QObject::connect(
61  loader_.robotPropLoader.refresh_robot,SIGNAL(clicked(bool)),
62  this,SLOT(updateRobotOpen()));
63 
64  QObject::connect(
65  loader_.sonarPropLoader.pushButton,SIGNAL(clicked(bool)),
66  this,SLOT(updateSonar()));
67  QObject::connect(
68  loader_.sonarPropLoader.refresh_sonar,SIGNAL(clicked(bool)),
69  this,SLOT(updateSonarOpen()));
70 
71  QObject::connect(
72  loader_.rfidAntennaPropLoader.pushButton,SIGNAL(clicked(bool)),
73  this,SLOT(updateRfidAntenna()));
74  QObject::connect(
75  loader_.rfidAntennaPropLoader.refreshRfid,SIGNAL(clicked(bool)),
76  this,SLOT(updateRfidAntennaOpen()));
77 
78  QObject::connect(
79  loader_.co2SensorPropLoader.pushButton,SIGNAL(clicked(bool)),
80  this,SLOT(updateCO2Sensor()));
81  QObject::connect(
82  loader_.co2SensorPropLoader.refreshButton,SIGNAL(clicked(bool)),
83  this,SLOT(updateCO2SensorOpen()));
84 
85  QObject::connect(
86  loader_.thermalSensorPropLoader.pushButton,SIGNAL(clicked(bool)),
87  this,SLOT(updateThermalSensor()));
88  QObject::connect(
89  loader_.thermalSensorPropLoader.refreshButton,SIGNAL(clicked(bool)),
90  this,SLOT(updateThermalSensorOpen()));
91 
92  QObject::connect(
93  loader_.soundSensorPropLoader.pushButton,SIGNAL(clicked(bool)),
94  this,SLOT(updateSoundSensor()));
95  QObject::connect(
96  loader_.soundSensorPropLoader.refreshButton,SIGNAL(clicked(bool)),
97  this,SLOT(updateSoundSensorOpen()));
98 
99  QObject::connect(
100  loader_.robotFootLoader.updateButton,SIGNAL(clicked(bool)),
101  this,SLOT(updateFootprintPoint()));
102  QObject::connect(
103  loader_.robotFootLoader.refresh_robot,SIGNAL(clicked(bool)),
104  this,SLOT(updateFootprintPointOpen()));
105 
106  QObject::connect(
107  loader_.kinematicPropLoader.updateButton,SIGNAL(clicked(bool)),
108  this,SLOT(updateKinematicModel()));
109 
110  QObject::connect(
111  loader_.loadRobotButton,SIGNAL(clicked(bool)),
112  this,SLOT(loadRobot()));
113 
114 
115  climax_ = - 1;
116  sonar_hightlight_id_ = -1;
117  laser_hightlight_id_ = -1;
118  rfid_antenna_hightlight_id_ = -1;
119  co2_sensor_hightlight_id_ = -1;
120  thermal_sensor_hightlight_id_ = -1;
121  sound_sensor_hightlight_id_ = -1;
122  }
123 
128  CRobotCreatorConnector::~CRobotCreatorConnector(void)
129  {
130 
131  }
132 
137  void CRobotCreatorConnector::initialise(void)
138  {
139  new_robot_msg_ = stdr_msgs::RobotMsg();
140 
141  loader_.robotInfoRadius.setText(0,"Radius");
142  loader_.robotInfoRadius.setText(1,"0.15");
143  loader_.robotInfoOrientation.setText(0,"Orientation");
144  loader_.robotInfoOrientation.setText(1,"0");
145 
146  new_robot_msg_.footprint.radius = 0.15;
147 
148  unsigned int laserCount = loader_.lasersNode.childCount();
149  unsigned int sonarCount = loader_.sonarsNode.childCount();
150  unsigned int rfidCount = loader_.rfidAntennasNode.childCount();
151  unsigned int co2SensorsCount = loader_.co2SensorsNode.childCount();
152  unsigned int thermalSensorsCount = loader_.thermalSensorsNode.childCount();
153  unsigned int soundSensorsCount = loader_.soundSensorsNode.childCount();
154  unsigned int footprintCount = loader_.robotInfoFootprint.childCount();
155 
156  for(int i = laserCount - 1 ; i >= 0 ; i--)
157  deleteTreeNode(loader_.lasersNode.child(i));
158  for(int i = sonarCount - 1 ; i >= 0 ; i--)
159  deleteTreeNode(loader_.sonarsNode.child(i));
160  for(int i = rfidCount - 1 ; i >= 0 ; i--)
161  deleteTreeNode(loader_.rfidAntennasNode.child(i));
162  for(int i = co2SensorsCount - 1 ; i >= 0 ; i--)
163  deleteTreeNode(loader_.co2SensorsNode.child(i));
164  for(int i = thermalSensorsCount - 1 ; i >= 0 ; i--)
165  deleteTreeNode(loader_.thermalSensorsNode.child(i));
166  for(int i = soundSensorsCount - 1 ; i >= 0 ; i--)
167  deleteTreeNode(loader_.soundSensorsNode.child(i));
168  for(int i = footprintCount - 1 ; i >= 0 ; i--)
169  deleteTreeNode(loader_.robotInfoFootprint.child(i));
170 
171  CRobotCreatorConnector::laser_number = 0;
172  CRobotCreatorConnector::sonar_number = 0;
173  CRobotCreatorConnector::rfid_number = 0;
174  CRobotCreatorConnector::co2_sensors_number = 0;
175  CRobotCreatorConnector::thermal_sensors_number = 0;
176  CRobotCreatorConnector::sound_sensors_number = 0;
177 
178  updateRobotPreview();
179 
180  loader_.show();
181  }
182 
189  void CRobotCreatorConnector::treeItemClicked(
190  QTreeWidgetItem * item,
191  int column)
192  {
193 
195  if(item->parent() == &loader_.lasersNode)
196  {
197  unsigned int laserFrameId = searchLaser(item->text(0));
198  if(laserFrameId == -1)
199  {
200  ROS_ERROR("Something went terribly wrong...");
201  }
202  laser_hightlight_id_ = laserFrameId;
203  sonar_hightlight_id_ = -1;
204  rfid_antenna_hightlight_id_ = -1;
205  co2_sensor_hightlight_id_ = -1;
206  thermal_sensor_hightlight_id_ = -1;
207  sound_sensor_hightlight_id_ = -1;
208  }
210  if(item->parent() == &loader_.sonarsNode)
211  {
212  unsigned int sonarFrameId = searchSonar(item->text(0));
213  if(sonarFrameId == -1)
214  {
215  ROS_ERROR("Something went terribly wrong...");
216  }
217  sonar_hightlight_id_ = sonarFrameId;
218  laser_hightlight_id_ = -1;
219  rfid_antenna_hightlight_id_ = -1;
220  co2_sensor_hightlight_id_ = -1;
221  thermal_sensor_hightlight_id_ = -1;
222  sound_sensor_hightlight_id_ = -1;
223  }
225  if(item->parent() == &loader_.rfidAntennasNode)
226  {
227  unsigned int frameId = searchRfid(item->text(0));
228  if(frameId == -1)
229  {
230  ROS_ERROR("Something went terribly wrong...");
231  }
232  rfid_antenna_hightlight_id_ = frameId;
233  laser_hightlight_id_ = -1;
234  sonar_hightlight_id_ = -1;
235  co2_sensor_hightlight_id_ = -1;
236  thermal_sensor_hightlight_id_ = -1;
237  sound_sensor_hightlight_id_ = -1;
238  }
240  if(item->parent() == &loader_.co2SensorsNode)
241  {
242  unsigned int frameId = searchCO2Sensor(item->text(0));
243  if(frameId == -1)
244  {
245  ROS_ERROR("Something went terribly wrong...");
246  }
247  rfid_antenna_hightlight_id_ = -1;
248  laser_hightlight_id_ = -1;
249  sonar_hightlight_id_ = -1;
250  co2_sensor_hightlight_id_ = frameId;
251  thermal_sensor_hightlight_id_ = -1;
252  sound_sensor_hightlight_id_ = -1;
253  }
255  if(item->parent() == &loader_.thermalSensorsNode)
256  {
257  unsigned int frameId = searchThermalSensor(item->text(0));
258  if(frameId == -1)
259  {
260  ROS_ERROR("Something went terribly wrong...");
261  }
262  rfid_antenna_hightlight_id_ = -1;
263  laser_hightlight_id_ = -1;
264  sonar_hightlight_id_ = -1;
265  co2_sensor_hightlight_id_ = -1;
266  thermal_sensor_hightlight_id_ = frameId;
267  sound_sensor_hightlight_id_ = -1;
268  }
270  if(item->parent() == &loader_.soundSensorsNode)
271  {
272  unsigned int frameId = searchSoundSensor(item->text(0));
273  if(frameId == -1)
274  {
275  ROS_ERROR("Something went terribly wrong...");
276  }
277  rfid_antenna_hightlight_id_ = -1;
278  laser_hightlight_id_ = -1;
279  sonar_hightlight_id_ = -1;
280  co2_sensor_hightlight_id_ = -1;
281  thermal_sensor_hightlight_id_ = -1;
282  sound_sensor_hightlight_id_ = frameId;
283  }
284 
285  updateRobotPreview();
286 
288  if(item == &loader_.robotNode && column == 2)
289  {
290  editRobot();
291  }
293  if(item == &loader_.robotNode && column == 3)
294  {
295  saveRobot();
296  }
298  if(item == &loader_.robotNode && column == 4)
299  {
300  getRobotFromYaml();
301  }
303  if(item == &loader_.kinematicNode && column == 2)
304  {
305  loader_.kinematicPropLoader.show();
306  }
308  if(item == &loader_.lasersNode && column == 2)
309  {
310  addLaser();
311  }
313  if(item->parent() == &loader_.lasersNode && column == 2)
314  {
315  eraseLaser(item);
316  }
318  if(item->parent() == &loader_.lasersNode && column == 1)
319  {
320  editLaser(item);
321  }
323  if(item == &loader_.sonarsNode && column == 2)
324  {
325  addSonar();
326  }
328  if(item == &loader_.rfidAntennasNode && column == 2)
329  {
330  addRfidAntenna();
331  }
333  if(item == &loader_.co2SensorsNode && column == 2)
334  {
335  addCO2Sensor();
336  }
338  if(item == &loader_.thermalSensorsNode && column == 2)
339  {
340  addThermalSensor();
341  }
343  if(item == &loader_.soundSensorsNode && column == 2)
344  {
345  addSoundSensor();
346  }
348  if(item->parent() == &loader_.sonarsNode && column == 2)
349  {
350  eraseSonar(item);
351  }
353  if(item->parent() == &loader_.rfidAntennasNode && column == 2)
354  {
355  eraseRfid(item);
356  }
358  if(item->parent() == &loader_.co2SensorsNode && column == 2)
359  {
360  eraseCO2Sensor(item);
361  }
363  if(item->parent() == &loader_.thermalSensorsNode && column == 2)
364  {
365  eraseThermalSensor(item);
366  }
368  if(item->parent() == &loader_.soundSensorsNode && column == 2)
369  {
370  eraseSoundSensor(item);
371  }
373  if(item->parent() == &loader_.sonarsNode && column == 1)
374  {
375  editSonar(item);
376  }
378  if(item->parent() == &loader_.rfidAntennasNode && column == 1)
379  {
380  editRfid(item);
381  }
383  if(item->parent() == &loader_.co2SensorsNode && column == 1)
384  {
385  editCO2Sensor(item);
386  }
388  if(item->parent() == &loader_.thermalSensorsNode && column == 1)
389  {
390  editThermalSensor(item);
391  }
393  if(item->parent() == &loader_.soundSensorsNode && column == 1)
394  {
395  editSoundSensor(item);
396  }
398  if(item->parent() == &loader_.lasersNode && column == 3)
399  {
400  saveLaser(item);
401  }
403  if(item->parent() == &loader_.lasersNode && column == 4)
404  {
405  loadLaser(item);
406  }
408  if(item->parent() == &loader_.rfidAntennasNode && column == 3)
409  {
410  saveRfidAntenna(item);
411  }
413  if(item->parent() == &loader_.co2SensorsNode && column == 3)
414  {
415  saveCO2Sensor(item);
416  }
418  if(item->parent() == &loader_.thermalSensorsNode && column == 3)
419  {
420  saveThermalSensor(item);
421  }
423  if(item->parent() == &loader_.soundSensorsNode && column == 3)
424  {
425  saveSoundSensor(item);
426  }
428  if(item->parent() == &loader_.rfidAntennasNode && column == 4)
429  {
430  loadRfidAntenna(item);
431  }
433  if(item->parent() == &loader_.co2SensorsNode && column == 4)
434  {
435  loadCO2Sensor(item);
436  }
438  if(item->parent() == &loader_.thermalSensorsNode && column == 4)
439  {
440  loadThermalSensor(item);
441  }
443  if(item->parent() == &loader_.soundSensorsNode && column == 4)
444  {
445  loadSoundSensor(item);
446  }
448  if(item->parent() == &loader_.sonarsNode && column == 3)
449  {
450  saveSonar(item);
451  }
453  if(item->parent() == &loader_.sonarsNode && column == 4)
454  {
455  loadSonar(item);
456  }
458  if(item == &loader_.robotInfoFootprint && column == 2)
459  {
460  addFootprintPoint();
461  }
463  if(item->parent() == &loader_.robotInfoFootprint && column == 2)
464  {
465  eraseFootprintPoint(item);
466  }
468  if(item->parent() == &loader_.robotInfoFootprint && column == 1)
469  {
470  editFootprintPoint(item);
471  }
472  }
473 
478  void CRobotCreatorConnector::addFootprintPoint(geometry_msgs::Point pt)
479  {
480  QTreeWidgetItem *new_point;
481 
482  new_point = new QTreeWidgetItem();
483 
484  new_point->setText(0,QString("[") + QString().setNum(pt.x) + QString(",") +
485  QString().setNum(pt.y) + QString("]"));
486  new_point->setIcon(1,loader_.editIcon);
487  new_point->setIcon(2,loader_.removeIcon);
488 
489  loader_.robotInfoFootprint.addChild(new_point);
490 
491  loader_.robotInfoFootprint.setExpanded(true);
492  updateRobotPreview();
493  }
494 
499  void CRobotCreatorConnector::addFootprintPoint(void)
500  {
501  geometry_msgs::Point pt;
502  pt.x = 0;
503  pt.y = 0;
504 
505  new_robot_msg_.footprint.points.push_back(pt);
506 
507  QTreeWidgetItem *new_point;
508 
509  new_point = new QTreeWidgetItem();
510 
511  new_point->setText(0,QString("[0,0]"));
512  new_point->setIcon(1,loader_.editIcon);
513  new_point->setIcon(2,loader_.removeIcon);
514 
515  loader_.robotInfoFootprint.addChild(new_point);
516 
517  loader_.robotInfoFootprint.setExpanded(true);
518  updateRobotPreview();
519  }
520 
525  void CRobotCreatorConnector::eraseFootprintPoint(QTreeWidgetItem *item)
526  {
527 
528  for(unsigned int i = 0 ; i < loader_.robotInfoFootprint.childCount() ; i++)
529  {
530  if(loader_.robotInfoFootprint.child(i) == item)
531  {
532  delete item;
533  new_robot_msg_.footprint.points.erase(
534  new_robot_msg_.footprint.points.begin() + i);
535  }
536  }
537  updateRobotPreview();
538  }
539 
544  void CRobotCreatorConnector::updateFootprintPoint(void)
545  {
546  QString xstr = loader_.robotFootLoader.robotFootprintX->text();
547  QString ystr = loader_.robotFootLoader.robotFootprintY->text();
548  float x = xstr.toFloat();
549  float y = ystr.toFloat();
550 
551  int index = -1;
552  for(unsigned int i = 0 ; i < loader_.robotInfoFootprint.childCount() ; i++)
553  {
554  if(loader_.robotInfoFootprint.child(i) == current_footprint_point_)
555  {
556  index = i;
557  break;
558  }
559  }
560  if( index == -1 )
561  {
562  return;
563  }
564 
565  new_robot_msg_.footprint.points[index].x = x;
566  new_robot_msg_.footprint.points[index].y = y;
567 
568  current_footprint_point_->setText(0,QString("[") + xstr + QString(",") +
569  ystr + QString("]"));
570 
571  loader_.robotFootLoader.hide();
572 
573  updateRobotPreview();
574  }
575 
580  void CRobotCreatorConnector::updateKinematicModel(void)
581  {
582  QString model_lit = loader_.kinematicPropLoader.comboBox->currentText();
583  int model_ind = loader_.kinematicPropLoader.comboBox->currentIndex();
584 
585  switch(model_ind){
586  case 0:
587  new_robot_msg_.kinematicModel.type = "ideal";
588  break;
589  case 1:
590  new_robot_msg_.kinematicModel.type = "omni";
591  break;
592  }
593 
594  loader_.kinematicPropLoader.hide();
595  loader_.kinematicNode.setText(0,"Kinematic model: " \
596  + QString(new_robot_msg_.kinematicModel.type.c_str()));
597 
598 
599  updateRobotPreview();
600  }
601 
606  void CRobotCreatorConnector::updateFootprintPointOpen(void)
607  {
608  QString xstr = loader_.robotFootLoader.robotFootprintX->text();
609  QString ystr = loader_.robotFootLoader.robotFootprintY->text();
610  float x = xstr.toFloat();
611  float y = ystr.toFloat();
612 
613  int index = -1;
614  for(unsigned int i = 0 ; i < loader_.robotInfoFootprint.childCount() ; i++)
615  {
616  if(loader_.robotInfoFootprint.child(i) == current_footprint_point_)
617  {
618  index = i;
619  break;
620  }
621  }
622  if( index == -1 )
623  {
624  return;
625  }
626 
627  new_robot_msg_.footprint.points[index].x = x;
628  new_robot_msg_.footprint.points[index].y = y;
629 
630  current_footprint_point_->setText(0,QString("[") + xstr + QString(",") +
631  ystr + QString("]"));
632 
633  updateRobotPreview();
634  }
635 
640  void CRobotCreatorConnector::addLaser(void)
641  {
642  QString laserFrameId=QString("laser_") +
643  QString().setNum(++CRobotCreatorConnector::laser_number);
644 
645  stdr_msgs::LaserSensorMsg lmsg;
646  lmsg.frame_id = laserFrameId.toStdString();
647  lmsg.numRays = 270;
648  lmsg.maxAngle = 135;
649  lmsg.minAngle = - 135;
650  lmsg.maxRange = 4.0;
651  lmsg.minRange = 0.0;
652  lmsg.pose.x = 0;
653  lmsg.pose.y = 0;
654  lmsg.pose.theta = 0;
655  lmsg.noise.noiseMean = 0;
656  lmsg.noise.noiseStd = 0;
657  lmsg.frequency = 10.0;
658 
659  new_robot_msg_.laserSensors.push_back(lmsg);
660 
661  QTreeWidgetItem *lnode;
662  lnode = new QTreeWidgetItem();
663  lnode->setText(0,laserFrameId);
664  lnode->setIcon(1,loader_.editIcon);
665  lnode->setIcon(2,loader_.removeIcon);
666  lnode->setIcon(3,loader_.saveIcon);
667  lnode->setIcon(4,loader_.loadIcon);
668 
669  QTreeWidgetItem
670  *angleSpan,
671  *orientation,
672  *maxRange,
673  *minRange,
674  *noiseMean,
675  *noiseStd,
676  *poseX,
677  *poseY,
678  *frequency,
679  *rays;
680 
681  rays = new QTreeWidgetItem();
682  angleSpan = new QTreeWidgetItem();
683  orientation = new QTreeWidgetItem();
684  maxRange = new QTreeWidgetItem();
685  minRange = new QTreeWidgetItem();
686  noiseMean = new QTreeWidgetItem();
687  noiseStd = new QTreeWidgetItem();
688  poseX = new QTreeWidgetItem();
689  poseY = new QTreeWidgetItem();
690  frequency = new QTreeWidgetItem();
691 
692  rays->setText(0,QString("Number of rays"));
693  angleSpan->setText(0,QString("Angle span"));
694  orientation->setText(0,QString("Orientation"));
695  maxRange->setText(0,QString("Max range"));
696  minRange->setText(0,QString("Min range"));
697  noiseMean->setText(0,QString("Noise mean"));
698  noiseStd->setText(0,QString("Noise std"));
699  poseX->setText(0,QString("Pose - x"));
700  poseY->setText(0,QString("Pose - y"));
701  frequency->setText(0,QString("Frequency"));
702 
703  rays->setText(1,QString().setNum(lmsg.numRays));
704  angleSpan->setText(1,QString().setNum(lmsg.maxAngle - lmsg.minAngle));
705  orientation->setText(1,QString().setNum(lmsg.maxAngle + lmsg.minAngle));
706  maxRange->setText(1,QString().setNum(lmsg.maxRange));
707  minRange->setText(1,QString().setNum(lmsg.minRange));
708  noiseMean->setText(1,QString().setNum(lmsg.noise.noiseMean));
709  noiseStd->setText(1,QString().setNum(lmsg.noise.noiseStd));
710  poseX->setText(1,QString().setNum(lmsg.pose.x));
711  poseY->setText(1,QString().setNum(lmsg.pose.y));
712  frequency->setText(1,QString().setNum(lmsg.frequency));
713 
714  lnode->addChild(rays);
715  lnode->addChild(angleSpan);
716  lnode->addChild(orientation);
717  lnode->addChild(maxRange);
718  lnode->addChild(minRange);
719  lnode->addChild(noiseMean);
720  lnode->addChild(noiseStd);
721  lnode->addChild(poseX);
722  lnode->addChild(poseY);
723  lnode->addChild(frequency);
724 
725  loader_.lasersNode.addChild(lnode);
726 
727  lnode->setExpanded(false);
728  loader_.lasersNode.setExpanded(true);
729  updateRobotPreview();
730  }
731 
737  void CRobotCreatorConnector::addLaser(stdr_msgs::LaserSensorMsg lmsg)
738  {
739  CRobotCreatorConnector::laser_number++;
740  QString laserFrameId=QString(lmsg.frame_id.c_str());
741 
742  QTreeWidgetItem *lnode;
743  lnode = new QTreeWidgetItem();
744  lnode->setText(0,laserFrameId);
745  lnode->setIcon(1,loader_.editIcon);
746  lnode->setIcon(2,loader_.removeIcon);
747  lnode->setIcon(3,loader_.saveIcon);
748  lnode->setIcon(4,loader_.loadIcon);
749 
750  QTreeWidgetItem
751  *angleSpan,
752  *orientation,
753  *maxRange,
754  *minRange,
755  *noiseMean,
756  *noiseStd,
757  *poseX,
758  *poseY,
759  *frequency,
760  *rays;
761 
762  rays = new QTreeWidgetItem();
763  angleSpan = new QTreeWidgetItem();
764  orientation = new QTreeWidgetItem();
765  maxRange = new QTreeWidgetItem();
766  minRange = new QTreeWidgetItem();
767  noiseMean = new QTreeWidgetItem();
768  noiseStd = new QTreeWidgetItem();
769  poseX = new QTreeWidgetItem();
770  poseY = new QTreeWidgetItem();
771  frequency = new QTreeWidgetItem();
772 
773  rays->setText(0,QString("Number of rays"));
774  angleSpan->setText(0,QString("Angle span"));
775  orientation->setText(0,QString("Orientation"));
776  maxRange->setText(0,QString("Max range"));
777  minRange->setText(0,QString("Min range"));
778  noiseMean->setText(0,QString("Noise mean"));
779  noiseStd->setText(0,QString("Noise std"));
780  poseX->setText(0,QString("Pose - x"));
781  poseY->setText(0,QString("Pose - y"));
782  frequency->setText(0,QString("Frequency"));
783 
784  rays->setText(1,QString().setNum(lmsg.numRays));
785  angleSpan->setText(1,QString().setNum(lmsg.maxAngle - lmsg.minAngle));
786  orientation->setText(1,QString().setNum(lmsg.pose.theta));
787  maxRange->setText(1,QString().setNum(lmsg.maxRange));
788  minRange->setText(1,QString().setNum(lmsg.minRange));
789  noiseMean->setText(1,QString().setNum(lmsg.noise.noiseMean));
790  noiseStd->setText(1,QString().setNum(lmsg.noise.noiseStd));
791  poseX->setText(1,QString().setNum(lmsg.pose.x));
792  poseY->setText(1,QString().setNum(lmsg.pose.y));
793  frequency->setText(1,QString().setNum(lmsg.frequency));
794 
795  lnode->addChild(rays);
796  lnode->addChild(angleSpan);
797  lnode->addChild(orientation);
798  lnode->addChild(maxRange);
799  lnode->addChild(minRange);
800  lnode->addChild(noiseMean);
801  lnode->addChild(noiseStd);
802  lnode->addChild(poseX);
803  lnode->addChild(poseY);
804  lnode->addChild(frequency);
805 
806  loader_.lasersNode.addChild(lnode);
807 
808  lnode->setExpanded(false);
809  loader_.lasersNode.setExpanded(true);
810  }
811 
816  void CRobotCreatorConnector::addSonar(void)
817  {
818  QString sonarFrameId =
819  QString("sonar_") +
820  QString().setNum(++CRobotCreatorConnector::sonar_number);
821 
822  stdr_msgs::SonarSensorMsg smsg;
823  smsg.frame_id = sonarFrameId.toStdString();
824  smsg.maxRange = 3.0;
825  smsg.minRange = 0.3;
826  smsg.coneAngle = 50.0;
827  smsg.pose.x = 0;
828  smsg.pose.y = 0;
829  smsg.pose.theta = 0;
830  smsg.noise.noiseMean = 0;
831  smsg.noise.noiseStd = 0;
832  smsg.frequency = 10;
833 
834  new_robot_msg_.sonarSensors.push_back(smsg);
835 
836  QTreeWidgetItem *snode;
837  snode = new QTreeWidgetItem();
838  snode->setText(0,sonarFrameId);
839  snode->setIcon(1,loader_.editIcon);
840  snode->setIcon(2,loader_.removeIcon);
841  snode->setIcon(3,loader_.saveIcon);
842  snode->setIcon(4,loader_.loadIcon);
843 
844  QTreeWidgetItem
845  *coneAngle,
846  *orientation,
847  *maxRange,
848  *minRange,
849  *noiseMean,
850  *noiseStd,
851  *poseX,
852  *poseY,
853  *frequency;
854 
855  coneAngle = new QTreeWidgetItem();
856  orientation = new QTreeWidgetItem();
857  maxRange = new QTreeWidgetItem();
858  minRange = new QTreeWidgetItem();
859  noiseMean = new QTreeWidgetItem();
860  noiseStd = new QTreeWidgetItem();
861  poseX = new QTreeWidgetItem();
862  poseY = new QTreeWidgetItem();
863  frequency = new QTreeWidgetItem();
864 
865  coneAngle->setText(0,QString("Cone span"));
866  orientation->setText(0,QString("Orientation"));
867  maxRange->setText(0,QString("Max range"));
868  minRange->setText(0,QString("Min range"));
869  noiseMean->setText(0,QString("Noise mean"));
870  noiseStd->setText(0,QString("Noise std"));
871  poseX->setText(0,QString("Pose - x"));
872  poseY->setText(0,QString("Pose - y"));
873  frequency->setText(0,QString("Frequency"));
874 
875  coneAngle->setText(1,QString().setNum(smsg.coneAngle));
876  orientation->setText(1,QString().setNum(smsg.pose.theta));
877  maxRange->setText(1,QString().setNum(smsg.maxRange));
878  minRange->setText(1,QString().setNum(smsg.minRange));
879  noiseMean->setText(1,QString().setNum(smsg.noise.noiseMean));
880  noiseStd->setText(1,QString().setNum(smsg.noise.noiseStd));
881  poseX->setText(1,QString().setNum(smsg.pose.x));
882  poseY->setText(1,QString().setNum(smsg.pose.y));
883  frequency->setText(1,QString().setNum(smsg.frequency));
884 
885  snode->addChild(coneAngle);
886  snode->addChild(orientation);
887  snode->addChild(maxRange);
888  snode->addChild(minRange);
889  snode->addChild(noiseMean);
890  snode->addChild(noiseStd);
891  snode->addChild(poseX);
892  snode->addChild(poseY);
893  snode->addChild(frequency);
894 
895  loader_.sonarsNode.addChild(snode);
896 
897  snode->setExpanded(false);
898  loader_.sonarsNode.setExpanded(true);
899  updateRobotPreview();
900  }
901 
907  void CRobotCreatorConnector::addSonar(stdr_msgs::SonarSensorMsg smsg)
908  {
909  CRobotCreatorConnector::sonar_number++;
910  QString sonarFrameId = QString(smsg.frame_id.c_str());
911 
912  QTreeWidgetItem *snode;
913  snode = new QTreeWidgetItem();
914  snode->setText(0,sonarFrameId);
915  snode->setIcon(1,loader_.editIcon);
916  snode->setIcon(2,loader_.removeIcon);
917  snode->setIcon(3,loader_.saveIcon);
918  snode->setIcon(4,loader_.loadIcon);
919 
920  QTreeWidgetItem
921  *coneAngle,
922  *orientation,
923  *maxRange,
924  *minRange,
925  *noiseMean,
926  *noiseStd,
927  *poseX,
928  *poseY,
929  *frequency;
930 
931  coneAngle = new QTreeWidgetItem();
932  orientation = new QTreeWidgetItem();
933  maxRange = new QTreeWidgetItem();
934  minRange = new QTreeWidgetItem();
935  noiseMean = new QTreeWidgetItem();
936  noiseStd = new QTreeWidgetItem();
937  poseX = new QTreeWidgetItem();
938  poseY = new QTreeWidgetItem();
939  frequency = new QTreeWidgetItem();
940 
941  coneAngle->setText(0,QString("Cone span"));
942  orientation->setText(0,QString("Orientation"));
943  maxRange->setText(0,QString("Max range"));
944  minRange->setText(0,QString("Min range"));
945  noiseMean->setText(0,QString("Noise mean"));
946  noiseStd->setText(0,QString("Noise std"));
947  poseX->setText(0,QString("Pose - x"));
948  poseY->setText(0,QString("Pose - y"));
949  frequency->setText(0,QString("Frequency"));
950 
951  coneAngle->setText(1,QString().setNum(smsg.coneAngle));
952  orientation->setText(1,QString().setNum(smsg.pose.theta));
953  maxRange->setText(1,QString().setNum(smsg.maxRange));
954  minRange->setText(1,QString().setNum(smsg.minRange));
955  noiseMean->setText(1,QString().setNum(smsg.noise.noiseMean));
956  noiseStd->setText(1,QString().setNum(smsg.noise.noiseStd));
957  poseX->setText(1,QString().setNum(smsg.pose.x));
958  poseY->setText(1,QString().setNum(smsg.pose.y));
959  frequency->setText(1,QString().setNum(smsg.frequency));
960 
961  snode->addChild(coneAngle);
962  snode->addChild(orientation);
963  snode->addChild(maxRange);
964  snode->addChild(minRange);
965  snode->addChild(noiseMean);
966  snode->addChild(noiseStd);
967  snode->addChild(poseX);
968  snode->addChild(poseY);
969  snode->addChild(frequency);
970 
971  loader_.sonarsNode.addChild(snode);
972 
973  snode->setExpanded(false);
974  loader_.sonarsNode.setExpanded(true);
975  }
976 
981  void CRobotCreatorConnector::addRfidAntenna(void)
982  {
983  QString rfidFrameId=QString("rfid_reader_") +
984  QString().setNum(CRobotCreatorConnector::rfid_number++);
985 
986  stdr_msgs::RfidSensorMsg smsg;
987  smsg.frame_id = rfidFrameId.toStdString();
988  smsg.maxRange = 3.0;
989  smsg.angleSpan = 360.0;
990  smsg.pose.x = 0;
991  smsg.pose.y = 0;
992  smsg.pose.theta = 0;
993  smsg.signalCutoff = 0;
994  smsg.frequency = 10;
995 
996  new_robot_msg_.rfidSensors.push_back(smsg);
997 
998  QTreeWidgetItem *snode;
999  snode = new QTreeWidgetItem();
1000  snode->setText(0,rfidFrameId);
1001  snode->setIcon(1,loader_.editIcon);
1002  snode->setIcon(2,loader_.removeIcon);
1003  snode->setIcon(3,loader_.saveIcon);
1004  snode->setIcon(4,loader_.loadIcon);
1005 
1006  QTreeWidgetItem
1007  *angleSpan,
1008  *orientation,
1009  *maxRange,
1010  *poseX,
1011  *poseY,
1012  *signalCutoff,
1013  *frequency;
1014 
1015  angleSpan = new QTreeWidgetItem();
1016  orientation = new QTreeWidgetItem();
1017  maxRange = new QTreeWidgetItem();
1018  poseX = new QTreeWidgetItem();
1019  poseY = new QTreeWidgetItem();
1020  signalCutoff = new QTreeWidgetItem();
1021  frequency = new QTreeWidgetItem();
1022 
1023  angleSpan->setText(0,QString("Angle span"));
1024  orientation->setText(0,QString("Orientation"));
1025  maxRange->setText(0,QString("Max range"));
1026  poseX->setText(0,QString("Pose - x"));
1027  poseY->setText(0,QString("Pose - y"));
1028  signalCutoff->setText(0,QString("Signal cutoff"));
1029  frequency->setText(0,QString("Frequency"));
1030 
1031  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1032  orientation->setText(1,QString().setNum(smsg.pose.theta));
1033  maxRange->setText(1,QString().setNum(smsg.maxRange));
1034  poseX->setText(1,QString().setNum(smsg.pose.x));
1035  poseY->setText(1,QString().setNum(smsg.pose.y));
1036  signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1037  frequency->setText(1,QString().setNum(smsg.frequency));
1038 
1039  snode->addChild(angleSpan);
1040  snode->addChild(orientation);
1041  snode->addChild(maxRange);
1042  snode->addChild(poseX);
1043  snode->addChild(poseY);
1044  snode->addChild(signalCutoff);
1045  snode->addChild(frequency);
1046 
1047  loader_.rfidAntennasNode.addChild(snode);
1048 
1049  snode->setExpanded(false);
1050  loader_.rfidAntennasNode.setExpanded(true);
1051  updateRobotPreview();
1052  }
1056  void CRobotCreatorConnector::addCO2Sensor(void)
1057  {
1058  QString co2SensorFrameId=QString("co2_sensor_") +
1059  QString().setNum(CRobotCreatorConnector::co2_sensors_number++);
1060 
1061  stdr_msgs::CO2SensorMsg smsg;
1062  smsg.frame_id = co2SensorFrameId.toStdString();
1063  smsg.maxRange = 3.0;
1064  //~ smsg.angleSpan = 360.0;
1065  smsg.pose.x = 0;
1066  smsg.pose.y = 0;
1067  smsg.pose.theta = 0;
1068  //~ smsg.signalCutoff = 0;
1069  smsg.frequency = 10;
1070 
1071  new_robot_msg_.co2Sensors.push_back(smsg);
1072 
1073  QTreeWidgetItem *snode;
1074  snode = new QTreeWidgetItem();
1075  snode->setText(0,co2SensorFrameId);
1076  snode->setIcon(1,loader_.editIcon);
1077  snode->setIcon(2,loader_.removeIcon);
1078  snode->setIcon(3,loader_.saveIcon);
1079  snode->setIcon(4,loader_.loadIcon);
1080 
1081  QTreeWidgetItem
1082  //~ *angleSpan,
1083  *orientation,
1084  *maxRange,
1085  *poseX,
1086  *poseY,
1087  //~ *signalCutoff,
1088  *frequency;
1089 
1090  //~ angleSpan = new QTreeWidgetItem();
1091  orientation = new QTreeWidgetItem();
1092  maxRange = new QTreeWidgetItem();
1093  poseX = new QTreeWidgetItem();
1094  poseY = new QTreeWidgetItem();
1095  //~ signalCutoff = new QTreeWidgetItem();
1096  frequency = new QTreeWidgetItem();
1097 
1098  //~ angleSpan->setText(0,QString("Angle span"));
1099  orientation->setText(0,QString("Orientation"));
1100  maxRange->setText(0,QString("Max range"));
1101  poseX->setText(0,QString("Pose - x"));
1102  poseY->setText(0,QString("Pose - y"));
1103  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1104  frequency->setText(0,QString("Frequency"));
1105 
1106  //~ angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1107  orientation->setText(1,QString().setNum(smsg.pose.theta));
1108  maxRange->setText(1,QString().setNum(smsg.maxRange));
1109  poseX->setText(1,QString().setNum(smsg.pose.x));
1110  poseY->setText(1,QString().setNum(smsg.pose.y));
1111  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1112  frequency->setText(1,QString().setNum(smsg.frequency));
1113 
1114  //~ snode->addChild(angleSpan);
1115  snode->addChild(orientation);
1116  snode->addChild(maxRange);
1117  snode->addChild(poseX);
1118  snode->addChild(poseY);
1119  //~ snode->addChild(signalCutoff);
1120  snode->addChild(frequency);
1121 
1122  loader_.co2SensorsNode.addChild(snode);
1123 
1124  snode->setExpanded(false);
1125  loader_.co2SensorsNode.setExpanded(true);
1126  updateRobotPreview();
1127  }
1131  void CRobotCreatorConnector::addThermalSensor(void)
1132  {
1133  QString thermalSensorFrameId=QString("thermal_sensor_") +
1134  QString().setNum(CRobotCreatorConnector::thermal_sensors_number++);
1135 
1136  stdr_msgs::ThermalSensorMsg smsg;
1137  smsg.frame_id = thermalSensorFrameId.toStdString();
1138  smsg.maxRange = 3.0;
1139  smsg.angleSpan = 20.0;
1140  smsg.pose.x = 0;
1141  smsg.pose.y = 0;
1142  smsg.pose.theta = 0;
1143  //~ smsg.signalCutoff = 0;
1144  smsg.frequency = 10;
1145 
1146  new_robot_msg_.thermalSensors.push_back(smsg);
1147 
1148  QTreeWidgetItem *snode;
1149  snode = new QTreeWidgetItem();
1150  snode->setText(0,thermalSensorFrameId);
1151  snode->setIcon(1,loader_.editIcon);
1152  snode->setIcon(2,loader_.removeIcon);
1153  snode->setIcon(3,loader_.saveIcon);
1154  snode->setIcon(4,loader_.loadIcon);
1155 
1156  QTreeWidgetItem
1157  *angleSpan,
1158  *orientation,
1159  *maxRange,
1160  *poseX,
1161  *poseY,
1162  //~ *signalCutoff,
1163  *frequency;
1164 
1165  angleSpan = new QTreeWidgetItem();
1166  orientation = new QTreeWidgetItem();
1167  maxRange = new QTreeWidgetItem();
1168  poseX = new QTreeWidgetItem();
1169  poseY = new QTreeWidgetItem();
1170  //~ signalCutoff = new QTreeWidgetItem();
1171  frequency = new QTreeWidgetItem();
1172 
1173  angleSpan->setText(0,QString("Angle span"));
1174  orientation->setText(0,QString("Orientation"));
1175  maxRange->setText(0,QString("Max range"));
1176  poseX->setText(0,QString("Pose - x"));
1177  poseY->setText(0,QString("Pose - y"));
1178  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1179  frequency->setText(0,QString("Frequency"));
1180 
1181  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1182  orientation->setText(1,QString().setNum(smsg.pose.theta));
1183  maxRange->setText(1,QString().setNum(smsg.maxRange));
1184  poseX->setText(1,QString().setNum(smsg.pose.x));
1185  poseY->setText(1,QString().setNum(smsg.pose.y));
1186  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1187  frequency->setText(1,QString().setNum(smsg.frequency));
1188 
1189  snode->addChild(angleSpan);
1190  snode->addChild(orientation);
1191  snode->addChild(maxRange);
1192  snode->addChild(poseX);
1193  snode->addChild(poseY);
1194  //~ snode->addChild(signalCutoff);
1195  snode->addChild(frequency);
1196 
1197  loader_.thermalSensorsNode.addChild(snode);
1198 
1199  snode->setExpanded(false);
1200  loader_.thermalSensorsNode.setExpanded(true);
1201  updateRobotPreview();
1202  }
1206  void CRobotCreatorConnector::addSoundSensor(void)
1207  {
1208  QString soundSensorFrameId=QString("sound_sensor_") +
1209  QString().setNum(CRobotCreatorConnector::sound_sensors_number++);
1210 
1211  stdr_msgs::SoundSensorMsg smsg;
1212  smsg.frame_id = soundSensorFrameId.toStdString();
1213  smsg.maxRange = 3.0;
1214  smsg.angleSpan = 180.0;
1215  smsg.pose.x = 0;
1216  smsg.pose.y = 0;
1217  smsg.pose.theta = 0;
1218  //~ smsg.signalCutoff = 0;
1219  smsg.frequency = 10;
1220 
1221  new_robot_msg_.soundSensors.push_back(smsg);
1222 
1223  QTreeWidgetItem *snode;
1224  snode = new QTreeWidgetItem();
1225  snode->setText(0,soundSensorFrameId);
1226  snode->setIcon(1,loader_.editIcon);
1227  snode->setIcon(2,loader_.removeIcon);
1228  snode->setIcon(3,loader_.saveIcon);
1229  snode->setIcon(4,loader_.loadIcon);
1230 
1231  QTreeWidgetItem
1232  *angleSpan,
1233  *orientation,
1234  *maxRange,
1235  *poseX,
1236  *poseY,
1237  //~ *signalCutoff,
1238  *frequency;
1239 
1240  angleSpan = new QTreeWidgetItem();
1241  orientation = new QTreeWidgetItem();
1242  maxRange = new QTreeWidgetItem();
1243  poseX = new QTreeWidgetItem();
1244  poseY = new QTreeWidgetItem();
1245  //~ signalCutoff = new QTreeWidgetItem();
1246  frequency = new QTreeWidgetItem();
1247 
1248  angleSpan->setText(0,QString("Angle span"));
1249  orientation->setText(0,QString("Orientation"));
1250  maxRange->setText(0,QString("Max range"));
1251  poseX->setText(0,QString("Pose - x"));
1252  poseY->setText(0,QString("Pose - y"));
1253  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1254  frequency->setText(0,QString("Frequency"));
1255 
1256  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1257  orientation->setText(1,QString().setNum(smsg.pose.theta));
1258  maxRange->setText(1,QString().setNum(smsg.maxRange));
1259  poseX->setText(1,QString().setNum(smsg.pose.x));
1260  poseY->setText(1,QString().setNum(smsg.pose.y));
1261  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1262  frequency->setText(1,QString().setNum(smsg.frequency));
1263 
1264  snode->addChild(angleSpan);
1265  snode->addChild(orientation);
1266  snode->addChild(maxRange);
1267  snode->addChild(poseX);
1268  snode->addChild(poseY);
1269  //~ snode->addChild(signalCutoff);
1270  snode->addChild(frequency);
1271 
1272  loader_.soundSensorsNode.addChild(snode);
1273 
1274  snode->setExpanded(false);
1275  loader_.soundSensorsNode.setExpanded(true);
1276  updateRobotPreview();
1277  }
1278 
1283  void CRobotCreatorConnector::addRfidAntenna(stdr_msgs::RfidSensorMsg smsg)
1284  {
1285  CRobotCreatorConnector::rfid_number++;
1286  QString rfidFrameId=QString(smsg.frame_id.c_str());
1287 
1288  QTreeWidgetItem *snode;
1289  snode = new QTreeWidgetItem();
1290  snode->setText(0,rfidFrameId);
1291  snode->setIcon(1,loader_.editIcon);
1292  snode->setIcon(2,loader_.removeIcon);
1293  snode->setIcon(3,loader_.saveIcon);
1294  snode->setIcon(4,loader_.loadIcon);
1295 
1296  QTreeWidgetItem
1297  *angleSpan,
1298  *orientation,
1299  *maxRange,
1300  *poseX,
1301  *poseY,
1302  *signalCutoff,
1303  *frequency;
1304 
1305  angleSpan = new QTreeWidgetItem();
1306  orientation = new QTreeWidgetItem();
1307  maxRange = new QTreeWidgetItem();
1308  poseX = new QTreeWidgetItem();
1309  poseY = new QTreeWidgetItem();
1310  signalCutoff = new QTreeWidgetItem();
1311  frequency = new QTreeWidgetItem();
1312 
1313  angleSpan->setText(0,QString("Angle span"));
1314  orientation->setText(0,QString("Orientation"));
1315  maxRange->setText(0,QString("Max range"));
1316  poseX->setText(0,QString("Pose - x"));
1317  poseY->setText(0,QString("Pose - y"));
1318  signalCutoff->setText(0,QString("Signal cutoff"));
1319  frequency->setText(0,QString("Frequency"));
1320 
1321  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1322  orientation->setText(1,QString().setNum(smsg.pose.theta));
1323  maxRange->setText(1,QString().setNum(smsg.maxRange));
1324  poseX->setText(1,QString().setNum(smsg.pose.x));
1325  poseY->setText(1,QString().setNum(smsg.pose.y));
1326  signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1327  frequency->setText(1,QString().setNum(smsg.frequency));
1328 
1329  snode->addChild(angleSpan);
1330  snode->addChild(orientation);
1331  snode->addChild(maxRange);
1332  snode->addChild(poseX);
1333  snode->addChild(poseY);
1334  snode->addChild(signalCutoff);
1335  snode->addChild(frequency);
1336 
1337  loader_.rfidAntennasNode.addChild(snode);
1338 
1339  snode->setExpanded(false);
1340  loader_.rfidAntennasNode.setExpanded(true);
1341  updateRobotPreview();
1342  }
1347  void CRobotCreatorConnector::addCO2Sensor(stdr_msgs::CO2SensorMsg smsg)
1348  {
1349  CRobotCreatorConnector::co2_sensors_number++;
1350  QString co2SensorFrameId=QString(smsg.frame_id.c_str());
1351 
1352  QTreeWidgetItem *snode;
1353  snode = new QTreeWidgetItem();
1354  snode->setText(0,co2SensorFrameId);
1355  snode->setIcon(1,loader_.editIcon);
1356  snode->setIcon(2,loader_.removeIcon);
1357  snode->setIcon(3,loader_.saveIcon);
1358  snode->setIcon(4,loader_.loadIcon);
1359 
1360  QTreeWidgetItem
1361  //~ *angleSpan,
1362  *orientation,
1363  *maxRange,
1364  *poseX,
1365  *poseY,
1366  //~ *signalCutoff,
1367  *frequency;
1368 
1369  //~ angleSpan = new QTreeWidgetItem();
1370  orientation = new QTreeWidgetItem();
1371  maxRange = new QTreeWidgetItem();
1372  poseX = new QTreeWidgetItem();
1373  poseY = new QTreeWidgetItem();
1374  //~ signalCutoff = new QTreeWidgetItem();
1375  frequency = new QTreeWidgetItem();
1376 
1377  //~ angleSpan->setText(0,QString("Angle span"));
1378  orientation->setText(0,QString("Orientation"));
1379  maxRange->setText(0,QString("Max range"));
1380  poseX->setText(0,QString("Pose - x"));
1381  poseY->setText(0,QString("Pose - y"));
1382  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1383  frequency->setText(0,QString("Frequency"));
1384 
1385  //~ angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1386  orientation->setText(1,QString().setNum(smsg.pose.theta));
1387  maxRange->setText(1,QString().setNum(smsg.maxRange));
1388  poseX->setText(1,QString().setNum(smsg.pose.x));
1389  poseY->setText(1,QString().setNum(smsg.pose.y));
1390  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1391  frequency->setText(1,QString().setNum(smsg.frequency));
1392 
1393  //~ snode->addChild(angleSpan);
1394  snode->addChild(orientation);
1395  snode->addChild(maxRange);
1396  snode->addChild(poseX);
1397  snode->addChild(poseY);
1398  //~ snode->addChild(signalCutoff);
1399  snode->addChild(frequency);
1400 
1401  loader_.co2SensorsNode.addChild(snode);
1402 
1403  snode->setExpanded(false);
1404  loader_.co2SensorsNode.setExpanded(true);
1405  updateRobotPreview();
1406  }
1411  void CRobotCreatorConnector::addThermalSensor(stdr_msgs::ThermalSensorMsg smsg)
1412  {
1413  CRobotCreatorConnector::thermal_sensors_number++;
1414  QString thermalSensorFrameId=QString(smsg.frame_id.c_str());
1415 
1416  QTreeWidgetItem *snode;
1417  snode = new QTreeWidgetItem();
1418  snode->setText(0,thermalSensorFrameId);
1419  snode->setIcon(1,loader_.editIcon);
1420  snode->setIcon(2,loader_.removeIcon);
1421  snode->setIcon(3,loader_.saveIcon);
1422  snode->setIcon(4,loader_.loadIcon);
1423 
1424  QTreeWidgetItem
1425  *angleSpan,
1426  *orientation,
1427  *maxRange,
1428  *poseX,
1429  *poseY,
1430  //~ *signalCutoff,
1431  *frequency;
1432 
1433  angleSpan = new QTreeWidgetItem();
1434  orientation = new QTreeWidgetItem();
1435  maxRange = new QTreeWidgetItem();
1436  poseX = new QTreeWidgetItem();
1437  poseY = new QTreeWidgetItem();
1438  //~ signalCutoff = new QTreeWidgetItem();
1439  frequency = new QTreeWidgetItem();
1440 
1441  angleSpan->setText(0,QString("Angle span"));
1442  orientation->setText(0,QString("Orientation"));
1443  maxRange->setText(0,QString("Max range"));
1444  poseX->setText(0,QString("Pose - x"));
1445  poseY->setText(0,QString("Pose - y"));
1446  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1447  frequency->setText(0,QString("Frequency"));
1448 
1449  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1450  orientation->setText(1,QString().setNum(smsg.pose.theta));
1451  maxRange->setText(1,QString().setNum(smsg.maxRange));
1452  poseX->setText(1,QString().setNum(smsg.pose.x));
1453  poseY->setText(1,QString().setNum(smsg.pose.y));
1454  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1455  frequency->setText(1,QString().setNum(smsg.frequency));
1456 
1457  snode->addChild(angleSpan);
1458  snode->addChild(orientation);
1459  snode->addChild(maxRange);
1460  snode->addChild(poseX);
1461  snode->addChild(poseY);
1462  //~ snode->addChild(signalCutoff);
1463  snode->addChild(frequency);
1464 
1465  loader_.thermalSensorsNode.addChild(snode);
1466 
1467  snode->setExpanded(false);
1468  loader_.thermalSensorsNode.setExpanded(true);
1469  updateRobotPreview();
1470  }
1475  void CRobotCreatorConnector::addSoundSensor(stdr_msgs::SoundSensorMsg smsg)
1476  {
1477  CRobotCreatorConnector::sound_sensors_number++;
1478  QString soundSensorFrameId=QString(smsg.frame_id.c_str());
1479 
1480  QTreeWidgetItem *snode;
1481  snode = new QTreeWidgetItem();
1482  snode->setText(0,soundSensorFrameId);
1483  snode->setIcon(1,loader_.editIcon);
1484  snode->setIcon(2,loader_.removeIcon);
1485  snode->setIcon(3,loader_.saveIcon);
1486  snode->setIcon(4,loader_.loadIcon);
1487 
1488  QTreeWidgetItem
1489  *angleSpan,
1490  *orientation,
1491  *maxRange,
1492  *poseX,
1493  *poseY,
1494  //~ *signalCutoff,
1495  *frequency;
1496 
1497  angleSpan = new QTreeWidgetItem();
1498  orientation = new QTreeWidgetItem();
1499  maxRange = new QTreeWidgetItem();
1500  poseX = new QTreeWidgetItem();
1501  poseY = new QTreeWidgetItem();
1502  //~ signalCutoff = new QTreeWidgetItem();
1503  frequency = new QTreeWidgetItem();
1504 
1505  angleSpan->setText(0,QString("Angle span"));
1506  orientation->setText(0,QString("Orientation"));
1507  maxRange->setText(0,QString("Max range"));
1508  poseX->setText(0,QString("Pose - x"));
1509  poseY->setText(0,QString("Pose - y"));
1510  //~ signalCutoff->setText(0,QString("Signal cutoff"));
1511  frequency->setText(0,QString("Frequency"));
1512 
1513  angleSpan->setText(1,QString().setNum(smsg.angleSpan));
1514  orientation->setText(1,QString().setNum(smsg.pose.theta));
1515  maxRange->setText(1,QString().setNum(smsg.maxRange));
1516  poseX->setText(1,QString().setNum(smsg.pose.x));
1517  poseY->setText(1,QString().setNum(smsg.pose.y));
1518  //~ signalCutoff->setText(1,QString().setNum(smsg.signalCutoff));
1519  frequency->setText(1,QString().setNum(smsg.frequency));
1520 
1521  snode->addChild(angleSpan);
1522  snode->addChild(orientation);
1523  snode->addChild(maxRange);
1524  snode->addChild(poseX);
1525  snode->addChild(poseY);
1526  //~ snode->addChild(signalCutoff);
1527  snode->addChild(frequency);
1528 
1529  loader_.soundSensorsNode.addChild(snode);
1530 
1531  snode->setExpanded(false);
1532  loader_.soundSensorsNode.setExpanded(true);
1533  updateRobotPreview();
1534  }
1535 
1541  void CRobotCreatorConnector::eraseLaser(QTreeWidgetItem *item)
1542  {
1543  unsigned int laserFrameId = searchLaser(item->text(0));
1544  if(laserFrameId == -1)
1545  {
1546  return;
1547  }
1548  new_robot_msg_.laserSensors.erase(
1549  new_robot_msg_.laserSensors.begin() + laserFrameId);
1550  deleteTreeNode(item);
1551  updateRobotPreview();
1552  }
1553 
1559  void CRobotCreatorConnector::eraseSonar(QTreeWidgetItem *item)
1560  {
1561  unsigned int sonarFrameId = searchSonar(item->text(0));
1562  if(sonarFrameId == -1)
1563  {
1564  return;
1565  }
1566  new_robot_msg_.sonarSensors.erase(
1567  new_robot_msg_.sonarSensors.begin() + sonarFrameId);
1568  deleteTreeNode(item);
1569  updateRobotPreview();
1570  }
1571 
1577  void CRobotCreatorConnector::eraseRfid(QTreeWidgetItem *item)
1578  {
1579  unsigned int rfidFrameId = searchRfid(item->text(0));
1580  if(rfidFrameId == -1)
1581  {
1582  return;
1583  }
1584  new_robot_msg_.rfidSensors.erase(
1585  new_robot_msg_.rfidSensors.begin() + rfidFrameId);
1586  deleteTreeNode(item);
1587  updateRobotPreview();
1588  }
1592  void CRobotCreatorConnector::eraseCO2Sensor(QTreeWidgetItem *item)
1593  {
1594  unsigned int frameId = searchCO2Sensor(item->text(0));
1595  if(frameId == -1)
1596  {
1597  return;
1598  }
1599  new_robot_msg_.co2Sensors.erase(
1600  new_robot_msg_.co2Sensors.begin() + frameId);
1601  deleteTreeNode(item);
1602  updateRobotPreview();
1603  }
1607  void CRobotCreatorConnector::eraseThermalSensor(QTreeWidgetItem *item)
1608  {
1609  unsigned int frameId = searchThermalSensor(item->text(0));
1610  if(frameId == -1)
1611  {
1612  return;
1613  }
1614  new_robot_msg_.thermalSensors.erase(
1615  new_robot_msg_.thermalSensors.begin() + frameId);
1616  deleteTreeNode(item);
1617  updateRobotPreview();
1618  }
1622  void CRobotCreatorConnector::eraseSoundSensor(QTreeWidgetItem *item)
1623  {
1624  unsigned int frameId = searchSoundSensor(item->text(0));
1625  if(frameId == -1)
1626  {
1627  return;
1628  }
1629  new_robot_msg_.soundSensors.erase(
1630  new_robot_msg_.soundSensors.begin() + frameId);
1631  deleteTreeNode(item);
1632  updateRobotPreview();
1633  }
1634 
1640  void CRobotCreatorConnector::editFootprintPoint(QTreeWidgetItem *item)
1641  {
1642  int index = -1;
1643  for(unsigned int i = 0 ; i < loader_.robotInfoFootprint.childCount() ; i++)
1644  {
1645  if(loader_.robotInfoFootprint.child(i) == item)
1646  {
1647  index = i;
1648  break;
1649  }
1650  }
1651  if( index == -1 )
1652  {
1653  return;
1654  }
1655 
1656  loader_.robotFootLoader.robotFootprintX->setText(
1657  QString().setNum(new_robot_msg_.footprint.points[index].x));
1658  loader_.robotFootLoader.robotFootprintY->setText(
1659  QString().setNum(new_robot_msg_.footprint.points[index].y));
1660 
1661  loader_.robotFootLoader.setWindowTitle(
1662  QApplication::translate(
1663  "Footprint point",
1664  item->text(0).toStdString().c_str(),
1665  0,
1666  QApplication::UnicodeUTF8));
1667 
1668  current_footprint_point_ = item;
1669 
1670  loader_.robotFootLoader.show();
1671  }
1672 
1678  void CRobotCreatorConnector::editLaser(QTreeWidgetItem *item)
1679  {
1680  unsigned int laserFrameId = searchLaser(item->text(0));
1681  if(laserFrameId == -1)
1682  {
1683  return;
1684  }
1685  loader_.laserPropLoader.laserRays->setText(
1686  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].numRays));
1687 
1688  loader_.laserPropLoader.laserMaxDistance->setText(
1689  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].maxRange));
1690 
1691  loader_.laserPropLoader.laserMinDistance->setText(
1692  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].minRange));
1693 
1694  loader_.laserPropLoader.laserAngleSpan->setText(
1695  QString().setNum(
1696  new_robot_msg_.laserSensors[laserFrameId].maxAngle -
1697  new_robot_msg_.laserSensors[laserFrameId].minAngle));
1698 
1699  loader_.laserPropLoader.laserOrientation->setText(
1700  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].pose.theta));
1701 
1702  loader_.laserPropLoader.laserNoiseMean->setText(
1703  QString().setNum(
1704  new_robot_msg_.laserSensors[laserFrameId].noise.noiseMean));
1705 
1706  loader_.laserPropLoader.laserNoiseStd->setText(
1707  QString().setNum(
1708  new_robot_msg_.laserSensors[laserFrameId].noise.noiseStd));
1709 
1710  loader_.laserPropLoader.laserTranslationX->setText(
1711  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].pose.x));
1712 
1713  loader_.laserPropLoader.laserTranslationY->setText(
1714  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].pose.y));
1715 
1716  loader_.laserPropLoader.laserFrequency->setText(
1717  QString().setNum(new_robot_msg_.laserSensors[laserFrameId].frequency));
1718 
1719  loader_.laserPropLoader.setWindowTitle(
1720  QApplication::translate(
1721  "LaserProperties",
1722  item->text(0).toStdString().c_str(),
1723  0,
1724  QApplication::UnicodeUTF8));
1725 
1726  current_laser_ = item;
1727 
1728  loader_.laserPropLoader.show();
1729  }
1730 
1736  void CRobotCreatorConnector::saveLaser(QTreeWidgetItem *item)
1737  {
1738  unsigned int laserFrameId = searchLaser(item->text(0));
1739  if(laserFrameId == -1)
1740  {
1741  return;
1742  }
1743  QString file_name = QFileDialog::getSaveFileName(&loader_,
1744  tr("Save laser sensor"),
1745  QString().fromStdString(
1746  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1747  QString("/resources/"),
1748  tr("Yaml files (*.yaml)"));
1749 
1750  std::string file_name_str=file_name.toStdString();
1751  stdr_msgs::LaserSensorMsg lmsg = new_robot_msg_.laserSensors[laserFrameId];
1752 
1753  try {
1754  stdr_parser::Parser::saveMessage(
1755  stdr_gui_tools::fixLaserAnglesToRad(lmsg), file_name_str);
1756  }
1757  catch(stdr_parser::ParserException ex)
1758  {
1759  QMessageBox msg;
1760  msg.setWindowTitle(QString("STDR Parser - Error"));
1761  msg.setText(QString(ex.what()));
1762  msg.exec();
1763  return;
1764  }
1765  }
1766 
1772  void CRobotCreatorConnector::saveSonar(QTreeWidgetItem *item)
1773  {
1774  unsigned int sonarFrameId = searchSonar(item->text(0));
1775  if(sonarFrameId == -1)
1776  {
1777  return;
1778  }
1779  QString file_name = QFileDialog::getSaveFileName(&loader_,
1780  tr("Save sonar sensor"),
1781  QString().fromStdString(
1782  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1783  QString("/resources/"),
1784  tr("Resource files (*.yaml *.xml)"));
1785 
1786  std::string file_name_str=file_name.toStdString();
1787  stdr_msgs::SonarSensorMsg smsg = new_robot_msg_.sonarSensors[sonarFrameId];
1788 
1789  try {
1790  stdr_parser::Parser::saveMessage(
1791  stdr_gui_tools::fixSonarAnglesToRad(smsg), file_name_str);
1792  }
1793  catch(stdr_parser::ParserException ex)
1794  {
1795  QMessageBox msg;
1796  msg.setWindowTitle(QString("STDR Parser - Error"));
1797  msg.setText(QString(ex.what()));
1798  msg.exec();
1799  return;
1800  }
1801  }
1802 
1808  void CRobotCreatorConnector::saveRfidAntenna(QTreeWidgetItem *item)
1809  {
1810  unsigned int frameId = searchRfid(item->text(0));
1811  if(frameId == -1)
1812  {
1813  return;
1814  }
1815  QString file_name = QFileDialog::getSaveFileName(&loader_,
1816  tr("Save RFID reader sensor"),
1817  QString().fromStdString(
1818  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1819  QString("/resources/"),
1820  tr("Resource files (*.yaml *.xml)"));
1821 
1822  std::string file_name_str=file_name.toStdString();
1823  stdr_msgs::RfidSensorMsg smsg = new_robot_msg_.rfidSensors[frameId];
1824 
1825  try {
1826  stdr_parser::Parser::saveMessage(
1827  stdr_gui_tools::fixRfidAnglesToRad(smsg), file_name_str);
1828  }
1829  catch(stdr_parser::ParserException ex)
1830  {
1831  QMessageBox msg;
1832  msg.setWindowTitle(QString("STDR Parser - Error"));
1833  msg.setText(QString(ex.what()));
1834  msg.exec();
1835  return;
1836  }
1837  }
1838 
1842  void CRobotCreatorConnector::saveCO2Sensor(QTreeWidgetItem *item)
1843  {
1844  unsigned int frameId = searchCO2Sensor(item->text(0));
1845  if(frameId == -1)
1846  {
1847  return;
1848  }
1849  QString file_name = QFileDialog::getSaveFileName(&loader_,
1850  tr("Save CO2 sensor"),
1851  QString().fromStdString(
1852  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1853  QString("/resources/"),
1854  tr("Resource files (*.yaml *.xml)"));
1855 
1856  std::string file_name_str=file_name.toStdString();
1857  stdr_msgs::CO2SensorMsg smsg = new_robot_msg_.co2Sensors[frameId];
1858 
1859  try {
1860  stdr_parser::Parser::saveMessage(
1861  stdr_gui_tools::fixCO2AnglesToRad(smsg), file_name_str);
1862  }
1863  catch(stdr_parser::ParserException ex)
1864  {
1865  QMessageBox msg;
1866  msg.setWindowTitle(QString("STDR Parser - Error"));
1867  msg.setText(QString(ex.what()));
1868  msg.exec();
1869  return;
1870  }
1871  }
1875  void CRobotCreatorConnector::saveThermalSensor(QTreeWidgetItem *item)
1876  {
1877  unsigned int frameId = searchThermalSensor(item->text(0));
1878  if(frameId == -1)
1879  {
1880  return;
1881  }
1882  QString file_name = QFileDialog::getSaveFileName(&loader_,
1883  tr("Save Thermal sensor"),
1884  QString().fromStdString(
1885  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1886  QString("/resources/"),
1887  tr("Resource files (*.yaml *.xml)"));
1888 
1889  std::string file_name_str=file_name.toStdString();
1890  stdr_msgs::ThermalSensorMsg smsg = new_robot_msg_.thermalSensors[frameId];
1891 
1892  try {
1893  stdr_parser::Parser::saveMessage(
1894  stdr_gui_tools::fixThermalAnglesToRad(smsg), file_name_str);
1895  }
1896  catch(stdr_parser::ParserException ex)
1897  {
1898  QMessageBox msg;
1899  msg.setWindowTitle(QString("STDR Parser - Error"));
1900  msg.setText(QString(ex.what()));
1901  msg.exec();
1902  return;
1903  }
1904  }
1908  void CRobotCreatorConnector::saveSoundSensor(QTreeWidgetItem *item)
1909  {
1910  unsigned int frameId = searchSoundSensor(item->text(0));
1911  if(frameId == -1)
1912  {
1913  return;
1914  }
1915  QString file_name = QFileDialog::getSaveFileName(&loader_,
1916  tr("Save Sound sensor"),
1917  QString().fromStdString(
1918  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1919  QString("/resources/"),
1920  tr("Resource files (*.yaml *.xml)"));
1921 
1922  std::string file_name_str=file_name.toStdString();
1923  stdr_msgs::SoundSensorMsg smsg = new_robot_msg_.soundSensors[frameId];
1924 
1925  try {
1926  stdr_parser::Parser::saveMessage(
1927  stdr_gui_tools::fixSoundAnglesToRad(smsg), file_name_str);
1928  }
1929  catch(stdr_parser::ParserException ex)
1930  {
1931  QMessageBox msg;
1932  msg.setWindowTitle(QString("STDR Parser - Error"));
1933  msg.setText(QString(ex.what()));
1934  msg.exec();
1935  return;
1936  }
1937  }
1938 
1944  void CRobotCreatorConnector::loadLaser(QTreeWidgetItem *item)
1945  {
1946  unsigned int laserFrameId = searchLaser(item->text(0));
1947  if(laserFrameId == -1)
1948  {
1949  return;
1950  }
1951  QString file_name = QFileDialog::getOpenFileName(
1952  &loader_,
1953  tr("Load laser sensor"),
1954  QString().fromStdString(
1955  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
1956  QString("/resources/"),
1957  tr("Resource Files (*.yaml *.xml)"));
1958 
1959  if (file_name.isEmpty()) {
1960  return;
1961  }
1962  std::string old_frame_id = item->text(0).toStdString();
1963  stdr_msgs::LaserSensorMsg lmsg;
1964  try {
1965  lmsg =
1966  stdr_parser::Parser::createMessage<stdr_msgs::LaserSensorMsg>
1967  (file_name.toStdString());
1968  }
1969  catch(stdr_parser::ParserException ex)
1970  {
1971  QMessageBox msg;
1972  msg.setWindowTitle(QString("STDR Parser - Error"));
1973  msg.setText(QString(ex.what()));
1974  msg.exec();
1975  return;
1976  }
1977  lmsg = stdr_gui_tools::fixLaserAnglesToDegrees(lmsg);
1978  lmsg.frame_id = old_frame_id;
1979  new_robot_msg_.laserSensors[laserFrameId]=lmsg;
1980  updateLaserTree(item,lmsg);
1981  updateRobotPreview();
1982  }
1983 
1989  void CRobotCreatorConnector::loadSonar(QTreeWidgetItem *item)
1990  {
1991  unsigned int sonarFrameId = searchSonar(item->text(0));
1992  if(sonarFrameId == -1)
1993  {
1994  return;
1995  }
1996  QString file_name = QFileDialog::getOpenFileName(
1997  &loader_,
1998  tr("Load sonar sensor"),
1999  QString().fromStdString(
2000  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
2001  QString("/resources/"),
2002  tr("Resource Files (*.yaml *.xml)"));
2003 
2004  if (file_name.isEmpty()) {
2005  return;
2006  }
2007  stdr_msgs::SonarSensorMsg smsg;
2008  std::string old_frame_id = item->text(0).toStdString();
2009  try {
2010  smsg =
2011  stdr_parser::Parser::createMessage<stdr_msgs::SonarSensorMsg>
2012  (file_name.toStdString());
2013  }
2014  catch(stdr_parser::ParserException ex)
2015  {
2016  QMessageBox msg;
2017  msg.setWindowTitle(QString("STDR Parser - Error"));
2018  msg.setText(QString(ex.what()));
2019  msg.exec();
2020  return;
2021  }
2022  smsg = stdr_gui_tools::fixSonarAnglesToDegrees(smsg);
2023  smsg.frame_id = old_frame_id;
2024  new_robot_msg_.sonarSensors[sonarFrameId]=smsg;
2025  updateSonarTree(item,smsg);
2026  updateRobotPreview();
2027  }
2028 
2034  void CRobotCreatorConnector::loadRfidAntenna(QTreeWidgetItem *item)
2035  {
2036  unsigned int frameId = searchRfid(item->text(0));
2037  if(frameId == -1)
2038  {
2039  return;
2040  }
2041  QString file_name = QFileDialog::getOpenFileName(
2042  &loader_,
2043  tr("Load RFID reader sensor"),
2044  QString().fromStdString(
2045  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
2046  QString("/resources/"),
2047  tr("Resource Files (*.yaml *.xml)"));
2048 
2049  if (file_name.isEmpty()) {
2050  return;
2051  }
2052  stdr_msgs::RfidSensorMsg smsg;
2053  std::string old_frame_id = item->text(0).toStdString();
2054  try {
2055  smsg =
2056  stdr_parser::Parser::createMessage<stdr_msgs::RfidSensorMsg>
2057  (file_name.toStdString());
2058  }
2059  catch(stdr_parser::ParserException ex)
2060  {
2061  QMessageBox msg;
2062  msg.setWindowTitle(QString("STDR Parser - Error"));
2063  msg.setText(QString(ex.what()));
2064  msg.exec();
2065  return;
2066  }
2067  smsg = stdr_gui_tools::fixRfidAnglesToDegrees(smsg);
2068  smsg.frame_id = old_frame_id;
2069  new_robot_msg_.rfidSensors[frameId]=smsg;
2070  updateRfidTree(item,smsg);
2071  updateRobotPreview();
2072  }
2076  void CRobotCreatorConnector::loadCO2Sensor(QTreeWidgetItem *item)
2077  {
2078  unsigned int frameId = searchCO2Sensor(item->text(0));
2079  if(frameId == -1)
2080  {
2081  return;
2082  }
2083  QString file_name = QFileDialog::getOpenFileName(
2084  &loader_,
2085  tr("Load CO2 sensor"),
2086  QString().fromStdString(
2087  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
2088  QString("/resources/"),
2089  tr("Resource Files (*.yaml *.xml)"));
2090 
2091  if (file_name.isEmpty()) {
2092  return;
2093  }
2094  stdr_msgs::CO2SensorMsg smsg;
2095  std::string old_frame_id = item->text(0).toStdString();
2096  try {
2097  smsg =
2098  stdr_parser::Parser::createMessage<stdr_msgs::CO2SensorMsg>
2099  (file_name.toStdString());
2100  }
2101  catch(stdr_parser::ParserException ex)
2102  {
2103  QMessageBox msg;
2104  msg.setWindowTitle(QString("STDR Parser - Error"));
2105  msg.setText(QString(ex.what()));
2106  msg.exec();
2107  return;
2108  }
2109  smsg = stdr_gui_tools::fixCO2AnglesToDegrees(smsg);
2110  smsg.frame_id = old_frame_id;
2111  new_robot_msg_.co2Sensors[frameId]=smsg;
2112  updateCO2SensorTree(item,smsg);
2113  updateRobotPreview();
2114  }
2118  void CRobotCreatorConnector::loadThermalSensor(QTreeWidgetItem *item)
2119  {
2120  unsigned int frameId = searchThermalSensor(item->text(0));
2121  if(frameId == -1)
2122  {
2123  return;
2124  }
2125  QString file_name = QFileDialog::getOpenFileName(
2126  &loader_,
2127  tr("Load thermal sensor"),
2128  QString().fromStdString(
2129  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
2130  QString("/resources/"),
2131  tr("Resource Files (*.yaml *.xml)"));
2132 
2133  if (file_name.isEmpty()) {
2134  return;
2135  }
2136  stdr_msgs::ThermalSensorMsg smsg;
2137  std::string old_frame_id = item->text(0).toStdString();
2138  try {
2139  smsg =
2140  stdr_parser::Parser::createMessage<stdr_msgs::ThermalSensorMsg>
2141  (file_name.toStdString());
2142  }
2143  catch(stdr_parser::ParserException ex)
2144  {
2145  QMessageBox msg;
2146  msg.setWindowTitle(QString("STDR Parser - Error"));
2147  msg.setText(QString(ex.what()));
2148  msg.exec();
2149  return;
2150  }
2151  smsg = stdr_gui_tools::fixThermalAnglesToDegrees(smsg);
2152  smsg.frame_id = old_frame_id;
2153  new_robot_msg_.thermalSensors[frameId]=smsg;
2154  updateThermalSensorTree(item,smsg);
2155  updateRobotPreview();
2156  }
2160  void CRobotCreatorConnector::loadSoundSensor(QTreeWidgetItem *item)
2161  {
2162  unsigned int frameId = searchSoundSensor(item->text(0));
2163  if(frameId == -1)
2164  {
2165  return;
2166  }
2167  QString file_name = QFileDialog::getOpenFileName(
2168  &loader_,
2169  tr("Load sound sensor"),
2170  QString().fromStdString(
2171  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
2172  QString("/resources/"),
2173  tr("Resource Files (*.yaml *.xml)"));
2174 
2175  if (file_name.isEmpty()) {
2176  return;
2177  }
2178  stdr_msgs::SoundSensorMsg smsg;
2179  std::string old_frame_id = item->text(0).toStdString();
2180  try {
2181  smsg =
2182  stdr_parser::Parser::createMessage<stdr_msgs::SoundSensorMsg>
2183  (file_name.toStdString());
2184  }
2185  catch(stdr_parser::ParserException ex)
2186  {
2187  QMessageBox msg;
2188  msg.setWindowTitle(QString("STDR Parser - Error"));
2189  msg.setText(QString(ex.what()));
2190  msg.exec();
2191  return;
2192  }
2193  smsg = stdr_gui_tools::fixSoundAnglesToDegrees(smsg);
2194  smsg.frame_id = old_frame_id;
2195  new_robot_msg_.soundSensors[frameId]=smsg;
2196  updateSoundSensorTree(item,smsg);
2197  updateRobotPreview();
2198  }
2199 
2205  void CRobotCreatorConnector::editSonar(QTreeWidgetItem *item)
2206  {
2207  unsigned int sonarFrameId = searchSonar(item->text(0));
2208  if(sonarFrameId == -1)
2209  {
2210  return;
2211  }
2212  loader_.sonarPropLoader.sonarMaxDistance->setText(
2213  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].maxRange));
2214 
2215  loader_.sonarPropLoader.sonarMinDistance->setText(
2216  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].minRange));
2217 
2218  loader_.sonarPropLoader.sonarX->setText(
2219  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].pose.x));
2220 
2221  loader_.sonarPropLoader.sonarY->setText(
2222  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].pose.y));
2223 
2224  loader_.sonarPropLoader.sonarConeSpan->setText(
2225  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].coneAngle));
2226 
2227  loader_.sonarPropLoader.sonarNoiseMean->setText(
2228  QString().setNum(
2229  new_robot_msg_.sonarSensors[sonarFrameId].noise.noiseMean));
2230 
2231  loader_.sonarPropLoader.sonarNoiseStd->setText(
2232  QString().setNum(
2233  new_robot_msg_.sonarSensors[sonarFrameId].noise.noiseStd));
2234 
2235  loader_.sonarPropLoader.sonarOrientation->setText(
2236  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].pose.theta));
2237 
2238  loader_.sonarPropLoader.sonarFrequency->setText(
2239  QString().setNum(new_robot_msg_.sonarSensors[sonarFrameId].frequency));
2240 
2241  loader_.sonarPropLoader.setWindowTitle(
2242  QApplication::translate(
2243  "SonarProperties",
2244  item->text(0).toStdString().c_str(),
2245  0,
2246  QApplication::UnicodeUTF8));
2247 
2248  current_sonar_ = item;
2249 
2250  loader_.sonarPropLoader.show();
2251  }
2252 
2258  void CRobotCreatorConnector::editRfid(QTreeWidgetItem *item)
2259  {
2260  unsigned int frameId = searchRfid(item->text(0));
2261  if(frameId == -1)
2262  {
2263  return;
2264  }
2265  loader_.rfidAntennaPropLoader.rfidMaxDistance->setText(
2266  QString().setNum(new_robot_msg_.rfidSensors[frameId].maxRange));
2267 
2268  loader_.rfidAntennaPropLoader.rfidX->setText(
2269  QString().setNum(new_robot_msg_.rfidSensors[frameId].pose.x));
2270 
2271  loader_.rfidAntennaPropLoader.rfidY->setText(
2272  QString().setNum(new_robot_msg_.rfidSensors[frameId].pose.y));
2273 
2274  loader_.rfidAntennaPropLoader.rfidAngleSpan->setText(
2275  QString().setNum(new_robot_msg_.rfidSensors[frameId].angleSpan));
2276 
2277  loader_.rfidAntennaPropLoader.rfidOrientation->setText(
2278  QString().setNum(new_robot_msg_.rfidSensors[frameId].pose.theta));
2279 
2280  loader_.rfidAntennaPropLoader.rfidSignalCutoff->setText(
2281  QString().setNum(new_robot_msg_.rfidSensors[frameId].signalCutoff));
2282 
2283  loader_.rfidAntennaPropLoader.rfidFrequency->setText(
2284  QString().setNum(new_robot_msg_.rfidSensors[frameId].frequency));
2285 
2286  loader_.rfidAntennaPropLoader.setWindowTitle(
2287  QApplication::translate(
2288  "RfidAntennaProperties",
2289  item->text(0).toStdString().c_str(),
2290  0,
2291  QApplication::UnicodeUTF8));
2292 
2293  current_rfid_ = item;
2294 
2295  loader_.rfidAntennaPropLoader.show();
2296  }
2301  void CRobotCreatorConnector::editCO2Sensor(QTreeWidgetItem *item)
2302  {
2303  unsigned int frameId = searchCO2Sensor(item->text(0));
2304  if(frameId == -1)
2305  {
2306  return;
2307  }
2308  loader_.co2SensorPropLoader.maxDistance->setText(
2309  QString().setNum(new_robot_msg_.co2Sensors[frameId].maxRange));
2310 
2311  loader_.co2SensorPropLoader.x_->setText(
2312  QString().setNum(new_robot_msg_.co2Sensors[frameId].pose.x));
2313 
2314  loader_.co2SensorPropLoader.y_->setText(
2315  QString().setNum(new_robot_msg_.co2Sensors[frameId].pose.y));
2316 
2317  //~ loader_.co2SensorPropLoader.angleSpan->setText(
2318  //~ QString().setNum(new_robot_msg_.co2Sensors[frameId].angleSpan));
2319 
2320  loader_.co2SensorPropLoader.orientation->setText(
2321  QString().setNum(new_robot_msg_.co2Sensors[frameId].pose.theta));
2322 
2323  //~ loader_.co2SensorPropLoader.signalCutoff->setText(
2324  //~ QString().setNum(new_robot_msg_.co2Sensors[frameId].signalCutoff));
2325 
2326  loader_.co2SensorPropLoader.frequency->setText(
2327  QString().setNum(new_robot_msg_.co2Sensors[frameId].frequency));
2328 
2329  loader_.co2SensorPropLoader.setWindowTitle(
2330  QApplication::translate(
2331  "CO2SensorProperties",
2332  item->text(0).toStdString().c_str(),
2333  0,
2334  QApplication::UnicodeUTF8));
2335 
2336  current_co2_sensor_ = item;
2337 
2338  loader_.co2SensorPropLoader.show();
2339  }
2344  void CRobotCreatorConnector::editThermalSensor(QTreeWidgetItem *item)
2345  {
2346  unsigned int frameId = searchThermalSensor(item->text(0));
2347  if(frameId == -1)
2348  {
2349  return;
2350  }
2351  loader_.thermalSensorPropLoader.maxDistance->setText(
2352  QString().setNum(new_robot_msg_.thermalSensors[frameId].maxRange));
2353 
2354  loader_.thermalSensorPropLoader.x_->setText(
2355  QString().setNum(new_robot_msg_.thermalSensors[frameId].pose.x));
2356 
2357  loader_.thermalSensorPropLoader.y_->setText(
2358  QString().setNum(new_robot_msg_.thermalSensors[frameId].pose.y));
2359 
2360  loader_.thermalSensorPropLoader.angleSpan->setText(
2361  QString().setNum(new_robot_msg_.thermalSensors[frameId].angleSpan));
2362 
2363  loader_.thermalSensorPropLoader.orientation->setText(
2364  QString().setNum(new_robot_msg_.thermalSensors[frameId].pose.theta));
2365 
2366  loader_.thermalSensorPropLoader.frequency->setText(
2367  QString().setNum(new_robot_msg_.thermalSensors[frameId].frequency));
2368 
2369  loader_.thermalSensorPropLoader.setWindowTitle(
2370  QApplication::translate(
2371  "ThermalSensorProperties",
2372  item->text(0).toStdString().c_str(),
2373  0,
2374  QApplication::UnicodeUTF8));
2375 
2376  current_thermal_sensor_ = item;
2377 
2378  loader_.thermalSensorPropLoader.show();
2379  }
2384  void CRobotCreatorConnector::editSoundSensor(QTreeWidgetItem *item)
2385  {
2386  unsigned int frameId = searchSoundSensor(item->text(0));
2387  if(frameId == -1)
2388  {
2389  return;
2390  }
2391  loader_.soundSensorPropLoader.maxDistance->setText(
2392  QString().setNum(new_robot_msg_.soundSensors[frameId].maxRange));
2393 
2394  loader_.soundSensorPropLoader.x_->setText(
2395  QString().setNum(new_robot_msg_.soundSensors[frameId].pose.x));
2396 
2397  loader_.soundSensorPropLoader.y_->setText(
2398  QString().setNum(new_robot_msg_.soundSensors[frameId].pose.y));
2399 
2400  loader_.soundSensorPropLoader.angleSpan->setText(
2401  QString().setNum(new_robot_msg_.soundSensors[frameId].angleSpan));
2402 
2403  loader_.soundSensorPropLoader.orientation->setText(
2404  QString().setNum(new_robot_msg_.soundSensors[frameId].pose.theta));
2405 
2406  loader_.soundSensorPropLoader.frequency->setText(
2407  QString().setNum(new_robot_msg_.soundSensors[frameId].frequency));
2408 
2409  loader_.soundSensorPropLoader.setWindowTitle(
2410  QApplication::translate(
2411  "SoundSensorProperties",
2412  item->text(0).toStdString().c_str(),
2413  0,
2414  QApplication::UnicodeUTF8));
2415 
2416  current_sound_sensor_ = item;
2417 
2418  loader_.soundSensorPropLoader.show();
2419  }
2420 
2426  int CRobotCreatorConnector::searchLaser(QString frameId)
2427  {
2428  for(unsigned int i = 0 ; i < new_robot_msg_.laserSensors.size() ; i++)
2429  {
2430  if(new_robot_msg_.laserSensors[i].frame_id == frameId.toStdString())
2431  {
2432  return i;
2433  }
2434  }
2435  return -1;
2436  }
2437 
2443  int CRobotCreatorConnector::searchSonar(QString frameId)
2444  {
2445  for(unsigned int i = 0 ; i < new_robot_msg_.sonarSensors.size() ; i++)
2446  {
2447  if(new_robot_msg_.sonarSensors[i].frame_id == frameId.toStdString())
2448  {
2449  return i;
2450  }
2451  }
2452  return -1;
2453  }
2454 
2460  int CRobotCreatorConnector::searchRfid(QString frameId)
2461  {
2462  for(unsigned int i = 0 ; i < new_robot_msg_.rfidSensors.size() ; i++)
2463  {
2464  if(new_robot_msg_.rfidSensors[i].frame_id == frameId.toStdString())
2465  {
2466  return i;
2467  }
2468  }
2469  return -1;
2470  }
2476  int CRobotCreatorConnector::searchCO2Sensor(QString frameId)
2477  {
2478  for(unsigned int i = 0 ; i < new_robot_msg_.co2Sensors.size() ; i++)
2479  {
2480  if(new_robot_msg_.co2Sensors[i].frame_id == frameId.toStdString())
2481  {
2482  return i;
2483  }
2484  }
2485  return -1;
2486  }
2492  int CRobotCreatorConnector::searchThermalSensor(QString frameId)
2493  {
2494  for(unsigned int i = 0 ; i < new_robot_msg_.thermalSensors.size() ; i++)
2495  {
2496  if(new_robot_msg_.thermalSensors[i].frame_id == frameId.toStdString())
2497  {
2498  return i;
2499  }
2500  }
2501  return -1;
2502  }
2508  int CRobotCreatorConnector::searchSoundSensor(QString frameId)
2509  {
2510  for(unsigned int i = 0 ; i < new_robot_msg_.soundSensors.size() ; i++)
2511  {
2512  if(new_robot_msg_.soundSensors[i].frame_id == frameId.toStdString())
2513  {
2514  return i;
2515  }
2516  }
2517  return -1;
2518  }
2519 
2524  void CRobotCreatorConnector::updateRobotTree(void)
2525  {
2526  for(unsigned int i = 0 ; i < loader_.robotNode.childCount() ; i++)
2527  {
2528  if(loader_.robotNode.child(i)->text(0) == QString("Orientation"))
2529  {
2530  loader_.robotNode.child(i)->
2531  setText(1,QString().setNum(new_robot_msg_.initialPose.theta));
2532  }
2533  if(loader_.robotNode.child(i)->text(0) == QString("Radius"))
2534  {
2535  loader_.robotNode.child(i)->
2536  setText(1,QString().setNum(new_robot_msg_.footprint.radius));
2537  }
2538  }
2539  int count = 0;
2540 
2541  count = loader_.lasersNode.childCount();
2542  for(int i = count - 1 ; i >= 0 ; i--)
2543  {
2544  QTreeWidgetItem *child = loader_.lasersNode.child(i);
2545  loader_.lasersNode.removeChild(loader_.lasersNode.child(i));
2546  }
2547  for(unsigned int i = 0 ; i < new_robot_msg_.laserSensors.size() ; i++)
2548  {
2549  addLaser(new_robot_msg_.laserSensors[i]);
2550  }
2551 
2552  count = loader_.rfidAntennasNode.childCount();
2553  for(int i = count - 1 ; i >= 0 ; i--)
2554  {
2555  QTreeWidgetItem *child = loader_.rfidAntennasNode.child(i);
2556  loader_.rfidAntennasNode.removeChild(loader_.rfidAntennasNode.child(i));
2557  }
2558  for(unsigned int i = 0 ; i < new_robot_msg_.rfidSensors.size() ; i++)
2559  {
2560  addRfidAntenna(new_robot_msg_.rfidSensors[i]);
2561  }
2562 
2563  count = loader_.thermalSensorsNode.childCount();
2564  for(int i = count - 1 ; i >= 0 ; i--)
2565  {
2566  QTreeWidgetItem *child = loader_.thermalSensorsNode.child(i);
2567  loader_.thermalSensorsNode.removeChild(loader_.thermalSensorsNode.child(i));
2568  }
2569  for(unsigned int i = 0 ; i < new_robot_msg_.thermalSensors.size() ; i++)
2570  {
2571  addThermalSensor(new_robot_msg_.thermalSensors[i]);
2572  }
2573 
2574  count = loader_.soundSensorsNode.childCount();
2575  for(int i = count - 1 ; i >= 0 ; i--)
2576  {
2577  QTreeWidgetItem *child = loader_.soundSensorsNode.child(i);
2578  loader_.soundSensorsNode.removeChild(loader_.soundSensorsNode.child(i));
2579  }
2580  for(unsigned int i = 0 ; i < new_robot_msg_.soundSensors.size() ; i++)
2581  {
2582  addSoundSensor(new_robot_msg_.soundSensors[i]);
2583  }
2584 
2585  count = loader_.sonarsNode.childCount();
2586  for(int i = count - 1 ; i >= 0 ; i--)
2587  {
2588  QTreeWidgetItem *child = loader_.sonarsNode.child(i);
2589  loader_.sonarsNode.removeChild(loader_.sonarsNode.child(i));
2590  }
2591  for(unsigned int i = 0 ; i < new_robot_msg_.sonarSensors.size() ; i++)
2592  {
2593  addSonar(new_robot_msg_.sonarSensors[i]);
2594  }
2595 
2596  for(unsigned int i = 0 ; i < new_robot_msg_.footprint.points.size() ; i++)
2597  {
2598  addFootprintPoint(new_robot_msg_.footprint.points[i]);
2599  }
2600  }
2601 
2608  void CRobotCreatorConnector::updateLaserTree(
2609  QTreeWidgetItem *item,
2610  stdr_msgs::LaserSensorMsg l)
2611  {
2612  for(unsigned int i = 0 ; i < item->childCount() ; i++)
2613  {
2614  if(item->child(i)->text(0) == QString("Angle span"))
2615  {
2616  item->child(i)->setText(1,QString().setNum(l.maxAngle - l.minAngle));
2617  }
2618  else if(item->child(i)->text(0) == QString("Orientation"))
2619  {
2620  item->child(i)->setText(1,QString().setNum(l.pose.theta));
2621  }
2622  else if(item->child(i)->text(0) == QString("Max range"))
2623  {
2624  item->child(i)->setText(1,QString().setNum(l.maxRange));
2625  }
2626  else if(item->child(i)->text(0) == QString("Number of rays"))
2627  {
2628  item->child(i)->setText(1,QString().setNum(l.numRays));
2629  }
2630  else if(item->child(i)->text(0) == QString("Min range"))
2631  {
2632  item->child(i)->setText(1,QString().setNum(l.minRange));
2633  }
2634  else if(item->child(i)->text(0) == QString("Noise mean"))
2635  {
2636  item->child(i)->setText(1,QString().setNum(l.noise.noiseMean));
2637  }
2638  else if(item->child(i)->text(0) == QString("Noise std"))
2639  {
2640  item->child(i)->setText(1,QString().setNum(l.noise.noiseStd));
2641  }
2642  else if(item->child(i)->text(0) == QString("Pose - x"))
2643  {
2644  item->child(i)->setText(1,QString().setNum(l.pose.x));
2645  }
2646  else if(item->child(i)->text(0) == QString("Pose - y"))
2647  {
2648  item->child(i)->setText(1,QString().setNum(l.pose.y));
2649  }
2650  else if(item->child(i)->text(0) == QString("Frequency"))
2651  {
2652  item->child(i)->setText(1,QString().setNum(l.frequency));
2653  }
2654  }
2655  }
2656 
2661  void CRobotCreatorConnector::updateLaser(void)
2662  {
2663  unsigned int laserFrameId = searchLaser(current_laser_->text(0));
2664  if(laserFrameId == -1)
2665  {
2666  return;
2667  }
2668  float max_range = 1000.0;
2669  float min_range = 0.0;
2670  for(unsigned int i = 0 ; i < current_laser_->childCount() ; i++)
2671  {
2672 
2674  if(current_laser_->child(i)->text(0) == QString("Angle span"))
2675  {
2676  current_laser_->child(i)->setText(
2677  1,loader_.laserPropLoader.laserAngleSpan->text());
2678  float angleSpan = loader_.laserPropLoader.laserAngleSpan->
2679  text().toFloat() / 2.0;
2680  if( angleSpan <= 0 )
2681  {
2682  showMessage(QString("Laser angle span invalid :") +
2683  QString().setNum(angleSpan * 2.0));
2684  return;
2685  }
2686  new_robot_msg_.laserSensors[laserFrameId].minAngle = - angleSpan;
2687  new_robot_msg_.laserSensors[laserFrameId].maxAngle = angleSpan;
2688  }
2689 
2691  else if(current_laser_->child(i)->text(0) == QString("Orientation"))
2692  {
2693  float orientation = loader_.laserPropLoader.laserOrientation->
2694  text().toFloat();
2695  current_laser_->child(i)->setText(
2696  1,QString().setNum(orientation));
2697  //~ new_robot_msg_.laserSensors[laserFrameId].minAngle += orientation;
2698  //~ new_robot_msg_.laserSensors[laserFrameId].maxAngle += orientation;
2699  new_robot_msg_.laserSensors[laserFrameId].pose.theta = orientation;
2700  }
2701 
2703  else if(current_laser_->child(i)->text(0) == QString("Max range"))
2704  {
2705  max_range = loader_.laserPropLoader.laserMaxDistance->
2706  text().toFloat();
2707  if( max_range <= 0 )
2708  {
2709  showMessage(QString("Laser maximum range invalid :") +
2710  QString().setNum(max_range));
2711  return;
2712  }
2713  if( max_range < min_range )
2714  {
2715  showMessage(QString("Laser maximum range lower than minimum range"));
2716  return;
2717  }
2718  current_laser_->child(i)->setText(1,QString().setNum(max_range));
2719  new_robot_msg_.laserSensors[laserFrameId].maxRange = max_range;
2720  }
2721 
2723  else if(current_laser_->child(i)->text(0) == QString("Number of rays"))
2724  {
2725  int rays = loader_.laserPropLoader.laserRays->text().toFloat();
2726  if( rays <= 0 )
2727  {
2728  showMessage(QString("Laser rays number invalid :") +
2729  QString().setNum(rays));
2730  return;
2731  }
2732  current_laser_->child(i)->setText(1,QString().setNum(rays));
2733  new_robot_msg_.laserSensors[laserFrameId].numRays = rays;
2734  }
2735 
2737  else if(current_laser_->child(i)->text(0) == QString("Min range"))
2738  {
2739  min_range = loader_.laserPropLoader.laserMinDistance->
2740  text().toFloat();
2741  if( min_range < 0 )
2742  {
2743  showMessage(QString("Laser minimum range invalid :") +
2744  QString().setNum(min_range));
2745  return;
2746  }
2747  if( min_range > max_range )
2748  {
2749  showMessage(QString("Laser minimum range higher than maximum range"));
2750  return;
2751  }
2752  current_laser_->child(i)->setText(1,QString().setNum(min_range));
2753  new_robot_msg_.laserSensors[laserFrameId].minRange = min_range;
2754  }
2755 
2757  else if(current_laser_->child(i)->text(0) == QString("Noise mean"))
2758  {
2759  float noiseMean = loader_.laserPropLoader.laserNoiseMean->
2760  text().toFloat();
2761  current_laser_->child(i)->setText(1,QString().setNum(noiseMean));
2762  new_robot_msg_.laserSensors[laserFrameId].noise.noiseMean =
2763  noiseMean;
2764  }
2765 
2767  else if(current_laser_->child(i)->text(0) == QString("Noise std"))
2768  {
2769  float noiseStd =
2770  loader_.laserPropLoader.laserNoiseStd->text().toFloat();
2771  if( noiseStd < 0 )
2772  {
2773  showMessage(QString("Laser standard deviation of noise invalid :") +
2774  QString().setNum(noiseStd));
2775  return;
2776  }
2777  current_laser_->child(i)->setText(1,QString().setNum(noiseStd));
2778  new_robot_msg_.laserSensors[laserFrameId].noise.noiseStd =
2779  noiseStd;
2780  }
2781 
2783  else if(current_laser_->child(i)->text(0) == QString("Pose - x"))
2784  {
2785  float dx = loader_.laserPropLoader.laserTranslationX->
2786  text().toFloat();
2787  current_laser_->child(i)->setText(1,QString().setNum(dx));
2788  new_robot_msg_.laserSensors[laserFrameId].pose.x = dx;
2789  }
2790 
2792  else if(current_laser_->child(i)->text(0) == QString("Pose - y"))
2793  {
2794  float dy = loader_.laserPropLoader.laserTranslationY->
2795  text().toFloat();
2796  current_laser_->child(i)->setText(1,QString().setNum(dy));
2797  new_robot_msg_.laserSensors[laserFrameId].pose.y = dy;
2798  }
2799 
2801  else if(current_laser_->child(i)->text(0) == QString("Frequency"))
2802  {
2803  float frequency = loader_.laserPropLoader.laserFrequency->
2804  text().toFloat();
2805  if( frequency <= 0 )
2806  {
2807  showMessage(QString("Laser publishing frequency invalid :") +
2808  QString().setNum(frequency));
2809  return;
2810  }
2811  current_laser_->child(i)->setText(1,QString().setNum(frequency));
2812  new_robot_msg_.laserSensors[laserFrameId].frequency = frequency;
2813  }
2814  }
2815 
2816  loader_.laserPropLoader.hide();
2817 
2818  updateRobotPreview();
2819  }
2820 
2825  void CRobotCreatorConnector::updateLaserOpen(void)
2826  {
2827  unsigned int laserFrameId = searchLaser(current_laser_->text(0));
2828  if(laserFrameId == -1)
2829  {
2830  return;
2831  }
2832  float max_range = 1000.0;
2833  float min_range = 0.0;
2834  for(unsigned int i = 0 ; i < current_laser_->childCount() ; i++)
2835  {
2836 
2838  if(current_laser_->child(i)->text(0) == QString("Angle span"))
2839  {
2840  current_laser_->child(i)->setText(
2841  1,loader_.laserPropLoader.laserAngleSpan->text());
2842  float angleSpan = loader_.laserPropLoader.laserAngleSpan->
2843  text().toFloat() / 2.0;
2844  if( angleSpan <= 0 )
2845  {
2846  showMessage(QString("Laser angle span invalid :") +
2847  QString().setNum(angleSpan * 2.0));
2848  return;
2849  }
2850  new_robot_msg_.laserSensors[laserFrameId].minAngle = - angleSpan;
2851  new_robot_msg_.laserSensors[laserFrameId].maxAngle = angleSpan;
2852  }
2853 
2855  else if(current_laser_->child(i)->text(0) == QString("Orientation"))
2856  {
2857  float orientation = loader_.laserPropLoader.laserOrientation->
2858  text().toFloat();
2859  current_laser_->child(i)->setText(
2860  1,QString().setNum(orientation));
2861  //~ new_robot_msg_.laserSensors[laserFrameId].minAngle += orientation;
2862  //~ new_robot_msg_.laserSensors[laserFrameId].maxAngle += orientation;
2863  new_robot_msg_.laserSensors[laserFrameId].pose.theta = orientation;
2864  }
2865 
2867  else if(current_laser_->child(i)->text(0) == QString("Max range"))
2868  {
2869  max_range = loader_.laserPropLoader.laserMaxDistance->
2870  text().toFloat();
2871  if( max_range <= 0 )
2872  {
2873  showMessage(QString("Laser maximum range invalid :") +
2874  QString().setNum(max_range));
2875  return;
2876  }
2877  if( max_range < min_range )
2878  {
2879  showMessage(QString("Laser maximum range lower than minimum range"));
2880  return;
2881  }
2882  current_laser_->child(i)->setText(1,QString().setNum(max_range));
2883  new_robot_msg_.laserSensors[laserFrameId].maxRange = max_range;
2884  }
2885 
2887  else if(current_laser_->child(i)->text(0) == QString("Number of rays"))
2888  {
2889  int rays = loader_.laserPropLoader.laserRays->text().toFloat();
2890  if( rays <= 0 )
2891  {
2892  showMessage(QString("Laser rays number invalid :") +
2893  QString().setNum(rays));
2894  return;
2895  }
2896  current_laser_->child(i)->setText(1,QString().setNum(rays));
2897  new_robot_msg_.laserSensors[laserFrameId].numRays = rays;
2898  }
2899 
2901  else if(current_laser_->child(i)->text(0) == QString("Min range"))
2902  {
2903  min_range = loader_.laserPropLoader.laserMinDistance->
2904  text().toFloat();
2905  if( min_range < 0 )
2906  {
2907  showMessage(QString("Laser minimum range invalid :") +
2908  QString().setNum(min_range));
2909  return;
2910  }
2911  if( min_range > max_range )
2912  {
2913  showMessage(QString("Laser minimum range higher than maximum range"));
2914  return;
2915  }
2916  current_laser_->child(i)->setText(1,QString().setNum(min_range));
2917  new_robot_msg_.laserSensors[laserFrameId].minRange = min_range;
2918  }
2919 
2921  else if(current_laser_->child(i)->text(0) == QString("Noise mean"))
2922  {
2923  float noiseMean = loader_.laserPropLoader.laserNoiseMean->
2924  text().toFloat();
2925  current_laser_->child(i)->setText(1,QString().setNum(noiseMean));
2926  new_robot_msg_.laserSensors[laserFrameId].noise.noiseMean =
2927  noiseMean;
2928  }
2929 
2931  else if(current_laser_->child(i)->text(0) == QString("Noise std"))
2932  {
2933  float noiseStd =
2934  loader_.laserPropLoader.laserNoiseStd->text().toFloat();
2935  if( noiseStd < 0 )
2936  {
2937  showMessage(QString("Laser standard deviation of noise invalid :") +
2938  QString().setNum(noiseStd));
2939  return;
2940  }
2941  current_laser_->child(i)->setText(1,QString().setNum(noiseStd));
2942  new_robot_msg_.laserSensors[laserFrameId].noise.noiseStd =
2943  noiseStd;
2944  }
2945 
2947  else if(current_laser_->child(i)->text(0) == QString("Pose - x"))
2948  {
2949  float dx = loader_.laserPropLoader.laserTranslationX->
2950  text().toFloat();
2951  current_laser_->child(i)->setText(1,QString().setNum(dx));
2952  new_robot_msg_.laserSensors[laserFrameId].pose.x = dx;
2953  }
2954 
2956  else if(current_laser_->child(i)->text(0) == QString("Pose - y"))
2957  {
2958  float dy = loader_.laserPropLoader.laserTranslationY->
2959  text().toFloat();
2960  current_laser_->child(i)->setText(1,QString().setNum(dy));
2961  new_robot_msg_.laserSensors[laserFrameId].pose.y = dy;
2962  }
2963 
2965  else if(current_laser_->child(i)->text(0) == QString("Frequency"))
2966  {
2967  float frequency = loader_.laserPropLoader.laserFrequency->
2968  text().toFloat();
2969  if( frequency <= 0 )
2970  {
2971  showMessage(QString("Laser publishing frequency invalid :") +
2972  QString().setNum(frequency));
2973  return;
2974  }
2975  current_laser_->child(i)->setText(1,QString().setNum(frequency));
2976  new_robot_msg_.laserSensors[laserFrameId].frequency = frequency;
2977  }
2978  }
2979 
2980  updateRobotPreview();
2981  }
2982 
2983 
2988  void CRobotCreatorConnector::updateSonar(void)
2989  {
2990  unsigned int frameId=searchSonar(current_sonar_->text(0));
2991  if(frameId == -1)
2992  {
2993  return;
2994  }
2995  float min_range = 0;
2996  float max_range = 10000.0;
2997  for(unsigned int i = 0 ; i < current_sonar_->childCount() ; i++)
2998  {
3000  if(current_sonar_->child(i)->text(0) == QString("Cone span"))
3001  {
3002  float cone_span =
3003  loader_.sonarPropLoader.sonarConeSpan->text().toFloat();
3004  if( cone_span <= 0 )
3005  {
3006  showMessage(QString("Sonar cone span invalid :") +
3007  QString().setNum(cone_span));
3008  return;
3009  }
3010  current_sonar_->child(i)->setText(1,QString().setNum(cone_span));
3011  new_robot_msg_.sonarSensors[frameId].coneAngle = cone_span;
3012  }
3013 
3015  else if(current_sonar_->child(i)->text(0) == QString("Orientation"))
3016  {
3017  float orientation =
3018  loader_.sonarPropLoader.sonarOrientation->text().toFloat();
3019  current_sonar_->child(i)->
3020  setText(1,QString().setNum(orientation));
3021  new_robot_msg_.sonarSensors[frameId].pose.theta = orientation;
3022  }
3023 
3025  else if(current_sonar_->child(i)->text(0) == QString("Max range"))
3026  {
3027  max_range = loader_.sonarPropLoader.sonarMaxDistance->text().toFloat();
3028  if( max_range <= 0 )
3029  {
3030  showMessage(QString("Sonar maximum range invalid :") +
3031  QString().setNum(max_range));
3032  return;
3033  }
3034  if( max_range < min_range )
3035  {
3036  showMessage(QString("Sonar maximum range lower than minimum range."));
3037  return;
3038  }
3039  current_sonar_->child(i)->
3040  setText(1,QString().setNum(max_range));
3041  new_robot_msg_.sonarSensors[frameId].maxRange = max_range;
3042  }
3043 
3045  else if(current_sonar_->child(i)->text(0) == QString("Min range"))
3046  {
3047  min_range = loader_.sonarPropLoader.sonarMinDistance->text().toFloat();
3048  if( min_range < 0 )
3049  {
3050  showMessage(QString("Sonar minimum range invalid :") +
3051  QString().setNum(min_range));
3052  return;
3053  }
3054  if( max_range < min_range )
3055  {
3056  showMessage(
3057  QString("Sonar minimum range higher than maximum range."));
3058  return;
3059  }
3060  current_sonar_->child(i)->setText(1,QString().setNum(min_range));
3061  new_robot_msg_.sonarSensors[frameId].minRange = min_range;
3062  }
3063 
3065  else if(current_sonar_->child(i)->text(0) == QString("Noise mean"))
3066  {
3067  float noiseMean =
3068  loader_.sonarPropLoader.sonarNoiseMean->text().toFloat();
3069  current_sonar_->child(i)->
3070  setText(1,QString().setNum(noiseMean));
3071  new_robot_msg_.sonarSensors[frameId].noise.noiseMean = noiseMean;
3072  }
3073 
3075  else if(current_sonar_->child(i)->text(0) == QString("Noise std"))
3076  {
3077  float noiseStd =
3078  loader_.sonarPropLoader.sonarNoiseStd->text().toFloat();
3079  if( noiseStd < 0 )
3080  {
3081  showMessage(QString("Sonar noise standard deviation invalid :") +
3082  QString().setNum(noiseStd));
3083  return;
3084  }
3085  current_sonar_->
3086  child(i)->setText(1,QString().setNum(noiseStd));
3087  new_robot_msg_.sonarSensors[frameId].noise.noiseStd = noiseStd;
3088  }
3089 
3091  else if(current_sonar_->child(i)->text(0) == QString("Pose - x"))
3092  {
3093  float dx = loader_.sonarPropLoader.sonarX->text().toFloat();
3094  current_sonar_->child(i)->setText(1,QString().setNum(dx));
3095  new_robot_msg_.sonarSensors[frameId].pose.x = dx;
3096  }
3097 
3099  else if(current_sonar_->child(i)->text(0) == QString("Pose - y"))
3100  {
3101  float dy = loader_.sonarPropLoader.sonarY->text().toFloat();
3102  current_sonar_->child(i)->setText(1,QString().setNum(dy));
3103  new_robot_msg_.sonarSensors[frameId].pose.y = dy;
3104  }
3105 
3107  else if(current_sonar_->child(i)->text(0) == QString("Frequency"))
3108  {
3109  float frequency =
3110  loader_.sonarPropLoader.sonarFrequency->text().toFloat();
3111  if( frequency <= 0 )
3112  {
3113  showMessage(QString("Sonar publishing frequency invalid :") +
3114  QString().setNum(frequency));
3115  return;
3116  }
3117  current_sonar_->child(i)->setText(1,QString().setNum(frequency));
3118  new_robot_msg_.sonarSensors[frameId].frequency = frequency;
3119  }
3120  }
3121 
3122  loader_.sonarPropLoader.hide();
3123 
3124  updateRobotPreview();
3125  }
3126 
3131  void CRobotCreatorConnector::updateSonarOpen(void)
3132  {
3133  unsigned int frameId=searchSonar(current_sonar_->text(0));
3134  if(frameId == -1)
3135  {
3136  return;
3137  }
3138  float min_range = 0;
3139  float max_range = 10000.0;
3140  for(unsigned int i = 0 ; i < current_sonar_->childCount() ; i++)
3141  {
3143  if(current_sonar_->child(i)->text(0) == QString("Cone span"))
3144  {
3145  float cone_span =
3146  loader_.sonarPropLoader.sonarConeSpan->text().toFloat();
3147  if( cone_span <= 0 )
3148  {
3149  showMessage(QString("Sonar cone span invalid :") +
3150  QString().setNum(cone_span));
3151  return;
3152  }
3153  current_sonar_->child(i)->setText(1,QString().setNum(cone_span));
3154  new_robot_msg_.sonarSensors[frameId].coneAngle = cone_span;
3155  }
3156 
3158  else if(current_sonar_->child(i)->text(0) == QString("Orientation"))
3159  {
3160  float orientation =
3161  loader_.sonarPropLoader.sonarOrientation->text().toFloat();
3162  current_sonar_->child(i)->
3163  setText(1,QString().setNum(orientation));
3164  new_robot_msg_.sonarSensors[frameId].pose.theta = orientation;
3165  }
3166 
3168  else if(current_sonar_->child(i)->text(0) == QString("Max range"))
3169  {
3170  max_range = loader_.sonarPropLoader.sonarMaxDistance->text().toFloat();
3171  if( max_range <= 0 )
3172  {
3173  showMessage(QString("Sonar maximum range invalid :") +
3174  QString().setNum(max_range));
3175  return;
3176  }
3177  if( max_range < min_range )
3178  {
3179  showMessage(QString("Sonar maximum range lower than minimum range."));
3180  return;
3181  }
3182  current_sonar_->child(i)->
3183  setText(1,QString().setNum(max_range));
3184  new_robot_msg_.sonarSensors[frameId].maxRange = max_range;
3185  }
3186 
3188  else if(current_sonar_->child(i)->text(0) == QString("Min range"))
3189  {
3190  min_range = loader_.sonarPropLoader.sonarMinDistance->text().toFloat();
3191  if( min_range < 0 )
3192  {
3193  showMessage(QString("Sonar minimum range invalid :") +
3194  QString().setNum(min_range));
3195  return;
3196  }
3197  if( max_range < min_range )
3198  {
3199  showMessage(
3200  QString("Sonar minimum range higher than maximum range."));
3201  return;
3202  }
3203  current_sonar_->child(i)->setText(1,QString().setNum(min_range));
3204  new_robot_msg_.sonarSensors[frameId].minRange = min_range;
3205  }
3206 
3208  else if(current_sonar_->child(i)->text(0) == QString("Noise mean"))
3209  {
3210  float noiseMean =
3211  loader_.sonarPropLoader.sonarNoiseMean->text().toFloat();
3212  current_sonar_->child(i)->
3213  setText(1,QString().setNum(noiseMean));
3214  new_robot_msg_.sonarSensors[frameId].noise.noiseMean = noiseMean;
3215  }
3216 
3218  else if(current_sonar_->child(i)->text(0) == QString("Noise std"))
3219  {
3220  float noiseStd =
3221  loader_.sonarPropLoader.sonarNoiseStd->text().toFloat();
3222  if( noiseStd < 0 )
3223  {
3224  showMessage(QString("Sonar noise standard deviation invalid :") +
3225  QString().setNum(noiseStd));
3226  return;
3227  }
3228  current_sonar_->
3229  child(i)->setText(1,QString().setNum(noiseStd));
3230  new_robot_msg_.sonarSensors[frameId].noise.noiseStd = noiseStd;
3231  }
3232 
3234  else if(current_sonar_->child(i)->text(0) == QString("Pose - x"))
3235  {
3236  float dx = loader_.sonarPropLoader.sonarX->text().toFloat();
3237  current_sonar_->child(i)->setText(1,QString().setNum(dx));
3238  new_robot_msg_.sonarSensors[frameId].pose.x = dx;
3239  }
3240 
3242  else if(current_sonar_->child(i)->text(0) == QString("Pose - y"))
3243  {
3244  float dy = loader_.sonarPropLoader.sonarY->text().toFloat();
3245  current_sonar_->child(i)->setText(1,QString().setNum(dy));
3246  new_robot_msg_.sonarSensors[frameId].pose.y = dy;
3247  }
3248 
3250  else if(current_sonar_->child(i)->text(0) == QString("Frequency"))
3251  {
3252  float frequency =
3253  loader_.sonarPropLoader.sonarFrequency->text().toFloat();
3254  if( frequency <= 0 )
3255  {
3256  showMessage(QString("Sonar publishing frequency invalid :") +
3257  QString().setNum(frequency));
3258  return;
3259  }
3260  current_sonar_->child(i)->setText(1,QString().setNum(frequency));
3261  new_robot_msg_.sonarSensors[frameId].frequency = frequency;
3262  }
3263  }
3264 
3265  updateRobotPreview();
3266  }
3267 
3268 
3275  void CRobotCreatorConnector::updateSonarTree(
3276  QTreeWidgetItem *item,
3277  stdr_msgs::SonarSensorMsg l)
3278  {
3279  unsigned int frameId=searchSonar(item->text(0));
3280  if(frameId == -1)
3281  {
3282  return;
3283  }
3284  for(unsigned int i = 0 ; i < item->childCount() ; i++)
3285  {
3286  if(item->child(i)->text(0) == QString("Cone span"))
3287  {
3288  item->child(i)->setText(1,QString().setNum(l.coneAngle));
3289  }
3290  else if(item->child(i)->text(0) == QString("Orientation"))
3291  {
3292  item->child(i)->setText(1,QString().setNum(l.pose.theta));
3293  }
3294  else if(item->child(i)->text(0) == QString("Max range"))
3295  {
3296  item->child(i)->setText(1,QString().setNum(l.maxRange));
3297  }
3298  else if(item->child(i)->text(0) == QString("Min range"))
3299  {
3300  item->child(i)->setText(1,QString().setNum(l.minRange));
3301  }
3302  else if(item->child(i)->text(0) == QString("Noise mean"))
3303  {
3304  item->child(i)->setText(1,QString().setNum(l.noise.noiseMean));
3305  }
3306  else if(item->child(i)->text(0) == QString("Noise std"))
3307  {
3308  item->child(i)->setText(1,QString().setNum(l.noise.noiseStd));
3309  }
3310  else if(item->child(i)->text(0) == QString("Pose - x"))
3311  {
3312  item->child(i)->setText(1,QString().setNum(l.pose.x));
3313  }
3314  else if(item->child(i)->text(0) == QString("Pose - y"))
3315  {
3316  item->child(i)->setText(1,QString().setNum(l.pose.y));
3317  }
3318  else if(item->child(i)->text(0) == QString("Frequency"))
3319  {
3320  item->child(i)->setText(1,QString().setNum(l.frequency));
3321  }
3322  }
3323  }
3324 
3331  void CRobotCreatorConnector::updateRfidTree(
3332  QTreeWidgetItem *item,
3333  stdr_msgs::RfidSensorMsg l)
3334  {
3335  unsigned int frameId=searchRfid(item->text(0));
3336  if(frameId == -1)
3337  {
3338  return;
3339  }
3340  for(unsigned int i = 0 ; i < item->childCount() ; i++)
3341  {
3342  if(item->child(i)->text(0) == QString("Angle span"))
3343  {
3344  item->child(i)->setText(1,QString().setNum(l.angleSpan));
3345  }
3346  else if(item->child(i)->text(0) == QString("Orientation"))
3347  {
3348  item->child(i)->setText(1,QString().setNum(l.pose.theta));
3349  }
3350  else if(item->child(i)->text(0) == QString("Max range"))
3351  {
3352  item->child(i)->setText(1,QString().setNum(l.maxRange));
3353  }
3354  else if(item->child(i)->text(0) == QString("Signal cutoff"))
3355  {
3356  item->child(i)->setText(1,QString().setNum(l.signalCutoff));
3357  }
3358  else if(item->child(i)->text(0) == QString("Pose - x"))
3359  {
3360  item->child(i)->setText(1,QString().setNum(l.pose.x));
3361  }
3362  else if(item->child(i)->text(0) == QString("Pose - y"))
3363  {
3364  item->child(i)->setText(1,QString().setNum(l.pose.y));
3365  }
3366  else if(item->child(i)->text(0) == QString("Frequency"))
3367  {
3368  item->child(i)->setText(1,QString().setNum(l.frequency));
3369  }
3370  }
3371  }
3375  void CRobotCreatorConnector::updateCO2SensorTree(
3376  QTreeWidgetItem *item,
3377  stdr_msgs::CO2SensorMsg l)
3378  {
3379  unsigned int frameId=searchCO2Sensor(item->text(0));
3380  if(frameId == -1)
3381  {
3382  return;
3383  }
3384  for(unsigned int i = 0 ; i < item->childCount() ; i++)
3385  {
3386  //~ if(item->child(i)->text(0) == QString("Angle span"))
3387  //~ {
3388  //~ item->child(i)->setText(1,QString().setNum(l.angleSpan));
3389  //~ }
3390  if(item->child(i)->text(0) == QString("Orientation"))
3391  {
3392  item->child(i)->setText(1,QString().setNum(l.pose.theta));
3393  }
3394  else if(item->child(i)->text(0) == QString("Max range"))
3395  {
3396  item->child(i)->setText(1,QString().setNum(l.maxRange));
3397  }
3398  //~ else if(item->child(i)->text(0) == QString("Signal cutoff"))
3399  //~ {
3400  //~ item->child(i)->setText(1,QString().setNum(l.signalCutoff));
3401  //~ }
3402  else if(item->child(i)->text(0) == QString("Pose - x"))
3403  {
3404  item->child(i)->setText(1,QString().setNum(l.pose.x));
3405  }
3406  else if(item->child(i)->text(0) == QString("Pose - y"))
3407  {
3408  item->child(i)->setText(1,QString().setNum(l.pose.y));
3409  }
3410  else if(item->child(i)->text(0) == QString("Frequency"))
3411  {
3412  item->child(i)->setText(1,QString().setNum(l.frequency));
3413  }
3414  }
3415  }
3419  void CRobotCreatorConnector::updateThermalSensorTree(
3420  QTreeWidgetItem *item,
3421  stdr_msgs::ThermalSensorMsg l)
3422  {
3423  unsigned int frameId=searchThermalSensor(item->text(0));
3424  if(frameId == -1)
3425  {
3426  return;
3427  }
3428  for(unsigned int i = 0 ; i < item->childCount() ; i++)
3429  {
3430  if(item->child(i)->text(0) == QString("Angle span"))
3431  {
3432  item->child(i)->setText(1,QString().setNum(l.angleSpan));
3433  }
3434  else if(item->child(i)->text(0) == QString("Orientation"))
3435  {
3436  item->child(i)->setText(1,QString().setNum(l.pose.theta));
3437  }
3438  else if(item->child(i)->text(0) == QString("Max range"))
3439  {
3440  item->child(i)->setText(1,QString().setNum(l.maxRange));
3441  }
3442  //~ else if(item->child(i)->text(0) == QString("Signal cutoff"))
3443  //~ {
3444  //~ item->child(i)->setText(1,QString().setNum(l.signalCutoff));
3445  //~ }
3446  else if(item->child(i)->text(0) == QString("Pose - x"))
3447  {
3448  item->child(i)->setText(1,QString().setNum(l.pose.x));
3449  }
3450  else if(item->child(i)->text(0) == QString("Pose - y"))
3451  {
3452  item->child(i)->setText(1,QString().setNum(l.pose.y));
3453  }
3454  else if(item->child(i)->text(0) == QString("Frequency"))
3455  {
3456  item->child(i)->setText(1,QString().setNum(l.frequency));
3457  }
3458  }
3459  }
3463  void CRobotCreatorConnector::updateSoundSensorTree(
3464  QTreeWidgetItem *item,
3465  stdr_msgs::SoundSensorMsg l)
3466  {
3467  unsigned int frameId=searchSoundSensor(item->text(0));
3468  if(frameId == -1)
3469  {
3470  return;
3471  }
3472  for(unsigned int i = 0 ; i < item->childCount() ; i++)
3473  {
3474  if(item->child(i)->text(0) == QString("Angle span"))
3475  {
3476  item->child(i)->setText(1,QString().setNum(l.angleSpan));
3477  }
3478  else if(item->child(i)->text(0) == QString("Orientation"))
3479  {
3480  item->child(i)->setText(1,QString().setNum(l.pose.theta));
3481  }
3482  else if(item->child(i)->text(0) == QString("Max range"))
3483  {
3484  item->child(i)->setText(1,QString().setNum(l.maxRange));
3485  }
3486  //~ else if(item->child(i)->text(0) == QString("Signal cutoff"))
3487  //~ {
3488  //~ item->child(i)->setText(1,QString().setNum(l.signalCutoff));
3489  //~ }
3490  else if(item->child(i)->text(0) == QString("Pose - x"))
3491  {
3492  item->child(i)->setText(1,QString().setNum(l.pose.x));
3493  }
3494  else if(item->child(i)->text(0) == QString("Pose - y"))
3495  {
3496  item->child(i)->setText(1,QString().setNum(l.pose.y));
3497  }
3498  else if(item->child(i)->text(0) == QString("Frequency"))
3499  {
3500  item->child(i)->setText(1,QString().setNum(l.frequency));
3501  }
3502  }
3503  }
3504 
3509  void CRobotCreatorConnector::updateRfidAntenna(void)
3510  {
3511  unsigned int frameId = searchRfid(current_rfid_->text(0));
3512  if(frameId == -1)
3513  {
3514  return;
3515  }
3516  for(unsigned int i = 0 ; i < current_rfid_->childCount() ; i++)
3517  {
3518 
3520  if(current_rfid_->child(i)->text(0) == QString("Angle span"))
3521  {
3522  float angle_span =
3523  loader_.rfidAntennaPropLoader.rfidAngleSpan->text().toFloat();
3524  if( angle_span <= 0 )
3525  {
3526  showMessage(QString("Rfid antenna angle span invalid :") +
3527  QString().setNum(angle_span));
3528  return;
3529  }
3530  current_rfid_->child(i)->setText(1,QString().setNum(angle_span));
3531  new_robot_msg_.rfidSensors[frameId].angleSpan = angle_span;
3532  }
3533 
3535  else if(current_rfid_->child(i)->text(0) == QString("Orientation"))
3536  {
3537  float orientation =
3538  loader_.rfidAntennaPropLoader.rfidOrientation->
3539  text().toFloat();
3540  current_rfid_->child(i)->
3541  setText(1,QString().setNum(orientation));
3542  new_robot_msg_.rfidSensors[frameId].pose.theta = orientation;
3543  }
3544 
3546  else if(current_rfid_->child(i)->text(0) == QString("Max range"))
3547  {
3548  float maxRange =
3549  loader_.rfidAntennaPropLoader.rfidMaxDistance->
3550  text().toFloat();
3551  if( maxRange <= 0 )
3552  {
3553  showMessage(QString("Rfid antenna maximum range invalid :") +
3554  QString().setNum(maxRange));
3555  return;
3556  }
3557  current_rfid_->child(i)->setText(1,QString().setNum(maxRange));
3558  new_robot_msg_.rfidSensors[frameId].maxRange = maxRange;
3559  }
3560 
3562  else if(current_rfid_->child(i)->text(0) == QString("Pose - x"))
3563  {
3564  float dx = loader_.rfidAntennaPropLoader.rfidX->text().toFloat();
3565  current_rfid_->child(i)->setText(1,QString().setNum(dx));
3566  new_robot_msg_.rfidSensors[frameId].pose.x = dx;
3567  }
3568 
3570  else if(current_rfid_->child(i)->text(0) == QString("Pose - y"))
3571  {
3572  float dy = loader_.rfidAntennaPropLoader.rfidY->text().toFloat();
3573  current_rfid_->child(i)->setText(1,QString().setNum(dy));
3574  new_robot_msg_.rfidSensors[frameId].pose.y = dy;
3575  }
3576 
3578  else if(current_rfid_->child(i)->text(0) == QString("Signal cutoff"))
3579  {
3580  float signal =
3581  loader_.rfidAntennaPropLoader.rfidSignalCutoff->
3582  text().toFloat();
3583  current_rfid_->child(i)->setText(1,QString().setNum(signal));
3584  new_robot_msg_.rfidSensors[frameId].signalCutoff = signal;
3585  }
3586 
3588  else if(current_rfid_->child(i)->text(0) == QString("Frequency"))
3589  {
3590  float frequency =
3591  loader_.rfidAntennaPropLoader.rfidFrequency->
3592  text().toFloat();
3593  if( frequency <= 0 )
3594  {
3595  showMessage(QString("Rfid antenna publishing frequency invalid :") +
3596  QString().setNum(frequency));
3597  return;
3598  }
3599  current_rfid_->child(i)->setText(1,QString().setNum(frequency));
3600  new_robot_msg_.rfidSensors[frameId].frequency = frequency;
3601  }
3602  }
3603 
3604  loader_.rfidAntennaPropLoader.hide();
3605 
3606  updateRobotPreview();
3607  }
3611  void CRobotCreatorConnector::updateCO2Sensor(void)
3612  {
3613  unsigned int frameId = searchCO2Sensor(current_co2_sensor_->text(0));
3614  if(frameId == -1)
3615  {
3616  return;
3617  }
3618  for(unsigned int i = 0 ; i < current_co2_sensor_->childCount() ; i++)
3619  {
3620 
3622  //~ if(current_rfid_->child(i)->text(0) == QString("Angle span"))
3623  //~ {
3624  //~ float angle_span =
3625  //~ loader_.rfidAntennaPropLoader.rfidAngleSpan->text().toFloat();
3626  //~ if( angle_span <= 0 )
3627  //~ {
3628  //~ showMessage(QString("Rfid antenna angle span invalid :") +
3629  //~ QString().setNum(angle_span));
3630  //~ return;
3631  //~ }
3632  //~ current_rfid_->child(i)->setText(1,QString().setNum(angle_span));
3633  //~ new_robot_msg_.rfidSensors[frameId].angleSpan = angle_span;
3634  //~ }
3635 
3637  if(current_co2_sensor_->child(i)->text(0) == QString("Orientation"))
3638  {
3639  float orientation =
3640  loader_.co2SensorPropLoader.orientation->
3641  text().toFloat();
3642  current_co2_sensor_->child(i)->
3643  setText(1,QString().setNum(orientation));
3644  new_robot_msg_.co2Sensors[frameId].pose.theta = orientation;
3645  }
3646 
3648  else if(current_co2_sensor_->child(i)->text(0) == QString("Max range"))
3649  {
3650  float maxRange =
3651  loader_.co2SensorPropLoader.maxDistance->
3652  text().toFloat();
3653  if( maxRange <= 0 )
3654  {
3655  showMessage(QString("CO2 sensor maximum range invalid :") +
3656  QString().setNum(maxRange));
3657  return;
3658  }
3659  current_co2_sensor_->child(i)->setText(1,QString().setNum(maxRange));
3660  new_robot_msg_.co2Sensors[frameId].maxRange = maxRange;
3661  }
3662 
3664  else if(current_co2_sensor_->child(i)->text(0) == QString("Pose - x"))
3665  {
3666  float dx = loader_.co2SensorPropLoader.x_->text().toFloat();
3667  current_co2_sensor_->child(i)->setText(1,QString().setNum(dx));
3668  new_robot_msg_.co2Sensors[frameId].pose.x = dx;
3669  }
3670 
3672  else if(current_co2_sensor_->child(i)->text(0) == QString("Pose - y"))
3673  {
3674  float dy = loader_.co2SensorPropLoader.y_->text().toFloat();
3675  current_co2_sensor_->child(i)->setText(1,QString().setNum(dy));
3676  new_robot_msg_.co2Sensors[frameId].pose.y = dy;
3677  }
3678 
3680  else if(current_co2_sensor_->child(i)->text(0) == QString("Frequency"))
3681  {
3682  float frequency =
3683  loader_.co2SensorPropLoader.frequency->
3684  text().toFloat();
3685  if( frequency <= 0 )
3686  {
3687  showMessage(QString("CO2 sensor publishing frequency invalid :") +
3688  QString().setNum(frequency));
3689  return;
3690  }
3691  current_co2_sensor_->child(i)->setText(1,QString().setNum(frequency));
3692  new_robot_msg_.co2Sensors[frameId].frequency = frequency;
3693  }
3694  }
3695 
3696  loader_.co2SensorPropLoader.hide();
3697 
3698  updateRobotPreview();
3699  }
3703  void CRobotCreatorConnector::updateThermalSensor(void)
3704  {
3705  unsigned int frameId = searchThermalSensor(current_thermal_sensor_->text(0));
3706  if(frameId == -1)
3707  {
3708  return;
3709  }
3710  for(unsigned int i = 0 ; i < current_thermal_sensor_->childCount() ; i++)
3711  {
3712 
3713  //~ Sensor angle span
3714  if(current_thermal_sensor_->child(i)->text(0) == QString("Angle span"))
3715  {
3716  float angle_span =
3717  loader_.thermalSensorPropLoader.angleSpan->text().toFloat();
3718  if( angle_span <= 0 )
3719  {
3720  showMessage(QString("Thermal sensor angle span invalid :") +
3721  QString().setNum(angle_span));
3722  return;
3723  }
3724  current_thermal_sensor_->child(i)->setText(1,QString().setNum(angle_span));
3725  new_robot_msg_.thermalSensors[frameId].angleSpan = angle_span;
3726  }
3727 
3729  else if(current_thermal_sensor_->child(i)->text(0) == QString("Orientation"))
3730  {
3731  float orientation =
3732  loader_.thermalSensorPropLoader.orientation->
3733  text().toFloat();
3734  current_thermal_sensor_->child(i)->
3735  setText(1,QString().setNum(orientation));
3736  new_robot_msg_.thermalSensors[frameId].pose.theta = orientation;
3737  }
3738 
3740  else if(current_thermal_sensor_->child(i)->text(0) == QString("Max range"))
3741  {
3742  float maxRange =
3743  loader_.thermalSensorPropLoader.maxDistance->
3744  text().toFloat();
3745  if( maxRange <= 0 )
3746  {
3747  showMessage(QString("Thermal sensor maximum range invalid :") +
3748  QString().setNum(maxRange));
3749  return;
3750  }
3751  current_thermal_sensor_->child(i)->setText(1,QString().setNum(maxRange));
3752  new_robot_msg_.thermalSensors[frameId].maxRange = maxRange;
3753  }
3754 
3756  else if(current_thermal_sensor_->child(i)->text(0) == QString("Pose - x"))
3757  {
3758  float dx = loader_.thermalSensorPropLoader.x_->text().toFloat();
3759  current_thermal_sensor_->child(i)->setText(1,QString().setNum(dx));
3760  new_robot_msg_.thermalSensors[frameId].pose.x = dx;
3761  }
3762 
3764  else if(current_thermal_sensor_->child(i)->text(0) == QString("Pose - y"))
3765  {
3766  float dy = loader_.thermalSensorPropLoader.y_->text().toFloat();
3767  current_thermal_sensor_->child(i)->setText(1,QString().setNum(dy));
3768  new_robot_msg_.thermalSensors[frameId].pose.y = dy;
3769  }
3770 
3772  else if(current_thermal_sensor_->child(i)->text(0) == QString("Frequency"))
3773  {
3774  float frequency =
3775  loader_.thermalSensorPropLoader.frequency->
3776  text().toFloat();
3777  if( frequency <= 0 )
3778  {
3779  showMessage(QString("Thermal sensor publishing frequency invalid :") +
3780  QString().setNum(frequency));
3781  return;
3782  }
3783  current_thermal_sensor_->child(i)->setText(1,QString().setNum(frequency));
3784  new_robot_msg_.thermalSensors[frameId].frequency = frequency;
3785  }
3786  }
3787 
3788  loader_.thermalSensorPropLoader.hide();
3789 
3790  updateRobotPreview();
3791  }
3795  void CRobotCreatorConnector::updateSoundSensor(void)
3796  {
3797  unsigned int frameId = searchSoundSensor(current_sound_sensor_->text(0));
3798  if(frameId == -1)
3799  {
3800  return;
3801  }
3802  for(unsigned int i = 0 ; i < current_sound_sensor_->childCount() ; i++)
3803  {
3804 
3805  //~ Sensor angle span
3806  if(current_sound_sensor_->child(i)->text(0) == QString("Angle span"))
3807  {
3808  float angle_span =
3809  loader_.soundSensorPropLoader.angleSpan->text().toFloat();
3810  if( angle_span <= 0 )
3811  {
3812  showMessage(QString("Sound sensor angle span invalid :") +
3813  QString().setNum(angle_span));
3814  return;
3815  }
3816  current_sound_sensor_->child(i)->setText(1,QString().setNum(angle_span));
3817  new_robot_msg_.soundSensors[frameId].angleSpan = angle_span;
3818  }
3819 
3821  else if(current_sound_sensor_->child(i)->text(0) == QString("Orientation"))
3822  {
3823  float orientation =
3824  loader_.soundSensorPropLoader.orientation->
3825  text().toFloat();
3826  current_sound_sensor_->child(i)->
3827  setText(1,QString().setNum(orientation));
3828  new_robot_msg_.soundSensors[frameId].pose.theta = orientation;
3829  }
3830 
3832  else if(current_sound_sensor_->child(i)->text(0) == QString("Max range"))
3833  {
3834  float maxRange =
3835  loader_.soundSensorPropLoader.maxDistance->
3836  text().toFloat();
3837  if( maxRange <= 0 )
3838  {
3839  showMessage(QString("Sound sensor maximum range invalid :") +
3840  QString().setNum(maxRange));
3841  return;
3842  }
3843  current_sound_sensor_->child(i)->setText(1,QString().setNum(maxRange));
3844  new_robot_msg_.soundSensors[frameId].maxRange = maxRange;
3845  }
3846 
3848  else if(current_sound_sensor_->child(i)->text(0) == QString("Pose - x"))
3849  {
3850  float dx = loader_.soundSensorPropLoader.x_->text().toFloat();
3851  current_sound_sensor_->child(i)->setText(1,QString().setNum(dx));
3852  new_robot_msg_.soundSensors[frameId].pose.x = dx;
3853  }
3854 
3856  else if(current_sound_sensor_->child(i)->text(0) == QString("Pose - y"))
3857  {
3858  float dy = loader_.soundSensorPropLoader.y_->text().toFloat();
3859  current_sound_sensor_->child(i)->setText(1,QString().setNum(dy));
3860  new_robot_msg_.soundSensors[frameId].pose.y = dy;
3861  }
3862 
3864  else if(current_sound_sensor_->child(i)->text(0) == QString("Frequency"))
3865  {
3866  float frequency =
3867  loader_.soundSensorPropLoader.frequency->
3868  text().toFloat();
3869  if( frequency <= 0 )
3870  {
3871  showMessage(QString("Sound sensor publishing frequency invalid :") +
3872  QString().setNum(frequency));
3873  return;
3874  }
3875  current_sound_sensor_->child(i)->setText(1,QString().setNum(frequency));
3876  new_robot_msg_.soundSensors[frameId].frequency = frequency;
3877  }
3878  }
3879 
3880  loader_.soundSensorPropLoader.hide();
3881 
3882  updateRobotPreview();
3883  }
3884 
3889  void CRobotCreatorConnector::updateRfidAntennaOpen(void)
3890  {
3891  unsigned int frameId = searchRfid(current_rfid_->text(0));
3892  if(frameId == -1)
3893  {
3894  return;
3895  }
3896  for(unsigned int i = 0 ; i < current_rfid_->childCount() ; i++)
3897  {
3898 
3900  if(current_rfid_->child(i)->text(0) == QString("Angle span"))
3901  {
3902  float angle_span =
3903  loader_.rfidAntennaPropLoader.rfidAngleSpan->text().toFloat();
3904  if( angle_span <= 0 )
3905  {
3906  showMessage(QString("Rfid antenna angle span invalid :") +
3907  QString().setNum(angle_span));
3908  return;
3909  }
3910  current_rfid_->child(i)->setText(1,QString().setNum(angle_span));
3911  new_robot_msg_.rfidSensors[frameId].angleSpan = angle_span;
3912  }
3913 
3915  else if(current_rfid_->child(i)->text(0) == QString("Orientation"))
3916  {
3917  float orientation =
3918  loader_.rfidAntennaPropLoader.rfidOrientation->
3919  text().toFloat();
3920  current_rfid_->child(i)->
3921  setText(1,QString().setNum(orientation));
3922  new_robot_msg_.rfidSensors[frameId].pose.theta = orientation;
3923  }
3924 
3926  else if(current_rfid_->child(i)->text(0) == QString("Max range"))
3927  {
3928  float maxRange =
3929  loader_.rfidAntennaPropLoader.rfidMaxDistance->
3930  text().toFloat();
3931  if( maxRange <= 0 )
3932  {
3933  showMessage(QString("Rfid antenna maximum range invalid :") +
3934  QString().setNum(maxRange));
3935  return;
3936  }
3937  current_rfid_->child(i)->setText(1,QString().setNum(maxRange));
3938  new_robot_msg_.rfidSensors[frameId].maxRange = maxRange;
3939  }
3940 
3942  else if(current_rfid_->child(i)->text(0) == QString("Pose - x"))
3943  {
3944  float dx = loader_.rfidAntennaPropLoader.rfidX->text().toFloat();
3945  current_rfid_->child(i)->setText(1,QString().setNum(dx));
3946  new_robot_msg_.rfidSensors[frameId].pose.x = dx;
3947  }
3948 
3950  else if(current_rfid_->child(i)->text(0) == QString("Pose - y"))
3951  {
3952  float dy = loader_.rfidAntennaPropLoader.rfidY->text().toFloat();
3953  current_rfid_->child(i)->setText(1,QString().setNum(dy));
3954  new_robot_msg_.rfidSensors[frameId].pose.y = dy;
3955  }
3956 
3958  else if(current_rfid_->child(i)->text(0) == QString("Signal cutoff"))
3959  {
3960  float signal =
3961  loader_.rfidAntennaPropLoader.rfidSignalCutoff->
3962  text().toFloat();
3963  current_rfid_->child(i)->setText(1,QString().setNum(signal));
3964  new_robot_msg_.rfidSensors[frameId].signalCutoff = signal;
3965  }
3966 
3968  else if(current_rfid_->child(i)->text(0) == QString("Frequency"))
3969  {
3970  float frequency =
3971  loader_.rfidAntennaPropLoader.rfidFrequency->
3972  text().toFloat();
3973  if( frequency <= 0 )
3974  {
3975  showMessage(QString("Rfid antenna publishing frequency invalid :") +
3976  QString().setNum(frequency));
3977  return;
3978  }
3979  current_rfid_->child(i)->setText(1,QString().setNum(frequency));
3980  new_robot_msg_.rfidSensors[frameId].frequency = frequency;
3981  }
3982  }
3983 
3984  updateRobotPreview();
3985  }
3989  void CRobotCreatorConnector::updateCO2SensorOpen(void)
3990  {
3991  unsigned int frameId = searchCO2Sensor(current_co2_sensor_->text(0));
3992  if(frameId == -1)
3993  {
3994  return;
3995  }
3996  for(unsigned int i = 0 ; i < current_co2_sensor_->childCount() ; i++)
3997  {
3998 
3999  //~ //!< Angle span
4000  //~ if(current_co2_sensor_->child(i)->text(0) == QString("Angle span"))
4001  //~ {
4002  //~ float angle_span =
4003  //~ loader_.co2SensorPropLoader.angleSpan->text().toFloat();
4004  //~ if( angle_span <= 0 )
4005  //~ {
4006  //~ showMessage(QString("Rfid antenna angle span invalid :") +
4007  //~ QString().setNum(angle_span));
4008  //~ return;
4009  //~ }
4010  //~ current_rfid_->child(i)->setText(1,QString().setNum(angle_span));
4011  //~ new_robot_msg_.rfidSensors[frameId].angleSpan = angle_span;
4012  //~ }
4013 
4015  if(current_co2_sensor_->child(i)->text(0) == QString("Orientation"))
4016  {
4017  float orientation =
4018  loader_.co2SensorPropLoader.orientation->
4019  text().toFloat();
4020  current_co2_sensor_->child(i)->
4021  setText(1,QString().setNum(orientation));
4022  new_robot_msg_.co2Sensors[frameId].pose.theta = orientation;
4023  }
4024 
4026  else if(current_co2_sensor_->child(i)->text(0) == QString("Max range"))
4027  {
4028  float maxRange =
4029  loader_.co2SensorPropLoader.maxDistance->
4030  text().toFloat();
4031  if( maxRange <= 0 )
4032  {
4033  showMessage(QString("CO2 source maximum range invalid :") +
4034  QString().setNum(maxRange));
4035  return;
4036  }
4037  current_co2_sensor_->child(i)->setText(1,QString().setNum(maxRange));
4038  new_robot_msg_.co2Sensors[frameId].maxRange = maxRange;
4039  }
4040 
4042  else if(current_co2_sensor_->child(i)->text(0) == QString("Pose - x"))
4043  {
4044  float dx = loader_.co2SensorPropLoader.x_->text().toFloat();
4045  current_co2_sensor_->child(i)->setText(1,QString().setNum(dx));
4046  new_robot_msg_.co2Sensors[frameId].pose.x = dx;
4047  }
4048 
4050  else if(current_co2_sensor_->child(i)->text(0) == QString("Pose - y"))
4051  {
4052  float dy = loader_.co2SensorPropLoader.y_->text().toFloat();
4053  current_co2_sensor_->child(i)->setText(1,QString().setNum(dy));
4054  new_robot_msg_.co2Sensors[frameId].pose.y = dy;
4055  }
4056 
4058  else if(current_co2_sensor_->child(i)->text(0) == QString("Frequency"))
4059  {
4060  float frequency =
4061  loader_.co2SensorPropLoader.frequency->
4062  text().toFloat();
4063  if( frequency <= 0 )
4064  {
4065  showMessage(QString("CO2 sensor publishing frequency invalid :") +
4066  QString().setNum(frequency));
4067  return;
4068  }
4069  current_co2_sensor_->child(i)->setText(1,QString().setNum(frequency));
4070  new_robot_msg_.co2Sensors[frameId].frequency = frequency;
4071  }
4072  }
4073 
4074  updateRobotPreview();
4075  }
4079  void CRobotCreatorConnector::updateThermalSensorOpen(void)
4080  {
4081  unsigned int frameId = searchThermalSensor(current_thermal_sensor_->text(0));
4082  if(frameId == -1)
4083  {
4084  return;
4085  }
4086  for(unsigned int i = 0 ; i < current_thermal_sensor_->childCount() ; i++)
4087  {
4088 
4090  if(current_thermal_sensor_->child(i)->text(0) == QString("Angle span"))
4091  {
4092  float angle_span =
4093  loader_.thermalSensorPropLoader.angleSpan->text().toFloat();
4094  if( angle_span <= 0 )
4095  {
4096  showMessage(QString("Thermal sensor angle span invalid :") +
4097  QString().setNum(angle_span));
4098  return;
4099  }
4100  current_thermal_sensor_->child(i)->setText(1,QString().setNum(angle_span));
4101  new_robot_msg_.thermalSensors[frameId].angleSpan = angle_span;
4102  }
4103 
4105  else if(current_thermal_sensor_->child(i)->text(0) == QString("Orientation"))
4106  {
4107  float orientation =
4108  loader_.thermalSensorPropLoader.orientation->
4109  text().toFloat();
4110  current_thermal_sensor_->child(i)->
4111  setText(1,QString().setNum(orientation));
4112  new_robot_msg_.thermalSensors[frameId].pose.theta = orientation;
4113  }
4114 
4116  else if(current_thermal_sensor_->child(i)->text(0) == QString("Max range"))
4117  {
4118  float maxRange =
4119  loader_.thermalSensorPropLoader.maxDistance->
4120  text().toFloat();
4121  if( maxRange <= 0 )
4122  {
4123  showMessage(QString("Thermal sensor maximum range invalid :") +
4124  QString().setNum(maxRange));
4125  return;
4126  }
4127  current_thermal_sensor_->child(i)->setText(1,QString().setNum(maxRange));
4128  new_robot_msg_.thermalSensors[frameId].maxRange = maxRange;
4129  }
4130 
4132  else if(current_thermal_sensor_->child(i)->text(0) == QString("Pose - x"))
4133  {
4134  float dx = loader_.thermalSensorPropLoader.x_->text().toFloat();
4135  current_thermal_sensor_->child(i)->setText(1,QString().setNum(dx));
4136  new_robot_msg_.thermalSensors[frameId].pose.x = dx;
4137  }
4138 
4140  else if(current_thermal_sensor_->child(i)->text(0) == QString("Pose - y"))
4141  {
4142  float dy = loader_.thermalSensorPropLoader.y_->text().toFloat();
4143  current_thermal_sensor_->child(i)->setText(1,QString().setNum(dy));
4144  new_robot_msg_.thermalSensors[frameId].pose.y = dy;
4145  }
4146 
4148  else if(current_thermal_sensor_->child(i)->text(0) == QString("Frequency"))
4149  {
4150  float frequency =
4151  loader_.thermalSensorPropLoader.frequency->
4152  text().toFloat();
4153  if( frequency <= 0 )
4154  {
4155  showMessage(QString("Thermal sensor publishing frequency invalid :") +
4156  QString().setNum(frequency));
4157  return;
4158  }
4159  current_thermal_sensor_->child(i)->setText(1,QString().setNum(frequency));
4160  new_robot_msg_.thermalSensors[frameId].frequency = frequency;
4161  }
4162  }
4163 
4164  updateRobotPreview();
4165  }
4169  void CRobotCreatorConnector::updateSoundSensorOpen(void)
4170  {
4171  unsigned int frameId = searchSoundSensor(current_sound_sensor_->text(0));
4172  if(frameId == -1)
4173  {
4174  return;
4175  }
4176  for(unsigned int i = 0 ; i < current_sound_sensor_->childCount() ; i++)
4177  {
4178 
4180  if(current_sound_sensor_->child(i)->text(0) == QString("Angle span"))
4181  {
4182  float angle_span =
4183  loader_.soundSensorPropLoader.angleSpan->text().toFloat();
4184  if( angle_span <= 0 )
4185  {
4186  showMessage(QString("Sound sensor angle span invalid :") +
4187  QString().setNum(angle_span));
4188  return;
4189  }
4190  current_sound_sensor_->child(i)->setText(1,QString().setNum(angle_span));
4191  new_robot_msg_.soundSensors[frameId].angleSpan = angle_span;
4192  }
4193 
4195  else if(current_sound_sensor_->child(i)->text(0) == QString("Orientation"))
4196  {
4197  float orientation =
4198  loader_.soundSensorPropLoader.orientation->
4199  text().toFloat();
4200  current_sound_sensor_->child(i)->
4201  setText(1,QString().setNum(orientation));
4202  new_robot_msg_.soundSensors[frameId].pose.theta = orientation;
4203  }
4204 
4206  else if(current_sound_sensor_->child(i)->text(0) == QString("Max range"))
4207  {
4208  float maxRange =
4209  loader_.soundSensorPropLoader.maxDistance->
4210  text().toFloat();
4211  if( maxRange <= 0 )
4212  {
4213  showMessage(QString("Sound sensor maximum range invalid :") +
4214  QString().setNum(maxRange));
4215  return;
4216  }
4217  current_sound_sensor_->child(i)->setText(1,QString().setNum(maxRange));
4218  new_robot_msg_.soundSensors[frameId].maxRange = maxRange;
4219  }
4220 
4222  else if(current_sound_sensor_->child(i)->text(0) == QString("Pose - x"))
4223  {
4224  float dx = loader_.soundSensorPropLoader.x_->text().toFloat();
4225  current_sound_sensor_->child(i)->setText(1,QString().setNum(dx));
4226  new_robot_msg_.soundSensors[frameId].pose.x = dx;
4227  }
4228 
4230  else if(current_sound_sensor_->child(i)->text(0) == QString("Pose - y"))
4231  {
4232  float dy = loader_.soundSensorPropLoader.y_->text().toFloat();
4233  current_sound_sensor_->child(i)->setText(1,QString().setNum(dy));
4234  new_robot_msg_.soundSensors[frameId].pose.y = dy;
4235  }
4236 
4238  else if(current_sound_sensor_->child(i)->text(0) == QString("Frequency"))
4239  {
4240  float frequency =
4241  loader_.soundSensorPropLoader.frequency->
4242  text().toFloat();
4243  if( frequency <= 0 )
4244  {
4245  showMessage(QString("Sound sensor publishing frequency invalid :") +
4246  QString().setNum(frequency));
4247  return;
4248  }
4249  current_sound_sensor_->child(i)->setText(1,QString().setNum(frequency));
4250  new_robot_msg_.soundSensors[frameId].frequency = frequency;
4251  }
4252  }
4253 
4254  updateRobotPreview();
4255  }
4256 
4261  void CRobotCreatorConnector::editRobot(void)
4262  {
4263  loader_.robotPropLoader.robotOrientation->
4264  setText(QString().setNum(new_robot_msg_.initialPose.theta));
4265  loader_.robotPropLoader.robotRadius->
4266  setText(QString().setNum(new_robot_msg_.footprint.radius));
4267  loader_.robotPropLoader.show();
4268  }
4269 
4274  void CRobotCreatorConnector::updateRobot(void)
4275  {
4276  for(unsigned int i = 0 ; i < loader_.robotNode.childCount() ; i++)
4277  {
4278  if(loader_.robotNode.child(i)->text(0) == QString("Orientation"))
4279  {
4280  loader_.robotNode.child(i)->
4281  setText(1,loader_.robotPropLoader.robotOrientation->text());
4282  new_robot_msg_.initialPose.theta =
4283  loader_.robotPropLoader.robotOrientation->text().toFloat();
4284  }
4285  if(loader_.robotNode.child(i)->text(0) == QString("Radius"))
4286  {
4287  loader_.robotNode.child(i)->
4288  setText(1,loader_.robotPropLoader.robotRadius->text());
4289  new_robot_msg_.footprint.radius =
4290  loader_.robotPropLoader.robotRadius->text().toFloat();
4291  }
4292  }
4293 
4294  loader_.robotPropLoader.hide();
4295 
4296  updateRobotPreview();
4297  }
4298 
4303  void CRobotCreatorConnector::updateRobotOpen(void)
4304  {
4305  for(unsigned int i = 0 ; i < loader_.robotNode.childCount() ; i++)
4306  {
4307  if(loader_.robotNode.child(i)->text(0) == QString("Orientation"))
4308  {
4309  loader_.robotNode.child(i)->
4310  setText(1,loader_.robotPropLoader.robotOrientation->text());
4311  new_robot_msg_.initialPose.theta =
4312  loader_.robotPropLoader.robotOrientation->text().toFloat();
4313  }
4314  if(loader_.robotNode.child(i)->text(0) == QString("Radius"))
4315  {
4316  loader_.robotNode.child(i)->
4317  setText(1,loader_.robotPropLoader.robotRadius->text());
4318  new_robot_msg_.footprint.radius =
4319  loader_.robotPropLoader.robotRadius->text().toFloat();
4320  }
4321  }
4322 
4323  updateRobotPreview();
4324  }
4325 
4331  void CRobotCreatorConnector::deleteTreeNode(QTreeWidgetItem *item)
4332  {
4333  int count = item->childCount();
4334  for(int i = count - 1 ; i >= 0 ; i--)
4335  {
4336  deleteTreeNode(item->child(i));
4337  }
4338  delete item;
4339  }
4340 
4345  void CRobotCreatorConnector::updateRobotPreview(void)
4346  {
4347 
4348  loader_.robotPreviewImage.fill(QColor(220,220,220,1));
4349 
4350  climax_ = -1;
4351  if(climax_ < new_robot_msg_.footprint.radius)
4352  {
4353  climax_ = new_robot_msg_.footprint.radius;
4354  }
4355  for(unsigned int i = 0 ; i < new_robot_msg_.footprint.points.size() ; i++)
4356  {
4357  if(climax_ < new_robot_msg_.footprint.points[i].x)
4358  {
4359  climax_ = new_robot_msg_.footprint.points[i].x;
4360  }
4361  if(climax_ < new_robot_msg_.footprint.points[i].y)
4362  {
4363  climax_ = new_robot_msg_.footprint.points[i].y;
4364  }
4365  }
4366  for(unsigned int i = 0 ; i < new_robot_msg_.laserSensors.size() ; i++)
4367  {
4368  if(climax_ < (new_robot_msg_.laserSensors[i].maxRange +
4369  new_robot_msg_.laserSensors[i].pose.x))
4370  {
4371  climax_ = new_robot_msg_.laserSensors[i].maxRange +
4372  new_robot_msg_.laserSensors[i].pose.x;
4373  }
4374  if(climax_ < (new_robot_msg_.laserSensors[i].maxRange +
4375  new_robot_msg_.laserSensors[i].pose.y) )
4376  {
4377  climax_ = new_robot_msg_.laserSensors[i].maxRange +
4378  new_robot_msg_.laserSensors[i].pose.y;
4379  }
4380  if(climax_ < (new_robot_msg_.laserSensors[i].maxRange -
4381  new_robot_msg_.laserSensors[i].pose.x) )
4382  {
4383  climax_ = new_robot_msg_.laserSensors[i].maxRange -
4384  new_robot_msg_.laserSensors[i].pose.x;
4385  }
4386  if(climax_ < (new_robot_msg_.laserSensors[i].maxRange -
4387  new_robot_msg_.laserSensors[i].pose.y) )
4388  {
4389  climax_ = new_robot_msg_.laserSensors[i].maxRange -
4390  new_robot_msg_.laserSensors[i].pose.y;
4391  }
4392  }
4393  for(unsigned int i = 0 ; i < new_robot_msg_.sonarSensors.size() ; i++)
4394  {
4395  if(climax_ < (new_robot_msg_.sonarSensors[i].maxRange +
4396  new_robot_msg_.sonarSensors[i].pose.x) )
4397  {
4398  climax_ = new_robot_msg_.sonarSensors[i].maxRange +
4399  new_robot_msg_.sonarSensors[i].pose.x;
4400  }
4401  if(climax_ < (new_robot_msg_.sonarSensors[i].maxRange +
4402  new_robot_msg_.sonarSensors[i].pose.y) )
4403  {
4404  climax_ = new_robot_msg_.sonarSensors[i].maxRange +
4405  new_robot_msg_.sonarSensors[i].pose.y;
4406  }
4407  if(climax_ < (new_robot_msg_.sonarSensors[i].maxRange -
4408  new_robot_msg_.sonarSensors[i].pose.x) )
4409  {
4410  climax_ = new_robot_msg_.sonarSensors[i].maxRange -
4411  new_robot_msg_.sonarSensors[i].pose.x;
4412  }
4413  if(climax_ < (new_robot_msg_.sonarSensors[i].maxRange -
4414  new_robot_msg_.sonarSensors[i].pose.y) )
4415  {
4416  climax_ = new_robot_msg_.sonarSensors[i].maxRange -
4417  new_robot_msg_.sonarSensors[i].pose.y;
4418  }
4419  }
4420  for(unsigned int i = 0 ; i < new_robot_msg_.rfidSensors.size() ; i++)
4421  {
4422  if(climax_ < (new_robot_msg_.rfidSensors[i].maxRange +
4423  new_robot_msg_.rfidSensors[i].pose.x) )
4424  {
4425  climax_ = new_robot_msg_.rfidSensors[i].maxRange +
4426  new_robot_msg_.rfidSensors[i].pose.x;
4427  }
4428  if(climax_ < (new_robot_msg_.rfidSensors[i].maxRange +
4429  new_robot_msg_.rfidSensors[i].pose.y) )
4430  {
4431  climax_ = new_robot_msg_.rfidSensors[i].maxRange +
4432  new_robot_msg_.rfidSensors[i].pose.y;
4433  }
4434  if(climax_ < (new_robot_msg_.rfidSensors[i].maxRange -
4435  new_robot_msg_.rfidSensors[i].pose.x) )
4436  {
4437  climax_ = new_robot_msg_.rfidSensors[i].maxRange -
4438  new_robot_msg_.rfidSensors[i].pose.x;
4439  }
4440  if(climax_ < (new_robot_msg_.rfidSensors[i].maxRange -
4441  new_robot_msg_.rfidSensors[i].pose.y) )
4442  {
4443  climax_ = new_robot_msg_.rfidSensors[i].maxRange -
4444  new_robot_msg_.rfidSensors[i].pose.y;
4445  }
4446  }
4447  for(unsigned int i = 0 ; i < new_robot_msg_.co2Sensors.size() ; i++)
4448  {
4449  if(climax_ < (new_robot_msg_.co2Sensors[i].maxRange +
4450  new_robot_msg_.co2Sensors[i].pose.x) )
4451  {
4452  climax_ = new_robot_msg_.co2Sensors[i].maxRange +
4453  new_robot_msg_.co2Sensors[i].pose.x;
4454  }
4455  if(climax_ < (new_robot_msg_.co2Sensors[i].maxRange +
4456  new_robot_msg_.co2Sensors[i].pose.y) )
4457  {
4458  climax_ = new_robot_msg_.co2Sensors[i].maxRange +
4459  new_robot_msg_.co2Sensors[i].pose.y;
4460  }
4461  if(climax_ < (new_robot_msg_.co2Sensors[i].maxRange -
4462  new_robot_msg_.co2Sensors[i].pose.x) )
4463  {
4464  climax_ = new_robot_msg_.co2Sensors[i].maxRange -
4465  new_robot_msg_.co2Sensors[i].pose.x;
4466  }
4467  if(climax_ < (new_robot_msg_.co2Sensors[i].maxRange -
4468  new_robot_msg_.co2Sensors[i].pose.y) )
4469  {
4470  climax_ = new_robot_msg_.co2Sensors[i].maxRange -
4471  new_robot_msg_.co2Sensors[i].pose.y;
4472  }
4473  }
4474  for(unsigned int i = 0 ; i < new_robot_msg_.thermalSensors.size() ; i++)
4475  {
4476  if(climax_ < (new_robot_msg_.thermalSensors[i].maxRange +
4477  new_robot_msg_.thermalSensors[i].pose.x) )
4478  {
4479  climax_ = new_robot_msg_.thermalSensors[i].maxRange +
4480  new_robot_msg_.thermalSensors[i].pose.x;
4481  }
4482  if(climax_ < (new_robot_msg_.thermalSensors[i].maxRange +
4483  new_robot_msg_.thermalSensors[i].pose.y) )
4484  {
4485  climax_ = new_robot_msg_.thermalSensors[i].maxRange +
4486  new_robot_msg_.thermalSensors[i].pose.y;
4487  }
4488  if(climax_ < (new_robot_msg_.thermalSensors[i].maxRange -
4489  new_robot_msg_.thermalSensors[i].pose.x) )
4490  {
4491  climax_ = new_robot_msg_.thermalSensors[i].maxRange -
4492  new_robot_msg_.thermalSensors[i].pose.x;
4493  }
4494  if(climax_ < (new_robot_msg_.thermalSensors[i].maxRange -
4495  new_robot_msg_.thermalSensors[i].pose.y) )
4496  {
4497  climax_ = new_robot_msg_.thermalSensors[i].maxRange -
4498  new_robot_msg_.thermalSensors[i].pose.y;
4499  }
4500  }
4501  for(unsigned int i = 0 ; i < new_robot_msg_.soundSensors.size() ; i++)
4502  {
4503  if(climax_ < (new_robot_msg_.soundSensors[i].maxRange +
4504  new_robot_msg_.soundSensors[i].pose.x) )
4505  {
4506  climax_ = new_robot_msg_.soundSensors[i].maxRange +
4507  new_robot_msg_.soundSensors[i].pose.x;
4508  }
4509  if(climax_ < (new_robot_msg_.soundSensors[i].maxRange +
4510  new_robot_msg_.soundSensors[i].pose.y) )
4511  {
4512  climax_ = new_robot_msg_.soundSensors[i].maxRange +
4513  new_robot_msg_.soundSensors[i].pose.y;
4514  }
4515  if(climax_ < (new_robot_msg_.soundSensors[i].maxRange -
4516  new_robot_msg_.soundSensors[i].pose.x) )
4517  {
4518  climax_ = new_robot_msg_.soundSensors[i].maxRange -
4519  new_robot_msg_.soundSensors[i].pose.x;
4520  }
4521  if(climax_ < (new_robot_msg_.soundSensors[i].maxRange -
4522  new_robot_msg_.soundSensors[i].pose.y) )
4523  {
4524  climax_ = new_robot_msg_.soundSensors[i].maxRange -
4525  new_robot_msg_.soundSensors[i].pose.y;
4526  }
4527  }
4528 
4529  climax_ = 230.0 / climax_;
4530  drawRobot();
4531  drawLasers();
4532  drawSonars();
4533  drawRfidAntennas();
4534  drawCO2Sensors();
4535  drawThermalSensors();
4536  drawSoundSensors();
4537 
4538  loader_.robotTreeWidget->resizeColumnToContents(0);
4539  loader_.robotTreeWidget->resizeColumnToContents(1);
4540  loader_.robotTreeWidget->resizeColumnToContents(2);
4541  loader_.robotTreeWidget->resizeColumnToContents(3);
4542  loader_.robotTreeWidget->resizeColumnToContents(4);
4543  }
4544 
4549  void CRobotCreatorConnector::drawRobot(void)
4550  {
4551  QPainter painter(&loader_.robotPreviewImage);
4552  painter.setPen(Qt::blue);
4553 
4554  if(new_robot_msg_.footprint.points.size() == 0)
4555  {
4556  painter.drawEllipse(
4557  250 - new_robot_msg_.footprint.radius * climax_,
4558  250 - new_robot_msg_.footprint.radius * climax_,
4559  new_robot_msg_.footprint.radius * climax_ * 2,
4560  new_robot_msg_.footprint.radius * climax_ * 2);
4561 
4562  painter.setPen(Qt::red);
4563 
4564  painter.drawLine(
4565  250,
4566  250,
4567  250 + new_robot_msg_.footprint.radius * climax_ * 1.05 * cos(
4568  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI),
4569  250 - new_robot_msg_.footprint.radius * climax_ * 1.05 * sin(
4570  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI));
4571  }
4572  else
4573  {
4574  QPointF *points = new QPointF[new_robot_msg_.footprint.points.size() + 1];
4575 
4576  float max_val = 0;
4577 
4578  for(unsigned int i = 0 ;
4579  i < new_robot_msg_.footprint.points.size() + 1 ; i++)
4580  {
4581  float x = new_robot_msg_.footprint.points
4582  [i % new_robot_msg_.footprint.points.size()].x;
4583  float y = - new_robot_msg_.footprint.points
4584  [i % new_robot_msg_.footprint.points.size()].y;
4585 
4586  if( pow(x,2) + pow(y,2) > max_val )
4587  {
4588  max_val = pow(x,2) + pow(y,2);
4589  }
4590 
4591  points[i] = QPointF(
4592  250 +
4593  x * climax_ *
4594  cos(-new_robot_msg_.initialPose.theta / 180.0 * STDR_PI)
4595  - y * climax_ *
4596  sin(-new_robot_msg_.initialPose.theta / 180.0 * STDR_PI),
4597 
4598  250 +
4599  x * climax_ *
4600  sin(-new_robot_msg_.initialPose.theta / 180.0 * STDR_PI)
4601  + y * climax_ *
4602  cos(-new_robot_msg_.initialPose.theta / 180.0 * STDR_PI));
4603  }
4604  painter.drawPolyline(points, new_robot_msg_.footprint.points.size() + 1);
4605 
4606  painter.setPen(Qt::red);
4607 
4608  max_val = sqrt(max_val);
4609 
4610  painter.drawLine(
4611  250,
4612  250,
4613  250 + max_val * climax_ * 1.05 * cos(
4614  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI),
4615  250 - max_val * climax_ * 1.05 * sin(
4616  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI));
4617  }
4618 
4619  loader_.robotPreviewLabel->setPixmap(
4620  QPixmap().fromImage(loader_.robotPreviewImage));
4621  }
4622 
4627  void CRobotCreatorConnector::drawLasers(void)
4628  {
4629  QPainter painter(&loader_.robotPreviewImage);
4630  QBrush brush(QColor(0,200,0,50));
4631  painter.setBrush(brush);
4632  float robotOrientation =
4633  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4634 
4635  for(unsigned int i = 0 ; i < new_robot_msg_.laserSensors.size() ; i++)
4636  {
4637  if(laser_hightlight_id_ == i)
4638  {
4639  brush = QBrush(QColor(0,200,0,150));
4640  }
4641  else
4642  {
4643  brush = QBrush(QColor(0,200,0,50));
4644  }
4645  painter.setBrush(brush);
4646 
4647  float laserx = new_robot_msg_.laserSensors[i].pose.x;
4648  float lasery = new_robot_msg_.laserSensors[i].pose.y;
4649  float newx = laserx * cos(robotOrientation) -
4650  lasery * sin(robotOrientation);
4651  float newy = laserx * sin(robotOrientation) +
4652  lasery * cos(robotOrientation);
4653 
4654  painter.drawPie(
4655  250 - new_robot_msg_.laserSensors[i].maxRange * climax_ +
4656  newx * climax_,
4657 
4658  250 - new_robot_msg_.laserSensors[i].maxRange * climax_ -
4659  newy * climax_,
4660 
4661  new_robot_msg_.laserSensors[i].maxRange * climax_ * 2,
4662  new_robot_msg_.laserSensors[i].maxRange * climax_ * 2,
4663 
4664  (new_robot_msg_.laserSensors[i].minAngle +
4665  new_robot_msg_.initialPose.theta +
4666  new_robot_msg_.laserSensors[i].pose.theta) * 16,
4667 
4668  new_robot_msg_.laserSensors[i].maxAngle * 16 -
4669  new_robot_msg_.laserSensors[i].minAngle * 16);
4670  }
4671  loader_.robotPreviewLabel->setPixmap(
4672  QPixmap().fromImage(loader_.robotPreviewImage));
4673  }
4674 
4679  void CRobotCreatorConnector::drawSonars(void)
4680  {
4681  QPainter painter(&loader_.robotPreviewImage);
4682  QBrush brush(QColor(200,0,0,50));
4683  painter.setBrush(brush);
4684  float robotOrientation =
4685  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4686 
4687  for(unsigned int i = 0 ; i < new_robot_msg_.sonarSensors.size() ; i++)
4688  {
4689 
4690  if(sonar_hightlight_id_ == i)
4691  {
4692  brush = QBrush(QColor(200,0,0,150));
4693  }
4694  else
4695  {
4696  brush = QBrush(QColor(200,0,0,50));
4697  }
4698  painter.setBrush(brush);
4699 
4700  float sonarx = new_robot_msg_.sonarSensors[i].pose.x;
4701  float sonary = new_robot_msg_.sonarSensors[i].pose.y;
4702  float newx = sonarx * cos(robotOrientation) -
4703  sonary * sin(robotOrientation);
4704  float newy = sonarx * sin(robotOrientation) +
4705  sonary * cos(robotOrientation);
4706 
4707  painter.drawPie(
4708  250 - new_robot_msg_.sonarSensors[i].maxRange * climax_ +
4709  newx * climax_,
4710  250 - new_robot_msg_.sonarSensors[i].maxRange * climax_ -
4711  newy * climax_,
4712  new_robot_msg_.sonarSensors[i].maxRange * climax_ * 2,
4713  new_robot_msg_.sonarSensors[i].maxRange * climax_ * 2,
4714  (new_robot_msg_.sonarSensors[i].pose.theta -
4715  new_robot_msg_.sonarSensors[i].coneAngle / 2.0 +
4716  new_robot_msg_.initialPose.theta) * 16,
4717  (new_robot_msg_.sonarSensors[i].coneAngle) * 16);
4718  }
4719  loader_.robotPreviewLabel->setPixmap(
4720  QPixmap().fromImage(loader_.robotPreviewImage));
4721  }
4722 
4727  void CRobotCreatorConnector::drawRfidAntennas(void)
4728  {
4729  QPainter painter(&loader_.robotPreviewImage);
4730  QBrush brush(QColor(0,0,200,20));
4731  painter.setBrush(brush);
4732  float robotOrientation =
4733  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4734 
4735  for(unsigned int i = 0 ; i < new_robot_msg_.rfidSensors.size() ; i++)
4736  {
4737 
4738  if(rfid_antenna_hightlight_id_ == i)
4739  {
4740  brush = QBrush(QColor(0,0,200,30));
4741  }
4742  else
4743  {
4744  brush = QBrush(QColor(0,0,200,10));
4745  }
4746 
4747  float rfidx = new_robot_msg_.rfidSensors[i].pose.x;
4748  float rfidy = new_robot_msg_.rfidSensors[i].pose.y;
4749  float newx =
4750  rfidx * cos(robotOrientation) - rfidy * sin(robotOrientation);
4751  float newy =
4752  rfidx * sin(robotOrientation) + rfidy * cos(robotOrientation);
4753 
4754  painter.drawPie(
4755  250 - new_robot_msg_.rfidSensors[i].maxRange * climax_ + newx * climax_,
4756  250 - new_robot_msg_.rfidSensors[i].maxRange * climax_ - newy * climax_,
4757  new_robot_msg_.rfidSensors[i].maxRange * climax_ * 2,
4758  new_robot_msg_.rfidSensors[i].maxRange * climax_ * 2,
4759  (new_robot_msg_.rfidSensors[i].pose.theta -
4760  new_robot_msg_.rfidSensors[i].angleSpan / 2.0+
4761  new_robot_msg_.initialPose.theta) * 16,
4762  (new_robot_msg_.rfidSensors[i].angleSpan) * 16);
4763  }
4764  loader_.robotPreviewLabel->setPixmap(
4765  QPixmap().fromImage(loader_.robotPreviewImage));
4766  }
4770  void CRobotCreatorConnector::drawCO2Sensors(void)
4771  {
4772  QPainter painter(&loader_.robotPreviewImage);
4773  QBrush brush(QColor(100,0,200,20));
4774  painter.setBrush(brush);
4775  float robotOrientation =
4776  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4777 
4778  for(unsigned int i = 0 ; i < new_robot_msg_.co2Sensors.size() ; i++)
4779  {
4780 
4781  if(co2_sensor_hightlight_id_ == i)
4782  {
4783  brush = QBrush(QColor(100,0,200,30));
4784  }
4785  else
4786  {
4787  brush = QBrush(QColor(100,0,200,10));
4788  }
4789 
4790  float x = new_robot_msg_.co2Sensors[i].pose.x;
4791  float y = new_robot_msg_.co2Sensors[i].pose.y;
4792  float newx =
4793  x * cos(robotOrientation) - y * sin(robotOrientation);
4794  float newy =
4795  x * sin(robotOrientation) + y * cos(robotOrientation);
4796 
4797  painter.drawPie(
4798  250 - new_robot_msg_.co2Sensors[i].maxRange * climax_ + newx * climax_,
4799  250 - new_robot_msg_.co2Sensors[i].maxRange * climax_ - newy * climax_,
4800  new_robot_msg_.co2Sensors[i].maxRange * climax_ * 2,
4801  new_robot_msg_.co2Sensors[i].maxRange * climax_ * 2,
4802  0,
4803  (2 * 180.0) * 16);
4804  }
4805  loader_.robotPreviewLabel->setPixmap(
4806  QPixmap().fromImage(loader_.robotPreviewImage));
4807  }
4812  void CRobotCreatorConnector::drawThermalSensors(void)
4813  {
4814  QPainter painter(&loader_.robotPreviewImage);
4815  QBrush brush(QColor(200,0,0,10));
4816  painter.setBrush(brush);
4817  float robotOrientation =
4818  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4819 
4820  for(unsigned int i = 0 ; i < new_robot_msg_.thermalSensors.size() ; i++)
4821  {
4822 
4823  if(thermal_sensor_hightlight_id_ == i)
4824  {
4825  brush = QBrush(QColor(200,0,0,30));
4826  }
4827  else
4828  {
4829  brush = QBrush(QColor(200,0,0,10));
4830  }
4831 
4832  float x = new_robot_msg_.thermalSensors[i].pose.x;
4833  float y = new_robot_msg_.thermalSensors[i].pose.y;
4834  float newx =
4835  x * cos(robotOrientation) - y * sin(robotOrientation);
4836  float newy =
4837  x * sin(robotOrientation) + y * cos(robotOrientation);
4838 
4839  painter.drawPie(
4840  250 - new_robot_msg_.thermalSensors[i].maxRange * climax_ + newx * climax_,
4841  250 - new_robot_msg_.thermalSensors[i].maxRange * climax_ - newy * climax_,
4842  new_robot_msg_.thermalSensors[i].maxRange * climax_ * 2,
4843  new_robot_msg_.thermalSensors[i].maxRange * climax_ * 2,
4844  (new_robot_msg_.thermalSensors[i].pose.theta -
4845  new_robot_msg_.thermalSensors[i].angleSpan / 2.0+
4846  new_robot_msg_.initialPose.theta) * 16,
4847  (new_robot_msg_.thermalSensors[i].angleSpan) * 16);
4848  }
4849  loader_.robotPreviewLabel->setPixmap(
4850  QPixmap().fromImage(loader_.robotPreviewImage));
4851  }
4856  void CRobotCreatorConnector::drawSoundSensors(void)
4857  {
4858  QPainter painter(&loader_.robotPreviewImage);
4859  QBrush brush(QColor(0,50,200,20));
4860  painter.setBrush(brush);
4861  float robotOrientation =
4862  new_robot_msg_.initialPose.theta / 180.0 * STDR_PI;
4863 
4864  for(unsigned int i = 0 ; i < new_robot_msg_.soundSensors.size() ; i++)
4865  {
4866 
4867  if(sound_sensor_hightlight_id_ == i)
4868  {
4869  brush = QBrush(QColor(0,50,200,30));
4870  }
4871  else
4872  {
4873  brush = QBrush(QColor(0,50,200,10));
4874  }
4875 
4876  float x = new_robot_msg_.soundSensors[i].pose.x;
4877  float y = new_robot_msg_.soundSensors[i].pose.y;
4878  float newx =
4879  x * cos(robotOrientation) - y * sin(robotOrientation);
4880  float newy =
4881  x * sin(robotOrientation) + y * cos(robotOrientation);
4882 
4883  painter.drawPie(
4884  250 - new_robot_msg_.soundSensors[i].maxRange * climax_ + newx * climax_,
4885  250 - new_robot_msg_.soundSensors[i].maxRange * climax_ - newy * climax_,
4886  new_robot_msg_.soundSensors[i].maxRange * climax_ * 2,
4887  new_robot_msg_.soundSensors[i].maxRange * climax_ * 2,
4888  (new_robot_msg_.soundSensors[i].pose.theta -
4889  new_robot_msg_.soundSensors[i].angleSpan / 2.0+
4890  new_robot_msg_.initialPose.theta) * 16,
4891  (new_robot_msg_.soundSensors[i].angleSpan) * 16);
4892  }
4893  loader_.robotPreviewLabel->setPixmap(
4894  QPixmap().fromImage(loader_.robotPreviewImage));
4895  }
4896 
4901  void CRobotCreatorConnector::saveRobot(void)
4902  {
4903  QString file_name = QFileDialog::getSaveFileName(&loader_,
4904  tr("Save File"),
4905  QString().fromStdString(
4906  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
4907  QString("/resources/"),
4908  tr("Resource files (*.yaml *.xml)"));
4909 
4910  Q_EMIT saveRobotPressed(
4911  stdr_gui_tools::fixRobotAnglesToRad(new_robot_msg_),file_name);
4912  }
4913 
4918  void CRobotCreatorConnector::getRobotFromYaml(void)
4919  {
4920  QString file_name = QFileDialog::getOpenFileName(
4921  &loader_,
4922  tr("Load robot"),
4923  QString().fromStdString(
4924  stdr_gui_tools::getRosPackagePath("stdr_resources")) +
4925  QString("/resources/"),
4926  tr("Resource Files (*.yaml *.xml)"));
4927 
4929  if (file_name.isEmpty()) {
4930  return;
4931  }
4932 
4933  try {
4934  new_robot_msg_ =
4935  stdr_parser::Parser::createMessage<stdr_msgs::RobotMsg>
4936  (file_name.toStdString());
4937  }
4938  catch(stdr_parser::ParserException ex)
4939  {
4940  QMessageBox msg;
4941  msg.setWindowTitle(QString("STDR Parser - Error"));
4942  msg.setText(QString(ex.what()));
4943  msg.exec();
4944  return;
4945  }
4946 
4947  new_robot_msg_ = stdr_gui_tools::fixRobotAnglesToDegrees(new_robot_msg_);
4948 
4949  CRobotCreatorConnector::laser_number = -1;
4950  CRobotCreatorConnector::sonar_number = -1;
4951  CRobotCreatorConnector::rfid_number = -1;
4952  CRobotCreatorConnector::co2_sensors_number = -1;
4953  CRobotCreatorConnector::thermal_sensors_number = -1;
4954  CRobotCreatorConnector::sound_sensors_number = -1;
4955 
4956  for(int i = loader_.robotInfoFootprint.childCount() - 1 ; i >=0 ; i--)
4957  {
4958  delete loader_.robotInfoFootprint.child(i);
4959  }
4960 
4961  updateRobotTree();
4962 
4963  updateRobotPreview();
4964  }
4965 
4970  void CRobotCreatorConnector::loadRobot(void)
4971  {
4972  Q_EMIT loadRobotPressed(new_robot_msg_);
4973  loader_.hide();
4974  }
4975 
4982  void CRobotCreatorConnector::setInitialPose(float x, float y)
4983  {
4984  new_robot_msg_.initialPose.x = x;
4985  new_robot_msg_.initialPose.y = y;
4986  }
4987 
4992  stdr_msgs::RobotMsg CRobotCreatorConnector::getNewRobot(void)
4993  {
4994  return new_robot_msg_;
4995  }
4996 
5002  void CRobotCreatorConnector::setNewRobot(stdr_msgs::RobotMsg msg)
5003  {
5004  new_robot_msg_=msg;
5005  }
5006 
5012  void CRobotCreatorConnector::showMessage(QString msg)
5013  {
5014  QMessageBox msgBox;
5015  msgBox.setText(msg);
5016  msgBox.exec();
5017  }
5018 }
stdr_gui::CRobotCreatorConnector::updateRfidAntenna
void updateRfidAntenna(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3509
stdr_gui::CRobotCreatorConnector::updateLaserTree
void updateLaserTree(QTreeWidgetItem *item, stdr_msgs::LaserSensorMsg l)
Updates a tree item with a specific laser sensor.
Definition: stdr_robot_creator_connector.cpp:2608
stdr_gui::CRobotCreatorConnector::rfid_number
static int rfid_number
Definition: stdr_robot_creator_connector.h:95
stdr_gui::CRobotCreatorConnector::eraseCO2Sensor
void eraseCO2Sensor(QTreeWidgetItem *item)
Erases a specific co2 sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1592
stdr_gui::CRobotCreatorConnector::eraseRfid
void eraseRfid(QTreeWidgetItem *item)
Erases a specific rfid antenna sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1577
stdr_gui::CRobotCreatorConnector::current_laser_
QTreeWidgetItem * current_laser_
Tree item of the currently clicked sonar.
Definition: stdr_robot_creator_connector.h:69
stdr_gui::CRobotCreatorLoader::robotInfoFootprint
QTreeWidgetItem robotInfoFootprint
Holds the tree items that contain the footprint points.
Definition: stdr_robot_creator_loader.h:86
stdr_gui::CRobotCreatorConnector::saveRfidAntenna
void saveRfidAntenna(QTreeWidgetItem *item)
Saves a specific rfid reader sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1808
stdr_gui::CRobotCreatorConnector::current_sonar_
QTreeWidgetItem * current_sonar_
Tree item of the currently clicked rfid.
Definition: stdr_robot_creator_connector.h:71
stdr_gui_tools::getRosPackagePath
std::string getRosPackagePath(std::string package)
Returns the global path of the ROS package provided.
Definition: stdr_tools.cpp:31
stdr_gui::CRobotCreatorLoader::robotPropLoader
CRobotPropertiesLoader robotPropLoader
Object of robot footprint widget.
Definition: stdr_robot_creator_loader.h:105
stdr_gui::CRobotCreatorConnector::showMessage
void showMessage(QString msg)
Pops up a message box with a specific message.
Definition: stdr_robot_creator_connector.cpp:5012
stdr_gui::CRobotCreatorLoader::kinematicPropLoader
CKinematicPropertiesLoader kinematicPropLoader
Object of rfid antenna properties widget.
Definition: stdr_robot_creator_loader.h:113
stdr_gui::CRobotCreatorConnector::searchRfid
int searchRfid(QString frameId)
Returns the ID of an rfid antenna sensor.
Definition: stdr_robot_creator_connector.cpp:2460
stdr_gui_tools::fixCO2AnglesToRad
stdr_msgs::CO2SensorMsg fixCO2AnglesToRad(stdr_msgs::CO2SensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:336
stdr_gui::CRobotCreatorLoader::sonarsNode
QTreeWidgetItem sonarsNode
Tree item for the rfid antennas root.
Definition: stdr_robot_creator_loader.h:72
stdr_gui::CRobotCreatorConnector::drawRobot
void drawRobot(void)
Draws a robot.
Definition: stdr_robot_creator_connector.cpp:4549
stdr_gui::CRobotCreatorConnector::saveThermalSensor
void saveThermalSensor(QTreeWidgetItem *item)
Saves a specific thermal sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1875
stdr_gui::CRobotCreatorConnector::drawCO2Sensors
void drawCO2Sensors(void)
Draws the robot&#39;s rfid antennas.
Definition: stdr_robot_creator_connector.cpp:4770
stdr_gui::CRobotCreatorConnector::~CRobotCreatorConnector
~CRobotCreatorConnector(void)
Default destructor.
Definition: stdr_robot_creator_connector.cpp:128
stdr_gui::CRobotCreatorConnector::current_rfid_
QTreeWidgetItem * current_rfid_
Definition: stdr_robot_creator_connector.h:73
stdr_gui::CRobotCreatorConnector::drawLasers
void drawLasers(void)
Draws the robot&#39;s lasers.
Definition: stdr_robot_creator_connector.cpp:4627
stdr_gui_tools::fixRobotAnglesToDegrees
stdr_msgs::RobotMsg fixRobotAnglesToDegrees(stdr_msgs::RobotMsg rmsg)
Takes a stdr_msgs::RobotMsg and converts its angles to degrees.
Definition: stdr_tools.cpp:206
stdr_gui::CRobotCreatorConnector::loadLaser
void loadLaser(QTreeWidgetItem *item)
Loads a specific laser sensor from a file.
Definition: stdr_robot_creator_connector.cpp:1944
stdr_gui::CRobotCreatorConnector::updateSoundSensorTree
void updateSoundSensorTree(QTreeWidgetItem *item, stdr_msgs::SoundSensorMsg l)
Updates a tree item with a specific sound sensor.
Definition: stdr_robot_creator_connector.cpp:3463
stdr_gui::CRobotCreatorConnector::loader_
CRobotCreatorLoader loader_
Container of the new robot message.
Definition: stdr_robot_creator_connector.h:52
stdr_gui::CRobotCreatorConnector::initialise
void initialise(void)
Initializes the robot creator.
Definition: stdr_robot_creator_connector.cpp:137
stdr_gui::CRobotCreatorConnector::addFootprintPoint
void addFootprintPoint(void)
Adds a footprint point in the new robot.
Definition: stdr_robot_creator_connector.cpp:499
stdr_gui::CRobotCreatorConnector::searchSoundSensor
int searchSoundSensor(QString frameId)
Returns the ID of a sound sensor.
Definition: stdr_robot_creator_connector.cpp:2508
stdr_gui::CRobotCreatorLoader::rfidAntennaPropLoader
CRfidAntennaPropertiesLoader rfidAntennaPropLoader
Definition: stdr_robot_creator_loader.h:115
stdr_gui::CRobotCreatorConnector::addSoundSensor
void addSoundSensor(void)
Adds a sound sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:1206
stdr_gui::CRobotCreatorConnector::drawThermalSensors
void drawThermalSensors(void)
Draws the robot&#39;s rfid antennas.
Definition: stdr_robot_creator_connector.cpp:4812
stdr_gui::CRobotCreatorLoader::robotInfoOrientation
QTreeWidgetItem robotInfoOrientation
Tree item for the robot radius.
Definition: stdr_robot_creator_loader.h:81
stdr_gui::CRobotCreatorConnector::loadSoundSensor
void loadSoundSensor(QTreeWidgetItem *item)
Loads a specific sound sensor from a file.
Definition: stdr_robot_creator_connector.cpp:2160
stdr_gui::CRobotCreatorConnector::updateLaserOpen
void updateLaserOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:2825
stdr_gui_tools::fixRfidAnglesToDegrees
stdr_msgs::RfidSensorMsg fixRfidAnglesToDegrees(stdr_msgs::RfidSensorMsg rmsg)
Takes a stdr_msgs::RfidSensorMsg and converts its angles to degrees.
Definition: stdr_tools.cpp:325
stdr_gui_tools::fixSoundAnglesToDegrees
stdr_msgs::SoundSensorMsg fixSoundAnglesToDegrees(stdr_msgs::SoundSensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:388
stdr_gui::CRobotCreatorConnector::saveSonar
void saveSonar(QTreeWidgetItem *item)
Saves a specific sonar sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1772
stdr_gui_tools::fixThermalAnglesToRad
stdr_msgs::ThermalSensorMsg fixThermalAnglesToRad(stdr_msgs::ThermalSensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:357
stdr_gui::CRobotCreatorConnector::sound_sensors_number
static int sound_sensors_number
Definition: stdr_robot_creator_connector.h:98
stdr_gui::CRobotCreatorConnector::updateThermalSensorTree
void updateThermalSensorTree(QTreeWidgetItem *item, stdr_msgs::ThermalSensorMsg l)
Updates a tree item with a specific thermal sensor.
Definition: stdr_robot_creator_connector.cpp:3419
stdr_gui::CRobotCreatorLoader::laserPropLoader
CLaserPropertiesLoader laserPropLoader
Object of sonar properties widget.
Definition: stdr_robot_creator_loader.h:109
stdr_gui::CRobotCreatorConnector::updateThermalSensor
void updateThermalSensor(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3703
stdr_gui::CRobotCreatorConnector::eraseSoundSensor
void eraseSoundSensor(QTreeWidgetItem *item)
Erases a specific sound sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1622
stdr_gui_tools::fixLaserAnglesToDegrees
stdr_msgs::LaserSensorMsg fixLaserAnglesToDegrees(stdr_msgs::LaserSensorMsg rmsg)
Takes a stdr_msgs::LaserSensorMsg and converts its angles to degrees.
Definition: stdr_tools.cpp:275
stdr_gui::CRobotCreatorConnector::loadRobotPressed
void loadRobotPressed(stdr_msgs::RobotMsg newRobotMsg)
Emitted when the "load robot in map" button is pressed.
stdr_gui::CRobotCreatorConnector::thermal_sensor_hightlight_id_
unsigned int thermal_sensor_hightlight_id_
Definition: stdr_robot_creator_connector.h:65
stdr_robot_creator_connector.h
stdr_gui::CRobotCreatorLoader::kinematicNode
QTreeWidgetItem kinematicNode
Tree item for the robot orientation.
Definition: stdr_robot_creator_loader.h:79
stdr_gui::CRobotCreatorLoader::saveIcon
QIcon saveIcon
Load icon.
Definition: stdr_robot_creator_loader.h:100
stdr_gui::CRobotCreatorConnector::updateRobotTree
void updateRobotTree(void)
Updates the robot&#39;s tree widget.
Definition: stdr_robot_creator_connector.cpp:2524
stdr_gui::CRobotCreatorLoader::robotFootLoader
CRobotFootprintLoader robotFootLoader
Object of laser properties widget.
Definition: stdr_robot_creator_loader.h:107
stdr_gui::CRobotCreatorConnector::addLaser
void addLaser(void)
Adds a laser sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:640
stdr_gui::CRobotCreatorConnector::updateSonar
void updateSonar(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:2988
stdr_gui::CRobotCreatorConnector::thermal_sensors_number
static int thermal_sensors_number
Definition: stdr_robot_creator_connector.h:97
stdr_gui::CRobotCreatorConnector::addSonar
void addSonar(void)
Adds a sonar sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:816
y
TFSIMD_FORCE_INLINE const tfScalar & y() const
stdr_gui_tools::fixRfidAnglesToRad
stdr_msgs::RfidSensorMsg fixRfidAnglesToRad(stdr_msgs::RfidSensorMsg rmsg)
Takes a stdr_msgs::RfidSensorMsg and converts its angles to rads.
Definition: stdr_tools.cpp:313
stdr_gui::CRobotCreatorConnector::sound_sensor_hightlight_id_
unsigned int sound_sensor_hightlight_id_
Tree item of the currently clicked laser.
Definition: stdr_robot_creator_connector.h:66
stdr_gui::CRobotCreatorConnector::updateKinematicModel
void updateKinematicModel(void)
Called when the update button of the kinematic model widget is clicked.
Definition: stdr_robot_creator_connector.cpp:580
stdr_gui::CRobotCreatorConnector::saveSoundSensor
void saveSoundSensor(QTreeWidgetItem *item)
Saves a specific sound sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1908
stdr_gui::CRobotCreatorConnector::getRobotFromYaml
void getRobotFromYaml(void)
Called when the load robot button.
Definition: stdr_robot_creator_connector.cpp:4918
stdr_gui::CRobotCreatorConnector::saveRobot
void saveRobot(void)
Called when the save robot button is clicked.
Definition: stdr_robot_creator_connector.cpp:4901
stdr_gui::CRobotCreatorConnector::editThermalSensor
void editThermalSensor(QTreeWidgetItem *item)
Edits a specific thermal sensor based on a tree item. \ Initiates the thermal sensor editor widget...
Definition: stdr_robot_creator_connector.cpp:2344
stdr_gui::CRobotCreatorConnector::updateSoundSensor
void updateSoundSensor(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3795
stdr_gui::CRobotCreatorConnector::updateFootprintPoint
void updateFootprintPoint(void)
Called when the update button of the footprint widget is clicked.
Definition: stdr_robot_creator_connector.cpp:544
stdr_gui::CRobotCreatorLoader::soundSensorPropLoader
CSoundSensorPropertiesLoader soundSensorPropLoader
Definition: stdr_robot_creator_loader.h:118
stdr_gui::CRobotCreatorConnector::updateRfidTree
void updateRfidTree(QTreeWidgetItem *item, stdr_msgs::RfidSensorMsg l)
Updates a tree item with a specific rfid reader sensor.
Definition: stdr_robot_creator_connector.cpp:3331
stdr_gui_tools::fixLaserAnglesToRad
stdr_msgs::LaserSensorMsg fixLaserAnglesToRad(stdr_msgs::LaserSensorMsg rmsg)
Takes a stdr_msgs::LaserSensorMsg and converts its angles to rads.
Definition: stdr_tools.cpp:262
stdr_gui::CRobotCreatorConnector::updateRobot
void updateRobot(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:4274
stdr_gui::CRobotCreatorConnector::editCO2Sensor
void editCO2Sensor(QTreeWidgetItem *item)
Edits a specific co2 sensor based on a tree item. \ Initiates the co2 sensor editor widget...
Definition: stdr_robot_creator_connector.cpp:2301
stdr_gui::CRobotCreatorLoader::robotNode
QTreeWidgetItem robotNode
Tree item for the lasers root.
Definition: stdr_robot_creator_loader.h:68
stdr_gui::CRobotCreatorConnector::deleteTreeNode
void deleteTreeNode(QTreeWidgetItem *item)
Deletes a specific tree item and it&#39;s children recursively.
Definition: stdr_robot_creator_connector.cpp:4331
stdr_gui::CRobotCreatorConnector::updateSonarTree
void updateSonarTree(QTreeWidgetItem *item, stdr_msgs::SonarSensorMsg l)
Updates a tree item with a specific sonar sensor.
Definition: stdr_robot_creator_connector.cpp:3275
stdr_gui::CRobotCreatorConnector::current_sound_sensor_
QTreeWidgetItem * current_sound_sensor_
Tree item of the currently clicked footprint point.
Definition: stdr_robot_creator_connector.h:76
stdr_gui::CRobotCreatorConnector::editSonar
void editSonar(QTreeWidgetItem *item)
Edits a specific sonar sensor based on a tree item. Initiates the sonar sensor editor widget...
Definition: stdr_robot_creator_connector.cpp:2205
stdr_gui::CRobotCreatorLoader::soundSensorsNode
QTreeWidgetItem soundSensorsNode
Tree item for the kinematic.
Definition: stdr_robot_creator_loader.h:77
stdr_gui::CRobotCreatorLoader::co2SensorsNode
QTreeWidgetItem co2SensorsNode
Definition: stdr_robot_creator_loader.h:75
stdr_parser::Parser::saveMessage
static void saveMessage(T msg, std::string file_name)
stdr_gui::CRobotCreatorConnector::current_thermal_sensor_
QTreeWidgetItem * current_thermal_sensor_
Definition: stdr_robot_creator_connector.h:75
stdr_gui::CRobotCreatorLoader::sonarPropLoader
CSonarPropertiesLoader sonarPropLoader
Object of robot kinematic properties widget.
Definition: stdr_robot_creator_loader.h:111
stdr_gui::CRobotCreatorConnector::updateRobotPreview
void updateRobotPreview(void)
Updates the robot&#39;s preview.
Definition: stdr_robot_creator_connector.cpp:4345
stdr_gui::CRobotCreatorConnector::editFootprintPoint
void editFootprintPoint(QTreeWidgetItem *item)
Edits a specific footprint point based on a tree item. Initiates the footprint editor widget...
Definition: stdr_robot_creator_connector.cpp:1640
stdr_gui::CRobotCreatorConnector::getNewRobot
stdr_msgs::RobotMsg getNewRobot(void)
Returns the created robot.
Definition: stdr_robot_creator_connector.cpp:4992
stdr_gui_tools::fixSonarAnglesToDegrees
stdr_msgs::SonarSensorMsg fixSonarAnglesToDegrees(stdr_msgs::SonarSensorMsg rmsg)
Takes a stdr_msgs::SonarSensorMsg and converts its angles to degrees.
Definition: stdr_tools.cpp:300
stdr_gui::CRobotCreatorConnector::searchLaser
int searchLaser(QString frameId)
Returns the ID of a laser sensor.
Definition: stdr_robot_creator_connector.cpp:2426
stdr_gui::CRobotCreatorConnector::updateSoundSensorOpen
void updateSoundSensorOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:4169
stdr_gui::CRobotCreatorConnector::loadRobot
void loadRobot(void)
Called when the load robot in map button is clicked.
Definition: stdr_robot_creator_connector.cpp:4970
stdr_gui::CRobotCreatorConnector::updateLaser
void updateLaser(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:2661
stdr_gui::CRobotCreatorLoader::rfidAntennasNode
QTreeWidgetItem rfidAntennasNode
Definition: stdr_robot_creator_loader.h:74
stdr_gui_tools::fixRobotAnglesToRad
stdr_msgs::RobotMsg fixRobotAnglesToRad(stdr_msgs::RobotMsg rmsg)
Takes a stdr_msgs::RobotMsg and converts its angles to rads.
Definition: stdr_tools.cpp:150
stdr_gui::CRobotCreatorLoader::robotInfoRadius
QTreeWidgetItem robotInfoRadius
Tree item for the robot footprint.
Definition: stdr_robot_creator_loader.h:83
STDR_PI
#define STDR_PI
Definition: stdr_tools.h:100
stdr_gui::CRobotCreatorLoader::lasersNode
QTreeWidgetItem lasersNode
Tree item for the sonars root.
Definition: stdr_robot_creator_loader.h:70
x
TFSIMD_FORCE_INLINE const tfScalar & x() const
stdr_gui::CRobotCreatorConnector::updateFootprintPointOpen
void updateFootprintPointOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:606
stdr_gui::CRobotCreatorConnector::addThermalSensor
void addThermalSensor(void)
Adds a thermal sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:1131
stdr_gui_tools::fixSonarAnglesToRad
stdr_msgs::SonarSensorMsg fixSonarAnglesToRad(stdr_msgs::SonarSensorMsg rmsg)
Takes a stdr_msgs::SonarSensorMsg and converts its angles to rads.
Definition: stdr_tools.cpp:288
stdr_gui::CRobotCreatorConnector::climax_
float climax_
Object of CRobotCreatorLoader.
Definition: stdr_robot_creator_connector.h:49
stdr_gui::CRobotCreatorConnector::saveLaser
void saveLaser(QTreeWidgetItem *item)
Saves a specific laser sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1736
stdr_gui::CRobotCreatorConnector::searchCO2Sensor
int searchCO2Sensor(QString frameId)
Returns the ID of an co2 sensor.
Definition: stdr_robot_creator_connector.cpp:2476
stdr_gui::CRobotCreatorConnector::saveCO2Sensor
void saveCO2Sensor(QTreeWidgetItem *item)
Saves a specific co2 sensor in a file.
Definition: stdr_robot_creator_connector.cpp:1842
stdr_gui_tools::fixCO2AnglesToDegrees
stdr_msgs::CO2SensorMsg fixCO2AnglesToDegrees(stdr_msgs::CO2SensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:346
stdr_gui::CRobotCreatorConnector::searchSonar
int searchSonar(QString frameId)
Returns the ID of a sonar sensor.
Definition: stdr_robot_creator_connector.cpp:2443
stdr_gui::CRobotCreatorConnector::sonar_hightlight_id_
unsigned int sonar_hightlight_id_
Current rfid antenna for highlight.
Definition: stdr_robot_creator_connector.h:60
stdr_gui::CRobotCreatorConnector::loadRfidAntenna
void loadRfidAntenna(QTreeWidgetItem *item)
Loads a specific rfid reader sensor from a file.
Definition: stdr_robot_creator_connector.cpp:2034
stdr_gui::CRobotCreatorConnector::searchThermalSensor
int searchThermalSensor(QString frameId)
Returns the ID of a thermal sensor.
Definition: stdr_robot_creator_connector.cpp:2492
stdr_gui::CRobotCreatorConnector::laser_number
static int laser_number
< Number of laser sensors
Definition: stdr_robot_creator_connector.h:91
stdr_gui
The main namespace for STDR GUI.
stdr_gui::CRobotCreatorLoader::thermalSensorsNode
QTreeWidgetItem thermalSensorsNode
Definition: stdr_robot_creator_loader.h:76
stdr_gui::CRobotCreatorConnector::loadSonar
void loadSonar(QTreeWidgetItem *item)
Loads a specific sonar sensor from a file.
Definition: stdr_robot_creator_connector.cpp:1989
stdr_gui::CRobotCreatorLoader::editIcon
QIcon editIcon
Remove icon.
Definition: stdr_robot_creator_loader.h:96
stdr_gui::CRobotCreatorLoader::co2SensorPropLoader
CCO2SensorPropertiesLoader co2SensorPropLoader
Definition: stdr_robot_creator_loader.h:116
stdr_gui::CRobotCreatorConnector::treeItemClicked
void treeItemClicked(QTreeWidgetItem *item, int column)
Called when a tree item is clicked.
Definition: stdr_robot_creator_connector.cpp:189
stdr_gui_tools::fixThermalAnglesToDegrees
stdr_msgs::ThermalSensorMsg fixThermalAnglesToDegrees(stdr_msgs::ThermalSensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:367
stdr_gui::CRobotCreatorConnector::new_robot_msg_
stdr_msgs::RobotMsg new_robot_msg_
Current laser for highlight.
Definition: stdr_robot_creator_connector.h:55
stdr_gui::CRobotCreatorConnector::drawSonars
void drawSonars(void)
Draws the robot&#39;s sonars.
Definition: stdr_robot_creator_connector.cpp:4679
stdr_gui::CRobotCreatorConnector::CRobotCreatorConnector
CRobotCreatorConnector(int argc, char **argv)
Default contructor.
Definition: stdr_robot_creator_connector.cpp:40
stdr_gui::CRobotCreatorLoader::loadIcon
QIcon loadIcon
Object of robot properties widget.
Definition: stdr_robot_creator_loader.h:102
stdr_gui::CRobotCreatorConnector::current_footprint_point_
QTreeWidgetItem * current_footprint_point_
Definition: stdr_robot_creator_connector.h:78
stdr_gui::CRobotCreatorConnector::setNewRobot
void setNewRobot(stdr_msgs::RobotMsg msg)
Sets the created robot.
Definition: stdr_robot_creator_connector.cpp:5002
stdr_gui::CRobotCreatorConnector::addRfidAntenna
void addRfidAntenna(void)
Adds an rfid antenna sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:981
stdr_gui::CRobotCreatorLoader::thermalSensorPropLoader
CThermalSensorPropertiesLoader thermalSensorPropLoader
Definition: stdr_robot_creator_loader.h:117
stdr_gui::CRobotCreatorConnector::updateCO2SensorOpen
void updateCO2SensorOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3989
stdr_gui_tools::fixSoundAnglesToRad
stdr_msgs::SoundSensorMsg fixSoundAnglesToRad(stdr_msgs::SoundSensorMsg rmsg)
Angle conversion.
Definition: stdr_tools.cpp:378
stdr_gui::CRobotCreatorConnector::drawRfidAntennas
void drawRfidAntennas(void)
Draws the robot&#39;s rfid antennas.
Definition: stdr_robot_creator_connector.cpp:4727
stdr_gui::CRobotCreatorConnector::setInitialPose
void setInitialPose(float x, float y)
Sets the robot&#39;s initial pose.
Definition: stdr_robot_creator_connector.cpp:4982
stdr_gui::CRobotCreatorConnector::editLaser
void editLaser(QTreeWidgetItem *item)
Edits a specific laser sensor based on a tree item. Initiates the laser sensor editor widget...
Definition: stdr_robot_creator_connector.cpp:1678
stdr_gui::CRobotCreatorConnector::eraseLaser
void eraseLaser(QTreeWidgetItem *item)
Erases a specific laser sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1541
stdr_gui::CRobotCreatorConnector::updateCO2Sensor
void updateCO2Sensor(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3611
stdr_gui::CRobotCreatorConnector::updateThermalSensorOpen
void updateThermalSensorOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:4079
stdr_gui::CRobotCreatorConnector::drawSoundSensors
void drawSoundSensors(void)
Draws the robot&#39;s rfid antennas.
Definition: stdr_robot_creator_connector.cpp:4856
stdr_gui::CRobotCreatorConnector::editRfid
void editRfid(QTreeWidgetItem *item)
Edits a specific rfid antenna sensor based on a tree item. Initiates the rfid antenna sensor editor w...
Definition: stdr_robot_creator_connector.cpp:2258
stdr_gui::CRobotCreatorLoader::robotPreviewImage
QImage robotPreviewImage
Add icon.
Definition: stdr_robot_creator_loader.h:91
stdr_gui::CRobotCreatorConnector::current_co2_sensor_
QTreeWidgetItem * current_co2_sensor_
Definition: stdr_robot_creator_connector.h:74
stdr_gui::CRobotCreatorConnector::co2_sensor_hightlight_id_
unsigned int co2_sensor_hightlight_id_
Definition: stdr_robot_creator_connector.h:64
stdr_gui::CRobotCreatorConnector::addCO2Sensor
void addCO2Sensor(void)
Adds a co2 sensor in the new robot.
Definition: stdr_robot_creator_connector.cpp:1056
stdr_gui::CRobotCreatorConnector::sonar_number
static int sonar_number
Number of rfid antenna sensors.
Definition: stdr_robot_creator_connector.h:93
stdr_gui::CRobotCreatorLoader::removeIcon
QIcon removeIcon
Save icon.
Definition: stdr_robot_creator_loader.h:98
stdr_gui::CRobotCreatorConnector::updateRfidAntennaOpen
void updateRfidAntennaOpen(void)
Called when the update button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3889
stdr_gui::CRobotCreatorConnector::editSoundSensor
void editSoundSensor(QTreeWidgetItem *item)
Edits a specific sound sensor based on a tree item. \ Initiates the sound sensor editor widget...
Definition: stdr_robot_creator_connector.cpp:2384
stdr_gui::CRobotCreatorConnector::eraseThermalSensor
void eraseThermalSensor(QTreeWidgetItem *item)
Erases a specific thermal sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1607
stdr_gui::CRobotCreatorConnector::editRobot
void editRobot(void)
Shows the edit robot widget.
Definition: stdr_robot_creator_connector.cpp:4261
stdr_gui::CRobotCreatorConnector::eraseFootprintPoint
void eraseFootprintPoint(QTreeWidgetItem *item)
Erases a footprint point in the new robot.
Definition: stdr_robot_creator_connector.cpp:525
stdr_gui::CRobotCreatorConnector::rfid_antenna_hightlight_id_
unsigned int rfid_antenna_hightlight_id_
Current rfid antenna for highlight.
Definition: stdr_robot_creator_connector.h:62
stdr_gui::CRobotCreatorConnector::eraseSonar
void eraseSonar(QTreeWidgetItem *item)
Erases a specific sonar sensor based on a tree item.
Definition: stdr_robot_creator_connector.cpp:1559
stdr_gui::CRobotCreatorConnector::loadThermalSensor
void loadThermalSensor(QTreeWidgetItem *item)
Loads a specific thermal sensor from a file.
Definition: stdr_robot_creator_connector.cpp:2118
ROS_ERROR
#define ROS_ERROR(...)
stdr_gui::CRobotCreatorConnector::laser_hightlight_id_
unsigned int laser_hightlight_id_
Current sonar for highlight.
Definition: stdr_robot_creator_connector.h:58
stdr_gui::CRobotCreatorConnector::co2_sensors_number
static int co2_sensors_number
Definition: stdr_robot_creator_connector.h:96
stdr_gui::CRobotCreatorConnector::updateRobotOpen
void updateRobotOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:4303
stdr_gui::CRobotCreatorConnector::saveRobotPressed
void saveRobotPressed(stdr_msgs::RobotMsg newRobotMsg, QString file_name)
Emitted to save the robot in a yaml file.
stdr_gui::CRobotCreatorConnector::updateCO2SensorTree
void updateCO2SensorTree(QTreeWidgetItem *item, stdr_msgs::CO2SensorMsg l)
Updates a tree item with a specific co2 sensor.
Definition: stdr_robot_creator_connector.cpp:3375
stdr_gui::CRobotCreatorConnector::updateSonarOpen
void updateSonarOpen(void)
Called when the refresh button of the properties widget is clicked.
Definition: stdr_robot_creator_connector.cpp:3131
stdr_parser::ParserException
stdr_gui::CRobotCreatorConnector::loadCO2Sensor
void loadCO2Sensor(QTreeWidgetItem *item)
Loads a specific co2 sensor from a file.
Definition: stdr_robot_creator_connector.cpp:2076

stdr_gui
Author(s): Manos Tsardoulias
autogenerated on Mon Jun 10 2019 15:15:17