Developer Documentation
VertexSelection.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  * *
44  * $Revision$ *
45  * $Author$ *
46  * $Date$ *
47  * *
48 \*===========================================================================*/
49 
50 #include "MeshObjectSelectionPlugin.hh"
51 
52 #include <MeshTools/MeshSelectionT.hh>
53 
54 //=========================================================
55 //==== Vertex selections
56 //=========================================================
57 
58 void MeshObjectSelectionPlugin::selectVertices(int _objectId, IdList _vertexList) {
59 
60  if(_vertexList.empty() ) return;
61 
62  BaseObjectData* object = 0;
63  if (!PluginFunctions::getObject(_objectId,object)) {
64  emit log(LOGERR,tr("selectVertices: unable to get object"));
65  return;
66  }
67 
68  if (object->dataType() == DATA_TRIANGLE_MESH)
69  MeshSelection::selectVertices(PluginFunctions::triMesh(object), _vertexList);
70  else if (object->dataType() == DATA_POLY_MESH)
71  MeshSelection::selectVertices(PluginFunctions::polyMesh(object), _vertexList);
72  else {
73  emit log(LOGERR,tr("selectAllVertices: Unsupported object Type"));
74  return;
75  }
76 
77  QString selection = "selectVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
78 
79  for (uint i = 1 ; i < _vertexList.size(); ++i) {
80  selection += ", " + QString::number(_vertexList[i]);
81  }
82 
83  selection += " ])";
84 
85  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
86  emit scriptInfo(selection);
87 }
88 
89 //=========================================================
90 
91 bool MeshObjectSelectionPlugin::selectVertex(int _objectId, int _idx, bool _fly_to_vertex)
92 {
93  return selectElement(_objectId, OpenMesh::VertexHandle(_idx), _fly_to_vertex);
94 }
95 
96 //=========================================================
97 
98 void MeshObjectSelectionPlugin::unselectVertices(int _objectId, IdList _vertexList) {
99 
100  if(_vertexList.empty() ) return;
101 
102  BaseObjectData* object = 0;
103  if (!PluginFunctions::getObject(_objectId,object)) {
104  emit log(LOGERR,tr("unselectVertices: unable to get object"));
105  return;
106  }
107 
108  if (object->dataType() == DATA_TRIANGLE_MESH)
109  MeshSelection::unselectVertices(PluginFunctions::triMesh(object), _vertexList);
110  else if (object->dataType() == DATA_POLY_MESH)
111  MeshSelection::unselectVertices(PluginFunctions::polyMesh(object), _vertexList);
112  else {
113  emit log(LOGERR,tr("unselectVertices: Unsupported object Type"));
114  return;
115  }
116 
117  QString selection = "unselectVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
118 
119  for (uint i = 1 ; i < _vertexList.size(); ++i) {
120  selection += ", " + QString::number(_vertexList[i]);
121  }
122 
123  selection += " ])";
124 
125  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
126  emit scriptInfo(selection);
127 }
128 
129 
130 //=========================================================
131 
132 
133 void MeshObjectSelectionPlugin::selectAllVertices(int _objectId) {
134 
135  BaseObjectData* object;
136  if (!PluginFunctions::getObject(_objectId,object)) {
137  emit log(LOGERR,tr("selectAllVertices: unable to get object"));
138  return;
139  }
140 
141  if (object->dataType() == DATA_TRIANGLE_MESH)
142  MeshSelection::selectAllVertices(PluginFunctions::triMesh(object));
143  else if (object->dataType() == DATA_POLY_MESH)
144  MeshSelection::selectAllVertices(PluginFunctions::polyMesh(object));
145  else {
146  emit log(LOGERR,tr("selectAllVertices: Unsupported object Type"));
147  return;
148  }
149 
150  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
151  emit scriptInfo("selectAllVertices(ObjectId(" + QString::number(_objectId) + "))");
152 }
153 
154 //=========================================================
155 
156 void MeshObjectSelectionPlugin::clearVertexSelection(int _objectId) {
157 
158  BaseObjectData* object;
159  if (!PluginFunctions::getObject(_objectId,object)) {
160  emit log(LOGERR,tr("clearVertexSelection: unable to get object"));
161  return;
162  }
163 
164  if (object->dataType() == DATA_TRIANGLE_MESH)
165  MeshSelection::clearVertexSelection(PluginFunctions::triMesh(object));
166  else if (object->dataType() == DATA_POLY_MESH)
167  MeshSelection::clearVertexSelection(PluginFunctions::polyMesh(object));
168  else {
169  emit log(LOGERR,tr("clearVertexSelection: Unsupported object Type"));
170  return;
171  }
172 
173  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
174  emit scriptInfo("clearVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
175 }
176 
177 //=========================================================
178 
179 void MeshObjectSelectionPlugin::invertVertexSelection(int _objectId) {
180 
181  BaseObjectData* object;
182  if (!PluginFunctions::getObject(_objectId,object)) {
183  emit log(LOGERR,tr("invertVertexSelection: unable to get object"));
184  return;
185  }
186 
187  if (object->dataType() == DATA_TRIANGLE_MESH)
188  MeshSelection::invertVertexSelection(PluginFunctions::triMesh(object));
189  else if (object->dataType() == DATA_POLY_MESH)
190  MeshSelection::invertVertexSelection(PluginFunctions::polyMesh(object));
191  else {
192  emit log(LOGERR,tr("invertVertexSelection: Unsupported object Type"));
193  return;
194  }
195 
196  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
197  emit scriptInfo("invertVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
198 }
199 
200 //=========================================================
201 
202 void MeshObjectSelectionPlugin::selectBoundaryVertices(int _objectId) {
203 
204  BaseObjectData* object;
205  if (!PluginFunctions::getObject(_objectId,object)) {
206  emit log(LOGERR,tr("selectBoundaryVertices: unable to get object"));
207  return;
208  }
209 
210  if (object->dataType() == DATA_TRIANGLE_MESH)
211  MeshSelection::selectBoundaryVertices(PluginFunctions::triMesh(object));
212  else if (object->dataType() == DATA_POLY_MESH)
213  MeshSelection::selectBoundaryVertices(PluginFunctions::polyMesh(object));
214  else {
215  emit log(LOGERR,tr("selectBoundaryVertices: Unsupported object Type"));
216  return;
217  }
218 
219  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
220  emit scriptInfo("selectBoundaryVertices(ObjectId(" + QString::number(_objectId) + "))");
221 }
222 
223 //=========================================================
224 
225 void MeshObjectSelectionPlugin::selectClosestBoundaryVertices(int _objectId, int _vertexId) {
226 
227  BaseObjectData* object;
228  if (!PluginFunctions::getObject(_objectId,object)) {
229  emit log(LOGERR,tr("selectClosestBoundaryVertices: unable to get object"));
230  return;
231  }
232 
233  if (object->dataType() == DATA_TRIANGLE_MESH) {
234  closestBoundarySelection(PluginFunctions::triMesh(object),_vertexId, vertexType_, false);
235  } else if (object->dataType() == DATA_POLY_MESH) {
236  closestBoundarySelection(PluginFunctions::polyMesh(object),_vertexId, vertexType_, false);
237  } else {
238  emit log(LOGERR,tr("selectClosestBoundaryVertices: Unsupported object Type"));
239  return;
240  }
241 
242  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
243  emit scriptInfo("selectClosestBoundaryVertices(ObjectId(" + QString::number(_objectId) + "), VertexId)");
244 }
245 
246 //=========================================================
247 
248 void MeshObjectSelectionPlugin::shrinkVertexSelection(int _objectId) {
249 
250  BaseObjectData* object;
251  if (!PluginFunctions::getObject(_objectId,object)) {
252  emit log(LOGERR,tr("shrinkVertexSelection: unable to get object"));
253  return;
254  }
255 
256  if (object->dataType() == DATA_TRIANGLE_MESH)
257  MeshSelection::shrinkVertexSelection(PluginFunctions::triMesh(object));
258  else if (object->dataType() == DATA_POLY_MESH)
259  MeshSelection::shrinkVertexSelection(PluginFunctions::polyMesh(object));
260  else {
261  emit log(LOGERR,tr("shrinkVertexSelection: Unsupported object Type"));
262  return;
263  }
264 
265  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
266  emit scriptInfo("shrinkVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
267 }
268 
269 //=========================================================
270 
271 void MeshObjectSelectionPlugin::growVertexSelection(int _objectId) {
272 
273  BaseObjectData* object;
274  if (!PluginFunctions::getObject(_objectId,object)) {
275  emit log(LOGERR,tr("growVertexSelection: unable to get object"));
276  return;
277  }
278 
279  if (object->dataType() == DATA_TRIANGLE_MESH)
280  MeshSelection::growVertexSelection(PluginFunctions::triMesh(object));
281  else if (object->dataType() == DATA_POLY_MESH)
282  MeshSelection::growVertexSelection(PluginFunctions::polyMesh(object));
283  else {
284  emit log(LOGERR,tr("growVertexSelection: Unsupported object Type"));
285  return;
286  }
287 
288  emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
289  emit scriptInfo("growVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
290 }
291 
292 //=========================================================
293 
294 IdList MeshObjectSelectionPlugin::getVertexSelection(int _objectId) {
295 
296  BaseObjectData* object;
297  if (!PluginFunctions::getObject(_objectId,object)) {
298  emit log(LOGERR,tr("getVertexSelection: unable to get object"));
299  return IdList(0);
300  }
301 
302  emit scriptInfo("getVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
303 
304  if (object->dataType() == DATA_TRIANGLE_MESH)
305  return MeshSelection::getVertexSelection(PluginFunctions::triMesh(object));
306  else if (object->dataType() == DATA_POLY_MESH)
307  return MeshSelection::getVertexSelection(PluginFunctions::polyMesh(object));
308  else {
309  emit log(LOGERR,tr("getVertexSelection: Unsupported object Type"));
310  return IdList(0);
311  }
312 
313  return IdList(0);
314 }
315 
316 //=========================================================
317 
318 void MeshObjectSelectionPlugin::deleteVertexSelection(int _objectId) {
319 
320  BaseObjectData* object;
321  if (!PluginFunctions::getObject(_objectId,object)) {
322  emit log(LOGERR,tr("deleteVertexSelection: unable to get object"));
323  return;
324  }
325 
326  if (object->dataType() == DATA_TRIANGLE_MESH)
327  deleteSelection(PluginFunctions::triMesh(object), vertexType_);
328  else if (object->dataType() == DATA_POLY_MESH)
329  deleteSelection(PluginFunctions::polyMesh(object), vertexType_);
330  else {
331  emit log(LOGERR,tr("deleteVertexSelection: Unsupported object Type"));
332  return;
333  }
334 
335  emit updatedObject(object->id(), UPDATE_ALL);
336  emit scriptInfo("deleteVertexSelection(ObjectId(" + QString::number(_objectId) + "))");
337 }
338 
339 //=========================================================
340 
341 int MeshObjectSelectionPlugin::createMeshFromVertexSelection( int _objectId) {
342  return createMeshFromSelection(_objectId, vertexType_ );
343 }
344 
345 //=========================================================
346 
348 void MeshObjectSelectionPlugin::colorizeVertexSelection(int _objectId, int r, int g, int b, int a) {
349 
350  BaseObjectData* object;
351  if (!PluginFunctions::getObject(_objectId, object)) {
352  emit log(LOGERR,"colorizeVertexSelection: unable to get object");
353  return;
354  }
355 
356  if (object->dataType() == DATA_TRIANGLE_MESH) {
357  colorizeSelection(PluginFunctions::triMesh(object), vertexType_, r, g, b, a);
358  } else if (object->dataType() == DATA_POLY_MESH) {
359  colorizeSelection(PluginFunctions::polyMesh(object), vertexType_, r, g, b, a);
360  } else {
361  emit log(LOGERR,"colorizeVertexSelection: Unsupported object Type");
362  return;
363  }
364 
365  emit scriptInfo("colorizeVertexSelection(ObjectId(" + QString::number(_objectId) + "), "
366  + QString::number(r) + ", " + QString::number(g) + ", " + QString::number(b) + ")");
367 
368  emit updatedObject(_objectId, UPDATE_COLOR);
369 }
370 
371 //=========================================================
372 //==== Modeling Area selections
373 //=========================================================
374 
375 void MeshObjectSelectionPlugin::selectHandleVertices(int _objectId, IdList _vertexList) {
376 
377  BaseObjectData* object;
378  if (!PluginFunctions::getObject(_objectId,object)) {
379  emit log(LOGERR,tr("selectHandleVertices: unable to get object"));
380  return;
381  }
382 
383  if (_vertexList.empty() )
384  return;
385 
386  if (object->dataType() == DATA_TRIANGLE_MESH){
387  MeshSelection::setArea(PluginFunctions::triMesh(object), _vertexList, HANDLEAREA, true);
388  update_regions(PluginFunctions::triMesh(object));
389  } else if (object->dataType() == DATA_POLY_MESH){
390  MeshSelection::setArea(PluginFunctions::polyMesh(object), _vertexList, HANDLEAREA, true);
391  update_regions(PluginFunctions::polyMesh(object));
392  } else {
393  emit log(LOGERR,tr("selectHandleVertices: Unsupported object Type"));
394  return;
395  }
396 
397  QString selection = "selectHandleVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
398 
399  for (uint i = 1 ; i < _vertexList.size(); ++i) {
400  selection += ", " + QString::number(_vertexList[i]);
401  }
402 
403  selection += " ])";
404 
405  emit updatedObject(object->id(), UPDATE_ALL);
406  emit scriptInfo(selection);
407 }
408 
409 //=========================================================
410 
411 void MeshObjectSelectionPlugin::unselectHandleVertices(int _objectId, IdList _vertexList) {
412 
413  if(_vertexList.empty()) return;
414 
415  BaseObjectData* object = 0;
416  if (!PluginFunctions::getObject(_objectId,object)) {
417  emit log(LOGERR,tr("unselectHandleVertices: unable to get object"));
418  return;
419  }
420 
421  if (object->dataType() == DATA_TRIANGLE_MESH)
422  MeshSelection::setArea(PluginFunctions::triMesh(object), _vertexList, HANDLEAREA, false);
423  else if (object->dataType() == DATA_POLY_MESH)
424  MeshSelection::setArea(PluginFunctions::polyMesh(object), _vertexList, HANDLEAREA, false);
425  else {
426  emit log(LOGERR,tr("unselectHandleVertices: Unsupported object Type"));
427  return;
428  }
429 
430  QString selection = "unselectHandleVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
431 
432  for (uint i = 1 ; i < _vertexList.size(); ++i) {
433  selection += ", " + QString::number(_vertexList[i]);
434  }
435 
436  selection += " ])";
437 
438  emit updatedObject(object->id(), UPDATE_ALL);
439  emit scriptInfo(selection);
440 }
441 
442 //=========================================================
443 
444 void MeshObjectSelectionPlugin::clearHandleVertices(int _objectId) {
445 
446  BaseObjectData* object;
447  if (!PluginFunctions::getObject(_objectId,object)) {
448  emit log(LOGERR,tr("clearHandleVertices: unable to get object"));
449  return;
450  }
451 
452  if (object->dataType() == DATA_TRIANGLE_MESH)
453  MeshSelection::setArea(PluginFunctions::triMesh(object), HANDLEAREA, false);
454  else if (object->dataType() == DATA_POLY_MESH)
455  MeshSelection::setArea(PluginFunctions::polyMesh(object), HANDLEAREA, false);
456  else {
457  emit log(LOGERR,tr("clearHandleVertices: Unsupported object Type"));
458  return;
459  }
460 
461  emit updatedObject(object->id(), UPDATE_ALL);
462  emit scriptInfo("clearHandleVertices(ObjectId(" + QString::number(_objectId) + "))");
463 }
464 
465 //=========================================================
466 
467 void MeshObjectSelectionPlugin::setAllHandleVertices(int _objectId) {
468 
469  BaseObjectData* object;
470  if (!PluginFunctions::getObject(_objectId,object)) {
471  emit log(LOGERR,tr("setAllHandleVertices: unable to get object"));
472  return;
473  }
474 
475  if (object->dataType() == DATA_TRIANGLE_MESH)
476  MeshSelection::setArea(PluginFunctions::triMesh(object), HANDLEAREA, true);
477  else if (object->dataType() == DATA_POLY_MESH)
478  MeshSelection::setArea(PluginFunctions::polyMesh(object), HANDLEAREA, true);
479  else {
480  emit log(LOGERR,tr("setAllHandleVertices: Unsupported object Type"));
481  return;
482  }
483 
484  emit updatedObject(object->id(), UPDATE_ALL);
485  emit scriptInfo("setAllHandleVertices(ObjectId(" + QString::number(_objectId) + "))");
486 }
487 
488 //=========================================================
489 
490 IdList MeshObjectSelectionPlugin::getHandleVertices(int _objectId) {
491 
492  BaseObjectData* object;
493  if (!PluginFunctions::getObject(_objectId,object)) {
494  emit log(LOGERR,tr("getHandleVertices: unable to get object"));
495  return IdList(0);
496  }
497 
498  emit scriptInfo("getHandleVertices(ObjectId(" + QString::number(_objectId) + "))");
499 
500  if (object->dataType() == DATA_TRIANGLE_MESH)
501  return MeshSelection::getArea(PluginFunctions::triMesh(object), HANDLEAREA);
502  else if (object->dataType() == DATA_POLY_MESH)
503  return MeshSelection::getArea(PluginFunctions::polyMesh(object), HANDLEAREA);
504  else {
505  emit log(LOGERR,tr("getHandleVertices: Unsupported object Type"));
506  return IdList(0);;
507  }
508 
509  return IdList(0);
510 }
511 
512 //=========================================================
513 //==== Modeling Area selections
514 //=========================================================
515 
516 void MeshObjectSelectionPlugin::selectModelingVertices(int _objectId, IdList _vertexList) {
517 
518  if(_vertexList.empty() ) return;
519 
520  BaseObjectData* object = 0;
521  if (!PluginFunctions::getObject(_objectId,object)) {
522  emit log(LOGERR,tr("selectModelingVertices: unable to get object"));
523  return;
524  }
525 
526  if (object->dataType() == DATA_TRIANGLE_MESH) {
527  MeshSelection::setArea(PluginFunctions::triMesh(object), _vertexList, AREA, true);
528  update_regions(PluginFunctions::triMesh(object));
529  } else if (object->dataType() == DATA_POLY_MESH){
530  MeshSelection::setArea(PluginFunctions::polyMesh(object), _vertexList, AREA, true);
531  update_regions(PluginFunctions::polyMesh(object));
532  } else {
533  emit log(LOGERR,tr("selectModelingVertices: Unsupported object Type"));
534  return;
535  }
536 
537  QString selection = "selectModelingVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
538 
539  for (uint i = 1 ; i < _vertexList.size(); ++i) {
540  selection += ", " + QString::number(_vertexList[i]);
541  }
542 
543  selection += " ])";
544 
545  emit updatedObject(object->id(), UPDATE_ALL);
546  emit scriptInfo(selection);
547 }
548 
549 //=========================================================
550 
551 void MeshObjectSelectionPlugin::unselectModelingVertices(int _objectId, IdList _vertexList) {
552 
553  if(_vertexList.empty() ) return;
554 
555  BaseObjectData* object = 0;
556  if (!PluginFunctions::getObject(_objectId,object)) {
557  emit log(LOGERR,tr("unselectModelingVertices: unable to get object"));
558  return;
559  }
560 
561  if (object->dataType() == DATA_TRIANGLE_MESH)
562  MeshSelection::setArea(PluginFunctions::triMesh(object), _vertexList, AREA, false);
563  else if (object->dataType() == DATA_POLY_MESH)
564  MeshSelection::setArea(PluginFunctions::polyMesh(object), _vertexList, AREA, false);
565  else{
566  emit log(LOGERR,tr("unselectModelingVertices: Unsupported object Type"));
567  return;
568  }
569 
570  QString selection = "unselectModelingVertices(ObjectId(" + QString::number(_objectId) + "), [ " + QString::number(_vertexList[0]);
571 
572  for (uint i = 1 ; i < _vertexList.size(); ++i) {
573  selection += ", " + QString::number(_vertexList[i]);
574  }
575 
576  selection += " ])";
577 
578  emit updatedObject(object->id(), UPDATE_ALL);
579  emit scriptInfo(selection);
580 }
581 
582 // =========================================================
583 
584 void MeshObjectSelectionPlugin::selectVerticesByValue(int _objectId, QString _component, bool _greater, double _value ) {
585  BaseObjectData* object = 0;
586  if (!PluginFunctions::getObject(_objectId,object)) {
587  emit log(LOGERR,tr("selectVerticesByValue: unable to get object"));
588  return;
589  }
590 
591  if (object->dataType() == DATA_TRIANGLE_MESH)
592  selectVerticesByValue(PluginFunctions::triMesh(object), _component, _greater, _value);
593  else if (object->dataType() == DATA_POLY_MESH)
594  selectVerticesByValue(PluginFunctions::polyMesh(object), _component, _greater, _value);
595  else{
596  emit log(LOGERR,tr("selectVerticesByValue: Unsupported object Type"));
597  return;
598  }
599 
600  emit updatedObject(object->id(), UPDATE_SELECTION);
601 
603 
604 }
605 
606 
607 //=========================================================
608 
609 void MeshObjectSelectionPlugin::clearModelingVertices(int _objectId) {
610 
611  BaseObjectData* object;
612  if (!PluginFunctions::getObject(_objectId,object)) {
613  emit log(LOGERR,tr("clearModelingVertices: unable to get object"));
614  return;
615  }
616 
617  if (object->dataType() == DATA_TRIANGLE_MESH)
618  MeshSelection::setArea(PluginFunctions::triMesh(object), AREA, false);
619  else if (object->dataType() == DATA_POLY_MESH)
620  MeshSelection::setArea(PluginFunctions::polyMesh(object), AREA, false);
621  else{
622  emit log(LOGERR,tr("clearModelingVertices: Unsupported object Type"));
623  return;
624  }
625 
626  emit updatedObject(object->id(), UPDATE_ALL);
627  emit scriptInfo("clearModelingVertices(ObjectId(" + QString::number(_objectId) + "))");
628 }
629 
630 //=========================================================
631 
632 void MeshObjectSelectionPlugin::setAllModelingVertices(int _objectId) {
633 
634  BaseObjectData* object;
635  if (!PluginFunctions::getObject(_objectId,object)) {
636  emit log(LOGERR,tr("setAllModelingVertices: unable to get object"));
637  return;
638  }
639 
640  if (object->dataType() == DATA_TRIANGLE_MESH)
641  MeshSelection::setArea(PluginFunctions::triMesh(object), AREA, true);
642  else if (object->dataType() == DATA_POLY_MESH)
643  MeshSelection::setArea(PluginFunctions::polyMesh(object), AREA, true);
644  else{
645  emit log(LOGERR,tr("setAllModelingVertices: Unsupported object Type"));
646  return;
647  }
648 
649  emit updatedObject(object->id(), UPDATE_ALL);
650  emit scriptInfo("setAllModelingVertices(ObjectId(" + QString::number(_objectId) + "))");
651 }
652 
653 //=========================================================
654 IdList MeshObjectSelectionPlugin::getModelingVertices(int _objectId) {
655  BaseObjectData* object;
656  if (!PluginFunctions::getObject(_objectId,object)) {
657  emit log(LOGERR,tr("getModelingVertices: unable to get object"));
658  return IdList(0);
659  }
660 
661  emit scriptInfo("getModelingVertices(ObjectId(" + QString::number(_objectId) + "))");
662 
663  if (object->dataType() == DATA_TRIANGLE_MESH)
664  return MeshSelection::getArea(PluginFunctions::triMesh(object), AREA);
665  else if (object->dataType() == DATA_POLY_MESH)
666  return MeshSelection::getArea(PluginFunctions::polyMesh(object), AREA);
667  else{
668  emit log(LOGERR,tr("getModelingVertices: Unsupported object Type"));
669  return IdList(0);
670  }
671 
672  return IdList(0);
673 }
674 
675 //=========================================================
676 
677 void MeshObjectSelectionPlugin::loadFlipperModelingSelection(int _objectId, QString _filename) {
678 
679  QFile file(_filename);
680 
681  if (!file.exists()) {
682  emit log(LOGERR,tr("Unable to find file: ") + _filename);
683  return;
684  }
685 
686  if (file.open(QFile::ReadOnly)) {
687 
688  QTextStream input(&file);
689  QString header = input.readLine();
690 
691  if (!header.contains("Selection")) {
692  emit log(LOGERR,tr("Wrong file header!should be Selection but is ") + header);
693  return;
694  }
695 
696  header = input.readLine();
697 
698  bool ok = false;
699  uint vertexCount = header.toUInt(&ok);
700 
701  if (!ok) {
702  emit log(LOGERR,tr("Unable to parse header. Cant get vertex count from string: ") + header);
703  return;
704  }
705 
706  //compare VertexCount
707  BaseObjectData* object;
708  if (!PluginFunctions::getObject(_objectId, object)) {
709  emit log(LOGERR,tr("loadSelection: unable to get object"));
710  return;
711  }
712 
713  if (object->dataType() == DATA_TRIANGLE_MESH) {
714  if (PluginFunctions::triMesh(object)->n_vertices() != vertexCount)
715  return;
716  } else if (object->dataType() == DATA_POLY_MESH) {
717  if (PluginFunctions::polyMesh(object)->n_vertices() != vertexCount)
718  return;
719  } else {
720  return;
721  }
722 
723  //get selected handles
724  IdList handleVertices;
725  IdList modelingVertices;
726 
727  uint vertexId = 0;
728 
729  do {
730  // Split into two substrings
731  QStringList inputList = input.readLine().split(" ");
732 
733  if (inputList.size() != 2) {
734  emit log(LOGERR,tr("Unable to parse entry at vertex index ") + QString::number(vertexId));
735  return;
736  }
737 
738  if (inputList[0] == "1")
739  modelingVertices.push_back(vertexId);
740 
741  if (inputList[1] == "1")
742  handleVertices.push_back(vertexId);
743 
744  ++vertexId;
745 
746  } while (!input.atEnd());
747 
748  clearModelingVertices(_objectId);
749  selectModelingVertices(_objectId,modelingVertices);
750 
751  clearHandleVertices(_objectId);
752  selectHandleVertices(_objectId,handleVertices);
753 
754  } else {
755  emit log(LOGERR,tr("Unable to open selection file!"));
756  }
757 }
758 
759 //=========================================================
760 
761 void MeshObjectSelectionPlugin::saveFlipperModelingSelection(int _objectId, QString _filename) {
762 
763  QFile file(_filename);
764 
765  if (file.open(QFile::WriteOnly)) {
766  QTextStream input(&file);
767 
768  //get the object
769  BaseObjectData* object;
770  if (!PluginFunctions::getObject(_objectId,object)) {
771  emit log(LOGERR,tr("saveFlipperModelingSelection: unable to get object"));
772  return;
773  }
774 
775  if (object->dataType() == DATA_TRIANGLE_MESH) {
776  TriMesh* mesh = PluginFunctions::triMesh(object);
777 
778  //header
779  input << "Selection" << endl;
780  input << mesh->n_vertices() << endl;
781 
782  std::vector< int > modelingVertices = MeshSelection::getArea(mesh, AREA);
783  std::vector< int > handleVertices = MeshSelection::getArea(mesh, HANDLEAREA);
784 
785  std::vector< bool > modelingAll(mesh->n_vertices(), false);
786  std::vector< bool > handleAll(mesh->n_vertices(), false);
787 
788  for (uint i=0; i < modelingVertices.size(); i++)
789  modelingAll[ modelingVertices[i] ] = true;
790 
791  for (uint i=0; i < handleVertices.size(); i++)
792  handleAll[ handleVertices[i] ] = true;
793 
794  for (uint i=0; i < mesh->n_vertices(); i++)
795  input << (int) modelingAll[i] << " " << (int) handleAll[i] << endl;
796 
797  } else if (object->dataType() == DATA_POLY_MESH){
798 
799  PolyMesh* mesh = PluginFunctions::polyMesh(object);
800 
801  //header
802  input << "Selection" << endl;
803  input << mesh->n_vertices() << endl;
804 
805  std::vector< int > modelingVertices = MeshSelection::getArea(mesh, AREA);
806  std::vector< int > handleVertices = MeshSelection::getArea(mesh, HANDLEAREA);
807 
808  std::vector< bool > modelingAll(mesh->n_vertices(), false);
809  std::vector< bool > handleAll(mesh->n_vertices(), false);
810 
811  for (uint i=0; i < modelingVertices.size(); i++)
812  modelingAll[ modelingVertices[i] ] = true;
813 
814  for (uint i=0; i < handleVertices.size(); i++)
815  handleAll[ handleVertices[i] ] = true;
816 
817  for (uint i=0; i < mesh->n_vertices(); i++)
818  input << (int) modelingAll[i] << " " << (int) handleAll[i] << endl;
819 
820  } else {
821  emit log(LOGERR, tr("saveFlipperModelingSelection: Unsupported Type."));
822  }
823  } else {
824  emit log(LOGERR,tr("Unable to open selection file!"));
825  }
826 }
MeshObjectSelectionPlugin::unselectModelingVertices
void unselectModelingVertices(int objectId, IdList _vertexList)
Remove vertices from modeling area.
Definition: VertexSelection.cc:551
MeshObjectSelectionPlugin::selectHandleVertices
void selectHandleVertices(int objectId, IdList _vertexList)
Set vertices to be part of the handle area.
Definition: VertexSelection.cc:375
DATA_TRIANGLE_MESH
#define DATA_TRIANGLE_MESH
Definition: TriangleMesh.hh:60
MeshObjectSelectionPlugin::shrinkVertexSelection
void shrinkVertexSelection(int _objectId)
Shrink the current vertex selection.
Definition: VertexSelection.cc:248
DATA_POLY_MESH
#define DATA_POLY_MESH
Definition: PolyMesh.hh:59
MeshObjectSelectionPlugin::selectVerticesByValue
void selectVerticesByValue(int _objectId, QString _component, bool _greater, double _value)
Select vertices by their value.
Definition: VertexSelection.cc:584
UPDATE_ALL
const UpdateType UPDATE_ALL(UpdateTypeSet(1))
Identifier for all updates.
MeshObjectSelectionPlugin::saveFlipperModelingSelection
void saveFlipperModelingSelection(int _objectId, QString _filename)
Save a selection in Flipper Selection Format.
Definition: VertexSelection.cc:761
MeshObjectSelectionPlugin::unselectHandleVertices
void unselectHandleVertices(int objectId, IdList _vertexList)
Remove vertices from handle area.
Definition: VertexSelection.cc:411
PluginFunctions::polyMesh
PolyMesh * polyMesh(BaseObjectData *_object)
Get a poly mesh from an object.
Definition: PluginFunctionsPolyMesh.cc:128
UPDATE_SELECTION_VERTICES
const UpdateType UPDATE_SELECTION_VERTICES(UpdateTypeSet(1)<< 5)
Vertex selection has changed.
MeshObjectSelectionPlugin::setAllHandleVertices
void setAllHandleVertices(int objectId)
Set all vertices to be part of the handle area.
Definition: VertexSelection.cc:467
MeshObjectSelectionPlugin::selectModelingVertices
void selectModelingVertices(int objectId, IdList _vertexList)
Set vertices to be part of the modeling area.
Definition: VertexSelection.cc:516
PluginFunctions::getObject
bool getObject(const int _identifier, BaseObject *&_object)
Get the object which has the given identifier.
Definition: PluginFunctions.cc:296
OpenMesh::TriMesh_ArrayKernelT
Definition: PolyMesh_ArrayKernelT.hh:73
MeshObjectSelectionPlugin::createMeshFromVertexSelection
int createMeshFromVertexSelection(int _objectId)
set dihedral angle threshold for edge selection
Definition: VertexSelection.cc:341
PluginFunctions::triMesh
TriMesh * triMesh(BaseObjectData *_object)
Get a triangle mesh from an object.
Definition: PluginFunctionsTriangleMesh.cc:134
UPDATE_SELECTION
const UpdateType UPDATE_SELECTION(UpdateTypeSet(1)<< 4)
Selection updated.
MeshObjectSelectionPlugin::deleteSelection
bool deleteSelection(MeshT *_mesh, PrimitiveType _primitiveType)
Delete all selected elements of a mesh.
Definition: MeshObjectSelectionPluginT_impl.hh:58
OpenMesh::VertexHandle
Handle for a vertex entity.
Definition: Handles.hh:120
OpenMesh::PolyMesh_ArrayKernelT
Definition: PolyMesh_ArrayKernelT.hh:94
BaseObject::id
int id() const
Definition: BaseObject.cc:190
BaseObject::dataType
bool dataType(DataType _type) const
Definition: BaseObject.cc:221
IdList
std::vector< int > IdList
Standard Type for id Lists used for scripting.
Definition: DataTypes.hh:179
MeshObjectSelectionPlugin::vertexType_
SelectionInterface::PrimitiveType vertexType_
Primitive type handles:
Definition: MeshObjectSelectionPlugin.hh:598
MeshObjectSelectionPlugin::invertVertexSelection
void invertVertexSelection(int _objectId)
Invert the current vertex selection.
Definition: VertexSelection.cc:179
MeshObjectSelectionPlugin::unselectVertices
void unselectVertices(int objectId, IdList _vertexList)
unselect given vertices
Definition: VertexSelection.cc:98
MeshObjectSelectionPlugin::setAllModelingVertices
void setAllModelingVertices(int objectId)
Set all vertices to be part of the modeling area.
Definition: VertexSelection.cc:632
MeshObjectSelectionPlugin::selectBoundaryVertices
void selectBoundaryVertices(int _objectId)
Select all boundary vertices of the given object.
Definition: VertexSelection.cc:202
MeshObjectSelectionPlugin::getHandleVertices
IdList getHandleVertices(int objectId)
Get a list of all handle vertices.
Definition: VertexSelection.cc:490
MeshObjectSelectionPlugin::deleteVertexSelection
void deleteVertexSelection(int _objectId)
Delete vertices and faces that are currently selected.
Definition: VertexSelection.cc:318
MeshObjectSelectionPlugin::getModelingVertices
IdList getModelingVertices(int objectId)
Get a list of all modeling vertices.
Definition: VertexSelection.cc:654
MeshObjectSelectionPlugin::selectVertices
void selectVertices(int objectId, IdList _vertexList)
select given vertices
Definition: VertexSelection.cc:58
MeshSelectionT.hh
Functions for selection on a mesh.
MeshObjectSelectionPlugin::selectVertex
bool selectVertex(int _objectId, int _idx, bool _fly_to_vertex)
select vertex with id _idx and maybe fly to it
Definition: VertexSelection.cc:91
MeshObjectSelectionPlugin::createMeshFromSelection
void createMeshFromSelection(MeshT &_mesh, MeshT &_newMesh, PrimitiveType _primitiveType)
Create a new mesh from the selection.
Definition: MeshObjectSelectionPluginT_impl.hh:877
MeshObjectSelectionPlugin::colorizeSelection
void colorizeSelection(MeshT *_mesh, PrimitiveType _primitiveTypes, int _red, int _green, int _blue, int _alpha)
Colorize the selection.
Definition: MeshObjectSelectionPluginT_impl.hh:803
MeshObjectSelectionPlugin::selectClosestBoundaryVertices
void selectClosestBoundaryVertices(int _objectId, int _vertexId)
Select all vertices of the boundary close to the given vertex.
Definition: VertexSelection.cc:225
MeshObjectSelectionPlugin::clearHandleVertices
void clearHandleVertices(int objectId)
Clear handle Area.
Definition: VertexSelection.cc:444
MeshObjectSelectionPlugin::selectElement
bool selectElement(int _objectId, HandleT _handle, bool _fly_to_element)
set dihedral angle threshold for edge selection
Definition: MeshObjectSelectionPluginT_impl.hh:979
MeshObjectSelectionPlugin::getVertexSelection
IdList getVertexSelection(int _objectId)
Return a list of all selected vertices.
Definition: VertexSelection.cc:294
MeshObjectSelectionPlugin::closestBoundarySelection
void closestBoundarySelection(MeshT *_mesh, int _vh, PrimitiveType _primitiveTypes, bool _deselection)
Select all entities that are incident to closest boundary.
Definition: MeshObjectSelectionPluginT_impl.hh:474
MeshObjectSelectionPlugin::clearModelingVertices
void clearModelingVertices(int objectId)
Clear Modeling Area.
Definition: VertexSelection.cc:609
MeshObjectSelectionPlugin::selectAllVertices
void selectAllVertices(int _objectId)
Select all Vertices.
Definition: VertexSelection.cc:133
MeshObjectSelectionPlugin::update_regions
void update_regions(MeshT *_mesh)
Update face selection to correspond to the vertex selection.
MeshObjectSelectionPlugin::clearVertexSelection
void clearVertexSelection(int _objectId)
Unselect all vertices.
Definition: VertexSelection.cc:156
MeshObjectSelectionPlugin::growVertexSelection
void growVertexSelection(int _objectId)
Grow the current vertex selection.
Definition: VertexSelection.cc:271
MeshObjectSelectionPlugin::loadFlipperModelingSelection
void loadFlipperModelingSelection(int _objectId, QString _filename)
Load a selection from an Flipper selection file for the given object.
Definition: VertexSelection.cc:677
MeshObjectSelectionPlugin::colorizeVertexSelection
void colorizeVertexSelection(int _objectId, int _r, int _g, int _b, int a)
Colorize the vertex selection.
Definition: VertexSelection.cc:348
UPDATE_COLOR
const UpdateType UPDATE_COLOR(UpdateTypeSet(1)<< 10)
Colors have changed.