Developer Documentation
Loading...
Searching...
No Matches
OVMPropertyModelT_impl.hh
1/*===========================================================================*\
2* *
3* OpenFlipper *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openflipper.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenFlipper. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39* *
40\*===========================================================================*/
41
42
43
44#define OVM_PROPERTY_MODEL_CC
45
46template <typename MeshT>
47OVMPropertyModel<MeshT>::OVMPropertyModel(MeshT* mesh, int objectID, QObject *parent)
48 : OVMPropertyModelSubclass(parent),
49 mesh_(mesh),
50 objectID_(objectID),
51 mCombineProperty1(0),
52 mCombineProperty2(0)
53{
54 gatherProperties();
55 bCombine.setText(tr("Combine"));
56 bCombine.hide();
57 connect(&bCombine, SIGNAL(clicked()),
58 this, SLOT(slotCombine()));
59 widgets->layout()->addWidget(&bCombine);
60
61 widgets->layout()->addWidget(&mLoadSaveWidget);
62
63 connect(mLoadSaveWidget.save_property , SIGNAL(clicked()),
64 this, SLOT(slotSaveProperty()));
65
66 connect(mLoadSaveWidget.load_property , SIGNAL(clicked()),
67 this, SLOT(slotLoadProperty()));
68
69 widgets->layout()->addWidget(&mPickWidget);
70 connect(mPickWidget.pickButton, SIGNAL(clicked()),
71 this, SLOT(slotPickProperty()));
72 mPickWidget.hide();
73 QString iconPath = OpenFlipper::Options::iconDirStr() + OpenFlipper::Options::dirSeparator();
74 mPickWidget.pickButton->setIcon( QIcon(iconPath + "color-picker.png") );
75
76 lastPickMode = PluginFunctions::pickMode();
77 lastActionMode = PluginFunctions::actionMode();
78
79 initializeSupportedPropertyTypes();
80}
81
82#undef INITIALIZE_PROPTYPES
83
84template <typename MeshT>
85void OVMPropertyModel<MeshT>::updateWidget(const QModelIndexList& selectedIndices)
86{
87 SingleObjectPropertyModel::updateWidget(selectedIndices);
88
89 if (selectedIndices.size() == 2)
90 {
91 if (combinable(propertyVisualizers[selectedIndices[0].row()], propertyVisualizers[selectedIndices[1].row()]))
92 {
93
94 bCombine.show();
95 mCombineProperty1 = &propertyVisualizers[selectedIndices[0].row()]->getPropertyInfo();
96 mCombineProperty2 = &propertyVisualizers[selectedIndices[1].row()]->getPropertyInfo();
97 }
98 else
99 bCombine.hide();
100 }
101 else
102 {
103 bCombine.hide();
104 }
105
106 if (selectedIndices.size() == 1)
107 mPickWidget.show();
108 else
109 {
110 mPickWidget.hide();
111 //reset Picking, just if picking was enabled
112 if (mPickWidget.pickButton->isChecked())
113 resetPicking();
114 }
115
116}
117
118template <typename MeshT>
124
125
131template <typename MeshT>
132void OVMPropertyModel<MeshT>::pickProperty()
133{
134 if ( mPickWidget.pickButton->isChecked() ){
135
136 lastPickMode = PluginFunctions::pickMode();
137 lastActionMode = PluginFunctions::actionMode();
138
139 PluginFunctions::pickMode(PROP_VIS);
140 PluginFunctions::actionMode(Viewer::PickingMode);
141
142 } else {
143 resetPicking();
144 }
145}
146
147template <typename MeshT>
148void OVMPropertyModel<MeshT>::pickModeChanged(const std::string& _mode)
149{
150 pickModeActive = (_mode == PROP_VIS);
151
152 if (!pickModeActive)
153 {
154 lastPickMode = _mode;
155 }
156
157 mPickWidget.pickButton->setChecked(pickModeActive);
158}
159
166template <typename MeshT>
167void OVMPropertyModel<MeshT>::mouseEvent(QMouseEvent* _event)
168{
169 if (!pickModeActive) return;
170 if (currentlySelectedIndices.size() < 1) return;
171
172 if (_event->type() == QEvent::MouseButtonPress)
173 {
174 size_t node_idx;
175 ACG::Vec3d hit_point;
176
177
178 OVMPropertyVisualizer<MeshT>* viz = dynamic_cast<OVMPropertyVisualizer<MeshT>*>(propertyVisualizers[currentlySelectedIndices.first().row()]);
179 size_t entityId = 0;
180
181 ACG::SceneGraph::PickTarget pickTarget;
182 if (viz->getPropertyInfo().isCellProp())
183 pickTarget = ACG::SceneGraph::PICK_CELL;
184 if (viz->getPropertyInfo().isFaceProp())
185 pickTarget = ACG::SceneGraph::PICK_FACE;
186 if (viz->getPropertyInfo().isHalffaceProp())
187 pickTarget = ACG::SceneGraph::PICK_FACE;
188 if (viz->getPropertyInfo().isEdgeProp())
189 pickTarget = ACG::SceneGraph::PICK_EDGE;
190 if (viz->getPropertyInfo().isHalfedgeProp())
191 pickTarget = ACG::SceneGraph::PICK_FACE;
192 if (viz->getPropertyInfo().isVertexProp())
193 pickTarget = ACG::SceneGraph::PICK_VERTEX;
194
195 if (PluginFunctions::scenegraphPick(pickTarget, _event->pos(),node_idx, entityId, &hit_point)) {
196 BaseObjectData* object;
197 PluginFunctions::getPickedObject(node_idx, object);
198
199 if (object->id() == objectID_)
200 {
201 if (viz->getPropertyInfo().isHalfedgeProp() || viz->getPropertyInfo().isHalffaceProp()) //cant be picked directly
202 entityId = viz->getClosestPrimitiveId(entityId, hit_point);
203
204 mPickWidget.pickedHandle->setText(tr("%1").arg(entityId));
205 mPickWidget.pickedValue->setText(viz->getPropertyText(entityId));
206 }
207 }
208
209 }
210}
211
212template <typename MeshT>
213bool OVMPropertyModel<MeshT>::parseHeader(QString header, PropertyVisualizer*& propVis, unsigned int& n)
214{
215#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
216 QStringList headerParts = header.split(tr(", "), QString::SkipEmptyParts );
217#else
218 QStringList headerParts = header.split(tr(", "), Qt::SkipEmptyParts );
219#endif
220
221 int headerVersion = headerParts[0].toUInt();
222 if (headerVersion == 1)
223 {
224 n = headerParts[1].toUInt();
225 unsigned int nExpected = 0;
226
227 PropertyInfo::ENTITY_FILTER filter = (PropertyInfo::ENTITY_FILTER)headerParts[2].toInt();
228 switch (filter)
229 {
230 case PropertyInfo::EF_CELL:
231 nExpected = mesh_->n_cells();
232 break;
233 case PropertyInfo::EF_FACE:
234 nExpected = mesh_->n_faces();
235 break;
236 case PropertyInfo::EF_HALFFACE:
237 nExpected = mesh_->n_halffaces();
238 break;
239 case PropertyInfo::EF_EDGE:
240 nExpected = mesh_->n_edges();
241 break;
242 case PropertyInfo::EF_HALFEDGE:
243 nExpected = mesh_->n_halfedges();
244 break;
245 case PropertyInfo::EF_VERTEX:
246 nExpected = mesh_->n_vertices();
247 break;
248 default:
249 nExpected = -1;
250 break;
251 }
252
253 if (n != nExpected)
254 {
255 std::cerr << "unexpected number of entities" << std::endl;
256 return false;
257 }
258
259 QString friendlyName = headerParts[3];
260
261 if (!isSupported(friendlyName))
262 {
263 std::cerr << "unsupported property type " << friendlyName.toStdString() << std::endl;
264 return false;
265 }
266
267
268 TypeInfoWrapper typeInfo = getSupportedTypeInfoWrapper(friendlyName, filter);
269
270 QString propName = QInputDialog::getText(0, "Property Name", "Please enter name.",QLineEdit::Normal,headerParts[4]);
271 if (propName == "") return false;
272
273 bool replace = false;
274 if (!(isPropertyFree(propName, filter, typeInfo) || replace))
275 {
276 NewNameMessageBox* msgBox = new NewNameMessageBox(propName);
277 msgBox->exec();
278
279 if (msgBox->rename)
280 propName = QInputDialog::getText(0, "New Property Name", "Please enter new name.");
281 else if (msgBox->cancel)
282 return false;
283 else if (msgBox->replace)
284 replace = true;
285
286 delete msgBox;
287 }
288
289 if (!replace)
290 {
291 addProperty(propName, friendlyName, filter);
292 gatherProperties();
293 }
294
295 propVis = getPropertyVisualizer(propName, filter, typeInfo);
296
297 return true;
298
299 }
300 else
301 {
302 std::cerr << "unsupported header format" << std::endl;
303 return false;
304 }
305}
306
307
308template<typename MeshT>
309QString OVMPropertyModel<MeshT>::getLoadFilenameFilter()
310{
311 QString filter;
312 filter = tr("Vertex Property (*.vprop)");
313 filter += tr(";; HalfEdge Property (*.hprop)");
314 filter += tr(";; Edge Property (*.eprop)");
315 filter += tr(";; Halfface Property (*.hfprop)");
316 filter += tr(";; Face Property (*.fprop)");
317 filter += tr(";; Cell Property (*.cprop)");
318 filter += tr(";; All Files (*)");
319 return filter;
320}
321
322template<typename MeshT>
323QString OVMPropertyModel<MeshT>::getSaveFilenameFilter(unsigned int propId)
324{
325 PropertyVisualizer* propViz = propertyVisualizers[propId];
326
327 QString filter;
328
329 if (propViz->getPropertyInfo().isVertexProp())
330 filter = tr("Vertex Property (*.vprop)");
331 else if (propViz->getPropertyInfo().isHalfedgeProp())
332 filter = tr("HalfEdge Property (*.hprop)");
333 else if (propViz->getPropertyInfo().isEdgeProp())
334 filter = tr("Edge Property (*.eprop)");
335 else if (propViz->getPropertyInfo().isFaceProp())
336 filter = tr("Face Property (*.fprop)");
337
338 filter += tr(";; All Files (*)");
339
340 return filter;
341}
342
343
353template<typename MeshT>
354bool OVMPropertyModel<MeshT>::isPropertyFree(QString propName, PropertyInfo::ENTITY_FILTER filter, TypeInfoWrapper typeInfo)
355{
356 return getPropertyVisualizer(propName, filter, typeInfo) == 0;
357}
358
367template<typename MeshT>
368void OVMPropertyModel<MeshT>::combine()
369{
370 beginResetModel();
371 propertyVisualizers.push_back(new OVMPropertyVisualizerVectorFieldDifference<MeshT>(mesh_, objectID_, *mCombineProperty1, *mCombineProperty2));
372 endResetModel();
373}
374
375template<typename MeshT>
376void OVMPropertyModel<MeshT>::saveProperty()
377{
378 for (QModelIndexList::const_iterator it = currentlySelectedIndices.begin(), it_end = currentlySelectedIndices.end();
379 it != it_end; ++it) {
380 SingleObjectPropertyModel::saveProperty(it->row());
381 }
382}
383
397template<typename MeshT>
398bool OVMPropertyModel<MeshT>::combinable(PropertyVisualizer* propertyVisualizer1, PropertyVisualizer* propertyVisualizer2) const
399{
400 const PropertyInfo& propInfo1 = propertyVisualizer1->getPropertyInfo();
401 const PropertyInfo& propInfo2 = propertyVisualizer2->getPropertyInfo();
402 TypeInfoWrapper typeInfo1 = propInfo1.typeinfo();
403 TypeInfoWrapper typeInfo2 = propInfo2.typeinfo();
404
405 return (isVectorType(typeInfo1) && isVectorType(typeInfo2)) && (propInfo1.entityType() == propInfo2.entityType());
406}
407
408template<typename MeshT>
409template <typename PropIter>
410void OVMPropertyModel<MeshT>::gatherProperties( MeshT* mesh,
411 PropIter props_first, PropIter props_last,
412 PropertyInfo::ENTITY_FILTER filter)
413{
414 for (auto pit = props_first; pit != props_last; ++pit) {
415 OpenVolumeMesh::PropertyStorageBase*const storage_base = *pit;
416 const auto prop_ptr = storage_base->make_property_ptr();
417 if (isSupported(prop_ptr.get()) && isNew(prop_ptr.get(), filter))
418 addPropertyVisualizer(prop_ptr.get(), mesh, filter);
419 }
420}
421
422
423template<typename MeshT>
424void OVMPropertyModel<MeshT>::gatherProperties()
425{
426 beginResetModel();
427 if (mesh_) {
428 gatherProperties(mesh_, mesh_->face_props_begin(), mesh_->face_props_end(), PropertyInfo::EF_FACE);
429 gatherProperties(mesh_, mesh_->edge_props_begin(), mesh_->edge_props_end(), PropertyInfo::EF_EDGE);
430 gatherProperties(mesh_, mesh_->halfedge_props_begin(), mesh_->halfedge_props_end(), PropertyInfo::EF_HALFEDGE);
431 gatherProperties(mesh_, mesh_->vertex_props_begin(), mesh_->vertex_props_end(), PropertyInfo::EF_VERTEX);
432 gatherProperties(mesh_, mesh_->halfface_props_begin(), mesh_->halfface_props_end(), PropertyInfo::EF_HALFFACE);
433 gatherProperties(mesh_, mesh_->cell_props_begin(), mesh_->cell_props_end(), PropertyInfo::EF_CELL);
434 }
435 endResetModel();
436}
437
438
446template<typename MeshT>
447bool OVMPropertyModel<MeshT>::isSupported(OpenVolumeMesh::BasePropertyPtr* const baseProp) const
448{
449 TypeInfoWrapper bp_type = typeid(*baseProp);
450 TypeInfoWrapperSet::const_iterator propIt = supportedPropertyTypes.find(bp_type);
451 return propIt != supportedPropertyTypes.end();
452}
453
464template<typename MeshT>
465bool OVMPropertyModel<MeshT>::isSupported(QString friendlyName) const
466{
467 for (TypeInfoWrapperSet::const_iterator it = supportedPropertyTypes.begin();
468 it != supportedPropertyTypes.end();
469 ++it )
470 {
471 if (friendlyName.toStdString().compare(it->getName()) == 0)
472 return true;
473 }
474 return false;
475}
476
485template<typename MeshT>
486bool OVMPropertyModel<MeshT>::isNew(OpenVolumeMesh::BasePropertyPtr* const baseProp, PropertyInfo::ENTITY_FILTER filter) const
487{
488 for (unsigned int i = 0; i < propertyVisualizers.size(); ++i)
489 {
490 const PropertyInfo& propInfo = propertyVisualizers[i]->getPropertyInfo();
491 if (propInfo == PropertyInfo(baseProp->name(), getSupportedTypeInfoWrapper(baseProp) , filter))
492 return false;
493 }
494 return true;
495}
496
497
505template<typename MeshT>
506TypeInfoWrapper OVMPropertyModel<MeshT>::getSupportedTypeInfoWrapper(OpenVolumeMesh::BasePropertyPtr* const baseProp) const
507{
508 TypeInfoWrapper bp_type = typeid(*baseProp);
509 TypeInfoWrapperSet::const_iterator propIt = supportedPropertyTypes.find(bp_type);
510 if (propIt != supportedPropertyTypes.end())
511 return *propIt;
512 else
513 {
514 std::cerr << "error" << std::endl;
515 return *propIt;
516 }
517}
518
527template<typename MeshT>
528TypeInfoWrapper OVMPropertyModel<MeshT>::getSupportedTypeInfoWrapper(QString friendlyName, PropertyInfo::ENTITY_FILTER filter) const
529{
530
531 for (TypeInfoWrapperSet::const_iterator it = supportedPropertyTypes.begin();
532 it != supportedPropertyTypes.end();
533 ++it )
534 {
535 if ((friendlyName.toStdString().compare(it->getName()) == 0) && isEntityType(*it, filter))
536 return *it;
537 }
538 throw std::exception();
539}
540
541template<typename MeshT>
542bool OVMPropertyModel<MeshT>::isBoolType(const PropertyInfo& propInfo)
543{
544 return isBoolType(propInfo.typeinfo());
545}
546
547template<typename MeshT>
548bool OVMPropertyModel<MeshT>::isBoolType(const TypeInfoWrapper& typeInfo)
549{
550 return typeInfo == proptype_Cell_bool ||
551 typeInfo == proptype_Face_bool ||
552 typeInfo == proptype_HalfFace_bool ||
553 typeInfo == proptype_Edge_bool ||
554 typeInfo == proptype_HalfEdge_bool ||
555 typeInfo == proptype_Vertex_bool;
556}
557
558template<typename MeshT>
559bool OVMPropertyModel<MeshT>::isIntType(const PropertyInfo& propInfo)
560{
561 return isIntType(propInfo.typeinfo());
562}
563
564template<typename MeshT>
565bool OVMPropertyModel<MeshT>::isIntType(const TypeInfoWrapper& typeInfo)
566{
567 return typeInfo == proptype_Cell_int ||
568 typeInfo == proptype_Face_int ||
569 typeInfo == proptype_HalfFace_int ||
570 typeInfo == proptype_Edge_int ||
571 typeInfo == proptype_HalfEdge_int ||
572 typeInfo == proptype_Vertex_int;
573}
574
575template<typename MeshT>
576bool OVMPropertyModel<MeshT>::isDoubleType(const PropertyInfo& propInfo)
577{
578 return isDoubleType(propInfo.typeinfo());
579}
580
581template<typename MeshT>
582bool OVMPropertyModel<MeshT>::isDoubleType(const TypeInfoWrapper& typeInfo)
583{
584 return typeInfo == proptype_Cell_double ||
585 typeInfo == proptype_Face_double ||
586 typeInfo == proptype_HalfFace_double ||
587 typeInfo == proptype_Edge_double ||
588 typeInfo == proptype_HalfEdge_double ||
589 typeInfo == proptype_Vertex_double;
590}
591
592template<typename MeshT>
593bool OVMPropertyModel<MeshT>::isUnsignedIntType(const PropertyInfo& propInfo)
594{
595 return isUnsignedIntType(propInfo.typeinfo());
596}
597
598template<typename MeshT>
599bool OVMPropertyModel<MeshT>::isUnsignedIntType(const TypeInfoWrapper& typeInfo)
600{
601 return typeInfo == proptype_Cell_uint ||
602 typeInfo == proptype_Face_uint ||
603 typeInfo == proptype_HalfFace_uint ||
604 typeInfo == proptype_Edge_uint ||
605 typeInfo == proptype_HalfEdge_uint ||
606 typeInfo == proptype_Vertex_uint;
607}
608
609template<typename MeshT>
610bool OVMPropertyModel<MeshT>::isVec3dType(const PropertyInfo& propInfo)
611{
612 return isVec3dType(propInfo.typeinfo());
613}
614
615template<typename MeshT>
616bool OVMPropertyModel<MeshT>::isVec3dType(const TypeInfoWrapper& typeInfo)
617{
618 return typeInfo == proptype_Cell_Vec3d ||
619 typeInfo == proptype_Face_Vec3d ||
620 typeInfo == proptype_HalfFace_Vec3d ||
621 typeInfo == proptype_Edge_Vec3d ||
622 typeInfo == proptype_HalfEdge_Vec3d ||
623 typeInfo == proptype_Vertex_Vec3d;
624}
625
626template<typename MeshT>
627bool OVMPropertyModel<MeshT>::isVec3dOVMType(const PropertyInfo& propInfo)
628{
629 return isVec3dOVMType(propInfo.typeinfo());
630}
631
632template<typename MeshT>
633bool OVMPropertyModel<MeshT>::isVec3dOVMType(const TypeInfoWrapper& typeInfo)
634{
635 return typeInfo == proptype_Cell_Vec3dOVM ||
636 typeInfo == proptype_Face_Vec3dOVM ||
637 typeInfo == proptype_HalfFace_Vec3dOVM ||
638 typeInfo == proptype_Edge_Vec3dOVM ||
639 typeInfo == proptype_HalfEdge_Vec3dOVM ||
640 typeInfo == proptype_Vertex_Vec3dOVM;
641}
642
643template<typename MeshT>
644bool OVMPropertyModel<MeshT>::isVec3fType(const PropertyInfo& propInfo)
645{
646 return isVec3fType(propInfo.typeinfo());
647}
648
649template<typename MeshT>
650bool OVMPropertyModel<MeshT>::isVec3fType(const TypeInfoWrapper& typeInfo)
651{
652 return typeInfo == proptype_Cell_Vec3f ||
653 typeInfo == proptype_Face_Vec3f ||
654 typeInfo == proptype_HalfFace_Vec3f ||
655 typeInfo == proptype_Edge_Vec3f ||
656 typeInfo == proptype_HalfEdge_Vec3f ||
657 typeInfo == proptype_Vertex_Vec3f;
658}
659
660template<typename MeshT>
661bool OVMPropertyModel<MeshT>::isVectorType(const PropertyInfo& propInfo)
662{
663 return isVec3fType(propInfo) || isVec3dType(propInfo) ;
664}
665
666template<typename MeshT>
667bool OVMPropertyModel<MeshT>::isVectorType(const TypeInfoWrapper& typeInfo)
668{
669 return isVec3fType(typeInfo) || isVec3dType(typeInfo);
670}
671
672template<typename MeshT>
673bool OVMPropertyModel<MeshT>::isVectorOVMType(const PropertyInfo& propInfo)
674{
675 return isVec3dOVMType(propInfo) ;
676}
677
678template<typename MeshT>
679bool OVMPropertyModel<MeshT>::isVectorOVMType(const TypeInfoWrapper& typeInfo)
680{
681 return isVec3dOVMType(typeInfo);
682}
683
684template<typename MeshT>
685bool OVMPropertyModel<MeshT>::isMatrix3x3Type(const PropertyInfo& propInfo)
686{
687 return isMatrix3x3Type(propInfo.typeinfo());
688}
689
690template<typename MeshT>
691bool OVMPropertyModel<MeshT>::isMatrix3x3Type(const TypeInfoWrapper& typeInfo)
692{
693 return typeInfo == proptype_Cell_Matrix3x3d ||
694 typeInfo == proptype_Face_Matrix3x3d ||
695 typeInfo == proptype_HalfFace_Matrix3x3d ||
696 typeInfo == proptype_Edge_Matrix3x3d ||
697 typeInfo == proptype_HalfEdge_Matrix3x3d ||
698 typeInfo == proptype_Vertex_Matrix3x3d;
699}
700
701template<typename MeshT>
702bool OVMPropertyModel<MeshT>::isEntityType(const TypeInfoWrapper& typeInfo, PropertyInfo::ENTITY_FILTER entity_type) const
703{
704 bool result = false;
705 if (entity_type & PropertyInfo::EF_CELL)
706 {
707 result |= (typeInfo == proptype_Cell_bool)
708 || (typeInfo == proptype_Cell_int)
709 || (typeInfo == proptype_Cell_double)
710 || (typeInfo == proptype_Cell_uint)
711 || (typeInfo == proptype_Cell_Vec3d)
712 || (typeInfo == proptype_Cell_Vec3dOVM)
713 || (typeInfo == proptype_Cell_Vec3f);
714 }
715 if (entity_type & PropertyInfo::EF_FACE)
716 {
717 result |= (typeInfo == proptype_Face_bool)
718 || (typeInfo == proptype_Face_int)
719 || (typeInfo == proptype_Face_double)
720 || (typeInfo == proptype_Face_uint)
721 || (typeInfo == proptype_Face_Vec3d)
722 || (typeInfo == proptype_Face_Vec3dOVM)
723 || (typeInfo == proptype_Face_Vec3f);
724 }
725 if (entity_type & PropertyInfo::EF_HALFFACE)
726 {
727 result |= (typeInfo == proptype_HalfFace_bool)
728 || (typeInfo == proptype_HalfFace_int)
729 || (typeInfo == proptype_HalfFace_double)
730 || (typeInfo == proptype_HalfFace_uint)
731 || (typeInfo == proptype_HalfFace_Vec3d)
732 || (typeInfo == proptype_HalfFace_Vec3dOVM)
733 || (typeInfo == proptype_HalfFace_Vec3f);
734 }
735 if (entity_type & PropertyInfo::EF_EDGE)
736 {
737 result |= (typeInfo == proptype_Edge_bool)
738 || (typeInfo == proptype_Edge_int)
739 || (typeInfo == proptype_Edge_double)
740 || (typeInfo == proptype_Edge_uint)
741 || (typeInfo == proptype_Edge_Vec3d)
742 || (typeInfo == proptype_Edge_Vec3dOVM)
743 || (typeInfo == proptype_Edge_Vec3f);
744 }
745 if (entity_type & PropertyInfo::EF_HALFEDGE)
746 {
747 result |= (typeInfo == proptype_HalfEdge_bool)
748 || (typeInfo == proptype_HalfEdge_int)
749 || (typeInfo == proptype_HalfEdge_double)
750 || (typeInfo == proptype_HalfEdge_uint)
751 || (typeInfo == proptype_HalfEdge_Vec3d)
752 || (typeInfo == proptype_HalfEdge_Vec3dOVM)
753 || (typeInfo == proptype_HalfEdge_Vec3f);
754 }
755 if (entity_type & PropertyInfo::EF_VERTEX)
756 {
757 result |= (typeInfo == proptype_Vertex_bool)
758 || (typeInfo == proptype_Vertex_int)
759 || (typeInfo == proptype_Vertex_double)
760 || (typeInfo == proptype_Vertex_uint)
761 || (typeInfo == proptype_Vertex_Vec3d)
762 || (typeInfo == proptype_Vertex_Vec3dOVM)
763 || (typeInfo == proptype_Vertex_Vec3f);
764 }
765 return result;
766}
767
768
779template<typename MeshT>
780void OVMPropertyModel<MeshT>::addPropertyVisualizer(OpenVolumeMesh::BasePropertyPtr* const baseProp, MeshT* mesh, PropertyInfo::ENTITY_FILTER filter)
781{
782 PropertyInfo propInfo = PropertyInfo(baseProp->name(), getSupportedTypeInfoWrapper(baseProp) , filter);
783 if (isBoolType(propInfo))
784 propertyVisualizers.push_back(new OVMPropertyVisualizerBoolean<MeshT>(mesh, objectID_, propInfo));
785 else if (isIntType(propInfo))
786 propertyVisualizers.push_back(new OVMPropertyVisualizerInteger<MeshT, int>(mesh, objectID_, propInfo, false));
787 else if (isUnsignedIntType(propInfo))
788 propertyVisualizers.push_back(new OVMPropertyVisualizerInteger<MeshT, unsigned int>(mesh, objectID_, propInfo, true));
789 else if (isDoubleType(propInfo))
790 propertyVisualizers.push_back(new OVMPropertyVisualizerDouble<MeshT>(mesh, objectID_, propInfo));
791 else if (isVectorType(propInfo))
792 propertyVisualizers.push_back(new OVMPropertyVisualizerVector<MeshT, ACG::Vec3d>(mesh, objectID_, propInfo));
793 else if (isVectorOVMType(propInfo))
794 propertyVisualizers.push_back(new OVMPropertyVisualizerVector<MeshT, OpenVolumeMesh::Vec3d>(mesh, objectID_, propInfo));
795 else if (isMatrix3x3Type(propInfo))
796 propertyVisualizers.push_back(new OVMPropertyVisualizerMatrix3x3<MeshT>(mesh, objectID_, propInfo));
797 connectLogs(propertyVisualizers.back());
798}
799
810template<typename MeshT>
811void OVMPropertyModel<MeshT>::addProperty(QString propName, QString friendlyTypeName, PropertyInfo::ENTITY_FILTER filter)
812{
813
814 QString dtype = friendlyTypeName;
815 std::string pname = propName.toStdString();
816
817 MeshT* mesh = mesh_;
818
819 if ( filter == PropertyInfo::EF_VERTEX )
820 {
821 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
822 {
823 OpenVolumeMesh::VertexPropertyT< ACG::Vec3d > prop = mesh->template request_vertex_property< ACG::Vec3d >(pname);
824 mesh->set_persistent(prop, true);
825 }
826 else if ( dtype == tr("double") )
827 {
828 OpenVolumeMesh::VertexPropertyT< double > prop = mesh->template request_vertex_property< double >(pname);
829 mesh->set_persistent(prop, true);
830 }
831 else if ( dtype == tr("unsigned int") )
832 {
833 OpenVolumeMesh::VertexPropertyT< unsigned int > prop = mesh->template request_vertex_property< unsigned int >(pname);
834 mesh->set_persistent(prop, true);
835 }
836 else if ( dtype == tr("int") )
837 {
838 OpenVolumeMesh::VertexPropertyT< int > prop = mesh->template request_vertex_property< int >(pname);
839 mesh->set_persistent(prop, true);
840 }
841 else if ( dtype == tr("bool") )
842 {
843 OpenVolumeMesh::VertexPropertyT< bool > prop = mesh->template request_vertex_property< bool >(pname);
844 mesh->set_persistent(prop, true);
845 }
846 }
847 else if ( filter == PropertyInfo::EF_EDGE )
848 {
849 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
850 {
851 OpenVolumeMesh::EdgePropertyT< ACG::Vec3d > prop = mesh->template request_edge_property< ACG::Vec3d >(pname);
852 mesh->set_persistent(prop, true);
853 }
854 else if ( dtype == tr("double") )
855 {
856 OpenVolumeMesh::EdgePropertyT< double > prop = mesh->template request_edge_property< double >(pname);
857 mesh->set_persistent(prop, true);
858 }
859 else if ( dtype == tr("unsgined int") )
860 {
861 OpenVolumeMesh::EdgePropertyT< unsigned int > prop = mesh->template request_edge_property< unsigned int >(pname);
862 mesh->set_persistent(prop, true);
863 }
864 else if ( dtype == tr("int") )
865 {
866 OpenVolumeMesh::EdgePropertyT< int > prop = mesh->template request_edge_property< int >(pname);
867 mesh->set_persistent(prop, true);
868 }
869 else if ( dtype == tr("bool") )
870 {
871 OpenVolumeMesh::EdgePropertyT< bool > prop = mesh->template request_edge_property< bool >(pname);
872 mesh->set_persistent(prop, true);
873 }
874 }
875 else if ( filter == PropertyInfo::EF_FACE )
876 {
877 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
878 {
879 OpenVolumeMesh::FacePropertyT< ACG::Vec3d > prop = mesh->template request_face_property< ACG::Vec3d >(pname);
880 mesh->set_persistent(prop, true);
881 }
882 else if ( dtype == tr("double") )
883 {
884 OpenVolumeMesh::FacePropertyT< double > prop = mesh->template request_face_property< double >(pname);
885 mesh->set_persistent(prop, true);
886 }
887 else if ( dtype == tr("unsigned int") )
888 {
889 OpenVolumeMesh::FacePropertyT< unsigned int > prop = mesh->template request_face_property< unsigned int >(pname);
890 mesh->set_persistent(prop, true);
891 }
892 else if ( dtype == tr("int") )
893 {
894 OpenVolumeMesh::FacePropertyT< int > prop = mesh->template request_face_property< int >(pname);
895 mesh->set_persistent(prop, true);
896 }
897 else if ( dtype == tr("bool") )
898 {
899 OpenVolumeMesh::FacePropertyT< bool > prop = mesh->template request_face_property< bool >(pname);
900 mesh->set_persistent(prop, true);
901 }
902 }
903 else if ( filter == PropertyInfo::EF_HALFEDGE )
904 {
905 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
906 {
907 OpenVolumeMesh::HalfEdgePropertyT< ACG::Vec3d > prop = mesh->template request_halfedge_property< ACG::Vec3d >(pname);
908 mesh->set_persistent(prop, true);
909 }
910 else if ( dtype == tr("double") )
911 {
912 OpenVolumeMesh::HalfEdgePropertyT< double > prop = mesh->template request_halfedge_property< double >(pname);
913 mesh->set_persistent(prop, true);
914 }
915 else if ( dtype == tr("unsigned int") )
916 {
917 OpenVolumeMesh::HalfEdgePropertyT< unsigned int > prop = mesh->template request_halfedge_property< unsigned int >(pname);
918 mesh->set_persistent(prop, true);
919 }
920 else if ( dtype == tr("int") )
921 {
922 OpenVolumeMesh::HalfEdgePropertyT< int > prop = mesh->template request_halfedge_property< int >(pname);
923 mesh->set_persistent(prop, true);
924 }
925 else if ( dtype == tr("bool") )
926 {
927 OpenVolumeMesh::HalfEdgePropertyT< bool > prop = mesh->template request_halfedge_property< bool >(pname);
928 mesh->set_persistent(prop, true);
929 }
930 }
931 else if ( filter == PropertyInfo::EF_HALFFACE )
932 {
933 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
934 {
935 OpenVolumeMesh::HalfFacePropertyT< ACG::Vec3d > prop = mesh->template request_halfface_property< ACG::Vec3d >(pname);
936 mesh->set_persistent(prop, true);
937 }
938 else if ( dtype == tr("double") )
939 {
940 OpenVolumeMesh::HalfFacePropertyT< double > prop = mesh->template request_halfface_property< double >(pname);
941 mesh->set_persistent(prop, true);
942 }
943 else if ( dtype == tr("unsigned int") )
944 {
945 OpenVolumeMesh::HalfFacePropertyT< unsigned int > prop = mesh->template request_halfface_property< unsigned int >(pname);
946 mesh->set_persistent(prop, true);
947 }
948 else if ( dtype == tr("int") )
949 {
950 OpenVolumeMesh::HalfFacePropertyT< int > prop = mesh->template request_halfface_property< int >(pname);
951 mesh->set_persistent(prop, true);
952 }
953 else if ( dtype == tr("bool") )
954 {
955 OpenVolumeMesh::HalfFacePropertyT< bool > prop = mesh->template request_halfface_property< bool >(pname);
956 mesh->set_persistent(prop, true);
957 }
958 }
959 else if ( filter == PropertyInfo::EF_CELL )
960 {
961 if ( (dtype == tr("Vec3d")) || (dtype == tr("Vec3f")) )
962 {
963 OpenVolumeMesh::CellPropertyT< ACG::Vec3d > prop = mesh->template request_cell_property< ACG::Vec3d >(pname);
964 mesh->set_persistent(prop, true);
965 }
966 else if ( dtype == tr("double") )
967 {
968 OpenVolumeMesh::CellPropertyT< double > prop = mesh->template request_cell_property< double >(pname);
969 mesh->set_persistent(prop, true);
970 }
971 else if ( dtype == tr("unsigned int") )
972 {
973 OpenVolumeMesh::CellPropertyT< unsigned int > prop = mesh->template request_cell_property< unsigned int >(pname);
974 mesh->set_persistent(prop, true);
975 }
976 else if ( dtype == tr("int") )
977 {
978 OpenVolumeMesh::CellPropertyT< int > prop = mesh->template request_cell_property< int >(pname);
979 mesh->set_persistent(prop, true);
980 }
981 else if ( dtype == tr("bool") )
982 {
983 OpenVolumeMesh::CellPropertyT< bool > prop = mesh->template request_cell_property< bool >(pname);
984 mesh->set_persistent(prop, true);
985 }
986 }
987
988}
989
990template <typename MeshT>
991void OVMPropertyModel<MeshT>::initializeSupportedPropertyTypes()
992{
993
994#define INSERT_PROPTYPES(primitive) \
995supportedPropertyTypes.insert(proptype_##primitive##_bool); \
996supportedPropertyTypes.insert(proptype_##primitive##_int); \
997supportedPropertyTypes.insert(proptype_##primitive##_uint); \
998supportedPropertyTypes.insert(proptype_##primitive##_double); \
999supportedPropertyTypes.insert(proptype_##primitive##_Vec3d); \
1000supportedPropertyTypes.insert(proptype_##primitive##_Vec3dOVM); \
1001supportedPropertyTypes.insert(proptype_##primitive##_Vec3f); \
1002supportedPropertyTypes.insert(proptype_##primitive##_Matrix3x3d); \
1003
1004 INSERT_PROPTYPES(Cell)
1005 INSERT_PROPTYPES(Face)
1006 INSERT_PROPTYPES(HalfFace)
1007 INSERT_PROPTYPES(Edge)
1008 INSERT_PROPTYPES(HalfEdge)
1009 INSERT_PROPTYPES(Vertex)
1010
1011#undef INSERT_PROPTYPES
1012
1013
1014
1015}
1016
BaseObject::id
int id() const
Definition BaseObject.cc:188
NewNameMessageBox
Asks the user how to proceed after a name clash.
Definition Utils.hh:171
OVMPropertyModel::saveProperty
virtual void saveProperty()
Saves the currently slected properties.
Definition OVMPropertyModelT_impl.hh:376
OVMPropertyModel::gatherProperties
void gatherProperties()
Searches for all properties and creates the visualizers.
Definition OVMPropertyModelT_impl.hh:424
OVMPropertyModel::getSaveFilenameFilter
virtual QString getSaveFilenameFilter(unsigned int propId)
Returns the filename filter for saving.
Definition OVMPropertyModelT_impl.hh:323
OVMPropertyModel::resetPicking
void resetPicking()
Disables picking.
Definition OVMPropertyModelT_impl.hh:119
OVMPropertyModel::getSupportedTypeInfoWrapper
TypeInfoWrapper getSupportedTypeInfoWrapper(OpenVolumeMesh::BasePropertyPtr *const baseProp) const
Returns the TypeInfoWrapper for the property if it is supported.
Definition OVMPropertyModelT_impl.hh:506
OVMPropertyModel::addPropertyVisualizer
void addPropertyVisualizer(OpenVolumeMesh::BasePropertyPtr *const baseProp, MeshT *mesh, PropertyInfo::ENTITY_FILTER filter)
Adds a new PropertyVisualizer.
Definition OVMPropertyModelT_impl.hh:780
OVMPropertyModel::pickProperty
virtual void pickProperty()
Toggle picking on and off.
Definition OVMPropertyModelT_impl.hh:132
OVMPropertyModel::addProperty
void addProperty(QString propName, QString friendlyTypeName, PropertyInfo::ENTITY_FILTER filter)
Adds a new property to the mesh.
Definition OVMPropertyModelT_impl.hh:811
OVMPropertyModel::isPropertyFree
bool isPropertyFree(QString propName, PropertyInfo::ENTITY_FILTER filter, TypeInfoWrapper typeInfo)
Checks if a property name is still available for an entity type and a property type.
Definition OVMPropertyModelT_impl.hh:354
OVMPropertyModel::combinable
bool combinable(PropertyVisualizer *propertyVisualizer1, PropertyVisualizer *propertyVisualizer2) const
Checks if two properties are combinable.
Definition OVMPropertyModelT_impl.hh:398
OVMPropertyModel::pickModeChanged
virtual void pickModeChanged(const std::string &_mode)
Handles changing of pick mode.
Definition OVMPropertyModelT_impl.hh:148
OVMPropertyModel::isSupported
bool isSupported(OpenVolumeMesh::BasePropertyPtr *const baseProp) const
Checks if visualizing this property is supported.
Definition OVMPropertyModelT_impl.hh:447
OVMPropertyModel::parseHeader
virtual bool parseHeader(QString header, PropertyVisualizer *&propVis, unsigned int &n)
Parses the property file header.
Definition OVMPropertyModelT_impl.hh:213
OVMPropertyModel::mouseEvent
virtual void mouseEvent(QMouseEvent *_event)
Handles mouse events for picking.
Definition OVMPropertyModelT_impl.hh:167
OVMPropertyModel::updateWidget
virtual void updateWidget(const QModelIndexList &selectedIndices)
Updates the widget.
Definition OVMPropertyModelT_impl.hh:85
OVMPropertyModel::combine
virtual void combine()
Combines two properties.
Definition OVMPropertyModelT_impl.hh:368
OVMPropertyModel::getLoadFilenameFilter
virtual QString getLoadFilenameFilter()
Returns the filename filter for loading.
Definition OVMPropertyModelT_impl.hh:309
OVMPropertyModel::isNew
bool isNew(OpenVolumeMesh::BasePropertyPtr *const baseProp, PropertyInfo::ENTITY_FILTER filter) const
Checks if we already created a PropertyVisualizer for this property.
Definition OVMPropertyModelT_impl.hh:486
OVMPropertyVisualizer::getPropertyText
virtual QString getPropertyText(unsigned int index)=0
Returns the value of a property in text form.
OVMPropertyVisualizer::getClosestPrimitiveId
unsigned int getClosestPrimitiveId(unsigned int _face, ACG::Vec3d &_hitPoint)
Returns the ID of the closest primitive.
Definition OVMPropertyVisualizerT_impl.hh:144
PropertyInfo
Cellection of information about a property.
Definition Utils.hh:109
PropertyVisualizer
This class vizualizes a property.
Definition PropertyVisualizer.hh:78
PropertyVisualizer::getPropertyInfo
const PropertyInfo & getPropertyInfo() const
Returns the PropertyInfo.
Definition PropertyVisualizer.hh:129
SingleObjectPropertyModel::updateWidget
virtual void updateWidget(const QModelIndexList &selectedIndices) override
Updates the widget.
Definition SingleObjectPropertyModel.cc:142
SingleObjectPropertyModel::saveProperty
void saveProperty(unsigned int propId)
Saves property.
Definition SingleObjectPropertyModel.cc:260
TypeInfoWrapper
Wraps the information of a type.
Definition Utils.hh:73
ACG::SceneGraph::PickTarget
PickTarget
What target to use for picking.
Definition PickTarget.hh:74
ACG::SceneGraph::PICK_EDGE
@ PICK_EDGE
picks edges (may not be implemented for all nodes)
Definition PickTarget.hh:80
ACG::SceneGraph::PICK_CELL
@ PICK_CELL
picks faces (may not be implemented for all nodes)
Definition PickTarget.hh:76
ACG::SceneGraph::PICK_FACE
@ PICK_FACE
picks faces (should be implemented for all nodes)
Definition PickTarget.hh:78
ACG::SceneGraph::PICK_VERTEX
@ PICK_VERTEX
picks verices (may not be implemented for all nodes)
Definition PickTarget.hh:82
PluginFunctions::pickMode
const std::string pickMode()
Get the current Picking mode.
Definition PluginFunctions.cc:578
PluginFunctions::getPickedObject
bool getPickedObject(const size_t _node_idx, BaseObjectData *&_object)
Get the picked mesh.
Definition PluginFunctions.cc:263
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:480
PluginFunctions::actionMode
Viewer::ActionMode actionMode()
Get the current Action mode.
Definition PluginFunctions.cc:589