Developer Documentation
OVMPropertyVisualizerVectorT_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
45#define OVM_PROPERTY_VISUALIZER_VECTOR_CC
46
47#include <ACG/Utils/ColorConversion.hh>
48#include "OVMPropertyVisualizerVector.hh"
49
50
51template <typename MeshT, typename VectorT>
52OVMPropertyVisualizerVector<MeshT,VectorT>::OVMPropertyVisualizerVector(MeshT* _mesh, int objectID, PropertyInfo _propertyInfo)
53 : OVMPropertyVisualizer<MeshT>(_mesh, objectID, _propertyInfo)
54{
55 if (PropertyVisualizer::widget) delete PropertyVisualizer::widget;
56 VectorWidget* w = new VectorWidget();
57 w->paramVector->setTitle(QString("3D Vector Parameters of ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
58 PropertyVisualizer::widget = w;
59
60 BaseObjectData *bod;
61 PluginFunctions::getObject(objectID, bod);
62 lineNode = new ACG::SceneGraph::LineNode(ACG::SceneGraph::LineNode::LineSegmentsMode, bod->manipulatorNode());
63 w->vectors_edges_rb->hide();
64 this->connect(w->lineWidth, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
65 [this](double value) {lineNode->set_line_width(value);});
66}
67
68template <typename MeshT, typename VectorT>
69void OVMPropertyVisualizerVector<MeshT,VectorT>::clear()
70{
71 lineNode->clear();
72 OVMPropertyVisualizer<MeshT>::clear();
73}
74
75template <typename MeshT, typename VectorT>
76void OVMPropertyVisualizerVector<MeshT,VectorT>::duplicateProperty()
77{
78 OVMPropertyVisualizer<MeshT>::template duplicateProperty_stage1<VectorT>();
79}
80
81template<typename MeshT, typename VectorT>
82template<typename PropType, typename EntityIterator>
83void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeVectorAsColorForEntity(PropType prop, EntityIterator e_begin, EntityIterator e_end, bool normalized) {
84 if (!prop)
85 throw VizException("Getting PropHandle from mesh for selected property failed.");
86 VolumeMeshObject<MeshT>* object;
87 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
88 for (EntityIterator e_it = e_begin; e_it != e_end; ++e_it) {
89 ACG::Vec3d v = convert_to_acg(prop[*e_it]);
90 if (normalized)
91 v = v.normalized() * 0.5 + ACG::Vec3d(0.5);
92 else
93 v = v.min(ACG::Vec3d(1, 1, 1)).max(ACG::Vec3d(0, 0, 0));
94 object->colors()[*e_it] = ACG::Vec4f(v[0], v[1], v[2], 1.0);
95 }
96}
97
98template <typename MeshT, typename VectorT>
99void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeCellProp(bool _setDrawMode)
100{
101 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
102 if (w->vectors_colors_rb->isChecked())
103 {
104 OpenVolumeMesh::CellPropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_cell_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
105 visualizeVectorAsColorForEntity(prop,
106 OVMPropertyVisualizer<MeshT>::mesh->cells_begin(),
107 OVMPropertyVisualizer<MeshT>::mesh->cells_end(),
108 w->normalize_colors->isChecked());
109 if (_setDrawMode)
110 {
111 VolumeMeshObject<MeshT>* object;
112 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
113 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.cellsColoredPerCell);
114 }
115 }
116 else visualizeCellPropAsStrokes();
117}
118
119template <typename MeshT, typename VectorT>
120void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeFaceProp(bool _setDrawMode)
121{
122 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
123 if (w->vectors_colors_rb->isChecked())
124 {
125 OpenVolumeMesh::FacePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_face_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
126 visualizeVectorAsColorForEntity(prop,
127 OVMPropertyVisualizer<MeshT>::mesh->faces_begin(),
128 OVMPropertyVisualizer<MeshT>::mesh->faces_end(),
129 w->normalize_colors->isChecked());
130 if (_setDrawMode)
131 {
132 VolumeMeshObject<MeshT>* object;
133 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
134 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.facesColoredPerFace);
135 }
136 }
137 else visualizeFacePropAsStrokes();
138}
139
140
141template <typename MeshT, typename VectorT>
142void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeHalffaceProp(bool _setDrawMode)
143{
144 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
145 if (w->vectors_colors_rb->isChecked())
146 {
147 OpenVolumeMesh::HalfFacePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_halfface_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
148 visualizeVectorAsColorForEntity(prop,
149 OVMPropertyVisualizer<MeshT>::mesh->halffaces_begin(),
150 OVMPropertyVisualizer<MeshT>::mesh->halffaces_end(),
151 w->normalize_colors->isChecked());
152 if (_setDrawMode)
153 {
154 VolumeMeshObject<MeshT>* object;
155 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
156 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.halffacesColoredPerHalfface);
157 }
158 }
159 else visualizeHalffacePropAsStrokes();
160}
161
162template <typename MeshT, typename VectorT>
163void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeEdgeProp(bool _setDrawMode)
164{
165 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
166 if (w->vectors_colors_rb->isChecked())
167 {
168 OpenVolumeMesh::EdgePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_edge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
169 visualizeVectorAsColorForEntity(prop,
170 OVMPropertyVisualizer<MeshT>::mesh->edges_begin(),
171 OVMPropertyVisualizer<MeshT>::mesh->edges_end(),
172 w->normalize_colors->isChecked());
173 if (_setDrawMode)
174 {
175 VolumeMeshObject<MeshT>* object;
176 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
177 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.edgesColoredPerEdge);
178 }
179 }
180 else visualizeEdgePropAsStrokes();
181}
182
183template <typename MeshT, typename VectorT>
184void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeHalfedgeProp(bool _setDrawMode)
185{
186 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
187 if (w->vectors_colors_rb->isChecked())
188 {
189 OpenVolumeMesh::HalfEdgePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_halfedge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
190 visualizeVectorAsColorForEntity(prop,
191 OVMPropertyVisualizer<MeshT>::mesh->halfedges_begin(),
192 OVMPropertyVisualizer<MeshT>::mesh->halfedges_end(),
193 w->normalize_colors->isChecked());
194 if (_setDrawMode)
195 {
196 VolumeMeshObject<MeshT>* object;
197 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
198 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.halfedgesColoredPerHalfedge);
199 }
200 }
201 else visualizeHalfedgePropAsStrokes();
202}
203
204template <typename MeshT, typename VectorT>
205void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeVertexProp(bool _setDrawMode)
206{
207 VectorWidget* w = (VectorWidget*)PropertyVisualizer::widget;
208 if (w->vectors_colors_rb->isChecked())
209 {
210 OpenVolumeMesh::VertexPropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_vertex_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
211 visualizeVectorAsColorForEntity(prop,
212 OVMPropertyVisualizer<MeshT>::mesh->vertices_begin(),
213 OVMPropertyVisualizer<MeshT>::mesh->vertices_end(),
214 w->normalize_colors->isChecked());
215 if (_setDrawMode)
216 {
217 VolumeMeshObject<MeshT>* object;
218 PluginFunctions::getObject(OVMPropertyVisualizer<MeshT>::mObjectID, object);
219 object->setObjectDrawMode(OVMPropertyVisualizer<MeshT>::drawModes.verticesColored);
220 }
221 }
222 else visualizeVertexPropAsStrokes();
223}
224
225template <typename MeshT, typename VectorT>
226void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeFacePropAsStrokes()
227{
228 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
229
230 lineNode->clear();
231
232 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
233
234 OpenVolumeMesh::FacePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_face_property<VectorT>(PropertyVisualizer::propertyInfo.propName());
235
236 if ( !prop )
237 return;
238
239 OpenVolumeMesh::FaceIter f_begin(OVMPropertyVisualizer<MeshT>::mesh->faces_begin()), f_end(OVMPropertyVisualizer<MeshT>::mesh->faces_end());
240 for (OpenVolumeMesh::FaceIter f_it = f_begin; f_it != f_end; ++f_it){
241
242 ACG::Vec3d center(0.0, 0.0, 0.0);
243 int vCount = 0;
244
245 OpenVolumeMesh::HalfFaceHandle hfh = OVMPropertyVisualizer<MeshT>::mesh->halfface_handle(*f_it, 0);
246 for (OpenVolumeMesh::HalfFaceVertexIter hfv_it = OVMPropertyVisualizer<MeshT>::mesh->hfv_iter(hfh); hfv_it; ++hfv_it){
247 vCount++;
248 center += OVMPropertyVisualizer<MeshT>::mesh->vertex(*hfv_it);
249 }
250
251 center /= vCount;
252
253 ACG::Vec3d v = convert_to_acg(prop[*f_it]);
254
255 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
256 v.normalize();
257
258 if(vectorWidget->scale->isChecked())
259 v *= vectorWidget->scaleBox->value();
260
261 lineNode->add_line( center, (center+v) );
262 lineNode->add_color(color);
263 }
264}
265
266template <typename MeshT, typename VectorT>
267void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeEdgePropAsStrokes()
268{
269 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
270
271 lineNode->clear();
272
273 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
274
275 OpenVolumeMesh::EdgePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_edge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
276 if ( !prop )
277 return;
278
279 OpenVolumeMesh::EdgeIter e_begin(OVMPropertyVisualizer<MeshT>::mesh->edges_begin()), e_end(OVMPropertyVisualizer<MeshT>::mesh->edges_end());
280 for (OpenVolumeMesh::EdgeIter e_it = e_begin; e_it != e_end; ++e_it){
281
282 OpenVolumeMesh::OpenVolumeMeshEdge edge = OVMPropertyVisualizer<MeshT>::mesh->edge(*e_it);
283 ACG::Vec3d v1 = OVMPropertyVisualizer<MeshT>::mesh->vertex(edge.from_vertex());
284 ACG::Vec3d v2 = OVMPropertyVisualizer<MeshT>::mesh->vertex(edge.to_vertex());
285 ACG::Vec3d start = 0.5*(v1+v2);
286
287 ACG::Vec3d v = convert_to_acg(prop[*e_it]);
288
289 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
290 v.normalize();
291
292
293
294 if(vectorWidget->scale->isChecked())
295 v *= vectorWidget->scaleBox->value();
296
297 lineNode->add_line( start, (start+v) );
298 lineNode->add_color(color);
299 }
300}
301
302template <typename MeshT, typename VectorT>
303void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeHalfedgePropAsStrokes()
304{
305 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
306
307 lineNode->clear();
308
309 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
310
311 OpenVolumeMesh::HalfEdgePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_halfedge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
312 if ( !prop )
313 return;
314
315 OpenVolumeMesh::HalfEdgeIter he_begin(OVMPropertyVisualizer<MeshT>::mesh->halfedges_begin()), he_end(OVMPropertyVisualizer<MeshT>::mesh->halfedges_end());
316 for (OpenVolumeMesh::HalfEdgeIter he_it = he_begin; he_it != he_end; ++he_it){
317
318 OpenVolumeMesh::OpenVolumeMeshEdge edge = OVMPropertyVisualizer<MeshT>::mesh->halfedge(*he_it);
319
320 ACG::Vec3d v1 = OVMPropertyVisualizer<MeshT>::mesh->vertex(edge.from_vertex());
321 ACG::Vec3d v2 = OVMPropertyVisualizer<MeshT>::mesh->vertex(edge.to_vertex());
322 ACG::Vec3d start = (2.0*v1+v2)/3.0;
323
324 ACG::Vec3d v = convert_to_acg(prop[*he_it]);
325
326 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
327 v.normalize();
328
329 if(vectorWidget->scale->isChecked())
330 v *= vectorWidget->scaleBox->value();
331
332 lineNode->add_line( start, (start+v) );
333 lineNode->add_color(color);
334 }
335}
336
337template <typename MeshT, typename VectorT>
338void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeVertexPropAsStrokes()
339{
340 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
341
342 lineNode->clear();
343
344 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
345
346 OpenVolumeMesh::VertexPropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_vertex_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
347 if ( !prop )
348 return;
349
350 OpenVolumeMesh::VertexIter v_begin(OVMPropertyVisualizer<MeshT>::mesh->vertices_begin()), v_end(OVMPropertyVisualizer<MeshT>::mesh->vertices_end());
351 for (OpenVolumeMesh::VertexIter v_it = v_begin; v_it != v_end; ++v_it){
352
353 ACG::Vec3d start = OVMPropertyVisualizer<MeshT>::mesh->vertex(*v_it);
354
355 ACG::Vec3d v = convert_to_acg(prop[*v_it]);
356
357 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
358 v.normalize();
359
360 if(vectorWidget->scale->isChecked())
361 v *= vectorWidget->scaleBox->value();
362
363 lineNode->add_line( start, (start+v) );
364 lineNode->add_color(color);
365 }
366}
367
368template <typename MeshT, typename VectorT>
369void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeCellPropAsStrokes()
370{
371 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
372
373 lineNode->clear();
374
375 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
376
377 OpenVolumeMesh::CellPropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_cell_property<VectorT>(PropertyVisualizer::propertyInfo.propName());
378
379 if ( !prop )
380 return;
381
382 OpenVolumeMesh::CellIter c_begin(OVMPropertyVisualizer<MeshT>::mesh->cells_begin()), c_end(OVMPropertyVisualizer<MeshT>::mesh->cells_end());
383 for (OpenVolumeMesh::CellIter c_it = c_begin; c_it != c_end; ++c_it){
384
385 // Compute cell's center
386 ACG::Vec3d center(0.0, 0.0, 0.0);
387 unsigned int vCount = OVMPropertyVisualizer<MeshT>::mesh->n_vertices_in_cell(*c_it);
388 for(OpenVolumeMesh::CellVertexIter cv_it = OVMPropertyVisualizer<MeshT>::mesh->cv_iter(*c_it); cv_it.valid(); ++cv_it) {
389 center += OVMPropertyVisualizer<MeshT>::mesh->vertex(*cv_it) / (double)vCount;
390 }
391
392 ACG::Vec3d v = convert_to_acg(prop[*c_it]);
393
394 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
395 v.normalize();
396
397 if(vectorWidget->scale->isChecked())
398 v *= vectorWidget->scaleBox->value();
399
400 lineNode->add_line( center, (center+v) );
401 lineNode->add_color(color);
402 }
403}
404
405template <typename MeshT, typename VectorT>
406void OVMPropertyVisualizerVector<MeshT,VectorT>::visualizeHalffacePropAsStrokes()
407{
408 VectorWidget* vectorWidget = static_cast<VectorWidget*>(PropertyVisualizer::widget);
409
410 lineNode->clear();
411
412 ACG::Vec4f color = ACG::to_Vec4f(vectorWidget->lineColor->color());
413
414 OpenVolumeMesh::HalfFacePropertyT<VectorT> prop = OVMPropertyVisualizer<MeshT>::mesh->template request_halfface_property<VectorT>(PropertyVisualizer::propertyInfo.propName());
415
416 if ( !prop )
417 return;
418
419 OpenVolumeMesh::HalfFaceIter hf_begin(OVMPropertyVisualizer<MeshT>::mesh->halffaces_begin()), hf_end(OVMPropertyVisualizer<MeshT>::mesh->halffaces_end());
420 for (OpenVolumeMesh::HalfFaceIter hf_it = hf_begin; hf_it != hf_end; ++hf_it){
421
422 ACG::Vec3d center(0.0, 0.0, 0.0);
423 int vCount = 0;
424
425 for (OpenVolumeMesh::HalfFaceVertexIter hfv_it = OVMPropertyVisualizer<MeshT>::mesh->hfv_iter(*hf_it); hfv_it; ++hfv_it){
426 vCount++;
427 center += OVMPropertyVisualizer<MeshT>::mesh->vertex(*hfv_it);
428 }
429
430 center /= vCount;
431
432 ACG::Vec3d v = convert_to_acg(prop[*hf_it]);
433
434 if (vectorWidget->normalize->isChecked() && v.sqrnorm() > 1e-12)
435 v.normalize();
436
437 if(vectorWidget->scale->isChecked())
438 v *= vectorWidget->scaleBox->value();
439
440 lineNode->add_line( center, (center+v) );
441 lineNode->add_color(color);
442 }
443}
444
445template <typename MeshT, typename VectorT>
446QString OVMPropertyVisualizerVector<MeshT,VectorT>::getPropertyText(unsigned int index)
447{
448 return OVMPropertyVisualizer<MeshT>::template getPropertyText_<VectorT>(index);
449}
450
451
452template <typename MeshT, typename VectorT>
453void OVMPropertyVisualizerVector<MeshT,VectorT>::setCellPropertyFromText(unsigned int index, QString text)
454{
455 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
456
457 OpenVolumeMesh::CellPropertyT<VectorT> prop = mesh->template request_cell_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
458 if ( !prop )
459 {
460 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
461 return;
462 }
463
464 OpenVolumeMesh::CellHandle ch(index);
465
466 prop[ch] = this->template strToVec3<VectorT>(text);
467}
468
469template <typename MeshT, typename VectorT>
470void OVMPropertyVisualizerVector<MeshT,VectorT>::setFacePropertyFromText(unsigned int index, QString text)
471{
472 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
473
474 OpenVolumeMesh::FacePropertyT<VectorT> prop = mesh->template request_face_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
475 if ( !prop )
476 {
477 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
478 return;
479 }
480
481 OpenVolumeMesh::FaceHandle fh(index);
482
483 prop[fh] = this->template strToVec3<VectorT>(text);
484}
485
486template <typename MeshT, typename VectorT>
487void OVMPropertyVisualizerVector<MeshT,VectorT>::setHalffacePropertyFromText(unsigned int index, QString text)
488{
489 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
490
491 OpenVolumeMesh::HalfFacePropertyT<VectorT> prop = mesh->template request_halfface_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
492 if ( !prop )
493 {
494 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
495 return;
496 }
497
498 OpenVolumeMesh::HalfFaceHandle hfh(index);
499
500 prop[hfh] = this->template strToVec3<VectorT>(text);
501}
502
503template <typename MeshT, typename VectorT>
504void OVMPropertyVisualizerVector<MeshT,VectorT>::setEdgePropertyFromText(unsigned int index, QString text)
505{
506 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
507
508 OpenVolumeMesh::EdgePropertyT<VectorT> prop = mesh->template request_edge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
509 if ( !prop )
510 {
511 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
512 return;
513 }
514
515 OpenVolumeMesh::EdgeHandle eh(index);
516
517 prop[eh] = this->template strToVec3<VectorT>(text);
518}
519
520template <typename MeshT, typename VectorT>
521void OVMPropertyVisualizerVector<MeshT,VectorT>::setHalfedgePropertyFromText(unsigned int index, QString text)
522{
523 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
524
525 OpenVolumeMesh::HalfEdgePropertyT<VectorT> prop = mesh->template request_halfedge_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
526 if ( !prop )
527 {
528 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
529 return;
530 }
531
532 OpenVolumeMesh::HalfEdgeHandle heh(index);
533
534 prop[heh] = this->template strToVec3<VectorT>(text);
535}
536
537template <typename MeshT, typename VectorT>
538void OVMPropertyVisualizerVector<MeshT,VectorT>::setVertexPropertyFromText(unsigned int index, QString text)
539{
540 MeshT* mesh = OVMPropertyVisualizer<MeshT>::mesh;
541
542 OpenVolumeMesh::VertexPropertyT<VectorT> prop = mesh->template request_vertex_property<VectorT>(OVMPropertyVisualizer<MeshT>::propertyInfo.propName());
543 if ( !prop )
544 {
545 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
546 return;
547 }
548
549 OpenVolumeMesh::VertexHandle vh(index);
550
551 prop[vh] = this->template strToVec3<VectorT>(text);
552}
553
LOGERR
@ LOGERR
Definition: LoggingInterface.hh:96
BaseObjectData::manipulatorNode
QtTranslationManipulatorNode * manipulatorNode()
Definition: BaseObjectData.cc:255
OVMPropertyVisualizerVector::getPropertyText
QString getPropertyText(unsigned int index) override
Returns the value of a property in text form.
Definition: OVMPropertyVisualizerVectorT_impl.hh:446
OVMPropertyVisualizerVector::clear
void clear() override
Clears a property.
Definition: OVMPropertyVisualizerVectorT_impl.hh:69
OVMPropertyVisualizerVector::duplicateProperty
void duplicateProperty() override
Duplicates a property.
Definition: OVMPropertyVisualizerVectorT_impl.hh:76
OVMPropertyVisualizer::clear
virtual void clear()
Clears a property.
Definition: OVMPropertyVisualizerT_impl.hh:347
PropertyInfo
Cellection of information about a property.
Definition: Utils.hh:109
ACG::Vec4f
VectorT< float, 4 > Vec4f
Definition: VectorT.hh:138
ACG::Vec3d
VectorT< double, 3 > Vec3d
Definition: VectorT.hh:121
PluginFunctions::getObject
bool getObject(const int _identifier, BaseObject *&_object)
Get the object which has the given identifier.
Definition: PluginFunctions.cc:298