Developer Documentation

MeshObjectSelectionPlugin.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 #include "MeshObjectSelectionPlugin.hh"
43 #include "widgets/ParameterWidget.hh"
44
45 #include <MeshTools/MeshSelectionT.hh>
46
47
48 #include <QDesktopWidget>
49 #include <QColorDialog>
50
51 // Primitive type icons
52 #define VERTEX_TYPE "selection_vertex.png"
53 #define EDGE_TYPE "selection_edge.png"
54 #define HEDGE_TYPE "selection_halfedge.png"
55 #define FACE_TYPE "selection_face.png"
56 // =======================================
57 // Define operations
58 // =======================================
59 // General:
60 #define G_CLEAR_HANDLE "Clear Handle Region"
61 #define G_CLEAR_MODEL "Clear Modeling Region"
62 #define G_CONVERT "Convert Selection"
63 // Vertices:
64 #define V_SELECT_ALL "Select All Vertices"
65 #define V_CLEAR "Clear Vertex Selection"
66 #define V_INVERT "Invert Vertex Selection"
67 #define V_BOUNDARY "Select Boundary Vertices"
68 #define V_SHRINK "Shrink Vertex Selection"
69 #define V_GROW "Grow Vertex Selection"
70 #define V_DELETE "Delete selected Vertices"
71 #define V_COLORIZE "Colorize selected Vertices"
72 #define V_COPYSELECTION "Create mesh from Vertex Selection"
73 #define V_HANDLE "Set to Handle Region"
74 #define V_MODELING "Set to Modeling Region"
75 #define V_LOAD_FLIPPER "Load Flipper Selection"
76 // Edges
77 #define E_SELECT_ALL "Select All Edges"
78 #define E_CLEAR "Clear Edge Selection"
79 #define E_INVERT "Invert Edge Selection"
80 #define E_DELETE "Delete selected Edges"
81 #define E_BOUNDARY "Select Boundary Edges"
82 #define E_COLORIZE "Colorize selected Edges"
83 #define E_COPYSELECTION "Create mesh from Edge Selection"
84 #define E_TRACE_PATH "Trace Edge Path"
85
86 // Halfedges
87 #define HE_SELECT_ALL "Select All Halfedges"
88 #define HE_CLEAR "Clear Halfedge Selection"
89 #define HE_INVERT "Invert Halfedge Selection"
90 #define HE_BOUNDARY "Select Boundary Halfedges"
91 #define HE_COLORIZE "Colorize selected Halfedges"
92 // Faces
93 #define F_SELECT_ALL "Select All Faces"
94 #define F_CLEAR "Clear Face Selection"
95 #define F_INVERT "Invert Face Selection"
96 #define F_DELETE "Delete selected Faces"
97 #define F_BOUNDARY "Select Boundary Faces"
98 #define F_SHRINK "Shrink Face Selection"
99 #define F_GROW "Grow Face Selection"
100 #define F_COLORIZE "Colorize selected Faces"
101 #define F_COPYSELECTION "Create mesh from Face Selection"
102
103 //Colorize
104 #define C_SELECTIONCOLOR "Selection Color"
105 #define C_FEATURECOLOR "Feature Color"
106 #define C_HANDLECOLOR "Handle Color"
107 #define C_AREACOLOR "Area Color"
108
110 MeshObjectSelectionPlugin::MeshObjectSelectionPlugin() :
111 vertexType_(0),
112 edgeType_(0),
113 halfedgeType_(0),
114 faceType_(0),
115 allSupportedTypes_(0u),
116 conversionDialog_(0),
117 parameterWidget_(nullptr),
118 colorButtonSelection_(0),
119 colorButtonArea_(0),
120 colorButtonHandle_(0),
121 colorButtonFeature_(0),
122 dihedral_angle_threshold_(0.0),
123 max_angle_( 2*M_PI)
124 {
125 }
126
127 MeshObjectSelectionPlugin::~MeshObjectSelectionPlugin() {
128
129 delete conversionDialog_;
130 delete parameterWidget_;
131 }
132
133 void MeshObjectSelectionPlugin::initializePlugin() {
134
135 // Tell core about all scriptable slots
136 updateSlotDescriptions();
137
138 // Create conversion dialog
139 if(!OpenFlipper::Options::nogui()) {
140 conversionDialog_ = new ConversionDialog(0);
141 QRect scr = QApplication::desktop()->screenGeometry();
142 conversionDialog_->setGeometry((int)scr.width()/2-(int)conversionDialog_->width()/2,
143 (int)scr.height()/2-(int)conversionDialog_->height()/2,
144 conversionDialog_->width(), conversionDialog_->height());
145 conversionDialog_->hide();
146 connect(conversionDialog_->convertButton, SIGNAL(clicked()), this, SLOT(conversionRequested()));
147 // Fill in combo boxes
148 conversionDialog_->convertFromBox->addItems(
149 QString("Vertex Selection;Edge Selection;Halfedge Selection;Face Selection;" \
150 "Feature Vertices;Feature Edges;Feature Faces;Handle Region;Modeling Region").split(";"));
151 conversionDialog_->convertToBox->addItems(
152 QString("Vertex Selection;Edge Selection;Halfedge Selection;Face Selection;" \
153 "Feature Vertices;Feature Edges;Feature Faces;Handle Region;Modeling Region").split(";"));
154
155 parameterWidget_ = new ParameterWidget(nullptr);
156
157 }
158 }
159
160 void MeshObjectSelectionPlugin::pluginsInitialized() {
161 // Create new selection environment for mesh objects
162 // and register mesh types tri- and polymeshes for
163 // the environment.
164
165 QString iconPath = OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator();
166
167 emit addSelectionEnvironment("Mesh Object Selections", "Select mesh object primitives such as vertices, (half-)edges and faces.",
168 iconPath + "selections.png", environmentHandle_);
169
170 // Register mesh object types
171 emit registerType(environmentHandle_, DATA_POLY_MESH);
172 emit registerType(environmentHandle_, DATA_TRIANGLE_MESH);
173
174 // Register mesh primitive types
175 emit addPrimitiveType(environmentHandle_, "Select Vertices", iconPath + VERTEX_TYPE, vertexType_);
176 emit addPrimitiveType(environmentHandle_, "Select Edges", iconPath + EDGE_TYPE, edgeType_);
177 emit addPrimitiveType(environmentHandle_, "Select Halfedges", iconPath + HEDGE_TYPE, halfedgeType_);
178 emit addPrimitiveType(environmentHandle_, "Select Faces", iconPath + FACE_TYPE, faceType_);
179
180 // Combine all supported types
181 allSupportedTypes_ = (vertexType_ | edgeType_ | halfedgeType_ | faceType_);
182
183 // Determine, which selection modes are requested
184 emit showToggleSelectionMode(environmentHandle_, true, allSupportedTypes_);
185 emit showSphereSelectionMode(environmentHandle_, true, allSupportedTypes_);
186
187 emit showLassoSelectionMode(environmentHandle_, true, allSupportedTypes_);
188 emit showVolumeLassoSelectionMode(environmentHandle_, true, allSupportedTypes_);
189
190 emit showFloodFillSelectionMode(environmentHandle_, true, allSupportedTypes_);
191 emit showComponentsSelectionMode(environmentHandle_, true, allSupportedTypes_);
192 emit showClosestBoundarySelectionMode(environmentHandle_, true, allSupportedTypes_);
193
194 // Define general operations
195 QStringList generalOperations;
196 generalOperations.append(G_CLEAR_HANDLE);
197 generalOperations.append(G_CLEAR_MODEL);
198 generalOperations.append(G_CONVERT);
199
200 // Define vertex operations
201 QStringList vertexOperations;
202 vertexOperations.append(V_SELECT_ALL);
203 vertexOperations.append(V_CLEAR);
204 vertexOperations.append(V_INVERT);
205 vertexOperations.append(V_BOUNDARY);
206 vertexOperations.append(V_SHRINK);
207 vertexOperations.append(V_GROW);
208 vertexOperations.append(V_DELETE);
209 vertexOperations.append(V_COLORIZE);
210 vertexOperations.append(V_COPYSELECTION);
211 vertexOperations.append(V_HANDLE);
212 vertexOperations.append(V_MODELING);
213 vertexOperations.append(V_LOAD_FLIPPER);
214
215 // Define edge operations
216 QStringList edgeOperations;
217 edgeOperations.append(E_SELECT_ALL);
218 edgeOperations.append(E_CLEAR);
219 edgeOperations.append(E_INVERT);
220 edgeOperations.append(E_DELETE);
221 edgeOperations.append(E_BOUNDARY);
222 edgeOperations.append(E_COLORIZE);
223 edgeOperations.append(E_COPYSELECTION);
224 edgeOperations.append(E_TRACE_PATH);
225
226 // Define halfedge operations
227 QStringList hedgeOperations;
228 hedgeOperations.append(HE_SELECT_ALL);
229 hedgeOperations.append(HE_CLEAR);
230 hedgeOperations.append(HE_INVERT);
231 hedgeOperations.append(HE_BOUNDARY);
232 hedgeOperations.append(HE_COLORIZE);
233
234 // Define face operations
235 QStringList faceOperations;
236 faceOperations.append(F_SELECT_ALL);
237 faceOperations.append(F_CLEAR);
238 faceOperations.append(F_INVERT);
239 faceOperations.append(F_DELETE);
240 faceOperations.append(F_BOUNDARY);
241 faceOperations.append(F_SHRINK);
242 faceOperations.append(F_GROW);
243 faceOperations.append(F_COLORIZE);
244 faceOperations.append(F_COPYSELECTION);
245
246 // Define colorize operations
247 QStringList colorOperations;
248 colorOperations.append(C_SELECTIONCOLOR);
249 colorOperations.append(C_FEATURECOLOR);
250 colorOperations.append(C_AREACOLOR);
251 colorOperations.append(C_HANDLECOLOR);
252
253 emit addSelectionOperations(environmentHandle_, generalOperations, "Selection Operations");
254 emit addSelectionOperations(environmentHandle_, vertexOperations, "Vertex Operations", vertexType_);
255 emit addSelectionOperations(environmentHandle_, edgeOperations, "Edge Operations", edgeType_);
256 emit addSelectionOperations(environmentHandle_, hedgeOperations, "Halfedge Operations", halfedgeType_);
257 emit addSelectionOperations(environmentHandle_, faceOperations, "Face Operations", faceType_);
258 emit addSelectionOperations(environmentHandle_, colorOperations, "Highlight Operations");
259
260 if(!OpenFlipper::Options::nogui())
261 emit addSelectionParameters(environmentHandle_, parameterWidget_, "Selection Parameters");
262
263 // Register key shortcuts:
264
265 // Select (a)ll
266 emit registerKeyShortcut(Qt::Key_A, Qt::ControlModifier);
267 // (C)lear selection
268 emit registerKeyShortcut(Qt::Key_C, Qt::NoModifier);
269 // (I)nvert selection
270 emit registerKeyShortcut(Qt::Key_I, Qt::NoModifier);
271 // Delete selected entities
272 emit registerKeyShortcut(Qt::Key_Delete, Qt::NoModifier);
273
274 // load default Color values
275 std::string statusStr = OpenFlipperQSettings().value("SelectionMeshObject/StatusColor",QString()).toString().toStdString();
276 std::string handleStr = OpenFlipperQSettings().value("SelectionMeshObject/HandleColor",QString()).toString().toStdString();
277 std::string featureStr = OpenFlipperQSettings().value("SelectionMeshObject/FeatureColor",QString()).toString().toStdString();
278 std::string areaStr = OpenFlipperQSettings().value("SelectionMeshObject/AreaColor",QString()).toString().toStdString();
279 if (statusStr.empty() || handleStr.empty() || featureStr.empty() || areaStr.empty())
280 {
281 setDefaultColorValues();
282 }
283 else
284 {
285 std::stringstream sstream;
286
287 sstream.str(statusStr);
288 sstream >> statusColor_;
289
290 sstream.str("");
291 sstream.clear();
292 sstream.str(handleStr);
293 sstream >> handleColor_;
294
295 sstream.str("");
296 sstream.clear();
297 sstream.str(featureStr);
298 sstream >> featureColor_;
299
300 sstream.str("");
301 sstream.clear();
302 sstream.str(areaStr);
303 sstream >> areaColor_;
304 updateColorValues(); //update GUI
305 }
306
307 }
308
309 void MeshObjectSelectionPlugin::updateSlotDescriptions() {
310
311 emit setSlotDescription("selectVertices(int,IdList)", tr("Select the specified vertices"),
312 QString("objectId,vertexList").split(","), QString("Id of object,List of vertices").split(","));
313 emit setSlotDescription("unselectVertices(int,IdList)", tr("Unselect the specified vertices"),
314 QString("objectId,vertexList").split(","), QString("Id of object,List of vertices").split(","));
315 emit setSlotDescription("selectAllVertices(int)", tr("Select all vertices of an object"),
316 QStringList("objectId"), QStringList("Id of object"));
317 emit setSlotDescription("clearVertexSelection(int)", tr("Clear vertex selection of an object"),
318 QStringList("objectId"), QStringList("Id of an object"));
319 emit setSlotDescription("invertVertexSelection(int)", tr("Invert vertex selection of an object"),
320 QStringList("objectId"), QStringList("Id of an object"));
321 emit setSlotDescription("selectBoundaryVertices(int)", tr("Select all boundary vertices of an object"),
322 QStringList("objectId"), QStringList("Id of an object"));
323 emit setSlotDescription("selectClosestBoundaryVertices(int,int)", tr("Select boundary vertices closest to a specific vertex"),
324 QString("objectId,vertexId").split(","), QString("Id of an object,Id of closest vertex").split(","));
325 emit setSlotDescription("shrinkVertexSelection(int)", tr("Shrink vertex selection by outer selection ring"),
326 QStringList("objectId"), QStringList("Id of an object"));
327 emit setSlotDescription("growVertexSelection(int)", tr("Grow vertex selection by an-ring of selection"),
328 QStringList("objectId"), QStringList("Id of an object"));
329 emit setSlotDescription("deleteVertexSelection(int)", tr("Delete selected vertices"),
330 QStringList("objectId"), QStringList("Id of an object"));
331 emit setSlotDescription("createMeshFromVertexSelection(int)", tr("Take vertex selection and create a new mesh from it"),
332 QString("objectId").split(","), QString("Id of an object where the selection should be used to create a new mesh").split(","));
333
334 emit setSlotDescription("selectVerticesByValue(int,QString,bool,double)", tr("Select vertices based on the value of their component"),
335 QString("objectId,component,greater,value").split(","),
336 QString("Id of an object where the selection should be used to create a new mesh,component specification: \"x\" or \"y\" or \"z\" ,true: select vertex if component greater than value; false: select if component less than value ,value to test").split(","));
337
338 emit setSlotDescription("colorizeVertexSelection(int,int,int,int)", tr("Colorize the selected vertices"),
339 QString("objectId,r,g,b").split(","), QString("Id of an object,Red,Green,Blue").split(","));
340 emit setSlotDescription("selectHandleVertices(int,IdList)", tr("Add specified vertices to handle area"),
341 QString("objectId,vertexList").split(","), QString("Id of an object,List of vertices").split(","));
342 emit setSlotDescription("unselectHandleVertices(int,IdList)", tr("Remove specified vertices from handle area"),
343 QString("objectId,vertexList").split(","), QString("Id of an object,List of vertices").split(","));
344 emit setSlotDescription("clearHandleVertices(int)", tr("Clear handle area"),
345 QStringList("objectId"), QStringList("Id of an object"));
346 emit setSlotDescription("setAllHandleVertices(int)", tr("Add all vertices of an object to handle area"),
347 QStringList("objectId"), QStringList("Id of an object"));
348 emit setSlotDescription("selectModelingVertices(int,IdList)", tr("Add specified vertices to modeling area"),
349 QString("objectId,vertexList").split(","), QString("Id of an object,List of vertices").split(","));
350 emit setSlotDescription("unselectModelingVertices(int,IdList)", tr("Remove specified vertices to modeling area"),
351 QString("objectId,vertexList").split(","), QString("Id of an object,List of vertices").split(","));
352 emit setSlotDescription("clearModelingVertices(int)", tr("Clear modeling area"),
353 QStringList("objectId"), QStringList("Id of an object"));
354 emit setSlotDescription("setAllModelingVertices(int)", tr("Add al vertices of an object to modeling area"),
355 QStringList("objectId"), QStringList("Id of an object"));
356
357 emit setSlotDescription("loadSelection(int,QString)", tr("Load selection from selection file"),
358 QString("objectId,filename").split(","), QString("Id of an object,Selection file").split(","));
359
360 emit setSlotDescription("loadFlipperModelingSelection(int,QString)", tr("Load selection from Flipper selection file"),
361 QString("objectId,filename").split(","), QString("Id of an object,Flipper selection file").split(","));
362 emit setSlotDescription("saveFlipperModelingSelection(int,QString)", tr("Save selection into Flipper selection file"),
363 QString("objectId,filename").split(","), QString("Id of an object,Flipper selection file").split(","));
364
365 emit setSlotDescription("selectEdges(int,IdList)", tr("Select the specified edges"),
366 QString("objectId,edgeList").split(","), QString("Id of an object,List of edges").split(","));
367 emit setSlotDescription("unselectEdges(int,IdList)", tr("Unselect the specified edges"),
368 QString("objectId,edgeList").split(","), QString("Id of an object,List of edges").split(","));
369 emit setSlotDescription("selectAllEdges(int)", tr("Select all edges of an object"),
370 QStringList("objectId"), QStringList("Id of an object"));
371 emit setSlotDescription("invertEdgeSelection(int)", tr("Invert edge selection of an object"),
372 QStringList("objectId"), QStringList("Id of an object"));
373 emit setSlotDescription("clearEdgeSelection(int)", tr("Clear edge selection of an object"),
374 QStringList("objectId"), QStringList("Id of an object"));
375 emit setSlotDescription("selectBoundaryEdges(int)", tr("Select all boundary edges of an object"),
376 QStringList("objectId"), QStringList("Id of an object"));
377
378 emit setSlotDescription("colorizeEdgeSelection(int,int,int,int)", tr("Colorize the selected edges"),
379 QString("objectId,r,g,b").split(","), QString("Id of an object,Red,Green,Blue").split(","));
380 emit setSlotDescription("createMeshFromEdgeSelection(int)", tr("Take edge selection and create a new mesh from it"),
381 QString("objectId").split(","), QString("Id of an object where the selection should be used to create a new mesh").split(","));
382
383 emit setSlotDescription("selectHalfedges(int,IdList)", tr("Select the specified halfedges"),
384 QString("objectId,halfedgeList").split(","), QString("Id of an object,List of halfedges").split(","));
385 emit setSlotDescription("unselectHalfedges(int,IdList)", tr("Unselect the specified halfedges"),
386 QString("objectId,halfedgeList").split(","), QString("Id of an object,List of halfedges").split(","));
387 emit setSlotDescription("selectAllHalfedges(int)", tr("Select all halfedges of an object"),
388 QStringList("objectId"), QStringList("Id of an object"));
389 emit setSlotDescription("invertHalfedgeSelection(int)", tr("Invert halfedge selection of an object"),
390 QStringList("objectId"), QStringList("Id of an object"));
391 emit setSlotDescription("clearHalfedgeSelection(int)", tr("Clear halfedge selection of an object"),
392 QStringList("objectId"), QStringList("Id of an object"));
393 emit setSlotDescription("selectBoundaryHalfedges(int)", tr("Select all boundary halfedges of an object"),
394 QStringList("objectId"), QStringList("Id of an object"));
395
396 emit setSlotDescription("colorizeHalfedgeSelection(int,int,int,int)", tr("Colorize the selected halfedges"),
397 QString("objectId,r,g,b").split(","), QString("Id of an object,Red,Green,Blue").split(","));
398
399 emit setSlotDescription("selectFaces(int,IdList)", tr("Select the specified faces"),
400 QString("objectId,faceList").split(","), QString("Id of an object,List of faces").split(","));
401 emit setSlotDescription("unselectFaces(int,IdList)", tr("Unselect the specified faces"),
402 QString("objectId,faceList").split(","), QString("Id of an object,List of faces").split(","));
403 emit setSlotDescription("selectAllFaces(int)", tr("Select all vertices of an object"),
404 QStringList("objectId"), QStringList("Id of an object"));
405 emit setSlotDescription("clearFaceSelection(int)", tr("Clear face selection of an object"),
406 QStringList("objectId"), QStringList("Id of an object"));
407 emit setSlotDescription("invertFaceSelection(int)", tr("Invert face selection of an object"),
408 QStringList("objectId"), QStringList("Id of an object"));
409 emit setSlotDescription("selectBoundaryFaces(int)", tr("Select all boundary faces of an object"),
410 QStringList("objectId"), QStringList("Id of an object"));
411 emit setSlotDescription("shrinkFaceSelection(int)", tr("Shrink face selection by outer face ring of selection"),
412 QStringList("objectId"), QStringList("Id of an object"));
413 emit setSlotDescription("growFaceSelection(int)", tr("Grow face selection by an-ring of faces around selection"),
414 QStringList("objectId"), QStringList("Id of an object"));
415 emit setSlotDescription("colorizeFaceSelection(int,int,int,int)", tr("Colorize the selected faces"),
416 QString("objectId,r,g,b").split(","), QString("Id of an object,Red,Green,Blue").split(","));
417
418 emit setSlotDescription("createMeshFromFaceSelection(int)", tr("Take face selection and create a new mesh from it"),
419 QString("objectId").split(","), QString("Id of an object where the selection should be used to create a new mesh").split(","));
420
421
422 QString conversionStrings = tr(" Possible strings:\n"
423 "- Vertex/Edge/Halfedge/Face Selection\n"
424 "- Model/Handle Region\n"
425 "- Feature Vertices/Edges/Faces");
426
427 emit setSlotDescription("convertSelection(int,QString,QString,bool)", tr("Convert the selection on given object. Conversion must be given as strings.")+conversionStrings ,
428 QString("objectId,from,to,deselect").split(","), QString("Id of an object,string of selection which will be converted,resulting selection or area,deselect selection after conversion").split(","));
429
430 emit setSlotDescription("conversion(QString,QString,bool)", tr("Convert selection on all target Objects.")+conversionStrings,
431 QString("from,to,deselect").split(","), QString("string of selection which will be converted,resulting selection region or feature,deselect selection after conversion").split(","));
432
433 emit setSlotDescription("convertEdgesToVertexPairs(int,IdList)", tr("Convert edge ids to vertex pair ids. Returns vertex Idlist."),
434 QString("objectId, edgeIds").split(","), QString("Id of an object, Ids of edges").split(","));
435 emit setSlotDescription("convertHalfedgesToVertexPairs(int,IdList)", tr("Convert halfedge ids to vertex pair ids. Returns vertex Idlist."),
436 QString("objectId, halfedgeIds").split(","), QString("Id of an object, Ids of halfedges").split(","));
437
438 emit setSlotDescription("convertVertexPairsToHalfedges(int,IdList)", tr("Convert vertex pair ids to halfedge ids. Returns halfedge Idlist."),
439 QString("objectId, vertexIds").split(","), QString("Id of an object, Ids of paired vertices").split(","));
440 emit setSlotDescription("convertVertexPairsToEdges(int,IdList)", tr("Convert vertex pair ids to edge ids. Returns edge Idlist."),
441 QString("objectId, vertexIds").split(","), QString("Id of an object, Ids of paired vertices").split(","));
442 }
443
444 void MeshObjectSelectionPlugin::slotSelectionOperation(QString _operation) {
445
446 SelectionInterface::PrimitiveType type = 0u;
447 emit getActivePrimitiveType(type);
448
449 if((type & allSupportedTypes_) == 0)
450 return;
451
452 // Test if operation should be applied to target objects only
453 bool targetsOnly = false;
454 emit targetObjectsOnly(targetsOnly);
455 PluginFunctions::IteratorRestriction restriction =
456 (targetsOnly ? PluginFunctions::TARGET_OBJECTS : PluginFunctions::ALL_OBJECTS);
457
458 if(_operation == G_CLEAR_HANDLE) {
459 // Clear handle region
460 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
461 o_it != PluginFunctions::objectsEnd(); ++o_it) {
462 if (o_it->visible())
463 clearHandleVertices(o_it->id());
464 }
465 } else if(_operation == G_CLEAR_MODEL) {
466 // Clear modeling region
467 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
468 o_it != PluginFunctions::objectsEnd(); ++o_it) {
469 if (o_it->visible())
470 clearModelingVertices(o_it->id());
471 }
472 } else if(_operation == G_CONVERT) {
473 // Convert vertex selection
474 if(!OpenFlipper::Options::nogui())
475 conversionDialog_->show();
476 } else if(_operation == V_SELECT_ALL) {
477 // Select all vertices
478 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
479 o_it != PluginFunctions::objectsEnd(); ++o_it) {
480 if (o_it->visible())
481 selectAllVertices(o_it->id());
482 }
483 } else if(_operation == V_CLEAR) {
484 // Clear vertex selection
485 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
486 o_it != PluginFunctions::objectsEnd(); ++o_it) {
487 if (o_it->visible())
488 clearVertexSelection(o_it->id());
489 }
490 } else if(_operation == V_INVERT) {
491 // Invert vertex selection
492 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
493 o_it != PluginFunctions::objectsEnd(); ++o_it) {
494 if (o_it->visible())
495 invertVertexSelection(o_it->id());
496 }
497 } else if(_operation == V_BOUNDARY) {
498 // Select boundary vertices
499 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
500 o_it != PluginFunctions::objectsEnd(); ++o_it) {
501 if (o_it->visible())
502 selectBoundaryVertices(o_it->id());
503 }
504 } else if(_operation == V_SHRINK) {
505 // Shrink vertex selection
506 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
507 o_it != PluginFunctions::objectsEnd(); ++o_it) {
508 if (o_it->visible())
509 shrinkVertexSelection(o_it->id());
510 }
511 } else if(_operation == V_GROW) {
512 // Grow vertex selection
513 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
514 o_it != PluginFunctions::objectsEnd(); ++o_it) {
515 if (o_it->visible())
516 growVertexSelection(o_it->id());
517 }
518 } else if(_operation == V_DELETE) {
519 // Delete vertex selection
520 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
521 o_it != PluginFunctions::objectsEnd(); ++o_it) {
522 if (o_it->visible()){
523 deleteVertexSelection(o_it->id());
524 emit updatedObject(o_it->id(), UPDATE_GEOMETRY);
525 emit createBackup(o_it->id(), "Delete Vertices", UPDATE_GEOMETRY);
526 }
527 }
528 } else if(_operation == V_COLORIZE) {
529 // Colorize vertex selection
530 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
531 o_it != PluginFunctions::objectsEnd(); ++o_it) {
532 if (o_it->visible()) {
533 setColorForSelection(o_it->id(), vertexType_);
534 }
535 }
536 } else if(_operation == V_COPYSELECTION) {
537 // Copy vertex selection
538 std::vector<int> objects;
539 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
540 o_it != PluginFunctions::objectsEnd(); ++o_it) {
541 if (o_it->visible()) {
542 objects.push_back(o_it->id());
543 }
544 }
545
546 for ( unsigned int i = 0 ; i < objects.size() ; ++i)
547 createMeshFromSelection(objects[i],vertexType_);
548
549 } else if(_operation == V_HANDLE) {
550 // Set vertex selection to be handle region
551 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
552 o_it != PluginFunctions::objectsEnd(); ++o_it) {
553 if (o_it->visible()) {
554 std::vector<int> ids = getVertexSelection(o_it->id());
555 selectHandleVertices(o_it->id(), ids);
556 clearVertexSelection(o_it->id());
557 }
558 }
559 } else if(_operation == V_MODELING) {
560 // Set vertex selection to be modeling
561 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
562 o_it != PluginFunctions::objectsEnd(); ++o_it) {
563 if (o_it->visible()) {
564 std::vector<int> ids = getVertexSelection(o_it->id());
565 selectModelingVertices(o_it->id(), ids);
566 clearVertexSelection(o_it->id());
567 }
568 }
569 } else if(_operation == V_LOAD_FLIPPER) {
570 // Load Flipper selection file
571 QString fileName = QFileDialog::getOpenFileName(0,
572 tr("Open Flipper Selection File"), OpenFlipper::Options::dataDirStr(),
573 tr("Flipper Selection Files (*.sel)"));
574 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
575 o_it != PluginFunctions::objectsEnd(); ++o_it) {
576 if (o_it->visible()) {
577 loadFlipperModelingSelection(o_it->id(), fileName);
578 }
579 }
580 } else if(_operation == E_SELECT_ALL) {
581 // Select all edges
582 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
583 o_it != PluginFunctions::objectsEnd(); ++o_it) {
584 if (o_it->visible())
585 selectAllEdges(o_it->id());
586 }
587 } else if(_operation == E_CLEAR) {
588 // Clear edge selection
589 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
590 o_it != PluginFunctions::objectsEnd(); ++o_it) {
591 if (o_it->visible())
592 clearEdgeSelection(o_it->id());
593 }
594 } else if(_operation == E_INVERT) {
595 // Invert edge selection
596 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
597 o_it != PluginFunctions::objectsEnd(); ++o_it) {
598 if (o_it->visible())
599 invertEdgeSelection(o_it->id());
600 }
601 } else if(_operation == E_DELETE) {
602 // Delete edge selection
603 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
604 o_it != PluginFunctions::objectsEnd(); ++o_it) {
605 if (o_it->visible())
606 deleteEdgeSelection(o_it->id());
607 }
608 } else if(_operation == E_BOUNDARY) {
609 // Select boundary edges
610 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
611 o_it != PluginFunctions::objectsEnd(); ++o_it) {
612 if (o_it->visible())
613 selectBoundaryEdges(o_it->id());
614 }
615 } else if(_operation == E_COLORIZE) {
616 // Colorize edge selection
617 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
618 o_it != PluginFunctions::objectsEnd(); ++o_it) {
619 if (o_it->visible()) {
620 setColorForSelection(o_it->id(), edgeType_);
621 }
622 }
623 } else if(_operation == E_COPYSELECTION) {
624 // Copy edge selection
625 std::vector<int> objects;
626 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
627 o_it != PluginFunctions::objectsEnd(); ++o_it) {
628 if (o_it->visible()) {
629 objects.push_back(o_it->id());
630 }
631 }
632
633 for ( unsigned int i = 0 ; i < objects.size() ; ++i)
634 createMeshFromSelection(objects[i],edgeType_);
635
636 } else if (_operation == E_TRACE_PATH) {
637 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
638 o_it != PluginFunctions::objectsEnd(); ++o_it) {
639 if (o_it->visible()) {
640 traceEdgePath(o_it->id(), .9);
641 }
642 }
643 } else if(_operation == HE_SELECT_ALL) {
644 // Select all edges
645 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
646 o_it != PluginFunctions::objectsEnd(); ++o_it) {
647 if (o_it->visible())
648 selectAllHalfedges(o_it->id());
649 }
650 } else if(_operation == HE_CLEAR) {
651 // Clear edge selection
652 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
653 o_it != PluginFunctions::objectsEnd(); ++o_it) {
654 if (o_it->visible())
655 clearHalfedgeSelection(o_it->id());
656 }
657 } else if(_operation == HE_INVERT) {
658 // Invert edge selection
659 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
660 o_it != PluginFunctions::objectsEnd(); ++o_it) {
661 if (o_it->visible())
662 invertHalfedgeSelection(o_it->id());
663 }
664 } else if(_operation == HE_BOUNDARY) {
665 // Select boundary edges
666 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
667 o_it != PluginFunctions::objectsEnd(); ++o_it) {
668 if (o_it->visible())
669 selectBoundaryHalfedges(o_it->id());
670 }
671 } else if(_operation == HE_COLORIZE) {
672 // Colorize halfedge selection
673 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
674 o_it != PluginFunctions::objectsEnd(); ++o_it) {
675 if (o_it->visible()) {
676 setColorForSelection(o_it->id(), halfedgeType_);
677 }
678 }
679 } else if(_operation == F_SELECT_ALL) {
680 // Select all faces
681 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
682 o_it != PluginFunctions::objectsEnd(); ++o_it) {
683 if (o_it->visible())
684 selectAllFaces(o_it->id());
685 }
686 } else if(_operation == F_CLEAR) {
687 // Clear face selection
688 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
689 o_it != PluginFunctions::objectsEnd(); ++o_it) {
690 if (o_it->visible())
691 clearFaceSelection(o_it->id());
692 }
693 } else if(_operation == F_INVERT) {
694 // Invert face selection
695 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
696 o_it != PluginFunctions::objectsEnd(); ++o_it) {
697 if (o_it->visible())
698 invertFaceSelection(o_it->id());
699 }
700 } else if(_operation == F_DELETE) {
701 // Delete face selection
702 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
703 o_it != PluginFunctions::objectsEnd(); ++o_it) {
704 if (o_it->visible())
705 deleteFaceSelection(o_it->id());
706 }
707 } else if(_operation == F_BOUNDARY) {
708 // Select boundary faces
709 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
710 o_it != PluginFunctions::objectsEnd(); ++o_it) {
711 if (o_it->visible())
712 selectBoundaryFaces(o_it->id());
713 }
714 } else if(_operation == F_SHRINK) {
715 // Shrink face selection
716 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
717 o_it != PluginFunctions::objectsEnd(); ++o_it) {
718 if (o_it->visible())
719 shrinkFaceSelection(o_it->id());
720 }
721 } else if(_operation == F_GROW) {
722 // Grow face selection
723 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
724 o_it != PluginFunctions::objectsEnd(); ++o_it) {
725 if (o_it->visible())
726 growFaceSelection(o_it->id());
727 }
728 } else if(_operation == F_COLORIZE) {
729 // Colorize face selection
730 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
731 o_it != PluginFunctions::objectsEnd(); ++o_it) {
732 if (o_it->visible()) {
733 setColorForSelection(o_it->id(), faceType_);
734 }
735 }
736 } else if(_operation == F_COPYSELECTION) {
737 // Copy face selection
738 std::vector<int> objects;
739 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_ALL));
740 o_it != PluginFunctions::objectsEnd(); ++o_it) {
741 if (o_it->visible()) {
742 objects.push_back(o_it->id());
743 }
744 }
745
746 for ( unsigned int i = 0 ; i < objects.size() ; ++i)
747 createMeshFromSelection(objects[i],faceType_);
748 } else if(_operation == C_SELECTIONCOLOR) {
749 QColor newColor = QColorDialog::getColor(QColor::fromRgbF(statusColor_[0],statusColor_[1],statusColor_[2],statusColor_[3]), 0, "Pick Color", QColorDialog::ShowAlphaChannel);
750 if (newColor.isValid())
751 {
752 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_POLY_MESH));
753 o_it != PluginFunctions::objectsEnd(); ++o_it) {
754 PolyMeshObject* poly = 0;
755 PluginFunctions::getObject(o_it->id(),poly);
756 poly->setSelectionColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
757 }
758 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH));
759 o_it != PluginFunctions::objectsEnd(); ++o_it) {
760 TriMeshObject* tri = 0;
761 PluginFunctions::getObject(o_it->id(),tri);
762 tri->setSelectionColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
763 }
764 emit updateView();
765 }
766
767 }else if(_operation == C_FEATURECOLOR) {
768 QColor newColor = QColorDialog::getColor(QColor::fromRgbF(featureColor_[0],featureColor_[1],featureColor_[2],featureColor_[3]), 0, "Pick Color", QColorDialog::ShowAlphaChannel);
769 if (newColor.isValid())
770 {
771 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_POLY_MESH));
772 o_it != PluginFunctions::objectsEnd(); ++o_it) {
773 PolyMeshObject* poly = 0;
774 PluginFunctions::getObject(o_it->id(),poly);
775 poly->setFeatureColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
776 }
777 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH));
778 o_it != PluginFunctions::objectsEnd(); ++o_it) {
779 TriMeshObject* tri = 0;
780 PluginFunctions::getObject(o_it->id(),tri);
781 tri->setFeatureColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
782 }
783 emit updateView();
784 }
785
786 }else if(_operation == C_HANDLECOLOR) {
787 QColor newColor = QColorDialog::getColor(QColor::fromRgbF(handleColor_[0],handleColor_[1],handleColor_[2],handleColor_[3]), 0, "Pick Color", QColorDialog::ShowAlphaChannel);
788 if (newColor.isValid())
789 {
790 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_POLY_MESH));
791 o_it != PluginFunctions::objectsEnd(); ++o_it) {
792 PolyMeshObject* poly = 0;
793 PluginFunctions::getObject(o_it->id(),poly);
794 poly->setHandleColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
795 }
796 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH));
797 o_it != PluginFunctions::objectsEnd(); ++o_it) {
798 TriMeshObject* tri = 0;
799 PluginFunctions::getObject(o_it->id(),tri);
800 tri->setHandleColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
801 }
802 emit updateView();
803 }
804
805 }else if(_operation == C_AREACOLOR) {
806 QColor newColor = QColorDialog::getColor(QColor::fromRgbF(areaColor_[0],areaColor_[1],areaColor_[2],areaColor_[3]), 0, "Pick Color", QColorDialog::ShowAlphaChannel);
807 if (newColor.isValid())
808 {
809 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_POLY_MESH));
810 o_it != PluginFunctions::objectsEnd(); ++o_it) {
811 PolyMeshObject* poly = 0;
812 PluginFunctions::getObject(o_it->id(),poly);
813 poly->setAreaColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
814 }
815 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH));
816 o_it != PluginFunctions::objectsEnd(); ++o_it) {
817 TriMeshObject* tri = 0;
818 PluginFunctions::getObject(o_it->id(),tri);
819 tri->setAreaColor(ACG::Vec4f(newColor.redF(),newColor.greenF(),newColor.blueF(),newColor.alphaF()));
820 }
821 emit updateView();
822 }
823
824 }
825 }
826
827 void MeshObjectSelectionPlugin::setColorForSelection(const int _objectId, const PrimitiveType _primitiveTypes) {
828
829 QColor c = QColorDialog::getColor(Qt::red, 0, tr("Choose color"),QColorDialog::ShowAlphaChannel);
830
831 if(c.isValid()) {
832 if(_primitiveTypes & vertexType_) {
833 // Vertex colorization
834 colorizeVertexSelection(_objectId, c.red(), c.green(), c.blue(), c.alpha());
835 } else if (_primitiveTypes & edgeType_) {
836 // Edge colorization
837 colorizeEdgeSelection(_objectId, c.red(), c.green(), c.blue(), c.alpha());
838 } else if (_primitiveTypes & halfedgeType_) {
839 // Edge colorization
840 colorizeHalfedgeSelection(_objectId, c.red(), c.green(), c.blue(), c.alpha());
841 } else if (_primitiveTypes & faceType_) {
842 // Edge colorization
843 colorizeFaceSelection(_objectId, c.red(), c.green(), c.blue(), c.alpha());
844 }
845 }
846 }
847
848 void MeshObjectSelectionPlugin::conversionRequested() {
849
850 conversionDialog_->hide();
851
852 QString from = conversionDialog_->convertFromBox->currentText();
853 QString to = conversionDialog_->convertToBox->currentText();
854
855 if(from == to) return;
856
857 bool deselect = true;
858 if(!OpenFlipper::Options::nogui()) {
859 deselect = conversionDialog_->deselect->isChecked();
860 }
861
862 conversion(from, to, deselect);
863 }
864
865 void MeshObjectSelectionPlugin::convertSelection(const int& _objectId ,const QString& _from, const QString& _to, bool _deselect) {
866 BaseObject* object = 0;
867
868 PluginFunctions::getObject(_objectId,object);
869
870 if ( object == 0 ) {
871 emit log(LOGERR,"Object not found in convertSelection");
872 return;
873 }
874
875 if(_from == "Vertex Selection") {
876 if (_to == "Edge Selection") {
877 if(object->dataType() == DATA_TRIANGLE_MESH)
878 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::triMesh(_objectId));
879 else if(object->dataType() == DATA_POLY_MESH)
880 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::polyMesh(_objectId));
881 } else if (_to == "Halfedge Selection") {
882 if(object->dataType() == DATA_TRIANGLE_MESH)
883 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::triMesh(_objectId));
884 else if(object->dataType() == DATA_POLY_MESH)
885 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::polyMesh(_objectId));
886 } else if (_to == "Face Selection") {
887 if(object->dataType() == DATA_TRIANGLE_MESH)
888 MeshSelection::convertVertexToFaceSelection(PluginFunctions::triMesh(_objectId));
889 else if(object->dataType() == DATA_POLY_MESH)
890 MeshSelection::convertVertexToFaceSelection(PluginFunctions::polyMesh(_objectId));
891 } else if (_to == "Feature Vertices") {
892 if(object->dataType() == DATA_TRIANGLE_MESH)
893 MeshSelection::convertVertexSelectionToFeatureVertices(PluginFunctions::triMesh(_objectId));
894 else if(object->dataType() == DATA_POLY_MESH)
895 MeshSelection::convertVertexSelectionToFeatureVertices(PluginFunctions::polyMesh(_objectId));
896 } else if (_to == "Handle Region") {
897 selectHandleVertices(_objectId, getVertexSelection(_objectId));
898 } else if (_to == "Modeling Region") {
899 selectModelingVertices(_objectId, getVertexSelection(_objectId));
900 }
901
902 if(_deselect) {
903 clearVertexSelection(_objectId);
904 }
905
906 } else if (_from == "Edge Selection") {
907 if(_to == "Vertex Selection") {
908 if(object->dataType() == DATA_TRIANGLE_MESH)
909 MeshSelection::convertEdgeToVertexSelection(PluginFunctions::triMesh(_objectId));
910 else if(object->dataType() == DATA_POLY_MESH)
911 MeshSelection::convertEdgeToVertexSelection(PluginFunctions::polyMesh(_objectId));
912 } else if (_to == "Halfedge Selection") {
913 if(object->dataType() == DATA_TRIANGLE_MESH)
914 MeshSelection::convertEdgeToHalfedgeSelection(PluginFunctions::triMesh(_objectId));
915 else if(object->dataType() == DATA_POLY_MESH)
916 MeshSelection::convertEdgeToHalfedgeSelection(PluginFunctions::polyMesh(_objectId));
917 } else if (_to == "Face Selection") {
918 if(object->dataType() == DATA_TRIANGLE_MESH)
919 MeshSelection::convertEdgeToFaceSelection(PluginFunctions::triMesh(_objectId));
920 else if(object->dataType() == DATA_POLY_MESH)
921 MeshSelection::convertEdgeToFaceSelection(PluginFunctions::polyMesh(_objectId));
922 } else if (_to == "Feature Edges") {
923 if(object->dataType() == DATA_TRIANGLE_MESH)
924 MeshSelection::convertEdgeSelectionToFeatureEdges(PluginFunctions::triMesh(_objectId));
925 else if(object->dataType() == DATA_POLY_MESH)
926 MeshSelection::convertEdgeSelectionToFeatureEdges(PluginFunctions::polyMesh(_objectId));
927 } else if (_to == "Handle Region") {
928 if(object->dataType() == DATA_TRIANGLE_MESH) {
929 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
930 std::vector<int> ids;
931 for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
932 if(mesh->status(*e_it).selected()) {
933 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 0)).idx());
934 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 1)).idx());
935 }
936 }
937 selectHandleVertices(_objectId, ids);
938 } else if(object->dataType() == DATA_POLY_MESH) {
939 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
940 std::vector<int> ids;
941 for(PolyMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
942 if(mesh->status(*e_it).selected()) {
943 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 0)).idx());
944 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 1)).idx());
945 }
946 }
947 selectHandleVertices(_objectId, ids);
948 }
949 } else if (_to == "Modeling Region") {
950 if(object->dataType() == DATA_TRIANGLE_MESH) {
951 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
952 std::vector<int> ids;
953 for(TriMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
954 if(mesh->status(*e_it).selected()) {
955 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 0)).idx());
956 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 1)).idx());
957 }
958 }
959 selectModelingVertices(_objectId, ids);
960 } else if(object->dataType() == DATA_POLY_MESH) {
961 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
962 std::vector<int> ids;
963 for(PolyMesh::EdgeIter e_it = mesh->edges_begin(); e_it != mesh->edges_end(); ++e_it) {
964 if(mesh->status(*e_it).selected()) {
965 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 0)).idx());
966 ids.push_back(mesh->to_vertex_handle(mesh->halfedge_handle(*e_it, 1)).idx());
967 }
968 }
969 selectModelingVertices(_objectId, ids);
970 }
971 }
972
973 if(_deselect) {
974 clearEdgeSelection(_objectId);
975 }
976 } else if (_from == "Halfedge Selection") {
977 if(_to == "Vertex Selection") {
978 if(object->dataType() == DATA_TRIANGLE_MESH)
979 MeshSelection::convertHalfedgeToVertexSelection(PluginFunctions::triMesh(_objectId));
980 else if(object->dataType() == DATA_POLY_MESH)
981 MeshSelection::convertHalfedgeToVertexSelection(PluginFunctions::polyMesh(_objectId));
982 } else if (_to == "Edge Selection") {
983 if(object->dataType() == DATA_TRIANGLE_MESH)
984 MeshSelection::convertHalfedgeToEdgeSelection(PluginFunctions::triMesh(_objectId));
985 else if(object->dataType() == DATA_POLY_MESH)
986 MeshSelection::convertHalfedgeToEdgeSelection(PluginFunctions::polyMesh(_objectId));
987 } else if (_to == "Face Selection") {
988 if(object->dataType() == DATA_TRIANGLE_MESH)
989 MeshSelection::convertHalfedgeToFaceSelection(PluginFunctions::triMesh(_objectId));
990 else if(object->dataType() == DATA_POLY_MESH)
991 MeshSelection::convertHalfedgeToFaceSelection(PluginFunctions::polyMesh(_objectId));
992 } else if (_to == "Handle Region") {
993 if(object->dataType() == DATA_TRIANGLE_MESH) {
994 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
995 std::vector<int> ids;
996 for(TriMesh::HalfedgeIter h_it = mesh->halfedges_begin(); h_it != mesh->halfedges_end(); ++h_it) {
997 if(mesh->status(*h_it).selected()) {
998 ids.push_back(mesh->to_vertex_handle(*h_it).idx());
999 ids.push_back(mesh->from_vertex_handle(*h_it).idx());
1000 }
1001 }
1002 selectHandleVertices(_objectId, ids);
1003 } else if(object->dataType() == DATA_POLY_MESH) {
1004 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
1005 std::vector<int> ids;
1006 for(PolyMesh::HalfedgeIter h_it = mesh->halfedges_begin(); h_it != mesh->halfedges_end(); ++h_it) {
1007 if(mesh->status(*h_it).selected()) {
1008 ids.push_back(mesh->to_vertex_handle(*h_it).idx());
1009 ids.push_back(mesh->from_vertex_handle(*h_it).idx());
1010 }
1011 }
1012 selectHandleVertices(_objectId, ids);
1013 }
1014 } else if (_to == "Modeling Region") {
1015 if(object->dataType() == DATA_TRIANGLE_MESH) {
1016 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
1017 std::vector<int> ids;
1018 for(TriMesh::HalfedgeIter h_it = mesh->halfedges_begin(); h_it != mesh->halfedges_end(); ++h_it) {
1019 if(mesh->status(*h_it).selected()) {
1020 ids.push_back(mesh->to_vertex_handle(*h_it).idx());
1021 ids.push_back(mesh->from_vertex_handle(*h_it).idx());
1022 }
1023 }
1024 selectModelingVertices(_objectId, ids);
1025 } else if(object->dataType() == DATA_POLY_MESH) {
1026 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
1027 std::vector<int> ids;
1028 for(PolyMesh::HalfedgeIter h_it = mesh->halfedges_begin(); h_it != mesh->halfedges_end(); ++h_it) {
1029 if(mesh->status(*h_it).selected()) {
1030 ids.push_back(mesh->to_vertex_handle(*h_it).idx());
1031 ids.push_back(mesh->from_vertex_handle(*h_it).idx());
1032 }
1033 }
1034 selectModelingVertices(_objectId, ids);
1035 }
1036 }
1037
1038 if(_deselect) {
1039 clearHalfedgeSelection(_objectId);
1040 }
1041 } else if (_from == "Face Selection") {
1042 if(_to == "Vertex Selection") {
1043 if(object->dataType() == DATA_TRIANGLE_MESH)
1044 MeshSelection::convertFaceToVertexSelection(PluginFunctions::triMesh(_objectId));
1045 else if(object->dataType() == DATA_POLY_MESH)
1046 MeshSelection::convertFaceToVertexSelection(PluginFunctions::polyMesh(_objectId));
1047 } else if (_to == "Edge Selection") {
1048 if(object->dataType() == DATA_TRIANGLE_MESH)
1049 MeshSelection::convertFaceToEdgeSelection(PluginFunctions::triMesh(_objectId));
1050 else if(object->dataType() == DATA_POLY_MESH)
1051 MeshSelection::convertFaceToEdgeSelection(PluginFunctions::polyMesh(_objectId));
1052 } else if (_to == "Feature Faces") {
1053 if(object->dataType() == DATA_TRIANGLE_MESH)
1054 MeshSelection::convertFaceSelectionToFeatureFaces(PluginFunctions::triMesh(_objectId));
1055 else if(object->dataType() == DATA_POLY_MESH)
1056 MeshSelection::convertFaceSelectionToFeatureFaces(PluginFunctions::polyMesh(_objectId));
1057 } else if (_to == "Halfedge Selection") {
1058 if(object->dataType() == DATA_TRIANGLE_MESH)
1059 MeshSelection::convertFaceToHalfedgeSelection(PluginFunctions::triMesh(_objectId));
1060 else if(object->dataType() == DATA_POLY_MESH)
1061 MeshSelection::convertFaceToHalfedgeSelection(PluginFunctions::polyMesh(_objectId));
1062 } else if (_to == "Handle Region") {
1063 if(object->dataType() == DATA_TRIANGLE_MESH) {
1064 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
1065 std::vector<int> ids;
1066 for(TriMesh::FaceIter f_it = mesh->faces_begin(); f_it != mesh->faces_end(); ++f_it) {
1067 if(mesh->status(*f_it).selected()) {
1068 for(TriMesh::FaceVertexIter fv_it = mesh->fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
1069 ids.push_back(fv_it->idx());
1070 }
1071 }
1072 }
1073 selectHandleVertices(_objectId, ids);
1074 } else if(object->dataType() == DATA_POLY_MESH) {
1075 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
1076 std::vector<int> ids;
1077 for(PolyMesh::FaceIter f_it = mesh->faces_begin(); f_it != mesh->faces_end(); ++f_it) {
1078 if(mesh->status(*f_it).selected()) {
1079 for(PolyMesh::FaceVertexIter fv_it = mesh->fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
1080 ids.push_back(fv_it->idx());
1081 }
1082 }
1083 }
1084 selectHandleVertices(_objectId, ids);
1085 }
1086 } else if (_to == "Modeling Region") {
1087 if(object->dataType() == DATA_TRIANGLE_MESH) {
1088 TriMesh* mesh = PluginFunctions::triMesh(_objectId);
1089 std::vector<int> ids;
1090 for(TriMesh::FaceIter f_it = mesh->faces_begin(); f_it != mesh->faces_end(); ++f_it) {
1091 if(mesh->status(*f_it).selected()) {
1092 for(TriMesh::FaceVertexIter fv_it = mesh->fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
1093 ids.push_back(fv_it->idx());
1094 }
1095 }
1096 }
1097 selectModelingVertices(_objectId, ids);
1098 } else if(object->dataType() == DATA_POLY_MESH) {
1099 PolyMesh* mesh = PluginFunctions::polyMesh(_objectId);
1100 std::vector<int> ids;
1101 for(PolyMesh::FaceIter f_it = mesh->faces_begin(); f_it != mesh->faces_end(); ++f_it) {
1102 if(mesh->status(*f_it).selected()) {
1103 for(PolyMesh::FaceVertexIter fv_it = mesh->fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
1104 ids.push_back(fv_it->idx());
1105 }
1106 }
1107 }
1108 selectModelingVertices(_objectId, ids);
1109 }
1110 }
1111
1112 if(_deselect) {
1113 clearFaceSelection(_objectId);
1114 }
1115 } else if (_from == "Feature Vertices") {
1116
1117 if (_to == "Vertex Selection") {
1118 if(object->dataType() == DATA_TRIANGLE_MESH) {
1119 MeshSelection::convertFeatureVerticesToVertexSelection(PluginFunctions::triMesh(_objectId));
1120 if (_deselect) {
1121 MeshSelection::clearFeatureVertices(PluginFunctions::triMesh(_objectId));
1122 }
1123 } else if(object->dataType() == DATA_POLY_MESH) {
1124 MeshSelection::convertFeatureVerticesToVertexSelection(PluginFunctions::polyMesh(_objectId));
1125 if (_deselect) {
1126 MeshSelection::clearFeatureVertices(PluginFunctions::polyMesh(_objectId));
1127 }
1128 }
1129 }
1130 } else if (_from == "Feature Edges") {
1131
1132 if (_to == "Edge Selection") {
1133 if(object->dataType() == DATA_TRIANGLE_MESH) {
1134 MeshSelection::convertFeatureEdgesToEdgeSelection(PluginFunctions::triMesh(_objectId));
1135 if (_deselect) {
1136 MeshSelection::clearFeatureEdges(PluginFunctions::triMesh(_objectId));
1137 }
1138 } else if(object->dataType() == DATA_POLY_MESH) {
1139 MeshSelection::convertFeatureEdgesToEdgeSelection(PluginFunctions::polyMesh(_objectId));
1140 if (_deselect) {
1141 MeshSelection::clearFeatureEdges(PluginFunctions::polyMesh(_objectId));
1142 }
1143 }
1144 }
1145 } else if (_from == "Feature Faces") {
1146
1147 if (_to == "Face Selection") {
1148 if(object->dataType() == DATA_TRIANGLE_MESH) {
1149 MeshSelection::convertFeatureFacesToFaceSelection(PluginFunctions::triMesh(_objectId));
1150 if (_deselect) {
1151 MeshSelection::clearFeatureFaces(PluginFunctions::triMesh(_objectId));
1152 }
1153 } else if(object->dataType() == DATA_POLY_MESH) {
1154 MeshSelection::convertFeatureFacesToFaceSelection(PluginFunctions::polyMesh(_objectId));
1155 if (_deselect) {
1156 MeshSelection::clearFeatureFaces(PluginFunctions::polyMesh(_objectId));
1157 }
1158 }
1159 }
1160 } else if (_from == "Handle Region") {
1161 std::vector<int> ids = getHandleVertices(_objectId);
1162 if(_to == "Vertex Selection") {
1163 selectVertices(_objectId, ids);
1164 } else if (_to == "Edge Selection") {
1165 if(object->dataType() == DATA_TRIANGLE_MESH)
1166 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::triMesh(_objectId), ids);
1167 else if(object->dataType() == DATA_POLY_MESH)
1168 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::polyMesh(_objectId), ids);
1169 } else if (_to == "Halfedge Selection") {
1170 if(object->dataType() == DATA_TRIANGLE_MESH)
1171 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::triMesh(_objectId), ids);
1172 else if(object->dataType() == DATA_POLY_MESH)
1173 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::polyMesh(_objectId), ids);
1174 } else if (_to == "Face Selection") {
1175 if(object->dataType() == DATA_TRIANGLE_MESH)
1176 MeshSelection::convertVertexToFaceSelection(PluginFunctions::triMesh(_objectId), ids);
1177 else if(object->dataType() == DATA_POLY_MESH)
1178 MeshSelection::convertVertexToFaceSelection(PluginFunctions::polyMesh(_objectId), ids);
1179 } else if (_to == "Modeling Region") {
1180 selectModelingVertices(_objectId, ids);
1181 }
1182
1183 if(_deselect) {
1184 clearHandleVertices(_objectId);
1185 }
1186
1187 } else if (_from == "Modeling Region") {
1188 std::vector<int> ids = getModelingVertices(_objectId);
1189 if(_to == "Vertex Selection") {
1190 selectVertices(_objectId, ids);
1191 } else if (_to == "Edge Selection") {
1192 if(object->dataType() == DATA_TRIANGLE_MESH)
1193 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::triMesh(_objectId), ids);
1194 else if(object->dataType() == DATA_POLY_MESH)
1195 MeshSelection::convertVertexToEdgeSelection(PluginFunctions::polyMesh(_objectId), ids);
1196 } else if (_to == "Halfedge Selection") {
1197 if(object->dataType() == DATA_TRIANGLE_MESH)
1198 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::triMesh(_objectId), ids);
1199 else if(object->dataType() == DATA_POLY_MESH)
1200 MeshSelection::convertVertexToHalfedgeSelection(PluginFunctions::polyMesh(_objectId), ids);
1201 } else if (_to == "Face Selection") {
1202 if(object->dataType() == DATA_TRIANGLE_MESH)
1203 MeshSelection::convertVertexToFaceSelection(PluginFunctions::triMesh(_objectId), ids);
1204 else if(object->dataType() == DATA_POLY_MESH)
1205 MeshSelection::convertVertexToFaceSelection(PluginFunctions::polyMesh(_objectId), ids);
1206 } else if (_to == "Handle Region") {
1207 selectHandleVertices(_objectId, ids);
1208 }
1209
1210 if(_deselect) {
1211 clearModelingVertices(_objectId);
1212 }
1213 }
1214
1215 emit updatedObject(_objectId, UPDATE_SELECTION);
1216
1217 }
1218
1219
1220 void MeshObjectSelectionPlugin::conversion(const QString& _from, const QString& _to, bool _deselect) {
1221
1222 for (PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1223 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1224
1225 convertSelection(o_it->id(),_from,_to,_deselect);
1226 emit createBackup(o_it->id(), "Selection Conversion", UPDATE_SELECTION);
1227 }
1228 }
1229
1230 void MeshObjectSelectionPlugin::slotToggleSelection(QMouseEvent* _event, SelectionInterface::PrimitiveType _currentType, bool _deselect) {
1231
1232 // Return if none of the currently active types is handled by this plugin
1233 if((_currentType & allSupportedTypes_) == 0) return;
1234
1235 size_t node_idx, target_idx;
1236 ACG::Vec3d hit_point;
1237
1238 // First of all, pick anything to find all possible objects
1239 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_ANYTHING,
1240 _event->pos(), node_idx, target_idx, &hit_point)) {
1241
1242 BaseObjectData* object(0);
1243 PluginFunctions::getPickedObject(node_idx, object);
1244 if(!object) return;
1245
1246 if (object->dataType() == DATA_TRIANGLE_MESH) {
1247 // Pick triangle meshes
1248 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(),node_idx, target_idx, &hit_point)) {
1249
1250 if (object->dataType(DATA_TRIANGLE_MESH)) {
1251 toggleMeshSelection(object->id(), PluginFunctions::triMesh(object), target_idx, hit_point, _currentType);
1252 }
1253 } else {
1254 // Pick point cloud
1255 TriMesh* mesh = PluginFunctions::triMesh(object);
1256
1257 if (mesh->n_vertices() && !mesh->n_faces()) {
1258 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_VERTEX, _event->pos(), node_idx, target_idx, &hit_point)) {
1259
1260 TriMesh::VertexHandle vh = mesh->vertex_handle(target_idx);
1261 mesh->status(vh).set_selected(!mesh->status(vh).selected());
1262
1263 if (mesh->status(vh).selected())
1264 emit scriptInfo("selectVertices(ObjectId(" + QString::number(object->id()) + ") , [" + QString::number(vh.idx()) + "])");
1265 else
1266 emit scriptInfo("unselectVertices(ObjectId(" + QString::number(object->id()) + ") , [" + QString::number(vh.idx()) + "])");
1267 emit updatedObject(object->id(), UPDATE_SELECTION_VERTICES);
1268 }
1269 }
1270 }
1271 } else if (object->dataType() == DATA_POLY_MESH) {
1272 // Pick poly meshes
1273 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(),node_idx, target_idx, &hit_point)) {
1274
1275 if (object->dataType(DATA_POLY_MESH)) {
1276 toggleMeshSelection(object->id(), PluginFunctions::polyMesh(object), target_idx, hit_point, _currentType);
1277 }
1278 }
1279 }
1280 emit updatedObject(object->id(), UPDATE_SELECTION);
1281 emit createBackup(object->id(), "Toggle Selection", UPDATE_SELECTION);
1282 }
1283 }
1284
1285 void MeshObjectSelectionPlugin::slotLassoSelection(QMouseEvent* _event, PrimitiveType _currentType, bool _deselect) {
1286
1287 // Return if none of the currently active types is handled by this plugin
1288 if((_currentType & allSupportedTypes_) == 0) return;
1289
1290 if(_event->type() == QEvent::MouseButtonPress) {
1291
1292 // Add picked point
1293 lasso_2Dpoints_.push_back(_event->pos());
1294
1295 return;
1296
1297 } else if(_event->type() == QEvent::MouseButtonDblClick) {
1298
1299 // Finish surface lasso selection
1300 if (lasso_2Dpoints_.size() > 2) {
1301
1302 QRegion region(lasso_2Dpoints_);
1303
1304 lassoSelect(region, _currentType, _deselect);
1305 }
1306
1307 // Clear points
1308 lasso_2Dpoints_.clear();
1309 }
1310 }
1311
1312 void MeshObjectSelectionPlugin::slotVolumeLassoSelection(QMouseEvent* _event, PrimitiveType _currentType, bool _deselect) {
1313
1314 // Return if none of the currently active types is handled by this plugin
1315 if((_currentType & allSupportedTypes_) == 0) return;
1316
1317 if(_event->type() == QEvent::MouseButtonPress) {
1318
1319 // Add point on viewing plane to selection polygon
1320 volumeLassoPoints_.append(_event->pos());
1321
1322 return;
1323
1324 } else if(_event->type() == QEvent::MouseButtonDblClick) {
1325
1326 ACG::GLState &state = PluginFunctions::viewerProperties().glState();
1327 bool updateGL = state.updateGL();
1328 state.set_updateGL (false);
1329
1330 QPolygon p(volumeLassoPoints_);
1331 QRegion region = QRegion(p);
1332
1333 SelectVolumeAction action(region, this, _currentType, _deselect, state);
1334 ACG::SceneGraph::traverse (PluginFunctions::getRootNode(), action);
1335
1336 state.set_updateGL(updateGL);
1337
1338 // Clear lasso points
1339 volumeLassoPoints_.clear();
1340 }
1341 }
1342
1343 void MeshObjectSelectionPlugin::slotSphereSelection(QMouseEvent* _event, double _radius, PrimitiveType _currentType, bool _deselect) {
1344
1345 // Return if none of the currently active types is handled by this plugin
1346 if((_currentType & allSupportedTypes_) == 0) return;
1347
1348 size_t node_idx, target_idx;
1349 ACG::Vec3d hit_point;
1350
1351 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(), node_idx, target_idx, &hit_point)) {
1352
1353 BaseObjectData* object = 0;
1354
1355 if (PluginFunctions::getPickedObject(node_idx, object)) {
1356
1357 if (object->picked(node_idx) && object->dataType(DATA_TRIANGLE_MESH)) {
1358 paintSphereSelection(PluginFunctions::triMesh(object), object->id(), target_idx, hit_point, _radius, _currentType, _deselect);
1359 } else if (object->picked(node_idx) && object->dataType(DATA_POLY_MESH)) {
1360 paintSphereSelection(PluginFunctions::polyMesh(object), object->id(), target_idx, hit_point, _radius, _currentType, _deselect);
1361 }
1362
1363 emit updatedObject(object->id(), UPDATE_SELECTION);
1364 if ( _event->type() == QEvent::MouseButtonRelease )
1365 emit createBackup(object->id(), "Sphere Selection", UPDATE_SELECTION);
1366 }
1367 }
1368 }
1369
1370 void MeshObjectSelectionPlugin::slotClosestBoundarySelection(QMouseEvent* _event, PrimitiveType _currentType, bool _deselect) {
1371
1372 // Return if none of the currently active types is handled by this plugin
1373 if((_currentType & allSupportedTypes_) == 0) return;
1374
1375 size_t node_idx, target_idx;
1376 ACG::Vec3d hit_point;
1377
1378 if(PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos() ,node_idx, target_idx, &hit_point)) {
1379
1380 BaseObjectData* object = 0;
1381
1382 if(PluginFunctions::getPickedObject(node_idx, object)) {
1383
1384 if(object->dataType(DATA_TRIANGLE_MESH)) {
1385
1386 TriMesh* m = PluginFunctions::triMesh(object);
1387 TriMesh::VertexHandle vh = *(m->fv_iter(m->face_handle(target_idx)));
1388
1389 closestBoundarySelection(m, vh.idx(), _currentType, _deselect);
1390
1391 emit updatedObject(object->id(), UPDATE_SELECTION);
1392 emit createBackup(object->id(), "Boundary Selection", UPDATE_SELECTION);
1393
1394 } else if(object->dataType(DATA_POLY_MESH)) {
1395
1396 PolyMesh* m = PluginFunctions::polyMesh(object);
1397 PolyMesh::VertexHandle vh = *(m->fv_iter(m->face_handle(target_idx)));
1398
1399 closestBoundarySelection(m, vh.idx(), _currentType, _deselect);
1400
1401 emit updatedObject(object->id(), UPDATE_SELECTION);
1402 emit createBackup(object->id(), "Boundary Selection", UPDATE_SELECTION);
1403 }
1404
1405 emit updateView();
1406 }
1407 }
1408 }
1409
1410 void MeshObjectSelectionPlugin::slotFloodFillSelection(QMouseEvent* _event, PrimitiveType _currentType, bool _deselect) {
1411
1412 // Return if none of the currently active types is handled by this plugin
1413 if((_currentType & allSupportedTypes_) == 0) return;
1414
1415 size_t node_idx, target_idx;
1416 ACG::Vec3d hit_point;
1417
1418 if(!OpenFlipper::Options::nogui())
1419 max_angle_ = parameterWidget_->maxAngle->value();
1420
1421 // pick Anything to find all possible objects
1422 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_ANYTHING,
1423 _event->pos(), node_idx, target_idx, &hit_point)) {
1424
1425 BaseObjectData* object = 0;
1426
1427 if(PluginFunctions::getPickedObject(node_idx, object)) {
1428
1429 // TRIANGLE MESHES
1430 if(object->dataType() == DATA_TRIANGLE_MESH) {
1431
1432 if(PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(), node_idx, target_idx, &hit_point)) {
1433
1434 if(PluginFunctions::getPickedObject(node_idx, object)) {
1435
1436 if(object->dataType(DATA_TRIANGLE_MESH)) {
1437 floodFillSelection(
1438 PluginFunctions::triMesh(object),
1439 object->id(), target_idx, max_angle_,
1440 _currentType, _deselect);
1441 emit updatedObject(object->id(), UPDATE_SELECTION);
1442 emit createBackup(object->id(), "FloodFill Selection", UPDATE_SELECTION);
1443 }
1444 }
1445 }
1446
1447 // POLY MESHES
1448 } else if(object->dataType() == DATA_POLY_MESH) {
1449
1450 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(), node_idx, target_idx, &hit_point)) {
1451
1452 if(PluginFunctions::getPickedObject(node_idx, object) ) {
1453
1454 if(object->dataType(DATA_POLY_MESH)) {
1455 floodFillSelection(
1456 PluginFunctions::polyMesh(object),
1457 object->id(), target_idx, max_angle_,
1458 _currentType, _deselect);
1459 emit updatedObject(object->id(), UPDATE_SELECTION);
1460 emit createBackup(object->id(), "FloodFill Selection", UPDATE_SELECTION);
1461 }
1462 }
1463 }
1464 }
1465 else {
1466 emit log(LOGERR,tr("floodFillSelection: Unsupported dataType"));
1467 }
1468 }
1469 }
1470 }
1471
1472 void MeshObjectSelectionPlugin::slotComponentsSelection(QMouseEvent* _event, SelectionInterface::PrimitiveType _currentType, bool _deselect) {
1473
1474 // Return if none of the currently active types is handled by this plugin
1475 if((_currentType & allSupportedTypes_) == 0) return;
1476
1477 size_t node_idx, target_idx;
1478 ACG::Vec3d hit_point;
1479
1480 // First of all, pick anything to find all possible objects
1481 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_ANYTHING,
1482 _event->pos(), node_idx, target_idx, &hit_point)) {
1483
1484 BaseObjectData* object(0);
1485 PluginFunctions::getPickedObject(node_idx, object);
1486 if(!object) return;
1487
1488 if (object->dataType() == DATA_TRIANGLE_MESH) {
1489 // Pick triangle meshes
1490 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(),node_idx, target_idx, &hit_point)) {
1491
1492 if (object->dataType(DATA_TRIANGLE_MESH)) {
1493 componentsMeshSelection(PluginFunctions::triMesh(object),
1494 object->id(), target_idx, hit_point, _currentType);
1495 }
1496 }
1497 } else if (object->dataType() == DATA_POLY_MESH) {
1498 // Pick poly meshes
1499 if (PluginFunctions::scenegraphPick(ACG::SceneGraph::PICK_FACE, _event->pos(),node_idx, target_idx, &hit_point)) {
1500
1501 if (object->dataType(DATA_POLY_MESH)) {
1502 componentsMeshSelection(PluginFunctions::polyMesh(object),
1503 object->id(), target_idx, hit_point, _currentType);
1504 }
1505 }
1506 }
1507 emit updatedObject(object->id(), UPDATE_SELECTION);
1508 emit createBackup(object->id(), "Connected Components Selection", UPDATE_SELECTION);
1509 }
1510 }
1511
1512 void MeshObjectSelectionPlugin::loadSelection(int _objId, const QString& _filename) {
1513
1514 // Load ini file
1515 INIFile file;
1516
1517 if(!file.connect(_filename, false)) {
1518 emit log(LOGERR, QString("Could not read file '%1'!").arg(_filename));
1519 return;
1520 }
1521
1522 // Load selection from file
1523 loadIniFile(file, _objId);
1524 }
1525
1526 void MeshObjectSelectionPlugin::loadIniFile(INIFile& _ini, int _id) {
1527
1528 BaseObjectData* object = 0;
1529 if (!PluginFunctions::getObject(_id,object)) {
1530 emit log(LOGERR,tr("Cannot find object for id ") + QString::number(_id) + tr(" in saveFile") );
1531 return;
1532 }
1533
1534 std::vector<int> ids;
1535 bool invert = false;
1536
1537 bool updated_selection = false;
1538 bool updated_modeling_regions = false;
1539
1540 QString sectionName = object->name();
1541
1542 if (_ini.get_entry(ids, sectionName ,"ModelingRegion")) {
1543 invert = false;
1544 _ini.get_entry(invert, sectionName, "InvertModeling");
1545
1546 if (invert) {
1547 setAllModelingVertices(object->id());
1548 unselectModelingVertices(object->id() , ids);
1549 } else {
1550 clearModelingVertices(object->id());
1551 selectModelingVertices(object->id(), ids);
1552 }
1553
1554 if(object->dataType(DATA_TRIANGLE_MESH)) {
1555 update_regions(PluginFunctions::triMesh(object));
1556 }
1557
1558 if(object->dataType(DATA_POLY_MESH)) {
1559 update_regions(PluginFunctions::polyMesh(object));
1560 }
1561
1562 updated_modeling_regions = true;
1563 }
1564
1565 if(_ini.get_entry(ids, sectionName, "HandleRegion")) {
1566 invert = false;
1567 _ini.get_entry(invert, sectionName, "InvertHandle");
1568
1569 if(invert) {
1570 setAllHandleVertices(object->id());
1571 unselectHandleVertices(object->id(), ids);
1572 } else {
1573 clearHandleVertices(object->id());
1574 selectHandleVertices(object->id(), ids);
1575 }
1576
1577 if (object->dataType(DATA_TRIANGLE_MESH)) {
1578 update_regions(PluginFunctions::triMesh(object));
1579 }
1580
1581 if(object->dataType(DATA_POLY_MESH)) {
1582 update_regions(PluginFunctions::polyMesh(object));
1583 }
1584
1585 updated_modeling_regions = true;
1586 }
1587
1588 if(_ini.get_entry(ids, sectionName, "VertexSelection")) {
1589 invert = false;
1590 _ini.get_entry(invert, sectionName, "InvertVertexSelection");
1591
1592 if(invert) {
1593 selectAllVertices(object->id());
1594 unselectVertices(object->id(),ids);
1595 } else {
1596 clearVertexSelection(object->id());
1597 selectVertices(object->id(),ids);
1598 }
1599
1600 updated_selection = true;
1601 }
1602
1603 if(_ini.get_entry(ids, sectionName, "EdgeSelection")) {
1604 invert = false;
1605 _ini.get_entry(invert, sectionName, "InvertEdgeSelection");
1606
1607 ids = convertVertexPairsToEdges(_id, ids);
1608
1609 if(invert) {
1610 selectAllEdges(object->id());
1611 unselectEdges(object->id(),ids);
1612 } else {
1613 clearEdgeSelection(object->id());
1614 selectEdges(object->id(),ids);
1615 }
1616
1617 updated_selection = true;
1618 }
1619
1620 if(_ini.get_entry(ids, sectionName, "FaceSelection")) {
1621 invert = false;
1622 _ini.get_entry(invert, sectionName, "InvertFaceSelection");
1623
1624 if(invert) {
1625 selectAllFaces(object->id());
1626 unselectFaces(object->id(),ids);
1627 } else {
1628 clearFaceSelection(object->id());
1629 selectFaces(object->id(),ids);
1630 }
1631
1632 updated_selection = true;
1633 }
1634
1635 if(updated_modeling_regions) {
1636
1637 emit updatedObject(object->id(), UPDATE_ALL);
1638 emit updateView();
1639
1640 } else if(updated_selection) {
1641
1642 emit updatedObject(object->id(), UPDATE_SELECTION);
1643 emit updateView();
1644 }
1645
1646 if ( updated_modeling_regions || updated_selection )
1647 emit createBackup(object->id(), "Load Selection", UPDATE_SELECTION);
1648 }
1649
1650 void MeshObjectSelectionPlugin::saveIniFile(INIFile& _ini, int _id) {
1651
1652 BaseObjectData* object = 0;
1653 if ( !PluginFunctions::getObject(_id,object) ) {
1654 emit log(LOGERR,tr("Cannot find object for id ") + QString::number(_id) + tr(" in saveFile") );
1655 return;
1656 }
1657
1658 // The objects section should already exist
1659 QString sectionName = object->name();
1660 if(!_ini.section_exists(sectionName)) {
1661 emit log(LOGERR,tr("Cannot find object section id ") + QString::number(_id) + tr(" in saveFile") );
1662 return;
1663 }
1664
1665 _ini.add_entry(sectionName, "VertexSelection", getVertexSelection(object->id()));
1666 _ini.add_entry(sectionName, "EdgeSelection", convertEdgesToVertexPairs(_id, getEdgeSelection(object->id())));
1667
1668 if(object->dataType(DATA_POLY_MESH ) || object->dataType( DATA_TRIANGLE_MESH)) {
1669 _ini.add_entry(sectionName, "FaceSelection", getFaceSelection(object->id()));
1670 _ini.add_entry(sectionName, "HandleRegion", getHandleVertices(object->id()));
1671 _ini.add_entry(sectionName, "ModelingRegion", getModelingVertices(object->id()));
1672 }
1673 }
1674
1675 void MeshObjectSelectionPlugin::slotLoadSelection(const INIFile& _file) {
1676
1677 // Iterate over all mesh objects in the scene and save
1678 // the selections for all supported entity types
1679 for (PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1680 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1681
1682 // Read section for each object
1683 // Append object name to section identifier
1684 QString section = QString("MeshObjectSelection") + "//" + o_it->name();
1685 if(!_file.section_exists(section)) {
1686 continue;
1687 }
1688
1689 std::vector<int> ids;
1690 // Load vertex selection:
1691 _file.get_entry(ids, section, "VertexSelection");
1692 selectVertices(o_it->id(), ids);
1693 ids.clear();
1694 // Load edge selection:
1695 _file.get_entry(ids, section, "EdgeSelection");
1696 selectEdges(o_it->id(), convertVertexPairsToEdges(o_it->id(), ids));
1697 ids.clear();
1698 // Load halfedge selection:
1699 _file.get_entry(ids, section, "HalfedgeSelection");
1700 selectHalfedges(o_it->id(), convertVertexPairsToHalfedges(o_it->id(), ids));
1701 ids.clear();
1702 // Load face selection:
1703 _file.get_entry(ids, section, "FaceSelection");
1704 selectFaces(o_it->id(), ids);
1705 ids.clear();
1706 // Load handle region:
1707 _file.get_entry(ids, section, "HandleRegion");
1708 selectHandleVertices(o_it->id(), ids);
1709 ids.clear();
1710 // Load modeling region:
1711 _file.get_entry(ids, section, "ModelingRegion");
1712 selectModelingVertices(o_it->id(), ids);
1713 ids.clear();
1714
1715 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1716 emit createBackup(o_it->id(), "Load Selection", UPDATE_SELECTION);
1717 }
1718 }
1719
1720 void MeshObjectSelectionPlugin::slotSaveSelection(INIFile& _file) {
1721
1722 // Iterate over all mesh objects in the scene and save
1723 // the selections for all supported entity types
1724 for (PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1725 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1726
1727 // Create section for each object
1728 // Append object name to section identifier
1729 QString section = QString("MeshObjectSelection") + "//" + o_it->name();
1730
1731 // Store vertex selection:
1732 _file.add_entry(section, "VertexSelection", getVertexSelection(o_it->id()));
1733 // Store edge selection:
1734 _file.add_entry(section, "EdgeSelection", convertEdgesToVertexPairs(o_it->id(), getEdgeSelection(o_it->id())));
1735 // Store halfedge selection:
1736 _file.add_entry(section, "HalfedgeSelection", convertHalfedgesToVertexPairs(o_it->id(), getHalfedgeSelection(o_it->id())));
1737 // Store face selection:
1738 _file.add_entry(section, "FaceSelection", getFaceSelection(o_it->id()));
1739 // Store handle region:
1740 _file.add_entry(section, "HandleRegion", getHandleVertices(o_it->id()));
1741 // Store modeling region:
1742 _file.add_entry(section, "ModelingRegion", getModelingVertices(o_it->id()));
1743 }
1744 }
1745
1746 void MeshObjectSelectionPlugin::slotKeyShortcutEvent(int _key, Qt::KeyboardModifiers _modifiers) {
1747
1748 SelectionInterface::PrimitiveType type = 0u;
1749 emit getActivePrimitiveType(type);
1750
1751 if((type & allSupportedTypes_) == 0) {
1752 // No supported type is active
1753 return;
1754 }
1755
1756 bool targetsOnly = false;
1757 emit targetObjectsOnly(targetsOnly);
1758 PluginFunctions::IteratorRestriction restriction =
1759 (targetsOnly ? PluginFunctions::TARGET_OBJECTS : PluginFunctions::ALL_OBJECTS);
1760
1761 if(_key == Qt::Key_A && _modifiers == Qt::ControlModifier) {
1762
1763 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1764 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1765 if (o_it->visible()) {
1766
1767 if(type & vertexType_)
1768 selectAllVertices(o_it->id());
1769 if(type & edgeType_)
1770 selectAllEdges(o_it->id());
1771 if(type & halfedgeType_)
1772 selectAllHalfedges(o_it->id());
1773 if(type & faceType_)
1774 selectAllFaces(o_it->id());
1775 }
1776 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1777 emit createBackup(o_it->id(), "Select All", UPDATE_SELECTION);
1778 }
1779 } else if (_key == Qt::Key_C && _modifiers == Qt::NoModifier) {
1780
1781 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1782 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1783 if (o_it->visible()) {
1784
1785 if(type & vertexType_)
1786 clearVertexSelection(o_it->id());
1787 if(type & edgeType_)
1788 clearEdgeSelection(o_it->id());
1789 if(type & halfedgeType_)
1790 clearHalfedgeSelection(o_it->id());
1791 if(type & faceType_)
1792 clearFaceSelection(o_it->id());
1793 }
1794 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1795 emit createBackup(o_it->id(), "Clear Selection", UPDATE_SELECTION);
1796 }
1797 } else if(_key == Qt::Key_I && _modifiers == Qt::NoModifier) {
1798
1799 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1800 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1801 if (o_it->visible()) {
1802
1803 if(type & vertexType_)
1804 invertVertexSelection(o_it->id());
1805 if(type & edgeType_)
1806 invertEdgeSelection(o_it->id());
1807 if(type & halfedgeType_)
1808 invertHalfedgeSelection(o_it->id());
1809 if(type & faceType_)
1810 invertFaceSelection(o_it->id());
1811 }
1812 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1813 emit createBackup(o_it->id(), "Invert Selection", UPDATE_SELECTION);
1814 }
1815 } else if (_key == Qt::Key_Delete && _modifiers == Qt::NoModifier) {
1816
1817 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1818 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1819 if (o_it->visible()) {
1820 // Delete all selected primitives
1821 if(type & vertexType_)
1822 deleteVertexSelection(o_it->id());
1823 if(type & edgeType_)
1824 deleteEdgeSelection(o_it->id());
1825 if(type & faceType_)
1826 deleteFaceSelection(o_it->id());
1827 }
1828 emit updatedObject(o_it->id(), UPDATE_TOPOLOGY);
1829 emit createBackup(o_it->id(), "Delete Selection", UPDATE_TOPOLOGY);
1830 }
1831 }
1832 }
1833
1834 void MeshObjectSelectionPlugin::slotMouseWheelEvent(QWheelEvent* event, std::string const& mode) {
1835
1836 // Get currently active primitive type
1837 SelectionInterface::PrimitiveType type = 0u;
1838 emit getActivePrimitiveType(type);
1839
1840 // Only handle supported primitive types
1841 if((type & allSupportedTypes_) == 0) {
1842 // No supported type is active
1843 return;
1844 }
1845
1846 // Decide, if all or only target objects should be handled
1847 bool targetsOnly = false;
1848 emit targetObjectsOnly(targetsOnly);
1849 PluginFunctions::IteratorRestriction restriction =
1850 (targetsOnly ? PluginFunctions::TARGET_OBJECTS : PluginFunctions::ALL_OBJECTS);
1851
1852 if(event->modifiers() == Qt::ShiftModifier) {
1853
1854 if (event->delta() > 0) {
1855 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1856 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1857 if (o_it->visible()) {
1858
1859 if(type & vertexType_)
1860 growVertexSelection(o_it->id());
1861 if(type & faceType_)
1862 growFaceSelection(o_it->id());
1863 }
1864 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1865 emit createBackup(o_it->id(), "Grow Selection", UPDATE_SELECTION);
1866 }
1867 } else {
1868
1869 for (PluginFunctions::ObjectIterator o_it(restriction, DataType(DATA_TRIANGLE_MESH | DATA_POLY_MESH));
1870 o_it != PluginFunctions::objectsEnd(); ++o_it) {
1871 if (o_it->visible()) {
1872
1873 if(type & vertexType_)
1874 shrinkVertexSelection(o_it->id());
1875 if(type & faceType_)
1876 shrinkFaceSelection(o_it->id());
1877 }
1878 emit updatedObject(o_it->id(), UPDATE_SELECTION);
1879 emit createBackup(o_it->id(), "Shrink Selection", UPDATE_SELECTION);
1880 }
1881 }
1882 }
1883 }
1884
1885 void MeshObjectSelectionPlugin::lassoSelect(QRegion& _region,
1886 PrimitiveType _primitiveType,
1887 bool _deselection) {
1888
1889 // <object id, primitive id>
1890 QList <QPair<size_t, size_t> > list;
1891
1892 if(_primitiveType & vertexType_) {
1893 PluginFunctions::scenegraphRegionPick(ACG::SceneGraph::PICK_FRONT_VERTEX, _region, list);
1894
1895 std::set<int> alreadySelectedObjects;
1896
1897 for(int i = 0; i < list.size(); ++i) {
1898
1899 if(alreadySelectedObjects.count(list[i].first) != 0)
1900 continue;
1901
1902 BaseObjectData* bod = 0;
1903 PluginFunctions::getPickedObject(list[i].first, bod);
1904
1905 if(bod && (bod->dataType() == DATA_TRIANGLE_MESH || bod->dataType() == DATA_POLY_MESH)) {
1906 IdList elements;
1907 for(int j = 0; j < list.size(); ++j) {
1908 if(list[j].first == list[i].first) {
1909
1910 elements.push_back(list[j].second);
1911 }
1912 }
1913 if (!_deselection)
1914 selectVertices(bod->id(), elements);
1915 else
1916 unselectVertices(bod->id(), elements);
1917 alreadySelectedObjects.insert(list[i].first);
1918 emit updatedObject(bod->id(), UPDATE_SELECTION);
1919 emit createBackup(bod->id(), "Lasso Selection", UPDATE_SELECTION);
1920 }
1921 }
1922 }
1923 if(_primitiveType & edgeType_) {
1924 PluginFunctions::scenegraphRegionPick(ACG::SceneGraph::PICK_FRONT_EDGE, _region, list);
1925
1926 std::set<int> alreadySelectedObjects;
1927
1928 for(int i = 0; i < list.size(); ++i) {
1929
1930 if(alreadySelectedObjects.count(list[i].first) != 0)
1931 continue;
1932
1933 BaseObjectData* bod = 0;
1934 PluginFunctions::getPickedObject(list[i].first, bod);
1935
1936 if(bod && (bod->dataType() == DATA_TRIANGLE_MESH || bod->dataType() == DATA_POLY_MESH)) {
1937 IdList elements;
1938 for(int j = 0; j < list.size(); ++j) {
1939 if(list[j].first == list[i].first) {
1940
1941 elements.push_back(list[j].second);
1942 }
1943 }
1944 if (!_deselection)
1945 selectEdges(bod->id(), elements, dihedral_angle_threshold_);
1946 else
1947 unselectEdges(bod->id(), elements);
1948 alreadySelectedObjects.insert(list[i].first);
1949 emit updatedObject(bod->id(), UPDATE_SELECTION);
1950 emit createBackup(bod->id(), "Lasso Selection", UPDATE_SELECTION);
1951 }
1952 }
1953 }
1954 if(_primitiveType & halfedgeType_) {
1955 PluginFunctions::scenegraphRegionPick(ACG::SceneGraph::PICK_FRONT_EDGE, _region, list);
1956
1957 std::set<int> alreadySelectedObjects;
1958
1959 for(int i = 0; i < list.size(); ++i) {
1960
1961 if(alreadySelectedObjects.count(list[i].first) != 0)
1962 continue;
1963
1964 BaseObjectData* bod = 0;
1965 PluginFunctions::getPickedObject(list[i].first, bod);
1966
1967 if(bod && (bod->dataType() == DATA_TRIANGLE_MESH || bod->dataType() == DATA_POLY_MESH)) {
1968 IdList elements;
1969 for(int j = 0; j < list.size(); ++j) {
1970 if(list[j].first == list[i].first) {
1971
1972 elements.push_back(list[j].second);
1973 }
1974 }
1975 IdList oldEdgeSelection = getEdgeSelection(bod->id());
1976 clearEdgeSelection(bod->id());
1977
1978 if (!_deselection)
1979 {
1980 //on selection: select picked edges, convert to halfedge selection
1981 update_dihedral_angle_threshold_from_ui();
1982 selectEdges(bod->id(), elements, dihedral_angle_threshold_);
1983 }
1984 else
1985 {
1986 //on deselection: get current Halfedge Selection, unselect edge, convert back
1987 if(bod->dataType() == DATA_TRIANGLE_MESH)
1988 MeshSelection::convertHalfedgeToEdgeSelection(PluginFunctions::triMesh(bod));
1989 else if(bod->dataType() == DATA_POLY_MESH)
1990 MeshSelection::convertHalfedgeToEdgeSelection(PluginFunctions::polyMesh(bod));
1991
1992 clearHalfedgeSelection(bod->id());
1993 unselectEdges(bod->id(), elements);
1994 }
1995
1996
1997 if(bod->dataType() == DATA_TRIANGLE_MESH)
1998 MeshSelection::convertEdgeToHalfedgeSelection(PluginFunctions::triMesh(bod));
1999 else if(bod->dataType() == DATA_POLY_MESH)
2000 MeshSelection::convertEdgeToHalfedgeSelection(PluginFunctions::polyMesh(bod));
2001
2002 clearEdgeSelection(bod->id());
2003 selectEdges(bod->id(), oldEdgeSelection);
2004
2005 alreadySelectedObjects.insert(list[i].first);
2006 emit updatedObject(bod->id(), UPDATE_SELECTION);
2007 emit createBackup(bod->id(), "Lasso Selection", UPDATE_SELECTION);
2008 }
2009 }
2010 }
2011 if(_primitiveType & faceType_) {
2012 PluginFunctions::scenegraphRegionPick(ACG::SceneGraph::PICK_FACE, _region, list);
2013
2014 std::set<int> alreadySelectedObjects;
2015
2016 for(int i = 0; i < list.size(); ++i) {
2017
2018 if(alreadySelectedObjects.count(list[i].first) != 0)
2019 continue;
2020
2021 BaseObjectData* bod = 0;
2022 PluginFunctions::getPickedObject(list[i].first, bod);
2023
2024 if(bod && (bod->dataType() == DATA_TRIANGLE_MESH || bod->dataType() == DATA_POLY_MESH)) {
2025 IdList elements;
2026 for(int j = 0; j < list.size(); ++j) {
2027 if(list[j].first == list[i].first) {
2028
2029 elements.push_back(list[j].second);
2030 }
2031 }
2032 if (!_deselection)
2033 selectFaces(bod->id(), elements);
2034 else
2035 unselectFaces(bod->id(), elements);
2036 alreadySelectedObjects.insert(list[i].first);
2037 emit updatedObject(bod->id(), UPDATE_SELECTION);
2038 emit createBackup(bod->id(), "Lasso Selection", UPDATE_SELECTION);
2039 }
2040 }
2041 }
2042 }
2043
2045 bool SelectVolumeAction::operator()(BaseNode* _node) {
2046
2047 BaseObjectData* object = 0;
2048 if(PluginFunctions::getPickedObject(_node->id(), object)) {
2049
2050 bool selected = false;
2051 if (object->dataType(DATA_TRIANGLE_MESH)) {
2052
2053 TriMesh* m = PluginFunctions::triMesh(object);
2054 selected = plugin_->volumeSelection(m, object->id(), state_, &region_, type_, deselection_);
2055
2056 } else if(object->dataType(DATA_POLY_MESH)) {
2057
2058 PolyMesh* m = PluginFunctions::polyMesh(object);
2059 selected = plugin_->volumeSelection(m, object->id(), state_, &region_, type_, deselection_);
2060 }
2061
2062 if (selected){
2063 emit plugin_->updatedObject(object->id(), UPDATE_SELECTION);
2064 emit plugin_->createBackup( object->id(), "Lasso Selection", UPDATE_SELECTION);
2065 }
2066 }
2067 return true;
2068 }
2069
2071 int MeshObjectSelectionPlugin::createMeshFromSelection(int _objectId, PrimitiveType _primitiveType)
2072 {
2073
2074 // get object
2075 BaseObjectData *obj = 0;
2076 PluginFunctions::getObject(_objectId, obj);
2077
2078 if (obj == 0) {
2079 emit log(LOGERR, tr("Unable to get object"));
2080 return -1;
2081 }
2082
2083 if (obj->dataType(DATA_TRIANGLE_MESH)) {
2084 TriMesh* mesh = PluginFunctions::triMesh(obj);
2085
2086 if (mesh == 0) {
2087 emit log(LOGERR, tr("Unable to get mesh"));
2088 return -1;
2089 }
2090
2091 //add an empty mesh
2092 int id = -1;
2093 emit addEmptyObject(DATA_TRIANGLE_MESH, id);
2094
2095 if (id == -1) {
2096 emit log(LOGERR, tr("Unable to add empty object"));
2097 return -1;
2098 }
2099
2100 BaseObjectData *newObj;
2101 PluginFunctions::getObject(id, newObj);
2102
2103 TriMesh* newMesh = PluginFunctions::triMesh(newObj);
2104
2105 if (newMesh == 0) {
2106 emit log(LOGERR, tr("Unable to get mesh"));
2107 return -1;
2108 }
2109
2110 //fill the empty mesh with the selection
2111 createMeshFromSelection(*mesh, *newMesh,_primitiveType);
2112
2113 emit updatedObject(id, UPDATE_ALL);
2114
2115 return id;
2116
2117 } else if (obj->dataType(DATA_POLY_MESH)) {
2118 PolyMesh* mesh = PluginFunctions::polyMesh(obj);
2119
2120 if (mesh == 0) {
2121 emit log(LOGERR, tr("Unable to get mesh"));
2122 return -1;
2123 }
2124
2125 //add an empty mesh
2126 int id;
2127 emit addEmptyObject(DATA_POLY_MESH, id);
2128
2129 if (id == -1) {
2130 emit log(LOGERR, tr("Unable to add empty object"));
2131 return -1;
2132 }
2133
2134 BaseObjectData *newObj;
2135 PluginFunctions::getObject(id, newObj);
2136
2137 PolyMesh* newMesh = PluginFunctions::polyMesh(newObj);
2138
2139 if (newMesh == 0) {
2140 emit log(LOGERR, tr("Unable to get mesh"));
2141 return -1;
2142 }
2143
2144 //fill the empty mesh with the selection
2145 createMeshFromSelection(*mesh, *newMesh,_primitiveType);
2146
2147 emit updatedObject(id, UPDATE_ALL);
2148
2149 return id;
2150 } else {
2151 emit log(LOGERR, tr("DataType not supported"));
2152 return -1;
2153 }
2154 }
2155
2156 void MeshObjectSelectionPlugin::updateColorValues()
2157 {
2158 // apply color values to the gui
2159 if (OpenFlipper::Options::gui())
2160 {
2161 colorButtonSelection_->setColor(QColor::fromRgbF(statusColor_[0],statusColor_[1],statusColor_[2],statusColor_[3]));
2162 colorButtonHandle_->setColor(QColor::fromRgbF(handleColor_[0], handleColor_[1], handleColor_[2], handleColor_[3]));
2163 colorButtonArea_->setColor(QColor::fromRgbF(areaColor_[0],areaColor_[1],areaColor_[2],areaColor_[3]));
2164 colorButtonFeature_->setColor(QColor::fromRgbF(featureColor_[0],featureColor_[1],featureColor_[2],featureColor_[3]));
2165 }
2166
2167 // save new color values
2168 std::stringstream sstream;
2169 sstream << statusColor_;
2170 OpenFlipperQSettings().setValue("SelectionMeshObject/StatusColor",QString(sstream.str().c_str()));
2171 sstream.str("");
2172 sstream.clear();
2173
2174 sstream << handleColor_;
2175 OpenFlipperQSettings().setValue("SelectionMeshObject/HandleColor",QString(sstream.str().c_str()));
2176 sstream.str("");
2177 sstream.clear();
2178
2179 sstream << areaColor_;
2180 OpenFlipperQSettings().setValue("SelectionMeshObject/AreaColor",QString(sstream.str().c_str()));
2181 sstream.str("");
2182 sstream.clear();
2183
2184 sstream << featureColor_;
2185 OpenFlipperQSettings().setValue("SelectionMeshObject/FeatureColor",QString(sstream.str().c_str()));
2186 }
2187
2188
2189 void MeshObjectSelectionPlugin::setDefaultColorValues()
2190 {
2191 statusColor_ = ACG::Vec4f(1.0f,0.0f,0.0f,1.0f);
2192 areaColor_ = ACG::Vec4f(0.4f, 0.4f, 1.0f, 1.0f);
2193 handleColor_ = ACG::Vec4f(0.2f, 1.0f, 0.2f, 1.0f);
2194 featureColor_ = ACG::Vec4f(1.0f, 0.2f, 1.0f, 1.0f);
2195
2196 updateColorValues();
2197 }
2198
2199 bool MeshObjectSelectionPlugin::initializeOptionsWidget(QWidget*& _widget)
2200 {
2201 _widget = new QWidget();
2202 QVBoxLayout* vLayout = new QVBoxLayout();
2203 QHBoxLayout* hLayout = new QHBoxLayout();
2204
2205 hLayout->addWidget(new QLabel("Select default colors for newly created objects. Does not affect already created objects."));
2206 vLayout->addLayout(hLayout);
2207
2208 hLayout = new QHBoxLayout();
2209 colorButtonSelection_ = new QtColorChooserButton();
2210 hLayout->addWidget(new QLabel("Selection Color: "));
2211 hLayout->addWidget(colorButtonSelection_);
2212 vLayout->addLayout(hLayout);
2213
2214 hLayout = new QHBoxLayout();
2215 colorButtonHandle_ = new QtColorChooserButton();
2216 hLayout->addWidget(new QLabel("Handle Color: "));
2217 hLayout->addWidget(colorButtonHandle_);
2218 vLayout->addLayout(hLayout);
2219
2220 hLayout = new QHBoxLayout();
2221 colorButtonFeature_ = new QtColorChooserButton();
2222 hLayout->addWidget(new QLabel("Feature Color: "));
2223 hLayout->addWidget(colorButtonFeature_);
2224 vLayout->addLayout(hLayout);
2225
2226 hLayout = new QHBoxLayout();
2227 colorButtonArea_= new QtColorChooserButton();
2228 hLayout->addWidget(new QLabel("Area Color: "));
2229 hLayout->addWidget(colorButtonArea_);
2230 vLayout->addLayout(hLayout);
2231
2232 hLayout = new QHBoxLayout();
2233 QPushButton* restoreDefault = new QPushButton();
2234 connect(restoreDefault, SIGNAL(clicked()), this, SLOT(setDefaultColorValues()));
2235 restoreDefault->setText("Restore Default");
2236 hLayout->addWidget(restoreDefault);
2237 hLayout->addStretch();
2238 vLayout->addLayout(hLayout);
2239
2240 _widget->setLayout(vLayout);
2241
2242 return true;
2243 }
2244
2245 void MeshObjectSelectionPlugin::applyOptions()
2246 {
2247 statusColor_ = ACG::Vec4f(colorButtonSelection_->color().redF(),colorButtonSelection_->color().greenF(),colorButtonSelection_->color().blueF(),1.f);
2248 areaColor_ = ACG::Vec4f(colorButtonArea_->color().redF(),colorButtonArea_->color().greenF(),colorButtonArea_->color().blueF(),1.f);
2249 handleColor_ = ACG::Vec4f(colorButtonHandle_->color().redF(),colorButtonHandle_->color().greenF(),colorButtonHandle_->color().blueF(),1.f);
2250 featureColor_ = ACG::Vec4f(colorButtonFeature_->color().redF(),colorButtonFeature_->color().greenF(),colorButtonFeature_->color().blueF(),1.f);
2251
2252 updateColorValues();
2253 }
2254
2255 void MeshObjectSelectionPlugin::addedEmptyObject(int _id )
2256 {
2257 if (OpenFlipper::Options::nogui())
2258 return;
2259
2260 PolyMeshObject* polyObj = 0;
2261 TriMeshObject* triObj = 0;
2262
2263 triObj = PluginFunctions::triMeshObject(_id);
2264 polyObj = PluginFunctions::polyMeshObject(_id);
2265
2266 if (triObj)
2267 {
2268 triObj->setSelectionColor(statusColor_);
2269 triObj->setHandleColor(handleColor_);
2270 triObj->setAreaColor(areaColor_);
2271 triObj->setFeatureColor(featureColor_);
2272 }else if (polyObj)
2273 {
2274 polyObj->setSelectionColor(statusColor_);
2275 polyObj->setHandleColor(handleColor_);
2276 polyObj->setAreaColor(areaColor_);
2277 polyObj->setFeatureColor(featureColor_);
2278 }
2279
2280 }
2281
2282 void MeshObjectSelectionPlugin::set_dihedral_angle_threshold(const double _a)
2283 {
2284 dihedral_angle_threshold_ = OpenMesh::deg_to_rad(_a);
2285 }
2286
2287 double MeshObjectSelectionPlugin::get_dihedral_angle_threshold()
2288 {
2289 return dihedral_angle_threshold_;
2290 }
2291
2292 void MeshObjectSelectionPlugin::set_max_angle(const double _a)
2293 {
2294 max_angle_ = _a;
2295 }
2296
2297 double MeshObjectSelectionPlugin::get_max_angle()
2298 {
2299 return max_angle_;
2300 }
2301
2302 void MeshObjectSelectionPlugin::update_dihedral_angle_threshold_from_ui()
2303 {
2304 set_dihedral_angle_threshold( parameterWidget_->minDihedralAngle->value());
2305 }
2306
2307
2308
MeshObjectSelectionPlugin::invertEdgeSelection
void invertEdgeSelection(int objectId)
Unselect all Edges.
Definition: EdgeSelection.cc:171
OpenMesh::TriMesh_ArrayKernelT
Definition: PolyMesh_ArrayKernelT.hh:73
MeshObjectSelectionPlugin::convertSelection
void convertSelection(const int &_objectId, const QString &_from, const QString &_to, bool _deselect)
Convert the selection on one object.
Definition: MeshObjectSelectionPlugin.cc:865
MeshObjectSelectionPlugin::slotToggleSelection
void slotToggleSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a toggle selection.
Definition: MeshObjectSelectionPlugin.cc:1230
MeshObjectSelectionPlugin::colorizeHalfedgeSelection
void colorizeHalfedgeSelection(int objectId, int r, int g, int b, int a)
Colorize the edge selection.
Definition: HalfedgeSelection.cc:353
MeshObjectSelectionPlugin::getModelingVertices
IdList getModelingVertices(int objectId)
Get a list of all modeling vertices.
Definition: VertexSelection.cc:647
MeshObjectSelectionPlugin::deleteFaceSelection
void deleteFaceSelection(int _objectId)
Delete face that are currently selected.
Definition: FaceSelection.cc:193
UPDATE_SELECTION_VERTICES
const UpdateType UPDATE_SELECTION_VERTICES(UpdateTypeSet(1)<< 5)
Vertex selection has changed.
MeshObjectSelectionPlugin::shrinkFaceSelection
void shrinkFaceSelection(int objectId)
Shrink the current face selection.
Definition: FaceSelection.cc:246
MeshObjectSelectionPlugin::selectAllHalfedges
void selectAllHalfedges(int objectId)
Select all Halfedges.
Definition: HalfedgeSelection.cc:124
MeshObjectSelectionPlugin::set_max_angle
void set_max_angle(const double _a)
set max angle for flood fill selection
Definition: MeshObjectSelectionPlugin.cc:2292
MeshObjectSelectionPlugin::faceType_
SelectionInterface::PrimitiveType faceType_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:579
MeshObjectSelectionPlugin::update_regions
void update_regions(MeshT *_mesh)
Update face selection to correspond to the vertex selection.
UPDATE_ALL
const UpdateType UPDATE_ALL(UpdateTypeSet(1))
Identifier for all updates.
MeshObjectSelectionPlugin::setAllModelingVertices
void setAllModelingVertices(int objectId)
Set all vertices to be part of the modeling area.
Definition: VertexSelection.cc:625
MeshObjectSelectionPlugin::slotFloodFillSelection
void slotFloodFillSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a flood fill selection.
Definition: MeshObjectSelectionPlugin.cc:1410
MeshObjectSelectionPlugin::slotMouseWheelEvent
void slotMouseWheelEvent(QWheelEvent *event, std::string const &mode)
Wheel Event from main application.
Definition: MeshObjectSelectionPlugin.cc:1834
MeshObjectSelectionPlugin::unselectFaces
void unselectFaces(int objectId, IdList _facesList)
Unselect given faces.
Definition: FaceSelection.cc:91
MeshObjectSelectionPlugin::statusColor_
ACG::Vec4f statusColor_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:599
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
MeshObjectSelectionPlugin::selectBoundaryHalfedges
void selectBoundaryHalfedges(int objectId)
Select boundary edges.
Definition: HalfedgeSelection.cc:193
ACG::SceneGraph::PICK_ANYTHING
pick any of the prior targets (should be implemented for all nodes)
Definition: PickTarget.hh:84
MeshObject::setFeatureColor
void setFeatureColor(const ACG::Vec4f &_color)
set color for features
Definition: MeshObjectT_impl.hh:516
MeshObjectSelectionPlugin::invertHalfedgeSelection
void invertHalfedgeSelection(int objectId)
Unselect all Halfedges.
Definition: HalfedgeSelection.cc:170
MeshObjectSelectionPlugin::vertexType_
SelectionInterface::PrimitiveType vertexType_
Primitive type handles:
Definition: MeshObjectSelectionPlugin.hh:576
MeshObjectSelectionPlugin::colorButtonHandle_
QtColorChooserButton * colorButtonHandle_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:596
ACG::GLState::set_updateGL
void set_updateGL(bool _b)
should GL matrices be updated after each matrix operation
Definition: GLState.hh:235
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
UPDATE_SELECTION
const UpdateType UPDATE_SELECTION(UpdateTypeSet(1)<< 4)
Selection updated.
MeshObjectSelectionPlugin::colorizeEdgeSelection
void colorizeEdgeSelection(int objectId, int r, int g, int b, int a)
Colorize the edge selection.
Definition: EdgeSelection.cc:382
MeshObjectSelectionPlugin::slotClosestBoundarySelection
void slotClosestBoundarySelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a closest boundary selection.
Definition: MeshObjectSelectionPlugin.cc:1370
MeshObjectSelectionPlugin::clearFaceSelection
void clearFaceSelection(int objectId)
Unselect all faces.
Definition: FaceSelection.cc:147
MeshObjectSelectionPlugin::~MeshObjectSelectionPlugin
~MeshObjectSelectionPlugin()
Default destructor.
Definition: MeshObjectSelectionPlugin.cc:127
MeshObjectSelectionPlugin::createMeshFromSelection
void createMeshFromSelection(MeshT &_mesh, MeshT &_newMesh, PrimitiveType _primitiveType)
Create a new mesh from the selection.
Definition: MeshObjectSelectionPluginT_impl.hh:876
PluginFunctions::polyMeshObject
PolyMeshObject * polyMeshObject(BaseObjectData *_object)
Cast an BaseObject to a PolyMeshObject if possible.
Definition: PluginFunctionsPolyMesh.cc:149
MeshObjectSelectionPlugin::convertEdgesToVertexPairs
IdList convertEdgesToVertexPairs(int _id, const IdList &_edges)
Convert edge ids to vertex pairs.
Definition: EdgeSelection.cc:271
INIFile::section_exists
bool section_exists(const QString &_section) const
Check if given section exists in the current INI file.
Definition: INIFile.cc:227
MeshObjectSelectionPlugin::conversion
void conversion(const QString &_from, const QString &_to, bool _deselect)
Convert the selection on all target objects.
Definition: MeshObjectSelectionPlugin.cc:1220
ACG::Vec4f
VectorT< float, 4 > Vec4f
Definition: VectorT.hh:138
MeshObjectSelectionPlugin::areaColor_
ACG::Vec4f areaColor_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:600
MeshObjectSelectionPlugin::lasso_2Dpoints_
QPolygon lasso_2Dpoints_
Used for lasso selection tool.
Definition: MeshObjectSelectionPlugin.hh:584
MeshObjectSelectionPlugin::slotSphereSelection
void slotSphereSelection(QMouseEvent *_event, double _radius, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a sphere selection.
Definition: MeshObjectSelectionPlugin.cc:1343
MeshObjectSelectionPlugin::lassoSelect
void lassoSelect(QRegion &_region, PrimitiveType _primitiveType, bool _deselection)
Lasso selection tool.
Definition: MeshObjectSelectionPlugin.cc:1885
MeshObjectSelectionPlugin::updateColorValues
void updateColorValues()
Set descriptions for local public slots.
Definition: MeshObjectSelectionPlugin.cc:2156
MeshObjectSelectionPlugin::clearEdgeSelection
void clearEdgeSelection(int objectId)
Invert the current edge selection.
Definition: EdgeSelection.cc:148
MeshObjectSelectionPlugin::unselectVertices
void unselectVertices(int objectId, IdList _vertexList)
unselect given vertices
Definition: VertexSelection.cc:91
OpenFlipperQSettings::setValue
void setValue(const QString &key, const QVariant &value)
Wrapper function which makes it possible to enable Debugging output with -DOPENFLIPPER_SETTINGS_DEBUG...
Definition: OpenFlipperQSettings.cc:61
MeshObjectSelectionPlugin::slotKeyShortcutEvent
void slotKeyShortcutEvent(int _key, Qt::KeyboardModifiers _modifiers)
One of the previously registered keys has been pressed.
Definition: MeshObjectSelectionPlugin.cc:1746
ParameterWidget
Definition: ParameterWidget.hh:44
MeshObjectSelectionPlugin::slotVolumeLassoSelection
void slotVolumeLassoSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a volume lasso selection.
Definition: MeshObjectSelectionPlugin.cc:1312
OpenMesh::PolyMeshT::FaceVertexIter
Kernel::FaceVertexIter FaceVertexIter
Circulator.
Definition: PolyMeshT.hh:167
BaseObject::dataType
bool dataType(DataType _type) const
Definition: BaseObject.cc:221
PluginFunctions::TARGET_OBJECTS
const QStringList TARGET_OBJECTS("target")
Iterable object range.
MeshObjectSelectionPlugin::colorizeVertexSelection
void colorizeVertexSelection(int _objectId, int _r, int _g, int _b, int a)
Colorize the vertex selection.
Definition: VertexSelection.cc:341
PluginFunctions::IteratorRestriction
QStringList IteratorRestriction
Iterable object range.
Definition: PluginFunctions.hh:428
MeshObjectSelectionPlugin::colorButtonFeature_
QtColorChooserButton * colorButtonFeature_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:597
MeshObjectSelectionPlugin::conversionRequested
void conversionRequested()
Show selection conversion dialog.
Definition: MeshObjectSelectionPlugin.cc:848
MeshObjectSelectionPlugin::colorButtonSelection_
QtColorChooserButton * colorButtonSelection_
Options.
Definition: MeshObjectSelectionPlugin.hh:594
PluginFunctions::triMeshObject
TriMeshObject * triMeshObject(BaseObjectData *_object)
Cast an BaseObject to a TriMeshObject if possible.
Definition: PluginFunctionsTriangleMesh.cc:156
MeshObjectSelectionPlugin::setColorForSelection
void setColorForSelection(const int _objectId, const PrimitiveType _primitiveType)
Set color for selection.
Definition: MeshObjectSelectionPlugin.cc:827
MeshObjectSelectionPlugin::volumeLassoPoints_
QVector< QPoint > volumeLassoPoints_
Used for volume lasso tool.
Definition: MeshObjectSelectionPlugin.hh:587
INIFile::connect
bool connect(const QString &name, const bool create)
Connect INIFile object with given filename.
Definition: INIFile.cc:70
MeshObjectSelectionPlugin::clearModelingVertices
void clearModelingVertices(int objectId)
Clear Modeling Area.
Definition: VertexSelection.cc:602
MeshObjectSelectionPlugin::parameterWidget_
ParameterWidget * parameterWidget_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:591
MeshObjectSelectionPlugin::getFaceSelection
IdList getFaceSelection(int objectId)
Return a list of all selected faces.
Definition: FaceSelection.cc:292
OpenMesh::PolyMeshT::VertexHandle
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:136
PluginFunctions::triMesh
TriMesh * triMesh(BaseObjectData *_object)
Get a triangle mesh from an object.
Definition: PluginFunctionsTriangleMesh.cc:134
PluginFunctions::ALL_OBJECTS
const QStringList ALL_OBJECTS
Iterable object range.
Definition: PluginFunctions.hh:430
LOGERR
Definition: LoggingInterface.hh:96
MeshObjectSelectionPlugin::selectBoundaryVertices
void selectBoundaryVertices(int _objectId)
Select all boundary vertices of the given object.
Definition: VertexSelection.cc:195
MeshObjectSelectionPlugin::max_angle_
double max_angle_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:605
MeshObjectSelectionPlugin::selectAllVertices
void selectAllVertices(int _objectId)
Select all Vertices.
Definition: VertexSelection.cc:126
PluginFunctions::getRootNode
ACG::SceneGraph::BaseNode * getRootNode()
Get the root node for data objects.
Definition: PluginFunctions.cc:961
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:473
MeshObjectSelectionPlugin::growFaceSelection
void growFaceSelection(int objectId)
Grow the current face selection.
Definition: FaceSelection.cc:269
ACG::GLState
Definition: GLState.hh:213
MeshObjectSelectionPlugin::clearHalfedgeSelection
void clearHalfedgeSelection(int objectId)
Invert the current edge selection.
Definition: HalfedgeSelection.cc:147
MeshObjectSelectionPlugin::selectHandleVertices
void selectHandleVertices(int objectId, IdList _vertexList)
Set vertices to be part of the handle area.
Definition: VertexSelection.cc:368
MeshObjectSelectionPlugin::convertHalfedgesToVertexPairs
IdList convertHalfedgesToVertexPairs(int _id, const IdList &_halfedges)
Convert halfedge ids to vertex pairs.
Definition: HalfedgeSelection.cc:241
QtColorChooserButton
Definition: QtColorChooserButton.hh:48
MeshObjectSelectionPlugin::selectAllEdges
void selectAllEdges(int objectId)
Select all Edges.
Definition: EdgeSelection.cc:125
MeshObjectSelectionPlugin::getHalfedgeSelection
IdList getHalfedgeSelection(int objectId)
Return a list of all selected edges.
Definition: HalfedgeSelection.cc:216
MeshObjectSelectionPlugin::colorButtonArea_
QtColorChooserButton * colorButtonArea_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:595
MeshObjectSelectionPlugin::toggleMeshSelection
void toggleMeshSelection(int _objectId, MeshT *_mesh, uint _fh, ACG::Vec3d &_hit_point, PrimitiveType _primitiveType)
Toggle mesh selection.
Definition: MeshObjectSelectionPluginT_impl.hh:146
MeshObjectSelectionPlugin::unselectEdges
void unselectEdges(int objectId, IdList _edgeList)
Unselect given Edges.
Definition: EdgeSelection.cc:92
MeshObjectSelectionPlugin::edgeType_
SelectionInterface::PrimitiveType edgeType_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:577
PluginFunctions::getObject
bool getObject(const int _identifier, BaseObject *&_object)
Get the object which has the given identifier.
Definition: PluginFunctions.cc:294
TriMeshObject
Type for a MeshObject containing a triangle mesh.
Definition: TriangleMesh.hh:67
MeshObjectSelectionPlugin::update_dihedral_angle_threshold_from_ui
void update_dihedral_angle_threshold_from_ui()
set dihedral angle threshold for edge selection
Definition: MeshObjectSelectionPlugin.cc:2302
MeshObjectSelectionPlugin::selectModelingVertices
void selectModelingVertices(int objectId, IdList _vertexList)
Set vertices to be part of the modeling area.
Definition: VertexSelection.cc:509
MeshObjectSelectionPlugin::unselectHandleVertices
void unselectHandleVertices(int objectId, IdList _vertexList)
Remove vertices from handle area.
Definition: VertexSelection.cc:404
MeshObject::setSelectionColor
void setSelectionColor(const ACG::Vec4f &_color)
set color for selection
Definition: MeshObjectT_impl.hh:479
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
MeshObjectSelectionPlugin::setAllHandleVertices
void setAllHandleVertices(int objectId)
Set all vertices to be part of the handle area.
Definition: VertexSelection.cc:460
UPDATE_GEOMETRY
const UpdateType UPDATE_GEOMETRY(UpdateTypeSet(1)<< 2)
Geometry updated.
IdList
std::vector< int > IdList
Standard Type for id Lists used for scripting.
Definition: DataTypes.hh:179
MeshObjectSelectionPlugin::colorizeFaceSelection
void colorizeFaceSelection(int objectId, int r, int g, int b, int a)
Colorize the face selection.
Definition: FaceSelection.cc:315
MeshObjectSelectionPlugin::clearVertexSelection
void clearVertexSelection(int _objectId)
Unselect all vertices.
Definition: VertexSelection.cc:149
MeshSelectionT.hh
Functions for selection on a mesh.
OpenMesh::PolyMesh_ArrayKernelT
Definition: PolyMesh_ArrayKernelT.hh:94
MeshObjectSelectionPlugin::convertVertexPairsToHalfedges
IdList convertVertexPairsToHalfedges(int _id, const IdList &_vertices)
Inverse of function above.
Definition: HalfedgeSelection.cc:287
PluginFunctions::scenegraphRegionPick
bool scenegraphRegionPick(ACG::SceneGraph::PickTarget _pickTarget, const QRegion &_region, QList< QPair< size_t, size_t > > &_list, QVector< float > *_depths, QVector< ACG::Vec3d > *_points)
Definition: PluginFunctions.cc:545
MeshObjectSelectionPlugin::invertVertexSelection
void invertVertexSelection(int _objectId)
Invert the current vertex selection.
Definition: VertexSelection.cc:172
ConversionDialog
Definition: ConversionDialog.hh:47
MeshObjectSelectionPlugin::selectHalfedges
void selectHalfedges(int objectId, IdList _vertexList)
Select given Halfedges.
Definition: HalfedgeSelection.cc:58
MeshObjectSelectionPlugin::handleColor_
ACG::Vec4f handleColor_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:601
MeshObjectSelectionPlugin::selectBoundaryEdges
void selectBoundaryEdges(int objectId)
select boundary edges
Definition: EdgeSelection.cc:194
MeshObjectSelectionPlugin::environmentHandle_
QString environmentHandle_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:573
MeshObjectSelectionPlugin::slotSaveSelection
void slotSaveSelection(INIFile &_file)
Save selection for all objects in the scene.
Definition: MeshObjectSelectionPlugin.cc:1720
MeshObjectSelectionPlugin::initializeOptionsWidget
bool initializeOptionsWidget(QWidget *&_widget)
Initialize the Options Widget.
Definition: MeshObjectSelectionPlugin.cc:2199
SelectVolumeAction::operator()
bool operator()(BaseNode *_node)
Traverse the scenegraph and call the selection function for all mesh nodes.
Definition: MeshObjectSelectionPlugin.cc:2045
MeshObjectSelectionPlugin::setDefaultColorValues
void setDefaultColorValues()
sets the default color values for selection/handle/region/feature nodes for all objects of this type ...
Definition: MeshObjectSelectionPlugin.cc:2189
MeshObjectSelectionPlugin::deleteEdgeSelection
void deleteEdgeSelection(int _objectId)
Delete edges that are currently selected.
Definition: EdgeSelection.cc:217
MeshObjectSelectionPlugin::allSupportedTypes_
SelectionInterface::PrimitiveType allSupportedTypes_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:581
MeshObjectSelectionPlugin::invertFaceSelection
void invertFaceSelection(int objectId)
Invert the current face selection.
Definition: FaceSelection.cc:170
ACG::GLState::updateGL
bool updateGL() const
should GL matrices be updated after each matrix operation
Definition: GLState.hh:233
MeshObjectSelectionPlugin::get_max_angle
double get_max_angle()
get max angle for flood fill selection
Definition: MeshObjectSelectionPlugin.cc:2297
MeshObjectSelectionPlugin::componentsMeshSelection
void componentsMeshSelection(MeshT *_mesh, int _objectId, uint _fh, ACG::Vec3d &_hit_point, PrimitiveType _primitiveType)
Connected component mesh selection.
Definition: MeshObjectSelectionPluginT_impl.hh:644
MeshObjectSelectionPlugin::selectAllFaces
void selectAllFaces(int objectId)
Select all faces.
Definition: FaceSelection.cc:124
MeshObjectSelectionPlugin::slotLassoSelection
void slotLassoSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a lasso selection.
Definition: MeshObjectSelectionPlugin.cc:1285
INIFile::add_entry
void add_entry(const QString &_section, const QString &_key, const QString &_value)
Addition / modification of a string entry.
Definition: INIFile.cc:257
MeshObjectSelectionPlugin::MeshObjectSelectionPlugin
MeshObjectSelectionPlugin()
Default constructor.
Definition: MeshObjectSelectionPlugin.cc:110
MeshObjectSelectionPlugin::getHandleVertices
IdList getHandleVertices(int objectId)
Get a list of all handle vertices.
Definition: VertexSelection.cc:483
SelectVolumeAction
Traverse the scenegraph and call the selection function for all mesh nodes.
Definition: MeshObjectSelectionPlugin.hh:612
DataType
Predefined datatypes.
Definition: DataTypes.hh:83
PluginFunctions::ObjectIterator
Core Data Iterator.
Definition: PluginFunctions.hh:441
OpenFlipperQSettings::value
QVariant value(const QString &key, const QVariant &defaultValue=QVariant()) const
Definition: OpenFlipperQSettings.cc:46
ACG::SceneGraph::BaseNode
Definition: BaseNode.hh:104
PluginFunctions::objectsEnd
DLLEXPORT ObjectIterator objectsEnd()
Return Iterator to Object End.
Definition: PluginFunctionsIterator.cc:177
BaseObject
Definition: BaseObject.hh:82
OpenMesh::VectorT
Definition: Vector11T.hh:83
MeshObjectSelectionPlugin::getVertexSelection
IdList getVertexSelection(int _objectId)
Return a list of all selected vertices.
Definition: VertexSelection.cc:287
ACG::SceneGraph::traverse
void traverse(BaseNode *_node, Action &_action)
Definition: SceneGraph.hh:137
ACG::SceneGraph::PICK_FRONT_VERTEX
picks only visible front verices (may not be implemented for all nodes)
Definition: PickTarget.hh:89
MeshObjectSelectionPlugin::slotSelectionOperation
void slotSelectionOperation(QString _operation)
A specific operation is requested.
Definition: MeshObjectSelectionPlugin.cc:444
MeshObjectSelectionPlugin::floodFillSelection
void floodFillSelection(MeshT *_mesh, int _objectId, uint _fh, double _maxAngle, PrimitiveType _primitiveTypes, bool _deselection)
Select all entities that are connected (and do not exceed the maximum dihedral angle) ...
Definition: MeshObjectSelectionPluginT_impl.hh:555
Viewer::ViewerProperties::glState
ACG::GLState & glState()
Get the glState of the Viewer.
Definition: ViewerProperties.cc:318
MeshObjectSelectionPlugin::updateSlotDescriptions
void updateSlotDescriptions()
Set descriptions for local public slots.
Definition: MeshObjectSelectionPlugin.cc:309
MeshObjectSelectionPlugin::set_dihedral_angle_threshold
void set_dihedral_angle_threshold(const double _a)
set dihedral angle threshold for edge selection
Definition: MeshObjectSelectionPlugin.cc:2282
PluginFunctions::polyMesh
PolyMesh * polyMesh(BaseObjectData *_object)
Get a poly mesh from an object.
Definition: PluginFunctionsPolyMesh.cc:128
MeshObjectSelectionPlugin::growVertexSelection
void growVertexSelection(int _objectId)
Grow the current vertex selection.
Definition: VertexSelection.cc:264
ACG::SceneGraph::PICK_FACE
picks faces (should be implemented for all nodes)
Definition: PickTarget.hh:78
MeshObjectSelectionPlugin::loadFlipperModelingSelection
void loadFlipperModelingSelection(int _objectId, QString _filename)
Load a selection from an Flipper selection file for the given object.
Definition: VertexSelection.cc:670
MeshObjectSelectionPlugin::selectBoundaryFaces
void selectBoundaryFaces(int objectId)
Select all boundary faces of the given object.
Definition: FaceSelection.cc:222
UPDATE_TOPOLOGY
const UpdateType UPDATE_TOPOLOGY(UpdateTypeSet(1)<< 3)
Topology updated.
MeshObjectSelectionPlugin::slotLoadSelection
void slotLoadSelection(const INIFile &_file)
Load selection for specific objects in the scene.
Definition: MeshObjectSelectionPlugin.cc:1675
MeshObjectSelectionPlugin::paintSphereSelection
void paintSphereSelection(MeshT *_mesh, int _objectId, int _target_idx, typename MeshT::Point _hitpoint, double _radius, PrimitiveType _primitiveTypes, bool _deselection)
Use the event to paint selection with a sphere.
Definition: MeshObjectSelectionPluginT_impl.hh:254
MeshObjectSelectionPlugin::clearHandleVertices
void clearHandleVertices(int objectId)
Clear handle Area.
Definition: VertexSelection.cc:437
OpenFlipperQSettings
Definition: OpenFlipperQSettings.hh:47
BaseObjectData::picked
virtual bool picked(uint _node_idx)
detect if the node has been picked
Definition: BaseObjectData.cc:311
MeshObjectSelectionPlugin::deleteVertexSelection
void deleteVertexSelection(int _objectId)
Delete vertices and faces that are currently selected.
Definition: VertexSelection.cc:311
MeshObjectSelectionPlugin::get_dihedral_angle_threshold
double get_dihedral_angle_threshold()
get dihedral angle threshold for edge selection
Definition: MeshObjectSelectionPlugin.cc:2287
MeshObjectSelectionPlugin::selectEdges
void selectEdges(int objectId, IdList _edgeList, const double _dihedral_angle_threshold=0.0)
Select given Edges.
Definition: EdgeSelection.cc:58
DATA_TRIANGLE_MESH
#define DATA_TRIANGLE_MESH
Definition: TriangleMesh.hh:60
BaseObjectData
Definition: BaseObjectData.hh:102
DATA_ALL
const DataType DATA_ALL(UINT_MAX)
Identifier for all available objects.
MeshObjectSelectionPlugin::featureColor_
ACG::Vec4f featureColor_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:602
ACG::SceneGraph::BaseNode::id
unsigned int id() const
Definition: BaseNode.hh:423
MeshObjectSelectionPlugin::getEdgeSelection
IdList getEdgeSelection(int objectId)
Return a list of all selected edges.
Definition: EdgeSelection.cc:246
MeshObject::setAreaColor
void setAreaColor(const ACG::Vec4f &_color)
set color for areas
Definition: MeshObjectT_impl.hh:498
PolyMeshObject
Type for a Meshobject containing a poly mesh.
Definition: PolyMesh.hh:65
ACG::SceneGraph::PICK_VERTEX
picks verices (may not be implemented for all nodes)
Definition: PickTarget.hh:82
MeshObjectSelectionPlugin::traceEdgePath
void traceEdgePath(int objectId, double threshold)
Trace Edge Path.
Definition: EdgeSelection.cc:459
MeshObjectSelectionPlugin::selectFaces
void selectFaces(int objectId, IdList _facesList)
Select given faces.
Definition: FaceSelection.cc:58
MeshObject::setHandleColor
void setHandleColor(const ACG::Vec4f &_color)
set color for handles
Definition: MeshObjectT_impl.hh:534
MeshObjectSelectionPlugin::dihedral_angle_threshold_
double dihedral_angle_threshold_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:604
MeshObjectSelectionPlugin::halfedgeType_
SelectionInterface::PrimitiveType halfedgeType_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:578
MeshObjectSelectionPlugin::convertVertexPairsToEdges
IdList convertVertexPairsToEdges(int _id, const IdList &_vertices)
Inverse of function above.
Definition: EdgeSelection.cc:317
MeshObjectSelectionPlugin::slotComponentsSelection
void slotComponentsSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, bool _deselect)
Called whenever the user performs a connected components selection.
Definition: MeshObjectSelectionPlugin.cc:1472
INIFile
Class for the handling of simple configuration files.
Definition: INIFile.hh:99
ACG::SceneGraph::PICK_FRONT_EDGE
picks only visible front edges (may not be implemented for all nodes)
Definition: PickTarget.hh:87
MeshObjectSelectionPlugin::addedEmptyObject
void addedEmptyObject(int _id)
An empty object has been added.
Definition: MeshObjectSelectionPlugin.cc:2255
MeshObjectSelectionPlugin::shrinkVertexSelection
void shrinkVertexSelection(int _objectId)
Shrink the current vertex selection.
Definition: VertexSelection.cc:241
MeshObjectSelectionPlugin::conversionDialog_
ConversionDialog * conversionDialog_
Handle to selection environment.
Definition: MeshObjectSelectionPlugin.hh:589
INIFile::get_entry
bool get_entry(QString &_val, const QString &_section, const QString &_key) const
Access to a string entry.
Definition: INIFile.cc:433
MeshObjectSelectionPlugin::unselectModelingVertices
void unselectModelingVertices(int objectId, IdList _vertexList)
Remove vertices from modeling area.
Definition: VertexSelection.cc:544
MeshObjectSelectionPlugin::selectVertices
void selectVertices(int objectId, IdList _vertexList)
select given vertices
Definition: VertexSelection.cc:58