Developer Documentation
MovePlugin.cc
1 /*===========================================================================*\
2 * *
3 * OpenFlipper *
4  * Copyright (c) 2001-2015, RWTH-Aachen University *
5  * Department of Computer Graphics and Multimedia *
6  * All rights reserved. *
7  * www.openflipper.org *
8  * *
9  *---------------------------------------------------------------------------*
10  * This file is part of OpenFlipper. *
11  *---------------------------------------------------------------------------*
12  * *
13  * Redistribution and use in source and binary forms, with or without *
14  * modification, are permitted provided that the following conditions *
15  * are met: *
16  * *
17  * 1. Redistributions of source code must retain the above copyright notice, *
18  * this list of conditions and the following disclaimer. *
19  * *
20  * 2. Redistributions in binary form must reproduce the above copyright *
21  * notice, this list of conditions and the following disclaimer in the *
22  * documentation and/or other materials provided with the distribution. *
23  * *
24  * 3. Neither the name of the copyright holder nor the names of its *
25  * contributors may be used to endorse or promote products derived from *
26  * this software without specific prior written permission. *
27  * *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 \*===========================================================================*/
41 
42 
43 #include "MovePlugin.hh"
44 
45 #include <MeshTools/MeshInfoT.hh>
46 #include <OpenFlipper/BasePlugin/WhatsThisGenerator.hh>
47 
48 #ifdef USE_OPENMP
49 #endif
50 
51 
52 #ifdef ENABLE_POLYLINE_SUPPORT
53 #include <ObjectTypes/PolyLine/PolyLine.hh>
54 #endif
55 
56 #ifdef ENABLE_TSPLINEMESH_SUPPORT
57 #include <ObjectTypes/TSplineMesh/TSplineMesh.hh>
58 #endif
59 
60 #ifdef ENABLE_SKELETON_SUPPORT
61 #include <ObjectTypes/Skeleton/Helper/SkeletonTransform.hh>
62 #endif
63 
64 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
65 #include <ObjectTypes/HexahedralMesh/HexahedralMesh.hh>
66 #endif
67 
68 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
69 #include <ObjectTypes/TetrahedralMesh/TetrahedralMesh.hh>
70 #endif
71 
72 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
73 #include <ObjectTypes/PolyhedralMesh/PolyhedralMesh.hh>
74 #endif
75 
76 #include <QMessageBox>
77 
78 
82 MovePlugin::MovePlugin() :
83 axisA_(0),
84 axisB_(1),
85 toolboxActive_(false),
86 tool_(0),
87 toolIcon_(0),
88 moveAction_(0),
89 moveSelectionAction_(0),
90 toolBarActions_(0),
91 toolbar_(0),
92 pickToolbar_(0),
93 placeAction_(0),
94 rotateTranslateAction_(0),
95 rotateManipAction_(0),
96 resizeAction_(0),
97 biggerManipAction_(0),
98 smallerManipAction_(0),
99 fixChildManipAction_(0),
100 transformRefPoseManipAction_(0),
101 currentPoseManipAction_(0),
102 placeAndSnapAction_(0),
103 pickToolBarActions_(0),
104 manip_size_(1.0),
105 manip_size_modifier_(1.0),
106 lastActiveManipulator_(-1),
107 manMode_(QtTranslationManipulatorNode::TranslationRotation),
108 selectionType_(VERTEX),
109 contextAction_(0),
110 contextActionHide_(0),
111 toAllTargets_(0),
112 contextMenuManipControl_(0),
113 contextMenuManipControlsAction_(0),
114 hide_(true),
115 allTargets_(false),
116 placeMode_(false),
117 transformedSelected_(false)
118 {
119 
120 }
121 
125 MovePlugin::~MovePlugin() {
126 
127  if(contextAction_) {
128  delete contextAction_;
129  }
130 
131  if(contextActionHide_) {
132  delete contextActionHide_;
133  }
134 
135  if(toAllTargets_) {
136  delete toAllTargets_;
137  }
138 
139  for(QList<movePropsWidget*>::iterator it = propsWindows_.begin();
140  it != propsWindows_.end(); ++it) {
141 
142  if(*it) {
143  delete *it;
144  }
145  }
146 }
147 
148 
149 /*******************************************************************************
150  BaseInterface implementation
151  *******************************************************************************/
152 
156 void MovePlugin::pluginsInitialized() {
157 
158  //PICKMODES
159  emit addPickMode("Separator");
160  emit addHiddenPickMode("Move");
161  emit setPickModeMouseTracking ("Move", true);
162  emit addHiddenPickMode("MoveSelection");
163  emit setPickModeMouseTracking ("MoveSelection", true);
164 
165  //KEYS
166  emit registerKey (Qt::Key_Shift, Qt::NoModifier, tr("Manipulator rotation"), true);
167  emit registerKey (Qt::Key_Shift, Qt::ShiftModifier, tr("Manipulator rotation"), true);
168  emit registerKey (Qt::Key_Shift, Qt::ControlModifier | Qt::ShiftModifier, tr("Manipulator rotation"), true);
169  emit registerKey (Qt::Key_Control, Qt::NoModifier, tr("Resize"), true);
170  emit registerKey (Qt::Key_Control, Qt::ControlModifier, tr("Resize"), true);
171  emit registerKey (Qt::Key_Control, Qt::ShiftModifier | Qt::ControlModifier, tr("Resize"), true);
172 
173  //SCRIPTING SLOT DESCRIPTIONS
174  setDescriptions();
175 
176  // ==================================
177  // Toolbar
178  // ==================================
179 
180  WhatsThisGenerator whatsThis("Move");
181  WhatsThisGenerator whatsThisUser("user");
182 
183  toolbar_ = new QToolBar(tr("Transform and Move"));
184  toolbar_->setObjectName("TransformAndMoveToolBar");
185 
186  toolBarActions_ = new QActionGroup(toolbar_);
187 
188  moveAction_ = new QAction(tr("<B>Move Object</B><br>Move an object in 3D"), toolBarActions_);
189  moveAction_->setStatusTip(tr("Move object in 3D."));
190  moveAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-objects.png") );
191  moveAction_->setCheckable(true);
192  whatsThis.setWhatsThis(moveAction_,tr("Move the whole object."));
193  toolbar_->addAction(moveAction_);
194 
195  moveSelectionAction_ = new QAction(tr("<B>Move Selection</B><br>Move a selection on an object"), toolBarActions_);
196  moveSelectionAction_->setStatusTip(tr("Move selections in 3D."));
197  moveSelectionAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-selections.png") );
198  moveSelectionAction_->setCheckable(true);
199  whatsThis.setWhatsThis(moveSelectionAction_,tr("Move only a selection."));
200  toolbar_->addAction(moveSelectionAction_);
201 
202  connect(toolBarActions_, SIGNAL(triggered(QAction*)), this, SLOT(slotSetMoveMode(QAction*)) );
203 
204  emit addToolbar(toolbar_);
205 
206  // ==================================
207  // Pick Toolbar
208  // ==================================
209 
210  pickToolbar_ = new QToolBar(tr("Transform and Move PickTool bar"));
211  pickToolbar_->setObjectName("TransformAndMovePickToolBar");
212 
213  pickToolbar_->setAttribute(Qt::WA_AlwaysShowToolTips, true);
214  pickToolBarActions_ = new QActionGroup(pickToolbar_);
215  pickToolBarActions_->setExclusive (false);
216 
217  placeAction_ = new QAction(tr("Place manipulator"), pickToolBarActions_);
218  placeAction_->setStatusTip(tr("Place manipulator on object. <Doubleclick>"));
219  placeAction_->setToolTip(tr("Place manipulator on object. <Doubleclick>"));
220  placeAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-place.png") );
221  whatsThisUser.setWhatsThis(placeAction_,tr("Place the manipulator."),"obj_man","manipulator.html");
222  placeAction_->setCheckable(true);
223  pickToolbar_->addAction(placeAction_);
224 
225  pickToolbar_->addSeparator ();
226 
227  rotateTranslateAction_ = new QAction(tr("Rotate/Translate object"), pickToolBarActions_);
228  rotateTranslateAction_->setStatusTip(tr("Rotate/Translate object."));
229  rotateTranslateAction_->setToolTip(tr("Rotate/Translate object."));
230  rotateTranslateAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-translaterotate.png") );
231  rotateTranslateAction_->setCheckable(true);
232  rotateTranslateAction_->setChecked(true);
233  whatsThisUser.setWhatsThis(rotateTranslateAction_,tr("Rotate or translate an object or selection."),"obj_translation","manipulator.html");
234  pickToolbar_->addAction(rotateTranslateAction_);
235 
236  resizeAction_ = new QAction(tr("Resize object"), pickToolBarActions_);
237  resizeAction_->setStatusTip(tr("Resize object. <Control>"));
238  resizeAction_->setToolTip(tr("Resize object. <Control>"));
239  resizeAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-resize.png") );
240  whatsThisUser.setWhatsThis(resizeAction_,tr("Resize object or selection."),"obj_resizing","manipulator.html");
241  resizeAction_->setCheckable(true);
242  pickToolbar_->addAction(resizeAction_);
243 
244  pickToolbar_->addSeparator ();
245 
246  rotateManipAction_ = new QAction(tr("Rotate manipulator"), pickToolBarActions_);
247  rotateManipAction_->setStatusTip(tr("Rotate manipulator. <Shift>"));
248  rotateManipAction_->setToolTip(tr("Rotate manipulator. <Shift>"));
249  rotateManipAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-maniprotate.png") );
250  whatsThisUser.setWhatsThis(rotateManipAction_,tr("Rotate only the Manipulator."),"man_rotating","manipulator.html");
251  rotateManipAction_->setCheckable(true);
252  pickToolbar_->addAction(rotateManipAction_);
253 
254  placeAndSnapAction_ = new QAction(tr("Locally translate manipulator"), pickToolBarActions_);
255  placeAndSnapAction_->setStatusTip(tr("Locally translate manipulator. Press and hold <Alt> for snapping."));
256  whatsThisUser.setWhatsThis(placeAndSnapAction_,tr("Translate only the Manipulator."),"man_translation","manipulator.html");
257  placeAndSnapAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-placeandsnap.png") );
258  placeAndSnapAction_->setCheckable(true);
259  pickToolbar_->addAction(placeAndSnapAction_);
260 
261  smallerManipAction_ = new QAction(tr("Decrease size of manipulator"), pickToolBarActions_);
262  smallerManipAction_->setStatusTip(tr("Make manipulator smaller. <Mouse wheel up>"));
263  smallerManipAction_->setToolTip(tr("Make manipulator smaller. <Mouse wheel up>"));
264  whatsThisUser.setWhatsThis(smallerManipAction_,tr("Resize the Manipulator to a smaller one."),"man_resizing","manipulator.html");
265  smallerManipAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-manipsmall.png") );
266  smallerManipAction_->setCheckable(false);
267  pickToolbar_->addAction(smallerManipAction_);
268 
269  biggerManipAction_ = new QAction(tr("Increase size of manipulator"), pickToolBarActions_);
270  biggerManipAction_->setStatusTip(tr("Make manipulator bigger. <Mouse wheel down>"));
271  biggerManipAction_->setToolTip(tr("Make manipulator bigger. <Mouse wheel down>"));
272  whatsThisUser.setWhatsThis(biggerManipAction_,tr("Resize the Manipulator to a bigger one."),"man_resizing","manipulator.html");
273  biggerManipAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-manipbig.png") );
274  biggerManipAction_->setCheckable(false);
275  pickToolbar_->addAction(biggerManipAction_);
276 
277  connect(pickToolBarActions_, SIGNAL(triggered(QAction*)), this, SLOT(slotPickToolbarAction(QAction*)) );
278 #if defined(ARCH_DARWIN)
279  // Workaround for QPainter using an unsupported rendering backend on core profiles
280  // See https://bugreports.qt.io/browse/QTBUG-32639
281  // setting opacity to a value smaller than 1 forces rasterizer engine
282  pickToolbar_->setWindowOpacity(0.99);
283 #endif
284  emit setPickModeToolbar ("Move", pickToolbar_);
285  emit setPickModeToolbar ("MoveSelection", pickToolbar_);
286 
287  // ==================================
288  // CONTEXT MENU
289  // ==================================
290  toAllTargets_ = new QAction(tr("Apply to all targets"), this);
291  toAllTargets_->setCheckable(true);
292  toAllTargets_->setToolTip(tr("Apply transformation to all target objects"));
293  toAllTargets_->setStatusTip( toAllTargets_->toolTip() );
294 
295  contextAction_ = new QAction(tr("Set properties"), this);
296  contextAction_->setToolTip(tr("Set properties"));
297  contextAction_->setStatusTip( contextAction_->toolTip() );
298  contextAction_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-properties.png") );
299 
300  contextActionHide_ = new QAction(tr("Hide Manipulator"), this);
301  contextActionHide_->setToolTip(tr("Hide Manipulator"));
302  contextActionHide_->setStatusTip( contextActionHide_->toolTip() );
303  contextActionHide_->setIcon(QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-hide.png") );
304 
305  // QMenu replicating the relevant pick toolbar actions
306  contextMenuManipControl_ = new QMenu(tr("Manipulator Controls"));
307  contextMenuManipControl_->addAction(rotateTranslateAction_);
308  contextMenuManipControl_->addAction(resizeAction_);
309  contextMenuManipControl_->addAction(rotateManipAction_);
310  contextMenuManipControl_->addAction(placeAndSnapAction_);
311  contextMenuManipControl_->addAction(smallerManipAction_);
312  contextMenuManipControl_->addAction(biggerManipAction_);
313 
314 
315  contextMenuManipControlsAction_ = contextMenuManipControl_->menuAction();
316 
317  emit addContextMenuItem(toAllTargets_ , CONTEXTNODEMENU );
318  emit addContextMenuItem(contextAction_ , CONTEXTNODEMENU );
319  emit addContextMenuItem(contextActionHide_ , CONTEXTNODEMENU );
320  emit addContextMenuItem(contextMenuManipControlsAction_ , CONTEXTNODEMENU );
321 
322  connect( toAllTargets_ , SIGNAL(toggled(bool) ), this, SLOT(setAllTargets(bool)));
323  connect( contextAction_ , SIGNAL( triggered() ), this, SLOT(showProps()) );
324  connect( contextActionHide_ , SIGNAL( triggered() ), this, SLOT(hideManipulator()) );
325 }
326 
327 
328 /*******************************************************************************
329  ToolBoxInterface implementation
330  *******************************************************************************/
331 
332 void MovePlugin::initializePlugin()
333 {
334  toolboxActive_ = false;
335  tool_ = new moveToolbarWidget();
336 
337  connect(tool_->moveToOrigin,SIGNAL(clicked() ),this,SLOT(slotMoveToOrigin()));
338 
339  tool_->moveToOrigin->setIcon( QIcon(OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator() + "moveToCOG.png") );
340  tool_->moveToOrigin->setIconSize(QSize(48,48));
341  WhatsThisGenerator whatsThis("Move");
342  tool_->moveToOrigin->setWhatsThis(QString(tr("Moves the selected objects such that their center of gravity is at the origin."))
343  +whatsThis.generateLink("move_cog"));
344 
345  connect(tool_->unifyBoundingBoxDiagonal,SIGNAL(clicked() ),this,SLOT(slotUnifyBoundingBoxDiagonal()));
346  tool_->unifyBoundingBoxDiagonal->setIcon( QIcon(OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator() + "unifyBB.png") );
347  tool_->unifyBoundingBoxDiagonal->setIconSize(QSize(48,48));
348  tool_->unifyBoundingBoxDiagonal->setWhatsThis(QString(tr("Rescale objects such that its bounding box diagonal has length one."))
349  +whatsThis.generateLink("unifyBB"));
350 
351  connect(tool_->unifyBoundingBoxLongest,SIGNAL(clicked() ),this,SLOT(slotUnifyBoundingBoxLongestAxis()));
352  tool_->unifyBoundingBoxLongest->setIcon( QIcon(OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator() + "unifyBB_longest.png") );
353  tool_->unifyBoundingBoxLongest->setIconSize(QSize(48,48));
354 
355  connect(tool_->unifyBoundingBoxAll,SIGNAL(clicked() ),this,SLOT(slotUnifyBoundingBoxAllAxis()));
356  tool_->unifyBoundingBoxAll->setIcon( QIcon(OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator() + "unifyBB_all.png") );
357  tool_->unifyBoundingBoxAll->setIconSize(QSize(48,48));
358 
359  lastActiveManipulator_ = -1;
360 
361  toolIcon_ = new QIcon(OpenFlipper::Options::iconDirStr()+OpenFlipper::Options::dirSeparator()+"move-toolBox.png");
362  emit addToolbox( tr("Move") , tool_, toolIcon_ );
363 }
364 
365 
366 /*******************************************************************************
367  MouseInterface implementation
368  *******************************************************************************/
369 
370 void MovePlugin::slotMouseWheelEvent(QWheelEvent * _event, const std::string & /*_mode*/)
371 {
372  // Skip execution if this is not our pick mode
373  if( ( (PluginFunctions::pickMode() != "Move")
374  && (PluginFunctions::pickMode() != "MoveSelection") )
375  || PluginFunctions::actionMode() != Viewer::PickingMode)
376  return;
377 
378  // compute the manipulator size modifier based on the mouse wheel change
379  manip_size_modifier_ = manip_size_modifier_ - (float)_event->delta() / 120.0 * 0.1;
380 
381  //dont scroll into negative sizes
382  if (manip_size_modifier_ < 0.0)
383  manip_size_modifier_ = 0.0;
384 
385  // Resize all manipulators based on the modifier on all objects
386  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it)
387  o_it->manipulatorNode()->set_size(manip_size_ * manip_size_modifier_);
388 
389  // Redraw scene with updated manipulators
390  emit updateView();
391 }
392 
393 
394 //------------------------------------------------------------------------------
395 
400 void MovePlugin::slotMouseEvent(QMouseEvent* _event) {
401  if (((PluginFunctions::pickMode() == ("Move"))
402  || (PluginFunctions::pickMode() == ("MoveSelection")))
403  && PluginFunctions::actionMode() == Viewer::PickingMode) {
404 
405  if (_event->type() == QEvent::MouseButtonDblClick || (_event->type() == QEvent::MouseButtonPress
406  && _event->button() == Qt::LeftButton && (placeAction_->isChecked() || placeMode_))) {
407 
408  bool snap = (placeMode_ && (PluginFunctions::pickMode() == ("MoveSelection")));
409 
410  placeManip(_event, snap);
411  placeAction_->setChecked(false);
412  updateManipulatorDialog();
413 
414  if (placeMode_) {
415  manMode_ = QtTranslationManipulatorNode::TranslationRotation;
416 
417  for (PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS); o_it
418  != PluginFunctions::objectsEnd(); ++o_it)
419  if (o_it->manipPlaced())
420  o_it->manipulatorNode()->setMode(manMode_);
421 
422  resizeAction_->setChecked(false);
423  rotateManipAction_->setChecked(false);
424  rotateTranslateAction_->setChecked(true);
425  placeAndSnapAction_->setChecked(false);
426  }
427 
428  placeMode_ = false;
429  return;
430 
431  } else if (placeMode_) {
432 
433  /*
434  * Move manipulator along with cursor if placeAndSnap mode
435  * is active. Snap to nearest geometry element (vertex, line, face center)
436  * depending on which selection type is active.
437  *
438  */
439 
440  placeManip(_event, (PluginFunctions::pickMode() != ("Move")));
441  updateManipulatorDialog();
442  return;
443  }
444 
445  // interaction
446  ACG::SceneGraph::MouseEventAction action(_event,PluginFunctions::viewerProperties().glState());
447  PluginFunctions::traverse(action);
448 
449  if (_event->buttons() == Qt::LeftButton)
450  emit nodeVisibilityChanged(-1);
451 
452  }
453 }
454 
455 /*******************************************************************************
456  KeyInterface implementation
457  *******************************************************************************/
458 
459 void MovePlugin::slotKeyEvent (QKeyEvent* _event)
460 {
461  if ((_event->key() == Qt::Key_Control) && _event->modifiers() != Qt::ShiftModifier) {
462  setManipMode (QtTranslationManipulatorNode::Resize);
463  return;
464  } else if ((_event->key () == Qt::Key_Shift) && _event->modifiers() != Qt::ControlModifier) {
465  setManipMode (QtTranslationManipulatorNode::LocalRotation);
466  return;
467  }
468 
469  // Return to normal mode if Ctrl + Shift is pressed since this
470  // is used in translation manipulator node for rotation rasterization
471  setManipMode (QtTranslationManipulatorNode::TranslationRotation);
472 }
473 
474 //------------------------------------------------------------------------------
475 
476 void MovePlugin::slotEnableSelectionMode()
477 {
478  PluginFunctions::pickMode("MoveSelection");
479 }
480 
481 //------------------------------------------------------------------------------
482 void MovePlugin::slotEnableObjectMode()
483 {
484  PluginFunctions::pickMode("Move");
485 }
486 //------------------------------------------------------------------------------
487 
488 void MovePlugin::slotKeyReleaseEvent (QKeyEvent* _event)
489 {
490  if ((_event->key() == Qt::Key_Control && manMode_ == QtTranslationManipulatorNode::Resize) ||
491  (_event->key() == Qt::Key_Shift && manMode_ == QtTranslationManipulatorNode::LocalRotation))
492  setManipMode (QtTranslationManipulatorNode::TranslationRotation);
493 }
494 
495 void MovePlugin::setPickModeProps(movePropsWidget* _pW, const std::string &_pickmode)
496 {
497  if (_pickmode == "Move")
498  {
499  _pW->objectRadioButton->setChecked(true);
500  }
501  else if (_pickmode == "MoveSelection")
502  {
503  _pW->selectionRadioButton->setChecked(true);
504  }
505  else
506  {
507  //not supported, so deselect all radio buttons
508  _pW->objectRadioButton->setAutoExclusive(false);
509  _pW->selectionRadioButton->setAutoExclusive(false);
510  _pW->objectRadioButton->setChecked(false);
511  _pW->selectionRadioButton->setChecked(false);
512  _pW->objectRadioButton->setAutoExclusive(true);
513  _pW->selectionRadioButton->setAutoExclusive(true);
514  }
515 }
516 
517 /*******************************************************************************
518  PickingInterface implementation
519  *******************************************************************************/
520 
525 void MovePlugin::slotPickModeChanged( const std::string& _mode)
526 {
527  moveAction_->setChecked(_mode == "Move");
528  moveSelectionAction_->setChecked(_mode == "MoveSelection");
529 
530  hide_ = !(_mode == "Move" || _mode == "MoveSelection");
531 
532  showManipulators();
533 
534  if (!hide_)
535  {
536  switch (manMode_)
537  {
538  case QtTranslationManipulatorNode::Rotation:
539  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
540  break;
541  case QtTranslationManipulatorNode::Resize:
542  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
543  break;
544  case QtTranslationManipulatorNode::LocalRotation:
545  PluginFunctions::setViewObjectMarker (&objectMarker_);
546  break;
547  case QtTranslationManipulatorNode::Place:
548  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
549  break;
550  case QtTranslationManipulatorNode::TranslationRotation:
551  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
552  break;
553  }
554  }
555  else
556  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
557 
558  //change the selection mode in propety widget
559  for (int i = 0; i < propsWindows_.size(); ++i)
560  setPickModeProps(propsWindows_[i], _mode);
561 
562 }
563 
564 
565 /*******************************************************************************
566  MovePlugin implementation
567  *******************************************************************************/
568 
574 void MovePlugin::moveObject(ACG::Matrix4x4d mat, int _id) {
575  BaseObjectData* object;
576  if ( ! PluginFunctions::getObject(_id,object) )
577  return;
578 
579  if ( mat.is_identity() )
580  return;
581 
582  if ( object->dataType() == DATA_TRIANGLE_MESH ) {
583  transformMesh(mat , *PluginFunctions::triMesh(object) );
584  } else if ( object->dataType() == DATA_POLY_MESH ) {
585  transformMesh(mat , *PluginFunctions::polyMesh(object) );
586 #ifdef ENABLE_TSPLINEMESH_SUPPORT
587  } else if ( object->dataType() == DATA_TSPLINE_MESH ) {
588  transformMesh(mat , *PluginFunctions::tsplineMesh(object) );
589 #endif
590 #ifdef ENABLE_POLYLINE_SUPPORT
591  } else if ( object->dataType() == DATA_POLY_LINE ) {
592  transformPolyLine(mat , *PluginFunctions::polyLine(object) );
593 #endif
594 #ifdef ENABLE_SKELETON_SUPPORT
595  } else if ( object->dataType() == DATA_SKELETON ) {
596  transformSkeleton(mat , *PluginFunctions::skeleton(object) );
597 #endif
598 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
599  } else if ( object->dataType() == DATA_HEXAHEDRAL_MESH ) {
600  HexahedralMeshObject* obj = PluginFunctions::hexahedralMeshObject(object);
601  transformVolumeMesh(mat , *obj->mesh() , obj->normals() );
602 #endif
603 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
604  } else if ( object->dataType() == DATA_TETRAHEDRAL_MESH ) {
605  TetrahedralMeshObject* obj = PluginFunctions::tetrahedralMeshObject(object);
606  transformVolumeMesh(mat , *obj->mesh() , obj->normals() );
607 #endif
608 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
609  } else if ( object->dataType() == DATA_POLYHEDRAL_MESH ) {
610  PolyhedralMeshObject* obj = PluginFunctions::polyhedralMeshObject(object);
611  transformVolumeMesh(mat , *obj->mesh() , obj->normals() );
612 #endif
613  } else if ( object->dataType() == DATA_PLANE ) {
614  PluginFunctions::plane(object)->transform(mat);
615  } else {
616 
617  emit log(LOGERR,tr("moveObject called for unsupported Object Type"));
618  return;
619  }
620 
621  emit updatedObject(_id, UPDATE_GEOMETRY);
622  emit createBackup(_id, "Move Object", UPDATE_GEOMETRY);
623 }
624 
625 
626 //------------------------------------------------------------------------------
627 
638 void MovePlugin::moveSelection(ACG::Matrix4x4d _mat, int _id, QEvent::Type _type) {
639  // Get currently active primitive type
640  updateSelectionType();
641 
642  if ( !_mat.is_identity() ){
643  if (selectionType_ & VERTEX) {
644  transformedSelected_ = transformVertexSelection( _id , _mat );
645  }
646  if (selectionType_ & FACE) {
647  transformedSelected_ = transformFaceSelection( _id , _mat );
648  }
649  if (selectionType_ & EDGE) {
650  transformedSelected_ = transformEdgeSelection( _id , _mat );
651  }
652  if (selectionType_ & CELL) {
653  transformedSelected_ = transformCellSelection( _id , _mat );
654  }
655 
656  emit updatedObject(_id, UPDATE_GEOMETRY);
657  }
658 
659  //only create backups on mouseRelease and something has to have been selected and transformed
660  if ( _type == QEvent::MouseButtonRelease && transformedSelected_ )
661  emit createBackup(_id,"Move Selection", UPDATE_GEOMETRY);
662 
663 }
664 
665 //------------------------------------------------------------------------------
666 
671 void MovePlugin::setManipMode (QtTranslationManipulatorNode::ManipulatorMode _mode)
672 {
673  if (_mode != manMode_)
674  {
675  manMode_ = _mode;
676 
677  // Iterate over all objects that have a placed manip and set their mode
678  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it)
679  if ( o_it->manipPlaced() )
680  o_it->manipulatorNode()->setMode (_mode);
681 
682 
683  if (!hide_) {
684  switch (manMode_)
685  {
686  case QtTranslationManipulatorNode::Rotation:
687  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
688  placeMode_ = false;
689  break;
690  case QtTranslationManipulatorNode::Resize:
691  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
692  placeMode_ = false;
693  break;
694  case QtTranslationManipulatorNode::LocalRotation:
695  PluginFunctions::setViewObjectMarker (&objectMarker_);
696  placeMode_ = false;
697  break;
698  case QtTranslationManipulatorNode::Place:
699  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
700  placeMode_ = true;
701  break;
702  case QtTranslationManipulatorNode::TranslationRotation:
703  PluginFunctions::setViewObjectMarker (PluginFunctions::defaultViewObjectMarker ());
704  placeMode_ = false;
705  break;
706  }
707  }
708 
709  // Update the toolbar icons
710  switch (manMode_)
711  {
712  case QtTranslationManipulatorNode::Resize:
713  resizeAction_->setChecked (true);
714  rotateManipAction_->setChecked (false);
715  rotateTranslateAction_->setChecked (false);
716  placeAndSnapAction_->setChecked (false);
717  break;
718  case QtTranslationManipulatorNode::LocalRotation:
719  resizeAction_->setChecked (false);
720  rotateManipAction_->setChecked (true);
721  rotateTranslateAction_->setChecked (false);
722  placeAndSnapAction_->setChecked (false);
723  break;
724  case QtTranslationManipulatorNode::TranslationRotation:
725  resizeAction_->setChecked (false);
726  rotateManipAction_->setChecked (false);
727  rotateTranslateAction_->setChecked (true);
728  placeAndSnapAction_->setChecked (false);
729  break;
730  case QtTranslationManipulatorNode::Place:
731  resizeAction_->setChecked (false);
732  rotateManipAction_->setChecked (false);
733  rotateTranslateAction_->setChecked (false);
734  placeAndSnapAction_->setChecked (true);
735  break;
736  case QtTranslationManipulatorNode::Rotation:
737  resizeAction_->setChecked(false);
738  rotateManipAction_->setChecked(true);
739  rotateTranslateAction_->setChecked(false);
740  placeAndSnapAction_->setChecked(false);
741  break;
742  }
743  }
744 }
745 
746 //------------------------------------------------------------------------------
747 
748 
753 void MovePlugin::slotUpdateContextMenuNode(int _nodeId) {
754 
755  ACG::SceneGraph::BaseNode* node = ACG::SceneGraph::find_node(PluginFunctions::getSceneGraphRootNode(), _nodeId);
756 
757  if (node == 0)
758  return;
759 
760  if (node->className() != "QtTranslationManipulatorNode") {
761  contextAction_->setVisible(false);
762  } else {
763  contextAction_->setVisible(true);
764  }
765 }
766 
767 //------------------------------------------------------------------------------
768 
774 void MovePlugin::manipulatorMoved( QtTranslationManipulatorNode* _node , QMouseEvent* _event) {
775 
776  // React on event only in move mode
777  if ( PluginFunctions::pickMode() != "Move"
778  && PluginFunctions::pickMode() != "MoveSelection" )
779  return;
780 
781  OpenFlipper::Options::redrawDisabled( true );
782 
783  // Apply changes only on Release for moveMode and after every movement in MoveSelection Mode
784  if ( !placeMode_ && ((_event->type() == QEvent::MouseButtonRelease) ||
785  (PluginFunctions::pickMode() != "Move" && _event->buttons() != Qt::NoButton)) ) {
786 
787  int objectId = _node->getIdentifier();
788 
789  ACG::Matrix4x4d mat;
790  mat.identity();
791  mat = _node->matrix();
792 
793  // Reset Node
794  _node->loadIdentity();
795  _node->set_center(mat.transform_point(_node->center()));
796 
797  // move the object which corresponds to the manipulator
798  if (PluginFunctions::pickMode() == "Move")
799  moveObject( mat, objectId );
800  else if (PluginFunctions::pickMode() == "MoveSelection")
801  moveSelection( mat, objectId, _event->type() );
802 
803  // move all other targets without manipulator
804  if(allTargets_) {
805  for (PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS); o_it
806  != PluginFunctions::objectsEnd(); ++o_it) {
807  if ((o_it->id() != objectId) && !o_it->manipulatorNode()->draw_manipulator()) { // If it has its own manipulator active, dont move it
808 
809  // move the object which corresponds to the manipulator
810  if (PluginFunctions::pickMode() == "Move")
811  moveObject( mat, o_it->id() );
812  else if (PluginFunctions::pickMode() == "MoveSelection")
813  moveSelection( mat, o_it->id(), _event->type() );
814  }
815  }
816  }
817 
818  lastActiveManipulator_ = objectId;
819  updateManipulatorDialog();
820  }
821 
822  OpenFlipper::Options::redrawDisabled( false );
823 }
824 
825 
826 //------------------------------------------------------------------------------
827 
832 void MovePlugin::ManipulatorPositionChanged(QtTranslationManipulatorNode* _node ) {
833 
834  // Position has been changed of the manipulator by a direct function
835  int objectId = _node->getIdentifier();
836 
837  if ( objectId > 0 ){
838 
839  BaseObjectData* object;
840  PluginFunctions::getObject(objectId,object);
841 
842  // Assume that it has a good position now
843  object->manipPlaced( true );
844  }
845 
846  // Show manipulator only if in Move mode
847  if ( PluginFunctions::pickMode() == "Move" )
848  _node->show();
849 
850  lastActiveManipulator_ = objectId;
851  updateManipulatorDialog();
852 
853 }
854 
855 
856 //------------------------------------------------------------------------------
857 
863 void MovePlugin::placeManip(QMouseEvent * _event, bool _snap) {
864  size_t node_idx, target_idx;
865  OpenMesh::Vec3d hitPoint;
866  BaseObjectData* object;
867 
868  bool successfullyPicked = false;
869 
870 
871 
872  /*
873  * Snap manipulator to nearest geometry
874  * element depending on which selection type is
875  * active.
876  */
877  if (_snap) {
878 
879  successfullyPicked = PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(), node_idx,
880  target_idx, &hitPoint) && PluginFunctions::getPickedObject(node_idx, object);
881 
882  if(!successfullyPicked) {
883  //emit log(LOGWARN, tr("Picking failed"));
884  return;
885  }
886 
887  if (selectionType_ == VERTEX) {
888  if ( object->dataType(DATA_TRIANGLE_MESH) ) {
889  hitPoint = getNearestVertex(PluginFunctions::triMesh(object), target_idx, hitPoint);
890  } else if ( object->dataType(DATA_POLY_MESH) ) {
891  hitPoint = getNearestVertex(PluginFunctions::polyMesh(object), target_idx, hitPoint);
892 #ifdef ENABLE_TSPLINEMESH_SUPPORT
893  } else if ( object->dataType(DATA_TSPLINE_MESH) ) {
894  hitPoint = getNearestVertex(PluginFunctions::tsplineMesh(object), target_idx, hitPoint);
895 #endif
896  }
897  } else if (selectionType_ == EDGE) {
898  if ( object->dataType(DATA_TRIANGLE_MESH) ) {
899  hitPoint = getNearestEdge(PluginFunctions::triMesh(object), target_idx, hitPoint);
900  } else if ( object->dataType(DATA_POLY_MESH) ) {
901  hitPoint = getNearestEdge(PluginFunctions::polyMesh(object), target_idx, hitPoint);
902 #ifdef ENABLE_TSPLINEMESH_SUPPORT
903  } else if ( object->dataType(DATA_TSPLINE_MESH) ) {
904  hitPoint = getNearestEdge(PluginFunctions::tsplineMesh(object), target_idx, hitPoint);
905 #endif
906  }
907  } else if (selectionType_ == FACE) {
908  if ( object->dataType(DATA_TRIANGLE_MESH) ) {
909  hitPoint = getNearestFace(PluginFunctions::triMesh(object), target_idx, hitPoint);
910  } else if ( object->dataType(DATA_POLY_MESH) ) {
911  hitPoint = getNearestFace(PluginFunctions::polyMesh(object), target_idx, hitPoint);
912 #ifdef ENABLE_TSPLINEMESH_SUPPORT
913  } else if ( object->dataType(DATA_TSPLINE_MESH) ) {
914  hitPoint = getNearestFace(PluginFunctions::tsplineMesh(object), target_idx, hitPoint);
915 #endif
916  }
917  }
918 
919  } else {
920  successfullyPicked = PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_ANYTHING, _event->pos(), node_idx,
921  target_idx, &hitPoint) && PluginFunctions::getPickedObject(node_idx, object);
922  }
923 
924  if (successfullyPicked) {
925 
926  object->manipPlaced(true);
927 
928  object->manipulatorNode()->loadIdentity();
929  object->manipulatorNode()->set_center(hitPoint);
930  object->manipulatorNode()->set_draw_cylinder(true);
931  object->manipulatorNode()->set_autosize(QtTranslationManipulatorNode::Once);
932  object->manipulatorNode()->set_size(manip_size_ * manip_size_modifier_);
933  object->manipulatorNode()->setMode(manMode_);
934  object->manipulatorNode()->show();
935 
936  object->manipulatorNode()->apply_transformation(PluginFunctions::pickMode() == "Move");
937 
938  // Disconnect a previously connected Signal
939  disconnect(object->manipulatorNode() , SIGNAL(manipulatorMoved(QtTranslationManipulatorNode*,QMouseEvent*)),
940  this , SLOT( manipulatorMoved(QtTranslationManipulatorNode*,QMouseEvent*)));
941 
942  disconnect(object->manipulatorNode() , SIGNAL(positionChanged(QtTranslationManipulatorNode*)),
943  this , SLOT( ManipulatorPositionChanged(QtTranslationManipulatorNode*)));
944 
945  // Reconnect the signals.
946  connect(object->manipulatorNode() , SIGNAL(manipulatorMoved(QtTranslationManipulatorNode*,QMouseEvent*)),
947  this , SLOT( manipulatorMoved(QtTranslationManipulatorNode*,QMouseEvent*)));
948 
949  connect(object->manipulatorNode() , SIGNAL(positionChanged(QtTranslationManipulatorNode*)),
950  this , SLOT( ManipulatorPositionChanged(QtTranslationManipulatorNode*)));
951 
952  lastActiveManipulator_ = object->id();
953 
954  emit updateView();
955 
956  bool found = false;
957 
958  for (uint i=0; i < activeManipulators_.size(); i++)
959  if ( activeManipulators_[i] == object->id() ){
960  found = true;
961  break;
962  }
963 
964  if ( !found )
965  activeManipulators_.push_back( object->id() );
966 
967  } else {
968  //emit log(LOGWARN, tr("Picking failed"));
969  }
970 }
971 
972 
973 //------------------------------------------------------------------------------
974 
978 void MovePlugin::showManipulators( )
979 {
980 
981  if (!hide_ && (toolboxActive_ || (PluginFunctions::pickMode() == "Move")
982  || (PluginFunctions::pickMode() == "MoveSelection"))) {
983 
984  for (uint i=0; i < activeManipulators_.size(); i++){
985 
986  BaseObjectData* obj = 0;
987 
988  PluginFunctions::getObject( activeManipulators_[i], obj );
989 
990  if (obj != 0 && obj->manipPlaced()) {
991  obj->manipulatorNode()->show();
992  obj->manipulatorNode()->apply_transformation( PluginFunctions::pickMode() == "Move" );
993  emit nodeVisibilityChanged(obj->id());
994  }
995  }
996 
997  } else {
998 
999  for (uint i=0; i < activeManipulators_.size(); i++){
1000 
1001  BaseObjectData* obj = 0;
1002 
1003  PluginFunctions::getObject( activeManipulators_[i], obj );
1004 
1005  if ( obj != 0 ) {
1006  obj->manipulatorNode()->hide();
1007  emit nodeVisibilityChanged(obj->id());
1008  }
1009  }
1010  }
1011 
1012  emit updateView();
1013 
1014 }
1015 
1016 //------------------------------------------------------------------------------
1017 
1022 movePropsWidget* MovePlugin::getDialogFromButton(QPushButton* _but) {
1023 
1024  if(_but == 0) return 0;
1025  return dynamic_cast<movePropsWidget*>((((_but->parentWidget())->parentWidget())->parentWidget()));
1026 }
1027 //------------------------------------------------------------------------------
1028 
1032 void MovePlugin::slotSetPosition() {
1033 
1034  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1035  movePropsWidget* pW = getDialogFromButton(but);
1036  if(pW == 0) return;
1037 
1038  TriMesh::Point newpos;
1039 
1040  bool ok = false;
1041  newpos[0] = (pW->nposx->text()).toDouble(&ok);
1042  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for X Coordinate")); return; }
1043  newpos[1] = (pW->nposy->text()).toDouble(&ok);
1044  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Y Coordinate")); return; }
1045  newpos[2] = (pW->nposz->text()).toDouble(&ok);
1046  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Z Coordinate")); return; }
1047 
1048  BaseObjectData* object;
1049  if ( PluginFunctions::getObject(lastActiveManipulator_ , object) ) {
1050  if ( object->manipulatorNode()->visible() ) {
1051  // Compute translation vector
1052  ACG::Vec3d translation = newpos;
1053  translation -= object->manipulatorNode()->center();
1054  object->manipulatorNode()->set_center(newpos);
1055  // Stuff it into transformation matrix
1056  ACG::GLMatrixd m;
1057  m.identity();
1058  m.translate(translation);
1059  if (PluginFunctions::pickMode() == "Move")
1060  {
1061  // ...and transform mesh
1062  if(object->dataType() == DATA_TRIANGLE_MESH)
1063  transformMesh(m, *PluginFunctions::triMesh(object));
1064  else if(object->dataType() == DATA_POLY_MESH)
1065  transformMesh(m, *PluginFunctions::polyMesh(object));
1066 
1067  // Create backup
1068  emit createBackup(object->id(), "Object Translation");
1069 
1070  }
1071  else if (PluginFunctions::pickMode() == "MoveSelection")
1072  {
1073  updateSelectionType();
1074  if (selectionType_ & VERTEX) {
1075  transformVertexSelection(object->id(), m);
1076  }
1077  if (selectionType_ & FACE) {
1078  transformFaceSelection(object->id(), m);
1079  }
1080  if (selectionType_ & EDGE) {
1081  transformEdgeSelection(object->id(), m);
1082  }
1083 
1084  // Create backup
1085  emit createBackup(object->id(), "Translation of selection");
1086  }
1087 
1088 
1089  emit updatedObject(object->id(), UPDATE_GEOMETRY);
1090  }
1091  updateManipulatorDialog();
1092  emit updateView();
1093  }
1094 }
1095 
1096 
1097 //------------------------------------------------------------------------------
1098 
1102 void MovePlugin::slotToggleAxisA() {
1103 
1104  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1105  movePropsWidget* pW = getDialogFromButton(but);
1106  if(pW == 0) return;
1107 
1108  axisA_ = (axisA_ + 1) % 3;
1109 
1110  if (axisA_ == axisB_)
1111  axisA_ = (axisA_ + 1) % 3;
1112 
1113  switch(axisA_){
1114  case 0: pW->axisAButton->setText(tr("X Direction")); break;
1115  case 1: pW->axisAButton->setText(tr("Y Direction")); break;
1116  case 2: pW->axisAButton->setText(tr("Z Direction")); break;
1117  default: break;
1118  }
1119 }
1120 
1121 
1122 //------------------------------------------------------------------------------
1123 
1127 void MovePlugin::slotToggleAxisB() {
1128 
1129  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1130  movePropsWidget* pW = getDialogFromButton(but);
1131  if(pW == 0) return;
1132 
1133  axisB_ = (axisB_ + 1) % 3;
1134 
1135  if (axisA_ == axisB_)
1136  axisB_ = (axisB_ + 1) % 3;
1137 
1138  switch(axisB_){
1139  case 0: pW->axisBButton->setText(tr("X Direction")); break;
1140  case 1: pW->axisBButton->setText(tr("Y Direction")); break;
1141  case 2: pW->axisBButton->setText(tr("Z Direction")); break;
1142  default: break;
1143  }
1144 }
1145 
1146 
1147 //------------------------------------------------------------------------------
1148 
1152 void MovePlugin::slotSetDirection() {
1153 
1154  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1155  movePropsWidget* pW = getDialogFromButton(but);
1156  if(pW == 0) return;
1157 
1158  ACG::Vec3d newdirA,newdirB;
1159  ACG::Vec3d dirX,dirY;
1160  ACG::Vec3d dirZ(0.0,0.0,0.0);
1161 
1162  bool ok = false;
1163  newdirA[0] = (pW->ndirAx->text()).toDouble(&ok);
1164  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for X Coordinate")); return; }
1165  newdirA[1] = (pW->ndirAy->text()).toDouble(&ok);
1166  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Y Coordinate")); return; }
1167  newdirA[2] = (pW->ndirAz->text()).toDouble(&ok);
1168  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Z Coordinate")); return; }
1169 
1170  newdirB[0] = (pW->ndirBx->text()).toDouble(&ok);
1171  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for X Coordinate")); return; }
1172  newdirB[1] = (pW->ndirBy->text()).toDouble(&ok);
1173  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Y Coordinate")); return; }
1174  newdirB[2] = (pW->ndirBz->text()).toDouble(&ok);
1175  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Z Coordinate")); return; }
1176 
1177  bool xAxis = false;
1178  bool yAxis = false;
1179 
1180  switch(axisA_){
1181  case 0: dirX = newdirA; xAxis = true; break;
1182  case 1: dirY = newdirA; yAxis = true; break;
1183  default: dirZ = newdirA; break;
1184  }
1185 
1186  switch(axisB_){
1187  case 0: dirX = newdirB; xAxis = true; break;
1188  case 1: dirY = newdirB; yAxis = true; break;
1189  default: dirZ = newdirB; break;
1190  }
1191 
1192  if (!xAxis)
1193  dirX = dirY % dirZ;
1194 
1195  if (!yAxis)
1196  dirY = dirX % dirZ;
1197 
1198 
1199  if ( (dirX | dirY) != 0.0){
1200  emit log(LOGERR,tr("The axes of the new direction have to be orthogonal"));
1201  return;
1202  }
1203 
1204 // // Apply to All Target Objects
1205 // if ( pW->targetObjects->isChecked() ) {
1206 // for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ;
1207 // o_it PluginFunctions::objectsEnd(); ++o_it){
1208 //
1209 // o_it->manipulatorNode()->set_direction( dirX, dirY );
1210 // }
1211 // }
1212 
1213 
1214  BaseObjectData* object = 0;
1215  PluginFunctions::getObject(pW->getBaseObjectDataId(),object);
1216  if ( object != 0 ) {
1217  if ( object->manipulatorNode()->visible() ){
1218 
1219  object->manipulatorNode()->set_direction( dirX, dirY );
1220  }
1221  } else return;
1222 
1223  updateManipulatorDialog();
1224  emit updateView();
1225 }
1226 
1227 
1228 //------------------------------------------------------------------------------
1229 
1233 void MovePlugin::slotTranslation() {
1234 
1235  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1236  movePropsWidget* pW = getDialogFromButton(but);
1237  if(pW == 0) return;
1238 
1239  ACG::Vec3d translation;
1240 
1241  bool ok = false;
1242  translation[0] = (pW->translationX->text()).toDouble(&ok);
1243  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for X Coordinate")); return; }
1244  translation[1] = (pW->translationY->text()).toDouble(&ok);
1245  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Y Coordinate")); return; }
1246  translation[2] = (pW->translationZ->text()).toDouble(&ok);
1247  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Z Coordinate")); return; }
1248 
1249  BaseObjectData* object = 0;
1250  PluginFunctions::getObject(pW->getBaseObjectDataId(),object);
1251 
1252  if (object != 0) {
1253  if (object->manipulatorNode()->visible()) {
1254 
1255  object->manipulatorNode()->set_center(
1256  object->manipulatorNode()->center() + translation);
1257 
1258  if (PluginFunctions::pickMode() == "Move")
1259  {
1260 
1261  translate(object->id(), translation);
1262 
1263  // Create backup
1264  emit createBackup(object->id(), "Translation of Object");
1265 
1266  }
1267  else if (PluginFunctions::pickMode() == "MoveSelection")
1268  {
1269  updateSelectionType();
1270  if (selectionType_ & VERTEX) {
1271  translateVertexSelection(object->id(), translation);
1272  }
1273  if (selectionType_ & FACE) {
1274  translateFaceSelection(object->id(), translation);
1275  }
1276  if (selectionType_ & EDGE) {
1277  translateEdgeSelection(object->id(), translation);
1278  }
1279  emit createBackup(object->id(), "Translation of selection");
1280  }
1281 
1282 
1283 
1284  emit updatedObject(object->id(), UPDATE_GEOMETRY);
1285 
1286 
1287  // move all other targets without manipulator
1288  if(allTargets_) {
1289 
1290  for (PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS); o_it
1291  != PluginFunctions::objectsEnd(); ++o_it) {
1292  if ((o_it->id() != object->id()) && !o_it->manipulatorNode()->draw_manipulator()) { // If it has its own manipulator active, dont move it
1293  if (PluginFunctions::pickMode() == "Move") {
1294 
1295  translate(o_it->id(), translation);
1296 
1297  // Create backup
1298  emit createBackup(o_it->id(), "Translation of object");
1299 
1300  } else if (PluginFunctions::pickMode() == "MoveSelection") {
1301  updateSelectionType();
1302  if (selectionType_ & VERTEX) {
1303  translateVertexSelection(o_it->id(), translation);
1304  }
1305  if (selectionType_ & FACE) {
1306  translateFaceSelection(o_it->id(), translation);
1307  }
1308  if (selectionType_ & EDGE) {
1309  translateEdgeSelection(o_it->id(), translation);
1310  }
1311 
1312  emit createBackup(o_it->id(), "Translation of selection");
1313  }
1314 
1315 
1316  emit updatedObject(o_it->id(), UPDATE_GEOMETRY);
1317  }
1318  }
1319 
1320  }
1321  }
1322  } else {
1323  return;
1324  }
1325 
1326 
1327  updateManipulatorDialog();
1328  emit scriptInfo(QString("slotTranslation()"));
1329  emit updateView();
1330 }
1331 
1332 
1333 //------------------------------------------------------------------------------
1334 
1338 void MovePlugin::slotProjectToTangentPlane() {
1339 
1340  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1341  movePropsWidget* pW = getDialogFromButton(but);
1342  if(pW == 0) return;
1343 
1344  if ( allTargets_ ) {
1345  emit log(LOGWARN,tr("TODO Project for multiple targets"));
1346  return;
1347  } else {
1348  emit log(LOGWARN,tr("TODO Project for one target"));
1349  return;
1350  }
1351 
1352 }
1353 
1354 
1355 //------------------------------------------------------------------------------
1356 
1360 void MovePlugin::slotMoveManipToCOG() {
1361 
1362  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1363  movePropsWidget* pW = getDialogFromButton(but);
1364  if(pW == 0) return;
1365 
1366 
1367 // if ( pW->targetObjects->isChecked() ) {
1368 // for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it) {
1369 // if ( o_it->manipulatorNode()->hidden() )
1370 // continue;
1371 //
1372 // if ( o_it->dataType( DATA_TRIANGLE_MESH ) )
1373 // o_it->manipulatorNode()->set_center( MeshInfo::cog(*PluginFunctions::triMesh(*o_it) ) );
1374 // else if ( o_it->dataType( DATA_POLY_MESH ) )
1375 // o_it->manipulatorNode()->set_center( MeshInfo::cog(*PluginFunctions::polyMesh(*o_it)) );
1376 //
1377 // updateManipulatorDialog();
1378 // o_it->manipulatorNode()->loadIdentity();
1379 // }
1380 // } else {
1381 
1382  BaseObjectData* object = 0;
1383  PluginFunctions::getObject(pW->getBaseObjectDataId(),object);
1384  if ( object != 0 ) {
1385  if ( object->manipulatorNode()->visible() ){
1386 
1387  if ( object->dataType( DATA_TRIANGLE_MESH ) )
1388  object->manipulatorNode()->set_center( MeshInfo::cog(PluginFunctions::triMesh(object)) );
1389  else if ( object->dataType( DATA_POLY_MESH ) )
1390  object->manipulatorNode()->set_center( MeshInfo::cog(PluginFunctions::polyMesh(object)) );
1391 #ifdef ENABLE_TSPLINEMESH_SUPPORT
1392  else if ( object->dataType( DATA_TSPLINE_MESH ) )
1393  object->manipulatorNode()->set_center( MeshInfo::cog(PluginFunctions::tsplineMesh(object)) );
1394 #endif
1395 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1396  else if ( object->dataType( DATA_HEXAHEDRAL_MESH ) )
1397  object->manipulatorNode()->set_center( cogVolumeMesh(*PluginFunctions::hexahedralMesh(object)) );
1398 #endif
1399 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1400  else if ( object->dataType( DATA_TETRAHEDRAL_MESH ) )
1401  object->manipulatorNode()->set_center( cogVolumeMesh(*PluginFunctions::tetrahedralMesh(object)) );
1402 #endif
1403 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1404  else if ( object->dataType( DATA_POLYHEDRAL_MESH ) )
1405  object->manipulatorNode()->set_center( cogVolumeMesh(*PluginFunctions::polyhedralMesh(object)) );
1406 #endif
1407 
1408  updateManipulatorDialog();
1409  object->manipulatorNode()->loadIdentity();
1410  }
1411  }
1412 
1413  emit updateView();
1414 }
1415 
1416 
1417 //------------------------------------------------------------------------------
1418 
1422 void MovePlugin::slotRotate() {
1423 
1424  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1425  movePropsWidget* pW = getDialogFromButton(but);
1426  if(pW == 0) return;
1427 
1428  TriMesh::Point axis;
1429  double angle;
1430 
1431  bool ok = false;
1432  axis[0] = (pW->rotx->text()).toDouble(&ok);
1433  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for X Coordinate")); return; }
1434  axis[1] = (pW->roty->text()).toDouble(&ok);
1435  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Y Coordinate")); return; }
1436  axis[2] = (pW->rotz->text()).toDouble(&ok);
1437  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Z Coordinate")); return; }
1438 
1439  angle = (pW->rotAngle->text()).toDouble(&ok);
1440  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for Angle")); return; }
1441 
1442  BaseObjectData* object = 0;
1443  PluginFunctions::getObject(pW->getBaseObjectDataId(),object);
1444  if (object != 0) {
1445  if (object->manipulatorNode()->visible() && (object->target() || !allTargets_)) {
1446 
1447  object->manipulatorNode()->rotate(angle, axis);
1448 
1449  ACG::Matrix4x4d m = getLastManipulatorMatrix(true);
1450 
1451  if (PluginFunctions::pickMode() == "Move")
1452  {
1453  if (object->dataType(DATA_TRIANGLE_MESH))
1454  transformMesh(m, (*PluginFunctions::triMesh(object)));
1455 
1456  if (object->dataType(DATA_POLY_MESH))
1457  transformMesh(m, (*PluginFunctions::polyMesh(object)));
1458 
1459  #ifdef ENABLE_TSPLINEMESH_SUPPORT
1460  if (object->dataType(DATA_TSPLINE_MESH))
1461  transformMesh(m, (*PluginFunctions::tsplineMesh(object)));
1462  #endif
1463  #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1464  if (object->dataType(DATA_HEXAHEDRAL_MESH))
1465  transformVolumeMesh(m, (*PluginFunctions::hexahedralMesh(object)), (PluginFunctions::hexahedralMeshObject(object)->normals()));
1466  #endif
1467  #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1468  if (object->dataType(DATA_TETRAHEDRAL_MESH))
1469  transformVolumeMesh(m, (*PluginFunctions::tetrahedralMesh(object)), (PluginFunctions::tetrahedralMeshObject(object)->normals()));
1470  #endif
1471  #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1472  if (object->dataType(DATA_POLYHEDRAL_MESH))
1473  transformVolumeMesh(m, (*PluginFunctions::polyhedralMesh(object)), (PluginFunctions::polyhedralMeshObject(object)->normals()));
1474  #endif
1475 
1476  // Create backup
1477  emit createBackup(object->id(), "Rotation of object");
1478 
1479  }
1480  else if (PluginFunctions::pickMode() == "MoveSelection")
1481  {
1482  updateSelectionType();
1483  if (selectionType_ & VERTEX) {
1484  transformVertexSelection(object->id(), m);
1485  }
1486  if (selectionType_ & FACE) {
1487  transformFaceSelection(object->id(), m);
1488  }
1489  if (selectionType_ & EDGE) {
1490  transformEdgeSelection(object->id(), m);
1491  }
1492  if (selectionType_ & CELL) {
1493  transformCellSelection(object->id(), m);
1494  }
1495 
1496  // Create backup
1497  emit createBackup(object->id(), "Rotation of selection");
1498  }
1499 
1500  // move all other targets without manipulator
1501  if(allTargets_) {
1502 
1503  for (PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS); o_it != PluginFunctions::objectsEnd(); ++o_it) {
1504 
1505  // If it has its own manipulator active, don't move it
1506  if ((o_it->id() != object->id()) && !o_it->manipulatorNode()->draw_manipulator()) {
1507 
1508  if (PluginFunctions::pickMode() == "Move")
1509  {
1510  if (o_it->dataType(DATA_TRIANGLE_MESH))
1511  transformMesh(m, (*PluginFunctions::triMesh(o_it)));
1512 
1513  if (o_it->dataType(DATA_POLY_MESH))
1514  transformMesh(m, (*PluginFunctions::polyMesh(o_it)));
1515  #ifdef ENABLE_TSPLINEMESH_SUPPORT
1516  if (o_it->dataType(DATA_TSPLINE_MESH))
1517  transformMesh(m, (*PluginFunctions::tsplineMesh(o_it)));
1518  #endif
1519  #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1520  if (object->dataType(DATA_HEXAHEDRAL_MESH))
1521  transformVolumeMesh(m, (*PluginFunctions::hexahedralMesh(object)), (PluginFunctions::hexahedralMeshObject(object)->normals()));
1522  #endif
1523  #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1524  if (object->dataType(DATA_TETRAHEDRAL_MESH))
1525  transformVolumeMesh(m, (*PluginFunctions::tetrahedralMesh(object)), (PluginFunctions::tetrahedralMeshObject(object)->normals()));
1526  #endif
1527  #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1528  if (object->dataType(DATA_POLYHEDRAL_MESH))
1529  transformVolumeMesh(m, (*PluginFunctions::polyhedralMesh(object)), (PluginFunctions::polyhedralMeshObject(object)->normals()));
1530  #endif
1531 
1532  // Create backup
1533  emit createBackup(o_it->id(), "Rotation of object");
1534  }
1535  else if (PluginFunctions::pickMode() == "MoveSelection")
1536  {
1537  updateSelectionType();
1538  if (selectionType_ & VERTEX) {
1539  transformVertexSelection(o_it->id(), m);
1540  }
1541  if (selectionType_ & FACE) {
1542  transformFaceSelection(o_it->id(), m);
1543  }
1544  if (selectionType_ & EDGE) {
1545  transformEdgeSelection(o_it->id(), m);
1546  }
1547  if (selectionType_ & CELL) {
1548  transformCellSelection(o_it->id(), m);
1549  }
1550 
1551  // Create backup
1552  emit createBackup(o_it->id(), "Rotation of selection");
1553  }
1554 
1555  emit updatedObject(o_it->id(), UPDATE_GEOMETRY);
1556  }
1557  }
1558 
1559  }
1560 
1561  updateManipulatorDialog();
1562 
1563  emit updatedObject(object->id(), UPDATE_GEOMETRY);
1564 
1565  }
1566  }
1567 
1568  emit scriptInfo(QString("slotRotate()"));
1569  emit updateView();
1570 }
1571 
1572 
1573 //------------------------------------------------------------------------------
1574 
1578 void MovePlugin::slotScale() {
1579 
1580  QPushButton* but = dynamic_cast<QPushButton*>(QObject::sender());
1581  movePropsWidget* pW = getDialogFromButton(but);
1582  if(pW == 0) return;
1583 
1584 
1585  TriMesh::Point scale;
1586 
1587  bool ok = false;
1588  scale[0] = (pW->scalex->text()).toDouble(&ok);
1589  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for factor 1")); return; }
1590  scale[1] = (pW->scaley->text()).toDouble(&ok);
1591  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for factor 2")); return; }
1592  scale[2] = (pW->scalez->text()).toDouble(&ok);
1593  if ( !ok ) { emit log(LOGERR,tr("Wrong Format for factor 3")); return; }
1594 
1595  BaseObjectData* object = 0;
1596  PluginFunctions::getObject(pW->getBaseObjectDataId(),object);
1597  if (object != 0) {
1598  if (object->manipulatorNode()->visible() && (object->target()
1599  || !allTargets_)) {
1600 
1601  object->manipulatorNode()->scale(scale);
1602 
1603  ACG::Matrix4x4d m = getLastManipulatorMatrix(true);
1604 
1605  if (PluginFunctions::pickMode() == "Move")
1606  {
1607  if (object->dataType(DATA_TRIANGLE_MESH))
1608  transformMesh(m,(*PluginFunctions::triMesh(object)));
1609  if (object->dataType(DATA_POLY_MESH))
1610  transformMesh(m, (*PluginFunctions::polyMesh(object)));
1611  #ifdef ENABLE_TSPLINEMESH_SUPPORT
1612  if (object->dataType(DATA_TSPLINE_MESH))
1613  transformMesh(m, (*PluginFunctions::tsplineMesh(object)));
1614  #endif
1615  #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1616  if (object->dataType(DATA_HEXAHEDRAL_MESH))
1617  transformVolumeMesh(m, (*PluginFunctions::hexahedralMesh(object)), (PluginFunctions::hexahedralMeshObject(object)->normals()));
1618  #endif
1619  #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1620  if (object->dataType(DATA_TETRAHEDRAL_MESH))
1621  transformVolumeMesh(m, (*PluginFunctions::tetrahedralMesh(object)), (PluginFunctions::tetrahedralMeshObject(object)->normals()));
1622  #endif
1623  #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1624  if (object->dataType(DATA_POLYHEDRAL_MESH))
1625  transformVolumeMesh(m, (*PluginFunctions::polyhedralMesh(object)), (PluginFunctions::polyhedralMeshObject(object)->normals()));
1626  #endif
1627 
1628  // Create backup
1629  emit createBackup(object->id(), "Scaling of object");
1630  }
1631  else if (PluginFunctions::pickMode() == "MoveSelection")
1632  {
1633  updateSelectionType();
1634  if (selectionType_ & VERTEX) {
1635  transformVertexSelection(object->id(), m);
1636  }
1637  if (selectionType_ & FACE) {
1638  transformFaceSelection(object->id(), m);
1639  }
1640  if (selectionType_ & EDGE) {
1641  transformEdgeSelection(object->id(), m);
1642  }
1643  if (selectionType_ & CELL) {
1644  transformCellSelection(object->id(), m);
1645  }
1646 
1647  // Create backup
1648  emit createBackup(object->id(), "Scaling of selection");
1649  }
1650 
1651  // move all other targets without manipulator
1652  if(allTargets_) {
1653 
1654  for (PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS); o_it
1655  != PluginFunctions::objectsEnd(); ++o_it) {
1656  if ((o_it->id() != object->id()) && !o_it->manipulatorNode()->draw_manipulator()) { // If it has its own manipulator active, dont move it
1657 
1658  if (PluginFunctions::pickMode() == "Move")
1659  {
1660  if (o_it->dataType(DATA_TRIANGLE_MESH))
1661  transformMesh(m, (*PluginFunctions::triMesh(o_it)));
1662 
1663  if (o_it->dataType(DATA_POLY_MESH))
1664  transformMesh(m, (*PluginFunctions::polyMesh(o_it)));
1665  #ifdef ENABLE_TSPLINEMESH_SUPPORT
1666  if (o_it->dataType(DATA_TSPLINE_MESH))
1667  transformMesh(m, (*PluginFunctions::tsplineMesh(o_it)));
1668  #endif
1669  #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1670  if (object->dataType(DATA_HEXAHEDRAL_MESH))
1671  transformVolumeMesh(m, (*PluginFunctions::hexahedralMesh(object)), (PluginFunctions::hexahedralMeshObject(object)->normals()));
1672  #endif
1673  #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1674  if (object->dataType(DATA_TETRAHEDRAL_MESH))
1675  transformVolumeMesh(m, (*PluginFunctions::tetrahedralMesh(object)), (PluginFunctions::tetrahedralMeshObject(object)->normals()));
1676  #endif
1677  #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1678  if (object->dataType(DATA_POLYHEDRAL_MESH))
1679  transformVolumeMesh(m, (*PluginFunctions::polyhedralMesh(object)), (PluginFunctions::polyhedralMeshObject(object)->normals()));
1680  #endif
1681 
1682  // Create backup
1683  emit createBackup(o_it->id(), "Scaling of object");
1684  }
1685  else if (PluginFunctions::pickMode() == "MoveSelection")
1686  {
1687  updateSelectionType();
1688  if (selectionType_ & VERTEX) {
1689  transformVertexSelection(o_it->id(), m);
1690  }
1691  if (selectionType_ & FACE) {
1692  transformFaceSelection(o_it->id(), m);
1693  }
1694  if (selectionType_ & EDGE) {
1695  transformEdgeSelection(o_it->id(), m);
1696  }
1697  if (selectionType_ & CELL) {
1698  transformCellSelection(o_it->id(), m);
1699  }
1700 
1701  // Create backup
1702  emit createBackup(o_it->id(), "Scaling of selection");
1703  }
1704 
1705  emit updatedObject(o_it->id(), UPDATE_GEOMETRY);
1706  }
1707  }
1708 
1709  }
1710 
1711  updateManipulatorDialog();
1712 
1713  emit createBackup(object->id(), "Scaling");
1714  emit updatedObject(object->id(), UPDATE_GEOMETRY);
1715  }
1716  }
1717 
1718  emit scriptInfo(QString("slotScale()"));
1719  emit updateView();
1720 }
1721 
1722 
1723 //------------------------------------------------------------------------------
1724 
1725 
1729 void MovePlugin::slotMoveToOrigin() {
1730 
1731  bool useCommonCOG = false;
1732  ACG::Vec3d cog = ACG::Vec3d(0.0,0.0,0.0);
1733 
1734  if ( PluginFunctions::targetCount() > 1 ) {
1735  if ( OpenFlipper::Options::gui()) {
1736  QMessageBox::StandardButton button = QMessageBox::question( 0, tr("Use common COG?"), tr("Should the targets be moved depending on their common cog?"),QMessageBox::Yes|QMessageBox::No);
1737 
1738 
1739  useCommonCOG = ( button == QMessageBox::Yes );
1740  }
1741 
1742  if ( useCommonCOG ) {
1743 
1744  double vertexCount = 0.0;
1745 
1746  // Compute cog for all objects
1747  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it) {
1748  if ( o_it->dataType( DATA_TRIANGLE_MESH )) {
1749  TriMesh* mesh = PluginFunctions::triMesh(*o_it);
1750  cog += MeshInfo::cog(mesh) * double(mesh->n_vertices());
1751  vertexCount += double(mesh->n_vertices());
1752  }
1753 
1754  if ( o_it->dataType( DATA_POLY_MESH )) {
1755  PolyMesh* mesh = PluginFunctions::polyMesh(*o_it);
1756  cog += MeshInfo::cog(mesh) * double(mesh->n_vertices());
1757  vertexCount += double(mesh->n_vertices());
1758  }
1759 
1760 #ifdef ENABLE_TSPLINEMESH_SUPPORT
1761  if ( o_it->dataType( DATA_TSPLINE_MESH )) {
1762  TSplineMesh& mesh = *PluginFunctions::tsplineMesh(*o_it);
1763  cog += MeshInfo::cog(mesh) * double(mesh.n_vertices());
1764  vertexCount += double(mesh.n_vertices());
1765  }
1766 #endif
1767 
1768 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1769  if ( o_it->dataType( DATA_HEXAHEDRAL_MESH )) {
1770  HexahedralMesh& mesh = *PluginFunctions::hexahedralMesh(*o_it);
1771  cog += cogVolumeMesh(mesh) * double(mesh.n_vertices());
1772  vertexCount += double(mesh.n_vertices());
1773  }
1774 #endif
1775 
1776 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1777  if ( o_it->dataType( DATA_TETRAHEDRAL_MESH )) {
1778  TetrahedralMesh& mesh = *PluginFunctions::tetrahedralMesh(*o_it);
1779  cog += cogVolumeMesh(mesh) * double(mesh.n_vertices());
1780  vertexCount += double(mesh.n_vertices());
1781  }
1782 #endif
1783 
1784 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1785  if ( o_it->dataType( DATA_POLYHEDRAL_MESH )) {
1786  PolyhedralMesh& mesh = *PluginFunctions::polyhedralMesh(*o_it);
1787  cog += cogVolumeMesh(mesh) * double(mesh.n_vertices());
1788  vertexCount += double(mesh.n_vertices());
1789  }
1790 #endif
1791  }
1792 
1793  cog = cog / vertexCount;
1794  }
1795 
1796  }
1797 
1798  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it) {
1799  if ( o_it->dataType( DATA_TRIANGLE_MESH )) {
1800  TriMesh* mesh = PluginFunctions::triMesh(*o_it);
1801 
1802  if ( !useCommonCOG )
1803  cog = MeshInfo::cog(mesh);
1804 
1805  for ( TriMesh::VertexIter v_it = mesh->vertices_begin(); v_it != mesh->vertices_end() ; ++v_it)
1806  mesh->set_point(*v_it , ( mesh->point(*v_it) ) - cog );
1807 
1808  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1809  }
1810 
1811  if ( o_it->dataType( DATA_POLY_MESH )) {
1812  PolyMesh* mesh = PluginFunctions::polyMesh(*o_it);
1813 
1814  if ( !useCommonCOG )
1815  cog = MeshInfo::cog(mesh);
1816 
1817  for ( PolyMesh::VertexIter v_it = mesh->vertices_begin(); v_it != mesh->vertices_end() ; ++v_it)
1818  mesh->set_point(*v_it , ( mesh->point(*v_it) ) - cog );
1819 
1820  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1821 
1822  }
1823 
1824 #ifdef ENABLE_TSPLINEMESH_SUPPORT
1825  if ( o_it->dataType( DATA_TSPLINE_MESH )) {
1826  TSplineMesh* mesh = PluginFunctions::tsplineMesh(*o_it);
1827 
1828  if ( !useCommonCOG )
1829  cog = MeshInfo::cog(mesh);
1830 
1831  for ( TSplineMesh::VertexIter v_it = mesh->vertices_begin(); v_it != mesh->vertices_end() ; ++v_it)
1832  mesh->set_point(v_it , ( mesh->point(v_it) ) - cog );
1833 
1834  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1835 
1836  }
1837 #endif
1838 
1839 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1840  if ( o_it->dataType( DATA_HEXAHEDRAL_MESH )) {
1841  HexahedralMesh& mesh = *PluginFunctions::hexahedralMesh(*o_it);
1842 
1843  if ( !useCommonCOG )
1844  cog = cogVolumeMesh(mesh);
1845 
1846  for ( OpenVolumeMesh::VertexIter v_it = mesh.vertices_begin(); v_it != mesh.vertices_end() ; ++v_it)
1847  mesh.set_vertex(*v_it , mesh.vertex(*v_it) - cog );
1848 
1849  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1850 
1851  }
1852 #endif
1853 
1854 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1855  if ( o_it->dataType( DATA_TETRAHEDRAL_MESH )) {
1856  TetrahedralMesh& mesh = *PluginFunctions::tetrahedralMesh(*o_it);
1857 
1858  if ( !useCommonCOG )
1859  cog = cogVolumeMesh(mesh);
1860 
1861  for ( OpenVolumeMesh::VertexIter v_it = mesh.vertices_begin(); v_it != mesh.vertices_end() ; ++v_it)
1862  mesh.set_vertex(*v_it , mesh.vertex(*v_it) - cog );
1863 
1864  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1865 
1866  }
1867 #endif
1868 
1869 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1870  if ( o_it->dataType( DATA_POLYHEDRAL_MESH )) {
1871  PolyhedralMesh& mesh = *PluginFunctions::polyhedralMesh(*o_it);
1872 
1873  if ( !useCommonCOG )
1874  cog = cogVolumeMesh(mesh);
1875 
1876  for ( OpenVolumeMesh::VertexIter v_it = mesh.vertices_begin(); v_it != mesh.vertices_end() ; ++v_it)
1877  mesh.set_vertex(*v_it , mesh.vertex(*v_it) - cog );
1878 
1879  o_it->manipulatorNode()->set_center( o_it->manipulatorNode()->center() - cog );
1880 
1881  }
1882 #endif
1883 
1884 
1885  emit updatedObject( o_it->id(), UPDATE_GEOMETRY );
1886 
1887  updateManipulatorDialog();
1888  o_it->manipulatorNode()->loadIdentity();
1889 
1890  emit createBackup(o_it->id(),"Move to origin");
1891  }
1892 
1893  emit updateView();
1894 }
1895 
1896 
1897 //------------------------------------------------------------------------------
1898 
1902 void MovePlugin::slotUnifyBoundingBoxDiagonal()
1903 {
1904  unifyBoundingBox(MovePlugin::DIAGONAL);
1905 }
1906 
1907 void MovePlugin::slotUnifyBoundingBoxLongestAxis()
1908 {
1909  unifyBoundingBox((MovePlugin::LONGEST_AXIS));
1910 }
1911 
1912 void MovePlugin::slotUnifyBoundingBoxAllAxis()
1913 {
1914  unifyBoundingBox(MovePlugin::ALL_AXIS);
1915 }
1916 
1917 void MovePlugin::unifyBoundingBox(Unificationtype u)
1918 {
1919  bool useCommonBB = false;
1920  ACG::Vec3d bb_min = ACG::Vec3d(FLT_MAX,FLT_MAX,FLT_MAX);
1921  ACG::Vec3d bb_max = ACG::Vec3d(FLT_MIN,FLT_MIN,FLT_MIN);
1922 
1923  if ( PluginFunctions::targetCount() > 1 ) {
1924  if ( OpenFlipper::Options::gui()) {
1925  QMessageBox::StandardButton button = QMessageBox::question( 0, tr("Use common BB?"), tr("Should the targets be scaled depending on their common Bounding Box?"),QMessageBox::Yes|QMessageBox::No);
1926 
1927 
1928  useCommonBB = ( button == QMessageBox::Yes );
1929  }
1930 
1931 
1932  if ( useCommonBB ) {
1933 
1934  // Compute cog for all objects
1935  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it) {
1936  ACG::Vec3d bb_min_tmp(0.0,0.0,0.0);
1937  ACG::Vec3d bb_max_tmp(0.0,0.0,0.0);
1938 
1939  if ( o_it->dataType( DATA_TRIANGLE_MESH )) {
1940  TriMesh& mesh = *PluginFunctions::triMesh(*o_it);
1941  getBB(mesh,bb_min_tmp,bb_max_tmp);
1942  bb_min.minimize(bb_min_tmp);
1943  bb_max.maximize(bb_max_tmp);
1944  }
1945 
1946  if ( o_it->dataType( DATA_POLY_MESH )) {
1947  PolyMesh& mesh = *PluginFunctions::polyMesh(*o_it);
1948  getBB(mesh,bb_min_tmp,bb_max_tmp);
1949  bb_min.minimize(bb_min_tmp);
1950  bb_max.maximize(bb_max_tmp);
1951  }
1952 
1953 #ifdef ENABLE_TSPLINEMESH_SUPPORT
1954  if ( o_it->dataType( DATA_TSPLINE_MESH )) {
1955  TSplineMesh& mesh = *PluginFunctions::tsplineMesh(*o_it);
1956  getBB(mesh,bb_min_tmp,bb_max_tmp);
1957  bb_min.minimize(bb_min_tmp);
1958  bb_max.maximize(bb_max_tmp);
1959  }
1960 #endif
1961 
1962 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
1963  if ( o_it->dataType( DATA_HEXAHEDRAL_MESH )) {
1964  HexahedralMesh& mesh = *PluginFunctions::hexahedralMesh(*o_it);
1965  getBBVolumeMesh(mesh,bb_min_tmp,bb_max_tmp);
1966  bb_min.minimize(bb_min_tmp);
1967  bb_max.maximize(bb_max_tmp);
1968  }
1969 #endif
1970 
1971 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
1972  if ( o_it->dataType( DATA_TETRAHEDRAL_MESH )) {
1973  TetrahedralMesh& mesh = *PluginFunctions::tetrahedralMesh(*o_it);
1974  getBBVolumeMesh(mesh,bb_min_tmp,bb_max_tmp);
1975  bb_min.minimize(bb_min_tmp);
1976  bb_max.maximize(bb_max_tmp);
1977  }
1978 #endif
1979 
1980 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
1981  if ( o_it->dataType( DATA_POLYHEDRAL_MESH )) {
1982  PolyhedralMesh& mesh = *PluginFunctions::polyhedralMesh(*o_it);
1983  getBBVolumeMesh(mesh,bb_min_tmp,bb_max_tmp);
1984  bb_min.minimize(bb_min_tmp);
1985  bb_max.maximize(bb_max_tmp);
1986  }
1987 #endif
1988  }
1989  }
1990 
1991  }
1992 
1993  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it) {
1994  if ( useCommonBB ) {
1995  if ( o_it->dataType( DATA_TRIANGLE_MESH ) )
1996  unifyBB(*PluginFunctions::triMesh(*o_it),bb_min,bb_max, u);
1997  else if ( o_it->dataType( DATA_POLY_MESH ) )
1998  unifyBB(*PluginFunctions::polyMesh(*o_it),bb_min,bb_max, u);
1999 #ifdef ENABLE_TSPLINEMESH_SUPPORT
2000  else if ( o_it->dataType( DATA_TSPLINE_MESH ) )
2001  unifyBB(*PluginFunctions::tsplineMesh(*o_it),bb_min,bb_max, u);
2002 #endif
2003 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
2004  else if ( o_it->dataType( DATA_HEXAHEDRAL_MESH ) )
2005  unifyBBVolumeMesh(*PluginFunctions::hexahedralMesh(*o_it),(PluginFunctions::hexahedralMeshObject(*o_it)->normals()),bb_min,bb_max, u);
2006 #endif
2007 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
2008  else if ( o_it->dataType( DATA_TETRAHEDRAL_MESH ) )
2009  unifyBBVolumeMesh(*PluginFunctions::tetrahedralMesh(*o_it),(PluginFunctions::tetrahedralMeshObject(*o_it)->normals()),bb_min,bb_max, u);
2010 #endif
2011 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
2012  else if ( o_it->dataType( DATA_POLYHEDRAL_MESH ) )
2013  unifyBBVolumeMesh(*PluginFunctions::polyhedralMesh(*o_it),(PluginFunctions::polyhedralMeshObject(*o_it)->normals()),bb_min,bb_max, u);
2014 #endif
2015  } else {
2016  if ( o_it->dataType( DATA_TRIANGLE_MESH ) )
2017  unifyBB(*PluginFunctions::triMesh(*o_it), u);
2018  else if ( o_it->dataType( DATA_POLY_MESH ) )
2019  unifyBB(*PluginFunctions::polyMesh(*o_it), u);
2020 #ifdef ENABLE_TSPLINEMESH_SUPPORT
2021  else if ( o_it->dataType( DATA_TSPLINE_MESH ) )
2022  unifyBB(*PluginFunctions::tsplineMesh(*o_it), u);
2023 #endif
2024 #ifdef ENABLE_HEXAHEDRALMESH_SUPPORT
2025  else if ( o_it->dataType( DATA_HEXAHEDRAL_MESH ) )
2026  unifyBBVolumeMesh(*PluginFunctions::hexahedralMesh(*o_it),(PluginFunctions::hexahedralMeshObject(*o_it)->normals()), u);
2027 #endif
2028 #ifdef ENABLE_TETRAHEDRALMESH_SUPPORT
2029  else if ( o_it->dataType( DATA_TETRAHEDRAL_MESH ) )
2030  unifyBBVolumeMesh(*PluginFunctions::tetrahedralMesh(*o_it),(PluginFunctions::tetrahedralMeshObject(*o_it)->normals()), u);
2031 #endif
2032 #ifdef ENABLE_POLYHEDRALMESH_SUPPORT
2033  else if ( o_it->dataType( DATA_POLYHEDRAL_MESH ) )
2034  unifyBBVolumeMesh(*PluginFunctions::polyhedralMesh(*o_it),(PluginFunctions::polyhedralMeshObject(*o_it)->normals()), u);
2035 #endif
2036  }
2037 
2038  emit updatedObject( o_it->id(), UPDATE_GEOMETRY );
2039 
2040  }
2041 
2042  emit updateView();
2043 }
2044 
2045 
2046 //------------------------------------------------------------------------------
2047 
2051 void MovePlugin::updateManipulatorDialog() {
2052 
2053  BaseObjectData* object;
2054  if ( !PluginFunctions::getObject(lastActiveManipulator_ , object) ) {
2055  return;
2056  }
2057 
2058  if ( object->manipulatorNode()->visible() ) {
2059 
2060  // Get properties widget that corresponds to
2061  // to the last manipulated object
2062  movePropsWidget* pW = getDialogWidget(object);
2063 
2064  // If there's no properties dialog yet...
2065  if(pW == 0) return;
2066 
2067  const TriMesh::Point pos = object->manipulatorNode()->center();
2068 
2069  QString num;
2070 
2071  num = QString::number(pos[0]); pW->posx->setText(num);
2072  num = QString::number(pos[1]); pW->posy->setText(num);
2073  num = QString::number(pos[2]); pW->posz->setText(num);
2074 
2075  TriMesh::Point direction = object->manipulatorNode()->directionX();
2076  num = QString::number(direction[0]); pW->dirxx->setText(num);
2077  num = QString::number(direction[1]); pW->dirxy->setText(num);
2078  num = QString::number(direction[2]); pW->dirxz->setText(num);
2079 
2080  direction = object->manipulatorNode()->directionY();
2081  num = QString::number(direction[0]); pW->diryx->setText(num);
2082  num = QString::number(direction[1]); pW->diryy->setText(num);
2083  num = QString::number(direction[2]); pW->diryz->setText(num);
2084 
2085  direction = object->manipulatorNode()->directionZ();
2086  num = QString::number(direction[0]); pW->dirzx->setText(num);
2087  num = QString::number(direction[1]); pW->dirzy->setText(num);
2088  num = QString::number(direction[2]); pW->dirzz->setText(num);
2089 
2090  }
2091 }
2092 
2093 //------------------------------------------------------------------------------
2094 
2099 movePropsWidget* MovePlugin::getDialogWidget(BaseObjectData* _obj) {
2100 
2101  for(QList<movePropsWidget*>::iterator it = propsWindows_.begin();
2102  it != propsWindows_.end(); ++it) {
2103  if ( (*it)->getBaseObjectDataId() == _obj->id() )
2104  return *it;
2105  }
2106  return 0;
2107 }
2108 //------------------------------------------------------------------------------
2109 
2114 void MovePlugin::slotSetMoveMode(QAction* _action) {
2115 
2116  if (_action == moveAction_){
2117  PluginFunctions::actionMode(Viewer::PickingMode);
2118  PluginFunctions::pickMode("Move");
2119 
2120  moveAction_->setChecked( true );
2121  }
2122 
2123  if (_action == moveSelectionAction_){
2124 
2125  PluginFunctions::actionMode(Viewer::PickingMode);
2126  PluginFunctions::pickMode("MoveSelection");
2127 
2128  moveSelectionAction_->setChecked( true );
2129  }
2130 }
2131 
2132 //------------------------------------------------------------------------------
2133 
2139 void MovePlugin::slotPickToolbarAction(QAction* _action)
2140 {
2141 
2142  if (_action == rotateTranslateAction_)
2143  {
2144  setManipMode (QtTranslationManipulatorNode::TranslationRotation);
2145  }
2146 
2147  if (_action == rotateManipAction_)
2148  {
2149  setManipMode (QtTranslationManipulatorNode::LocalRotation);
2150  }
2151 
2152  if (_action == placeAndSnapAction_)
2153  {
2154  setManipMode(QtTranslationManipulatorNode::Place);
2155  }
2156 
2157  if (_action == resizeAction_)
2158  {
2159  setManipMode(QtTranslationManipulatorNode::Resize);
2160  }
2161 
2162  if (_action == biggerManipAction_)
2163  {
2164  manip_size_modifier_ = manip_size_modifier_ + 0.1;
2165  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it)
2166  o_it->manipulatorNode()->set_size(manip_size_ * manip_size_modifier_);
2167  emit nodeVisibilityChanged (-1);
2168  }
2169 
2170  if (_action == smallerManipAction_)
2171  {
2172  manip_size_modifier_ = manip_size_modifier_ - 0.1;
2173  for ( PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS) ; o_it != PluginFunctions::objectsEnd(); ++o_it)
2174  o_it->manipulatorNode()->set_size(manip_size_ * manip_size_modifier_);
2175  emit nodeVisibilityChanged (-1);
2176  }
2177 }
2178 
2179 
2180 //------------------------------------------------------------------------------
2181 
2187 ACG::Matrix4x4d MovePlugin::getLastManipulatorMatrix(bool _reset) {
2188  ACG::Matrix4x4d matrix;
2189  matrix.identity();
2190 
2191  BaseObjectData* object;
2192  if ( PluginFunctions::getObject(lastActiveManipulator_ , object) )
2193  if ( object->manipulatorNode()->visible() ) {
2194  matrix = object->manipulatorNode()->matrix();
2195  if (_reset)
2196  object->manipulatorNode()->loadIdentity();
2197  }
2198  return matrix;
2199 }
2200 
2201 
2202 //------------------------------------------------------------------------------
2203 
2212 template< typename MeshT >
2213 void MovePlugin::transformMesh(ACG::Matrix4x4d _mat , MeshT& _mesh ) {
2214  // Get the inverse matrix of the transformation for the normals
2215  ACG::Matrix4x4d invTranspMat = _mat;
2216 
2217  // Build inverse transposed matrix of _mat
2218  invTranspMat.invert();
2219  invTranspMat.transpose();
2220 
2221  typename MeshT::VertexIter v_it = _mesh.vertices_begin();
2222  typename MeshT::VertexIter v_end = _mesh.vertices_end();
2223  for (; v_it!=v_end; ++v_it) {
2224 
2225  // transform the mesh vertex
2226  _mesh.set_point(*v_it,_mat.transform_point(_mesh.point(*v_it)));
2227 
2228  // transform the vertex normal
2229  typename MeshT::Normal n = invTranspMat.transform_vector(_mesh.normal(*v_it));
2230 
2231  n.normalize();
2232 
2233  _mesh.set_normal(*v_it,n);
2234  }
2235 
2236  typename MeshT::FaceIter f_it = _mesh.faces_begin();
2237  typename MeshT::FaceIter f_end = _mesh.faces_end();
2238  for (; f_it != f_end; ++f_it) {
2239 
2240  // transform the face normal
2241  typename MeshT::Normal n = invTranspMat.transform_vector(_mesh.normal(*f_it));
2242 
2243  n.normalize();
2244 
2245  _mesh.set_normal(*f_it,n);
2246  }
2247 }
2248 
2249 
2250 //------------------------------------------------------------------------------
2251 
2252 #ifdef ENABLE_POLYLINE_SUPPORT
2253 
2259 template< class PolyLineT >
2260 void MovePlugin::transformPolyLine( ACG::Matrix4x4d _mat , PolyLineT& _polyLine ) {
2261  #ifdef USE_OPENMP
2262  #pragma omp parallel for
2263  #endif
2264  for ( int i = 0 ; i < (int)_polyLine.n_vertices(); ++i )
2265  _polyLine.point(i) = _mat.transform_point( _polyLine.point(i) );
2266 }
2267 
2268 #endif
2269 
2270 
2271 //------------------------------------------------------------------------------
2272 
2273 #ifdef ENABLE_SKELETON_SUPPORT
2274 
2280 void MovePlugin::transformSkeleton( ACG::Matrix4x4d _mat , Skeleton& _skeleton ) {
2281 
2282  SkeletonTransform transformer(_skeleton);
2283  transformer.transformSkeleton(_mat);
2284 }
2285 
2286 #endif
2287 
2288 #if defined(ENABLE_HEXAHEDRALMESH_SUPPORT) || defined(ENABLE_POLYHEDRALMESH_SUPPORT) || defined(ENABLE_TETRAHEDRALMESH_SUPPORT)
2289 
2298 template< typename VolumeMeshT >
2299 void MovePlugin::transformVolumeMesh(ACG::Matrix4x4d _mat , VolumeMeshT& _mesh , OpenVolumeMesh::NormalAttrib<VolumeMeshT>& _normalAttrib )
2300 {
2301  // Get the inverse matrix of the transformation for the normals
2302  ACG::Matrix4x4d invTranspMat = _mat;
2303 
2304  // Build inverse transposed matrix of _mat
2305  invTranspMat.invert();
2306  invTranspMat.transpose();
2307 
2308  OpenVolumeMesh::VertexIter v_begin = _mesh.vertices_begin();
2309  OpenVolumeMesh::VertexIter v_end = _mesh.vertices_end();
2310 
2311  // transform the mesh vertices
2312  for (OpenVolumeMesh::VertexIter v_it = v_begin; v_it != v_end; ++v_it)
2313  _mesh.set_vertex(*v_it, _mat.transform_point(_mesh.vertex(*v_it)));
2314 
2315  // transform the vertex normals
2316  for (OpenVolumeMesh::VertexIter v_it = v_begin; v_it != v_end; ++v_it)
2317  _normalAttrib[*v_it] = invTranspMat.transform_vector(_normalAttrib[*v_it]).normalized();
2318 
2319 
2320  // transform the face normals
2321  OpenVolumeMesh::FaceIter f_begin = _mesh.faces_begin();
2322  OpenVolumeMesh::FaceIter f_end = _mesh.faces_end();
2323  for (OpenVolumeMesh::FaceIter f_it = f_begin; f_it != f_end; ++f_it)
2324  _normalAttrib[*f_it] = invTranspMat.transform_vector(_normalAttrib[*f_it]).normalized();
2325 }
2326 
2327 //------------------------------------------------------------------------------
2328 
2333 template< typename VolumeMeshT >
2334 ACG::Vec3d MovePlugin::cogVolumeMesh( VolumeMeshT& _mesh )
2335 {
2336  ACG::Vec3d cog = ACG::Vec3d(0.0,0.0,0.0);
2337  OpenVolumeMesh::VertexIter v_it = _mesh.vertices_begin();
2338  OpenVolumeMesh::VertexIter v_end = _mesh.vertices_end();
2339  for (; v_it!=v_end; ++v_it)
2340  cog += _mesh.vertex(*v_it);
2341 
2342  return cog/(double)_mesh.n_vertices();
2343 }
2344 
2345 //------------------------------------------------------------------------------
2346 
2353 template< typename VolumeMeshT >
2354 void MovePlugin::getBBVolumeMesh( VolumeMeshT& _mesh, ACG::Vec3d& _bb_min, ACG::Vec3d& _bb_max)
2355 {
2356  OpenVolumeMesh::VertexIter v_it = _mesh.vertices_begin();
2357  OpenVolumeMesh::VertexIter v_end = _mesh.vertices_end();
2358 
2359  // no vertices?
2360  if( v_it == v_end) return;
2361 
2362  _bb_min = _mesh.vertex(*v_it);
2363  _bb_max = _mesh.vertex(*v_it);
2364 
2365  for(; v_it!=v_end; ++v_it)
2366  {
2367  _bb_min.minimize( _mesh.vertex(*v_it));
2368  _bb_max.maximize( _mesh.vertex(*v_it));
2369  }
2370 }
2371 
2372 //------------------------------------------------------------------------------
2373 
2379 template< typename VolumeMeshT >
2380 void MovePlugin::unifyBBVolumeMesh(VolumeMeshT& _mesh, OpenVolumeMesh::NormalAttrib<VolumeMeshT>& _normalAttrib, Unificationtype u)
2381 {
2382  // no vertices?
2383  if( _mesh.n_vertices() == 0) return;
2384 
2385  ACG::Vec3d bb_min, bb_max;
2386  getBBVolumeMesh( _mesh, bb_min, bb_max );
2387 
2388  unifyBBVolumeMesh( _mesh, _normalAttrib, bb_min, bb_max, u );
2389 }
2390 
2391 //------------------------------------------------------------------------------
2392 
2401 template< typename VolumeMeshT >
2402 void MovePlugin::unifyBBVolumeMesh( VolumeMeshT& _mesh, OpenVolumeMesh::NormalAttrib<VolumeMeshT>& _normalAttrib, ACG::Vec3d& _bb_min, ACG::Vec3d& _bb_max, Unificationtype u)
2403 {
2404  ACG::Vec3d bb_center = 0.5 * (_bb_min + _bb_max) ;
2405  ACG::Vec3d bb_diagonal = _bb_max-_bb_min;
2406  double bb_longestAxis = bb_diagonal.max();
2407 
2408  ACG::Vec3d scale;
2409  switch(u)
2410  {
2411  case MovePlugin::DIAGONAL :
2412  scale = ACG::Vec3d(1.0/(_bb_max-_bb_min).norm());
2413  break;
2414  case MovePlugin::LONGEST_AXIS :
2415  scale = ACG::Vec3d(1.0/(bb_longestAxis));
2416  break;
2417  case MovePlugin::ALL_AXIS :
2418  scale = ACG::Vec3d(ACG::Vec3d(1.0)/bb_diagonal);
2419  break;
2420  default:
2421  scale = ACG::Vec3d(1.0/(_bb_max-_bb_min).norm());
2422  }
2423 
2424 
2425  for( OpenVolumeMesh::VertexIter v_it = _mesh.vertices_begin(); v_it!=_mesh.vertices_end(); ++v_it)
2426  _mesh.set_vertex(*v_it, (_mesh.vertex(*v_it) - bb_center) * scale + bb_center);
2427 
2428  _normalAttrib.update_vertex_normals();
2429 }
2430 
2431 #endif
2432 
2433 //------------------------------------------------------------------------------
2434 
2440 template< typename MeshT >
2441 void MovePlugin::unifyBB(MeshT& _mesh , Unificationtype u)
2442 {
2443  typename MeshT::VertexIter v_it = _mesh.vertices_begin();
2444  typename MeshT::VertexIter v_end = _mesh.vertices_end();
2445 
2446  // no vertices?
2447  if( v_it == v_end) return;
2448 
2449  typename MeshT::Point bb_min = _mesh.point(*v_it);
2450  typename MeshT::Point bb_max = _mesh.point(*v_it);
2451 
2452  for(; v_it!=v_end; ++v_it)
2453  {
2454  bb_min.minimize( _mesh.point(*v_it));
2455  bb_max.maximize( _mesh.point(*v_it));
2456  }
2457 
2458  typename MeshT::Point bb_center = 0.5 * (bb_min + bb_max) ;
2459  ACG::Vec3d bb_diagonal = bb_max-bb_min;
2460  typename MeshT::Scalar bb_longestAxis = bb_diagonal.max();
2461 
2462  ACG::Vec3d scale;
2463  switch(u)
2464  {
2465  case MovePlugin::DIAGONAL :
2466  scale = ACG::Vec3d(1.0/(bb_max-bb_min).norm());
2467  break;
2468  case MovePlugin::LONGEST_AXIS :
2469  scale = ACG::Vec3d(1.0 / bb_longestAxis);
2470  break;
2471  case MovePlugin::ALL_AXIS :
2472  scale = ACG::Vec3d(ACG::Vec3d(1.0)/bb_diagonal);
2473  break;
2474  default:
2475  scale = ACG::Vec3d(1.0/(bb_max-bb_min).norm());
2476  }
2477 
2478  for( v_it = _mesh.vertices_begin(); v_it!=v_end; ++v_it)
2479  {
2480 
2481  _mesh.point(*v_it) = (_mesh.point(*v_it) - bb_center) * scale + bb_center;
2482  }
2483 
2484  _mesh.update_normals();
2485 
2486 }
2487 
2494 template< typename MeshT >
2495 void MovePlugin::getBB( MeshT& _mesh, ACG::Vec3d& _bb_min, ACG::Vec3d& _bb_max )
2496 {
2497  typename MeshT::VertexIter v_it = _mesh.vertices_begin();
2498  typename MeshT::VertexIter v_end = _mesh.vertices_end();
2499 
2500  // no vertices?
2501  if( v_it == v_end) return;
2502 
2503  _bb_min = _mesh.point(*v_it);
2504  _bb_max = _mesh.point(*v_it);
2505 
2506  for(; v_it!=v_end; ++v_it)
2507  {
2508  _bb_min.minimize( _mesh.point(*v_it));
2509  _bb_max.maximize( _mesh.point(*v_it));
2510  }
2511 
2512 
2513 }
2514 
2522 template< typename MeshT >
2523 void MovePlugin::unifyBB(MeshT& _mesh, ACG::Vec3d& _bb_min, ACG::Vec3d& _bb_max , Unificationtype u)
2524 {
2525 
2526  typename MeshT::Point bb_center = 0.5 * (_bb_min + _bb_max) ;
2527  ACG::Vec3d bb_diagonal = _bb_max-_bb_min;
2528  typename MeshT::Scalar bb_longestAxis = bb_diagonal.max();
2529  ACG::Vec3d scale;
2530  switch(u)
2531  {
2532  case MovePlugin::DIAGONAL :
2533  scale = ACG::Vec3d(1.0/(_bb_max-_bb_min).norm());
2534  break;
2535  case MovePlugin::LONGEST_AXIS :
2536  scale = ACG::Vec3d(1.0 / bb_longestAxis);
2537  break;
2538  case MovePlugin::ALL_AXIS :
2539  scale = ACG::Vec3d(ACG::Vec3d(1.0)/bb_diagonal);
2540  break;
2541  default:
2542  scale = ACG::Vec3d(1.0/(_bb_max-_bb_min).norm());
2543  }
2544 
2545  typename MeshT::VertexIter v_it;
2546 
2547  for( v_it = _mesh.vertices_begin(); v_it!=_mesh.vertices_end(); ++v_it)
2548  _mesh.point(*v_it) = (_mesh.point(*v_it) - bb_center) * scale + bb_center;
2549 
2550  _mesh.update_normals();
2551 
2552 }
2553 
2554 
2555 //------------------------------------------------------------------------------
2556 
2560 void MovePlugin::updateSelectionType() {
2561 
2562  bool functionExistsMeshV;
2563  emit functionExists("meshobjectselection", "vertexTypeActive()", functionExistsMeshV);
2564  bool functionExistsMeshE;
2565  emit functionExists("meshobjectselection", "edgeTypeActive()", functionExistsMeshE);
2566  bool functionExistsMeshF;
2567  emit functionExists("meshobjectselection", "faceTypeActive()", functionExistsMeshF);
2568 
2569  bool connected = false;
2570  selectionType_ = 0u;
2571 
2572  if(functionExistsMeshV && functionExistsMeshE && functionExistsMeshF) {
2573 
2574  connected = true;
2575 
2576  // Make RPC call
2577  if(RPC::callFunctionValue<bool>("meshobjectselection", "vertexTypeActive")) {
2578  selectionType_ |= VERTEX;
2579  }
2580  if(RPC::callFunctionValue<bool>("meshobjectselection", "edgeTypeActive")) {
2581  selectionType_ |= EDGE;
2582  }
2583  if(RPC::callFunctionValue<bool>("meshobjectselection", "faceTypeActive")) {
2584  selectionType_ |= FACE;
2585  }
2586 
2587  }
2588 
2589 #if defined(ENABLE_HEXAHEDRALMESH_SUPPORT) || defined(ENABLE_POLYHEDRALMESH_SUPPORT) || defined(ENABLE_TETRAHEDRALMESH_SUPPORT)
2590  bool functionExistsVolumeMeshV;
2591  emit functionExists("volumemeshselection", "vertexTypeActive()", functionExistsVolumeMeshV);
2592  bool functionExistsVolumeMeshE;
2593  emit functionExists("volumemeshselection", "edgeTypeActive()", functionExistsVolumeMeshE);
2594  bool functionExistsVolumeMeshF;
2595  emit functionExists("volumemeshselection", "faceTypeActive()", functionExistsVolumeMeshF);
2596  bool functionExistsVolumeMeshC;
2597  emit functionExists("volumemeshselection", "cellTypeActive()", functionExistsVolumeMeshC);
2598 
2599  if ( functionExistsVolumeMeshV && functionExistsVolumeMeshE && functionExistsVolumeMeshF && functionExistsVolumeMeshC) {
2600 
2601  connected = true;
2602 
2603  // Make RPC call
2604  if(RPC::callFunctionValue<bool>("volumemeshselection", "vertexTypeActive")) {
2605  selectionType_ |= VERTEX;
2606  }
2607  if(RPC::callFunctionValue<bool>("volumemeshselection", "edgeTypeActive")) {
2608  selectionType_ |= EDGE;
2609  }
2610  if(RPC::callFunctionValue<bool>("volumemeshselection", "faceTypeActive")) {
2611  selectionType_ |= FACE;
2612  }
2613  if(RPC::callFunctionValue<bool>("volumemeshselection", "cellTypeActive")) {
2614  selectionType_ |= CELL;
2615  }
2616  }
2617 #endif
2618 
2619  if (!connected) {
2620  emit log(LOGWARN, tr("Unable to connect to Selection-Plugin. MoveSelection will work on vertices only."));
2621  selectionType_ = VERTEX;
2622  }
2623 }
2624 
2625 //------------------------------------------------------------------------------
2626 
2632 void MovePlugin::setAllTargets(bool _state) {
2633  allTargets_ = _state;
2634 }
2635 
2636 //--------------------------------------------------------------------------------
2637 
2641 template< typename MeshType >
2642 OpenMesh::Vec3d MovePlugin::getNearestVertex(MeshType* _mesh, uint _fh, OpenMesh::Vec3d &_hitPoint) {
2643 
2644  typename MeshType::FaceHandle fh = _mesh->face_handle(_fh);
2645 
2646  if ( !fh.is_valid() )
2647  return OpenMesh::Vec3d(0.0, 0.0, 0.0);
2648 
2649  typename MeshType::FaceVertexIter fv_it(*_mesh, fh);
2650  typename MeshType::Point hitPointP = (typename MeshType::Point) _hitPoint;
2651  typename MeshType::Scalar shortest_distance = (_mesh->point(*fv_it) - hitPointP).sqrnorm();
2652  typename MeshType::VertexHandle vh = *fv_it;
2653 
2654  for (; fv_it.is_valid(); ++fv_it) {
2655 
2656  typename MeshType::Scalar tmpdist =
2657  (_mesh->point(*fv_it) - hitPointP).sqrnorm();
2658 
2659  if(tmpdist < shortest_distance) {
2660  shortest_distance = tmpdist;
2661  vh = *fv_it;
2662  }
2663  }
2664 
2665  return (OpenMesh::Vec3d)_mesh->point(vh);
2666 }
2667 
2668 //--------------------------------------------------------------------------------
2669 
2673 template< typename MeshType >
2674 OpenMesh::Vec3d MovePlugin::getNearestEdge(MeshType* _mesh, uint _fh, OpenMesh::Vec3d &_hitPoint) {
2675 
2676  typename MeshType::FaceHandle fh = _mesh->face_handle(_fh);
2677 
2678  if (!fh.is_valid())
2679  return OpenMesh::Vec3d(0.0, 0.0, 0.0);
2680 
2681  typename MeshType::FaceEdgeIter fe_it(*_mesh, fh);
2682  typename MeshType::Point hitPointP = (typename MeshType::Point) _hitPoint;
2683 
2684  typename MeshType::Point center;
2685  typename MeshType::Scalar closest_dist(-1);
2686 
2687  for (; fe_it.is_valid(); ++fe_it) {
2688 
2689  typename MeshType::HalfedgeHandle heh0 = _mesh->halfedge_handle(*fe_it, 0);
2690  typename MeshType::HalfedgeHandle heh1 = _mesh->halfedge_handle(*fe_it, 1);
2691 
2692  typename MeshType::Point lp0 = _mesh->point(_mesh->to_vertex_handle(heh0));
2693  typename MeshType::Point lp1 = _mesh->point(_mesh->to_vertex_handle(heh1));
2694 
2695  double dist_new = ACG::Geometry::distPointLineSquared( hitPointP, lp0, lp1);
2696 
2697  /*typename MeshType::Point b(hitPointP - lp0), a(((lp1 - lp0).sqrnorm()));
2698  typename MeshType::Scalar d = b|a;
2699  typename MeshType::Point x = lp0 + a * d;
2700  double dist_new = (hitPointP - x).length();*/
2701 
2702  if (dist_new < closest_dist || closest_dist == -1) {
2703  // save closest Edge
2704  closest_dist = dist_new;
2705  center = lp0 + (lp1 - lp0) * .5;
2706 
2707  }
2708  }
2709 
2710  return (OpenMesh::Vec3d)center;
2711 }
2712 
2713 //--------------------------------------------------------------------------------
2714 
2718 template< typename MeshType >
2719 OpenMesh::Vec3d MovePlugin::getNearestFace(MeshType* _mesh, uint _fh, OpenMesh::Vec3d &_hitPoint) {
2720 
2721  typename MeshType::FaceHandle fh = _mesh->face_handle(_fh);
2722 
2723  if ( !fh.is_valid() )
2724  return OpenMesh::Vec3d(0.0, 0.0, 0.0);
2725 
2726  typename MeshType::FaceVertexIter fv_it(*_mesh, fh);
2727 
2728  typename MeshType::Point cog(0.0,0.0,0.0);
2729  uint count = 0;
2730 
2731  for (; fv_it.is_valid(); ++fv_it) {
2732 
2733  cog += _mesh->point(*fv_it);
2734  ++count;
2735  }
2736 
2737  return (OpenMesh::Vec3d)cog/count;
2738 }
2739 
2740 //--------------------------------------------------------------------------------
2741 
2742 void MovePlugin::slotAllCleared(){
2743  activeManipulators_.clear();
2744 }
2745 
2746 //--------------------------------------------------------------------------------
2747 
2748 void MovePlugin::objectDeleted( int _id ){
2749 
2750  for (uint i=0; i < activeManipulators_.size(); i++)
2751  if ( activeManipulators_[i] == _id ){
2752  activeManipulators_.erase( activeManipulators_.begin() + i );
2753  return;
2754  }
2755 }
2756 
2757 //--------------------------------------------------------------------------------
2758 
2759 
ACG::Matrix4x4T::invert
bool invert()
matrix inversion (returns true on success)
Definition: Matrix4x4T_impl.hh:291
OpenMesh::VectorT::maximize
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition: Vector11T.hh:563
MovePlugin::toolboxActive_
bool toolboxActive_
True if the toolbox widget is active.
Definition: MovePlugin.hh:256
ACG::Matrix4x4T::is_identity
bool is_identity() const
check if the matrix is the identity ( up to an epsilon )
Definition: Matrix4x4T.hh:214
MovePlugin::placeManip
void placeManip(QMouseEvent *_event, bool _snap=false)
Place and show the Manipulator.
Definition: MovePlugin.cc:863
PluginFunctions::plane
Plane * plane(BaseObjectData *_object)
Get a Plane from an object.
Definition: PluginFunctionsPlane.cc:92
MovePlugin::transformCellSelection
bool transformCellSelection(int _objectId, Matrix4x4 _matrix)
transform current selection of an Object by a given matrix
Definition: MovePluginScript.cc:1608
MovePlugin::transformFaceSelection
bool transformFaceSelection(int _objectId, Matrix4x4 _matrix)
transform current selection of an Object by a given matrix
Definition: MovePluginScript.cc:1164
PluginFunctions::defaultViewObjectMarker
ViewObjectMarker * defaultViewObjectMarker()
Get the default ViewObjectMarker.
Definition: PluginFunctions.cc:951
MovePlugin::resizeAction_
QAction * resizeAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:296
MovePlugin::slotEnableSelectionMode
void slotEnableSelectionMode()
stores the current axes in the tool
Definition: MovePlugin.cc:476
MovePlugin::axisB_
int axisB_
stores the current axes in the tool
Definition: MovePlugin.hh:196
MovePlugin::biggerManipAction_
QAction * biggerManipAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:298
DATA_SKELETON
#define DATA_SKELETON
Definition: Skeleton.hh:64
WhatsThisGenerator::generateLink
QString generateLink(const QString &_ref="", const QString &_site="index.html") const
generates a clickable link to the documentation for whatsThis Messages
Definition: WhatsThisGenerator.cc:65
MovePlugin::slotToggleAxisB
void slotToggleAxisB()
Toggle the second axis for changing direction in tab.
Definition: MovePlugin.cc:1127
MovePlugin::setDescriptions
void setDescriptions()
Set Descriptions for scriptable functions.
Definition: MovePluginScript.cc:67
ACG::SceneGraph::BaseNode::className
virtual const std::string & className() const =0
Return class name (implemented by the ACG_CLASSNAME macro)
MovePlugin::updateSelectionType
void updateSelectionType()
Get current primitive selection.
Definition: MovePlugin.cc:2560
PluginFunctions::scenegraphPick
bool scenegraphPick(ACG::SceneGraph::PickTarget _pickTarget, const QPoint &_mousePos, size_t &_nodeIdx, size_t &_targetIdx, ACG::Vec3d *_hitPointPtr=0)
Execute picking operation on scenegraph.
Definition: PluginFunctions.cc:478
DATA_POLY_MESH
#define DATA_POLY_MESH
Definition: PolyMesh.hh:59
MovePlugin::pickToolBarActions_
QActionGroup * pickToolBarActions_
Called by pick Toolbar.
Definition: MovePlugin.hh:307
ACG::SceneGraph::PICK_ANYTHING
pick any of the prior targets (should be implemented for all nodes)
Definition: PickTarget.hh:84
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
ACG::SceneGraph::ACG::SceneGraph::BaseNode::visible
bool visible()
Is node visible (status == Active)?
Definition: MeshNode2T_impl.hh:409
MovePlugin::placeAction_
QAction * placeAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:293
MovePlugin::contextMenuManipControlsAction_
QAction * contextMenuManipControlsAction_
Action holding the context menu for toolbar replication.
Definition: MovePlugin.hh:491
BaseObjectData::manipPlaced
bool manipPlaced()
Check if the manipulator has been placed.
Definition: BaseObjectData.cc:279
BaseObject::id
int id() const
Definition: BaseObject.cc:190
PluginFunctions::getPickedObject
bool getPickedObject(const size_t _node_idx, BaseObjectData *&_object)
Get the picked mesh.
Definition: PluginFunctions.cc:259
SkeletonTransform::transformSkeleton
void transformSkeleton(Matrix4x4 _transformation, Skeleton::Pose *_pose=0)
transform the skeleton
Definition: SkeletonTransform.cc:143
MovePlugin::updateManipulatorDialog
void updateManipulatorDialog()
Update the Dialog with the last clicked manipulator.
Definition: MovePlugin.cc:2051
ACG::SceneGraph::TranslationManipulatorNode::ManipulatorMode
ManipulatorMode
enum to define the manipulator mode
Definition: TranslationManipulatorNode.hh:107
PluginFunctions::skeleton
Skeleton * skeleton(BaseObjectData *_object)
Get a skeleton from an object.
Definition: PluginFunctionsSkeleton.cc:80
MovePlugin::setPickModeProps
void setPickModeProps(movePropsWidget *_pW, const std::string &_pickmode)
List of properties dialogs (each corresponding to one manipulator)
Definition: MovePlugin.cc:495
MovePlugin::moveSelection
void moveSelection(ACG::Matrix4x4d mat, int _id, QEvent::Type _type)
Move selection on an object with given id.
Definition: MovePlugin.cc:638
MovePlugin::tool_
moveToolbarWidget * tool_
Widget for Toolbox.
Definition: MovePlugin.hh:259
MovePlugin::slotSetPosition
void slotSetPosition()
Position of manipulator in tab changed.
Definition: MovePlugin.cc:1032
MovePlugin::MovePlugin
MovePlugin()
Default Constructor.
Definition: MovePlugin.cc:82
MovePlugin::slotToggleAxisA
void slotToggleAxisA()
Toggle the first axis for changing direction in tab.
Definition: MovePlugin.cc:1102
MovePlugin::Unificationtype
Unificationtype
stores the current axes in the tool
Definition: MovePlugin.hh:198
BaseObject::dataType
bool dataType(DataType _type) const
Definition: BaseObject.cc:221
PluginFunctions::tetrahedralMeshObject
TetrahedralMeshObject * tetrahedralMeshObject(BaseObjectData *_object)
Cast an BaseObject to an TetrahedralMeshObject if possible.
Definition: PluginFunctionsTetrahedralMesh.cc:133
PluginFunctions::TARGET_OBJECTS
const QStringList TARGET_OBJECTS("target")
Iterable object range.
ACG::Matrix4x4T::transform_point
VectorT< T, 3 > transform_point(const VectorT< T, 3 > &_v) const
transform point (x&#39;,y&#39;,z&#39;,1) = M * (x,y,z,1)
Definition: Matrix4x4T_impl.hh:196
MovePlugin::getDialogWidget
movePropsWidget * getDialogWidget(BaseObjectData *_obj)
Get properties dialog widget that is attached to BaseDataObject obj.
Definition: MovePlugin.cc:2099
MovePlugin::manMode_
QtTranslationManipulatorNode::ManipulatorMode manMode_
Holds the current manipulator mode.
Definition: MovePlugin.hh:423
MovePlugin::translate
void translate(int _objectId, Vector _vector)
translate an Object by a given vector
Definition: MovePluginScript.cc:160
PluginFunctions::polyhedralMeshObject
PolyhedralMeshObject * polyhedralMeshObject(BaseObjectData *_object)
Cast an BaseObject to an PolyhedralMeshObject if possible.
Definition: PluginFunctionsPolyhedralMesh.cc:134
PluginFunctions::triMesh
TriMesh * triMesh(BaseObjectData *_object)
Get a triangle mesh from an object.
Definition: PluginFunctionsTriangleMesh.cc:134
ACG::Matrix4x4T::transpose
void transpose()
transpose matrix
Definition: Matrix4x4T_impl.hh:266
PluginFunctions::ALL_OBJECTS
const QStringList ALL_OBJECTS
Iterable object range.
Definition: PluginFunctions.hh:430
MovePlugin::showManipulators
void showManipulators()
Checks if the manipulators should be visible or not.
Definition: MovePlugin.cc:978
MovePlugin::setManipMode
void setManipMode(QtTranslationManipulatorNode::ManipulatorMode _mode)
Set the manipulator manipulation mode.
Definition: MovePlugin.cc:671
MovePlugin::showProps
void showProps()
Show properties of move manipulator in a dialog ( Called via context for picking. Get the picked id f...
Definition: MoveContextMenu.cc:88
MovePlugin::slotSetDirection
void slotSetDirection()
Set Direction of manipulator in tab changed.
Definition: MovePlugin.cc:1152
ACG::Geometry::distPointLineSquared
Vec::value_type distPointLineSquared(const Vec &_p, const Vec &_v0, const Vec &_v1, Vec *_min_v)
squared distance from point _p to line segment (_v0,_v1)
Definition: Algorithms.cc:290
MovePlugin::manip_size_
double manip_size_
Size for the manipulators.
Definition: MovePlugin.hh:400
MovePlugin::pickToolbar_
QToolBar * pickToolbar_
Called by pick Toolbar.
Definition: MovePlugin.hh:291
MovePlugin::transformedSelected_
bool transformedSelected_
stores if any selected elements where transformed
Definition: MovePlugin.hh:617
DATA_TETRAHEDRAL_MESH
#define DATA_TETRAHEDRAL_MESH
Definition: TetrahedralMesh.hh:55
MovePlugin::propsWindows_
QList< movePropsWidget * > propsWindows_
List of properties dialogs (each corresponding to one manipulator)
Definition: MovePlugin.hh:476
MovePlugin::moveAction_
QAction * moveAction_
Called by Toolbar to enable move mode.
Definition: MovePlugin.hh:271
MovePlugin::getNearestFace
OpenMesh::Vec3d getNearestFace(MeshType *_mesh, uint _fh, OpenMesh::Vec3d &_hitPoint)
Get closest face to hitpoint.
Definition: MovePlugin.cc:2719
PluginFunctions::getObject
bool getObject(const int _identifier, BaseObject *&_object)
Get the object which has the given identifier.
Definition: PluginFunctions.cc:294
PluginFunctions::polyhedralMesh
PolyhedralMesh * polyhedralMesh(BaseObjectData *_object)
Get an PolyhedralMesh from an object.
Definition: PluginFunctionsPolyhedralMesh.cc:115
MovePlugin::axisA_
int axisA_
stores the current axes in the tool
Definition: MovePlugin.hh:195
DATA_PLANE
#define DATA_PLANE
Definition: Plane.hh:58
MovePlugin::slotMoveToOrigin
void slotMoveToOrigin()
Move target Meshes cog to the origin.
Definition: MovePlugin.cc:1729
MovePlugin::objectMarker_
MoveObjectMarker objectMarker_
Object marker to dimm Objects during manipulator transformation.
Definition: MovePlugin.hh:418
PluginFunctions::hexahedralMesh
HexahedralMesh * hexahedralMesh(BaseObjectData *_object)
Get an HexahedralMesh from an object.
Definition: PluginFunctionsHexahedralMesh.cc:114
MovePlugin::transformMesh
void transformMesh(ACG::Matrix4x4d _mat, MeshT &_mesh)
Transform a mesh with the given transformation matrix.
Definition: MovePlugin.cc:2213
SkeletonTransform
Skeleton transformation class.
Definition: SkeletonTransform.hh:58
PluginFunctions::hexahedralMeshObject
HexahedralMeshObject * hexahedralMeshObject(BaseObjectData *_object)
Cast an BaseObject to an HexahedralMeshObject if possible.
Definition: PluginFunctionsHexahedralMesh.cc:133
PluginFunctions::viewerProperties
Viewer::ViewerProperties & viewerProperties(int _id)
Get the viewer properties Use this functions to get basic viewer properties such as backgroundcolor o...
Definition: PluginFunctions.cc:609
MovePlugin::getBB
void getBB(MeshT &_mesh, ACG::Vec3d &_bb_min, ACG::Vec3d &_bb_max)
get bounding box diagonal of a mesh
Definition: MovePlugin.cc:2495
OpenVolumeMesh::NormalAttrib::update_vertex_normals
void update_vertex_normals()
A simple heuristic to estimate the vertex normals.
Definition: NormalAttribT_impl.hh:68
MovePlugin::toolBarActions_
QActionGroup * toolBarActions_
Called by Toolbar to enable move mode.
Definition: MovePlugin.hh:274
VolumeMeshObject::normals
const NormalAttrib & normals() const
return a pointer to the mesh
Definition: VolumeMeshObject.hh:134
MovePlugin::slotScale
void slotScale()
Scale (with values from Tab)
Definition: MovePlugin.cc:1578
ACG::Geometry::Plane::transform
void transform(const ACG::Matrix4x4d &_mat)
Transform the plane with given matrix.
Definition: PlaneType.cc:89
UPDATE_GEOMETRY
const UpdateType UPDATE_GEOMETRY(UpdateTypeSet(1)<< 2)
Geometry updated.
MovePlugin::toAllTargets_
QAction * toAllTargets_
Checked if transformation should be applied to all target objs.
Definition: MovePlugin.hh:485
ACG::Vec3d
VectorT< double, 3 > Vec3d
Definition: VectorT.hh:121
MovePlugin::slotProjectToTangentPlane
void slotProjectToTangentPlane()
Project the current manipulator onto the tangent plane of the object.
Definition: MovePlugin.cc:1338
MovePlugin::placeAndSnapAction_
QAction * placeAndSnapAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:305
MovePlugin::slotEnableObjectMode
void slotEnableObjectMode()
stores the current axes in the tool
Definition: MovePlugin.cc:482
MovePlugin::contextAction_
QAction * contextAction_
Context menu entry for showing per manipulator settings.
Definition: MovePlugin.hh:479
ACG::SceneGraph::TransformNode::matrix
const GLMatrixd & matrix() const
Returns a const reference to the current transformation matrix.
Definition: TransformNode.hh:158
MovePlugin::unifyBB
void unifyBB(MeshT &_mesh, Unificationtype u=MovePlugin::DIAGONAL)
scale mesh to have a boundingboxdiagonal of one
Definition: MovePlugin.cc:2441
MovePlugin::moveObject
void moveObject(ACG::Matrix4x4d mat, int _id)
Move an object with given id.
Definition: MovePlugin.cc:574
MovePlugin::rotateTranslateAction_
QAction * rotateTranslateAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:294
DATA_HEXAHEDRAL_MESH
#define DATA_HEXAHEDRAL_MESH
Definition: HexahedralMesh.hh:56
MovePlugin::transformVertexSelection
bool transformVertexSelection(int _objectId, Matrix4x4 _matrix)
transform current selection of an Object by a given matrix
Definition: MovePluginScript.cc:1018
DATA_POLY_LINE
#define DATA_POLY_LINE
Definition: PolyLine.hh:64
MovePlugin::smallerManipAction_
QAction * smallerManipAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:299
MovePlugin::slotUnifyBoundingBoxLongestAxis
void slotUnifyBoundingBoxLongestAxis()
Scale Boundingbox longest axis to unit size (keeps aspect ratio)
Definition: MovePlugin.cc:1907
MovePlugin::contextActionHide_
QAction * contextActionHide_
Context menu entry to hide a manipulator.
Definition: MovePlugin.hh:482
MovePlugin::ManipulatorPositionChanged
void ManipulatorPositionChanged(QtTranslationManipulatorNode *_node)
update object when its manipulator changes position
Definition: MovePlugin.cc:832
CONTEXTNODEMENU
The Menu will be shown when a node was picked.
Definition: ContextMenuInterface.hh:62
MovePlugin::slotTranslation
void slotTranslation()
perform a translation for Manipulator in tab
Definition: MovePlugin.cc:1233
MovePlugin::rotateManipAction_
QAction * rotateManipAction_
Called by pick Toolbar.
Definition: MovePlugin.hh:295
MovePlugin::transformEdgeSelection
bool transformEdgeSelection(int _objectId, Matrix4x4 _matrix)
transform current selection of an Object by a given matrix
Definition: MovePluginScript.cc:1376
MovePlugin::toolIcon_
QIcon * toolIcon_
stores the current axes in the tool
Definition: MovePlugin.hh:261
OpenVolumeMesh::GeometryKernel::vertex
const VecT & vertex(const VertexHandle &_vh) const
Get point _vh&#39;s coordinates.
Definition: GeometryKernel.hh:89
ACG::SceneGraph::QtTranslationManipulatorNode::getIdentifier
int getIdentifier()
Get an identifier for that manipulator.
Definition: QtTranslationManipulatorNode.hh:130
MovePlugin::translateFaceSelection
void translateFaceSelection(int _objectId, Vector _vector)
translate current face selection of an Object by a given vector
Definition: MovePluginScript.cc:483
MovePlugin::~MovePlugin
~MovePlugin()
Destructor.
Definition: MovePlugin.cc:125
MovePlugin::manipulatorMoved
void manipulatorMoved(QtTranslationManipulatorNode *_node, QMouseEvent *_event)
move the object when its manipulator moves
Definition: MovePlugin.cc:774
MovePlugin::slotMoveManipToCOG
void slotMoveManipToCOG()
Move the current manipulator to the cog of the object.
Definition: MovePlugin.cc:1360
MovePlugin::getDialogFromButton
movePropsWidget * getDialogFromButton(QPushButton *_but)
Get parent properties dialog widget of QPushButton but.
Definition: MovePlugin.cc:1022
MovePlugin::toolbar_
QToolBar * toolbar_
Called by Toolbar to enable move mode.
Definition: MovePlugin.hh:276
OpenMesh::VectorT::minimize
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition: Vector11T.hh:535
PluginFunctions::objectsEnd
DLLEXPORT ObjectIterator objectsEnd()
Return Iterator to Object End.
Definition: PluginFunctionsIterator.cc:177
MovePlugin::manip_size_modifier_
double manip_size_modifier_
Modifier for the Size (changed by Mousewheel Events)
Definition: MovePlugin.hh:403
ACG::Matrix4x4T::identity
void identity()
setup an identity matrix
Definition: Matrix4x4T_impl.hh:250
ACG::SceneGraph::find_node
BaseNode * find_node(BaseNode *_root, unsigned int _node_idx)
Find a node in the scene graph.
Definition: SceneGraph.cc:77
WhatsThisGenerator
a class which provides an link generator for WhatsThisMessages linking to the user doc If you have an...
Definition: WhatsThisGenerator.hh:65
DATA_POLYHEDRAL_MESH
#define DATA_POLYHEDRAL_MESH
Definition: PolyhedralMesh.hh:54
MovePlugin::hideManipulator
void hideManipulator()
Hide the manipulator( Called via context for picking. Get the picked id from the Qvariant attached to...
Definition: MoveContextMenu.cc:49
PluginFunctions::polyLine
PolyLine * polyLine(BaseObjectData *_object)
Get a poly Line from an object.
Definition: PluginFunctionsPolyLine.cc:133
PluginFunctions::setViewObjectMarker
void setViewObjectMarker(ViewObjectMarker *_marker)
Definition: PluginFunctions.cc:940
PluginFunctions::polyMesh
PolyMesh * polyMesh(BaseObjectData *_object)
Get a poly mesh from an object.
Definition: PluginFunctionsPolyMesh.cc:128
MovePlugin::setAllTargets
void setAllTargets(bool _state)
Sets whether all targets should be affected or not.
Definition: MovePlugin.cc:2632
MovePlugin::getNearestEdge
OpenMesh::Vec3d getNearestEdge(MeshType *_mesh, uint _fh, OpenMesh::Vec3d &_hitPoint)
Get closest edge to hitpoint.
Definition: MovePlugin.cc:2674
ACG::SceneGraph::PICK_FACE
picks faces (should be implemented for all nodes)
Definition: PickTarget.hh:78
MovePlugin::slotPickToolbarAction
void slotPickToolbarAction(QAction *_action)
Called by pick Toolbar.
Definition: MovePlugin.cc:2139
MovePlugin::slotUnifyBoundingBoxDiagonal
void slotUnifyBoundingBoxDiagonal()
Scale Boundingbox Diagonal to unit size.
Definition: MovePlugin.cc:1902
PluginFunctions::actionMode
Viewer::ActionMode actionMode()
Get the current Action mode.
Definition: PluginFunctions.cc:586
MovePlugin::selectionType_
SelectionType selectionType_
Current SelectionType of SelectionPlugin.
Definition: MovePlugin.hh:435
MovePlugin::getLastManipulatorMatrix
ACG::Matrix4x4d getLastManipulatorMatrix(bool _reset=true)
Get the Matrix of the last active Manipulator ( Identity if not found or hidden Manipulator ) ...
Definition: MovePlugin.cc:2187
MovePlugin::getNearestVertex
OpenMesh::Vec3d getNearestVertex(MeshType *_mesh, uint _fh, OpenMesh::Vec3d &_hitPoint)
Get closest vertex to hitpoint.
Definition: MovePlugin.cc:2642
DATA_TRIANGLE_MESH
#define DATA_TRIANGLE_MESH
Definition: TriangleMesh.hh:60
MovePlugin::slotUpdateContextMenuNode
void slotUpdateContextMenuNode(int _nodeId)
Hide context menu entry when right clicking on node other than manipulator node.
Definition: MovePlugin.cc:753
MovePlugin::activeManipulators_
std::vector< int > activeManipulators_
Size for the manipulators.
Definition: MovePlugin.hh:323
MovePlugin::translateEdgeSelection
void translateEdgeSelection(int _objectId, Vector _vector)
translate current edge selection of an Object by a given vector
Definition: MovePluginScript.cc:615
MovePlugin::lastActiveManipulator_
int lastActiveManipulator_
Stores the last manipulator which has been clicked ( used for the toolbox dialog) ...
Definition: MovePlugin.hh:406
PluginFunctions::targetCount
int targetCount()
Get the number of target objects.
Definition: PluginFunctions.cc:1006
MovePlugin::slotSetMoveMode
void slotSetMoveMode(QAction *_action)
Called by Toolbar to enable move mode.
Definition: MovePlugin.cc:2114
VolumeMeshObject::mesh
MeshT * mesh()
return a pointer to the mesh
Definition: VolumeMeshObjectT_impl.hh:212
MovePlugin::slotRotate
void slotRotate()
Rotate Manipulator (with values from Tab)
Definition: MovePlugin.cc:1422
ACG::Matrix4x4T::transform_vector
VectorT< T, 3 > transform_vector(const VectorT< T, 3 > &_v) const
transform vector (x&#39;,y&#39;,z&#39;,0) = A * (x,y,z,0)
Definition: Matrix4x4T_impl.hh:219
OpenVolumeMesh::GeometryKernel::set_vertex
void set_vertex(const VertexHandle &_vh, const VecT &_p)
Set the coordinates of point _vh.
Definition: GeometryKernel.hh:81
ACG::GLMatrixT::translate
void translate(Scalar _x, Scalar _y, Scalar _z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
multiply self with translation matrix (x,y,z)
Definition: GLMatrixT_impl.hh:96
ACG::SceneGraph::TransformNode::center
const Vec3d & center() const
get center
Definition: TransformNode.hh:115
PluginFunctions::traverse
void traverse(ACG::SceneGraph::MouseEventAction &_action)
Definition: PluginFunctions.cc:569
MovePlugin::unifyBoundingBox
void unifyBoundingBox(Unificationtype u)
Size for the manipulators.
Definition: MovePlugin.cc:1917
MovePlugin::translateVertexSelection
void translateVertexSelection(int _objectId, Vector _vector)
translate current vertex selection of an Object by a given vector
Definition: MovePluginScript.cc:359
PluginFunctions::tetrahedralMesh
TetrahedralMesh * tetrahedralMesh(BaseObjectData *_object)
Get an TetrahedralMesh from an object.
Definition: PluginFunctionsTetrahedralMesh.cc:114
MovePlugin::slotPickModeChanged
void slotPickModeChanged(const std::string &_mode)
slot is called when the pickMode changed
Definition: MovePlugin.cc:525
MovePlugin::slotMouseEvent
void slotMouseEvent(QMouseEvent *_event)
MousePress event occured.
Definition: MovePlugin.cc:400
BaseObjectData::manipulatorNode
QtTranslationManipulatorNode * manipulatorNode()
Definition: BaseObjectData.cc:255
PluginFunctions::getSceneGraphRootNode
ACG::SceneGraph::BaseNode * getSceneGraphRootNode()
get scenegraph root node
Definition: PluginFunctions.cc:957
MovePlugin::contextMenuManipControl_
QMenu * contextMenuManipControl_
Additional Context Menu replicating the toolbar stuff.
Definition: MovePlugin.hh:488
PluginFunctions::pickMode
const std::string pickMode()
Get the current Picking mode.
Definition: PluginFunctions.cc:575
MovePlugin::slotUnifyBoundingBoxAllAxis
void slotUnifyBoundingBoxAllAxis()
Scale all Boundingbox axis to unit size.
Definition: MovePlugin.cc:1912
MovePlugin::pluginsInitialized
void pluginsInitialized()
Initialization of the plugin when it is loaded by the core.
Definition: MovePlugin.cc:156
OpenMesh::VectorT::max
Scalar max() const
return the maximal component
Definition: Vector11T.hh:493
WhatsThisGenerator::setWhatsThis
void setWhatsThis(QAction *_action, const QString &_msg, const QString &_ref="", const QString &_site="index.html") const
sets a whatsThis Message plus link to the doc for the given QAction
Definition: WhatsThisGenerator.cc:89
MovePlugin::moveSelectionAction_
QAction * moveSelectionAction_
Called by Toolbar to enable move mode.
Definition: MovePlugin.hh:272