Developer Documentation

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
OMPropertyVisualizerIntegerT.cc
1 /*===========================================================================*\
2 * *
3 * OpenFlipper *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openflipper.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenFlipper. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 \*===========================================================================*/
41
42 /*===========================================================================*\
43 * *
44 * $Revision$ *
45 * $LastChangedBy$ *
46 * $Date$ *
47 * *
48 \*===========================================================================*/
49
50 #define OM_PROPERTY_VISUALIZER_INTEGER_CC
51
52 #include "OMPropertyVisualizerInteger.hh"
53
54 template <typename MeshT, typename T>
55 OMPropertyVisualizerInteger<MeshT, T>::OMPropertyVisualizerInteger(MeshT* _mesh, PropertyInfo _propertyInfo, bool isUnsigned)
56 : OMPropertyVisualizer<MeshT>(_mesh, _propertyInfo)
57 {
58 if (PropertyVisualizer::widget) delete PropertyVisualizer::widget;
59 IntegerWidget* w = new IntegerWidget();
60 w->paramInt->setTitle(QString("Integer Parameters of ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
61 PropertyVisualizer::widget = w;
62
63 if (isUnsigned)
64 {
65 w->intAbsolute->setChecked(false); //because we already have unsigned integers wo don't have to calculate their absolute value
66 w->intAbsolute->setCheckable(false);
67 }
68 }
69
70 template <typename MeshT,typename T>
71 QString OMPropertyVisualizerInteger<MeshT, T>::getPropertyText(unsigned int index)
72 {
73 return OMPropertyVisualizer<MeshT>::template getPropertyText_<T>(index);
74 }
75
76 template <typename MeshT, typename T>
77 void OMPropertyVisualizerInteger<MeshT, T>::visualizeFaceProp(bool _setDrawMode)
78 {
79 IntegerWidget* integerWidget = static_cast<IntegerWidget*>(PropertyVisualizer::widget);
80 typename MeshT::Color colorMin, colorMax;
81
82 colorMin = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMin->color());
83 colorMax = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMax->color());
84
85 // color coder in [0,1]
86 ACG::ColorCoder cc;
87
88 std::map< int, typename MeshT::Color> randomColor;
89
90 if ( integerWidget->intRandom->isChecked() && integerWidget->intMapBlack->isChecked() )
91 randomColor[ integerWidget->intMapBlackValue->value() ] = typename MeshT::Color(0.0, 0.0, 0.0, 1.0);
92
93 //TODO check if this also works if the property is Vec3d
94 OpenMesh::FPropHandleT< T > prop;
95
96 if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
97 return;
98
99 T max = std::numeric_limits<T>::min();
100 T min = std::numeric_limits<T>::max();
101
102 for (typename MeshT::FaceIter f_it = OMPropertyVisualizer<MeshT>::mesh->faces_begin() ; f_it != OMPropertyVisualizer<MeshT>::mesh->faces_end() ; ++f_it){
103 min = std::min( min, getValue(prop, f_it));
104 max = std::max( max, getValue(prop, f_it));
105 }
106
107 // fixed range?
108 if( integerWidget->intFixedRange->isChecked())
109 {
110 min = integerWidget->intFixedRangeMin->value();
111 max = integerWidget->intFixedRangeMax->value();
112 }
113 else
114 {
115 integerWidget->intFixedRangeMin->setValue(min);
116 integerWidget->intFixedRangeMax->setValue(max);
117 }
118
119 unsigned int range = max - min;
120
121 if ( ! OMPropertyVisualizer<MeshT>::mesh->has_face_colors() )
122 OMPropertyVisualizer<MeshT>::mesh->request_face_colors();
123
124 for (typename MeshT::FaceIter f_it = OMPropertyVisualizer<MeshT>::mesh->faces_begin() ; f_it != OMPropertyVisualizer<MeshT>::mesh->faces_end() ; ++f_it){
125
126 if (range == 0)
127 OMPropertyVisualizer<MeshT>::mesh->set_color(*f_it, colorMin);
128 else {
129
130 double pos = (getValue(prop, f_it) - min) / (double) range;
131
132 typename MeshT::Color color;
133
134 if (integerWidget->intColorCoder->isChecked())
135 {
136 color = cc.color_float4(pos);
137 }
138 else if ( !integerWidget->intRandom->isChecked() ){
139
140 color[0] = colorMin[0] * (1-pos) + pos * colorMax[0];
141 color[1] = colorMin[1] * (1-pos) + pos * colorMax[1];
142 color[2] = colorMin[2] * (1-pos) + pos * colorMax[2];
143 color[3] = 1.0;
144
145 } else {
146
147 if ( randomColor.find( getValue(prop, f_it) ) == randomColor.end() ){
148
149 color = mColorGenerator.generateNextColor();
150 color[3] = 1.0;
151
152 randomColor[ getValue(prop, f_it) ] = color;
153 }
154
155 color = randomColor[ getValue(prop, f_it) ];
156 }
157
158 OMPropertyVisualizer<MeshT>::mesh->set_color(*f_it, color);
159 }
160 }
161
162 if (_setDrawMode)
163 PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::SOLID_FACES_COLORED);
164 }
165
166 template <typename MeshT, typename T>
167 void OMPropertyVisualizerInteger<MeshT, T>::visualizeEdgeProp(bool _setDrawMode)
168 {
169 IntegerWidget* integerWidget = static_cast<IntegerWidget*>(PropertyVisualizer::widget);
170 typename MeshT::Color colorMin, colorMax;
171
172 colorMin = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMin->color());
173 colorMax = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMax->color());
174
175 // color coder in [0,1]
176 ACG::ColorCoder cc;
177
178 std::map< int, typename MeshT::Color> randomColor;
179
180 if ( integerWidget->intRandom->isChecked() && integerWidget->intMapBlack->isChecked() )
181 randomColor[ integerWidget->intMapBlackValue->value() ] = typename MeshT::Color(0.0, 0.0, 0.0, 1.0);
182
183 //TODO check if this also works if the property is Vec3d
184 OpenMesh::EPropHandleT< T > prop;
185
186 if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
187 return;
188
189 T max = std::numeric_limits<T>::min();
190 T min = std::numeric_limits<T>::max();
191
192 for (typename MeshT::EdgeIter e_it = OMPropertyVisualizer<MeshT>::mesh->edges_begin() ; e_it != OMPropertyVisualizer<MeshT>::mesh->edges_end() ; ++e_it){
193 min = std::min( min, getValue(prop, e_it));
194 max = std::max( max, getValue(prop, e_it));
195 }
196
197 // fixed range?
198 if( integerWidget->intFixedRange->isChecked())
199 {
200 min = integerWidget->intFixedRangeMin->value();
201 max = integerWidget->intFixedRangeMax->value();
202 }
203 else
204 {
205 integerWidget->intFixedRangeMin->setValue(min);
206 integerWidget->intFixedRangeMax->setValue(max);
207 }
208
209 unsigned int range = max - min;
210
211 if ( ! OMPropertyVisualizer<MeshT>::mesh->has_edge_colors() )
212 OMPropertyVisualizer<MeshT>::mesh->request_edge_colors();
213
214 for (typename MeshT::EdgeIter e_it = OMPropertyVisualizer<MeshT>::mesh->edges_begin() ; e_it != OMPropertyVisualizer<MeshT>::mesh->edges_end() ; ++e_it){
215
216 if (range == 0)
217 OMPropertyVisualizer<MeshT>::mesh->set_color(*e_it, colorMin);
218 else {
219
220 double pos = (getValue(prop, e_it) - min) / (double) range;
221
222 typename MeshT::Color color;
223
224 if (integerWidget->intColorCoder->isChecked())
225 {
226 color = cc.color_float4(pos);
227 }
228 else if ( !integerWidget->intRandom->isChecked() ){
229
230 color[0] = colorMin[0] * (1-pos) + pos * colorMax[0];
231 color[1] = colorMin[1] * (1-pos) + pos * colorMax[1];
232 color[2] = colorMin[2] * (1-pos) + pos * colorMax[2];
233 color[3] = 1.0;
234
235 } else {
236
237 if ( randomColor.find( getValue(prop, e_it) ) == randomColor.end() ){
238
239 color = mColorGenerator.generateNextColor();
240 color[3] = 1.0;
241
242 randomColor[ getValue(prop, e_it) ] = color;
243 }
244
245 color = randomColor[ getValue(prop, e_it) ];
246 }
247
248 OMPropertyVisualizer<MeshT>::mesh->set_color(*e_it, color);
249 }
250 }
251
252 if (_setDrawMode)
253 PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::EDGES_COLORED);
254
255 }
256
257 template <typename MeshT, typename T>
258 void OMPropertyVisualizerInteger<MeshT, T>::visualizeHalfedgeProp(bool _setDrawMode)
259 {
260 IntegerWidget* integerWidget = static_cast<IntegerWidget*>(PropertyVisualizer::widget);
261 typename MeshT::Color colorMin, colorMax;
262
263 colorMin = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMin->color());
264 colorMax = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMax->color());
265
266 // color coder in [0,1]
267 ACG::ColorCoder cc;
268
269 std::map< int, typename MeshT::Color> randomColor;
270
271 if ( integerWidget->intRandom->isChecked() && integerWidget->intMapBlack->isChecked() )
272 randomColor[ integerWidget->intMapBlackValue->value() ] = typename MeshT::Color(0.0, 0.0, 0.0, 1.0);
273
274 //TODO check if this also works if the property is Vec3d
275 OpenMesh::HPropHandleT< T > prop;
276
277 if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
278 return;
279
280 T max = std::numeric_limits<T>::min();
281 T min = std::numeric_limits<T>::max();
282
283 for (typename MeshT::HalfedgeIter he_it = OMPropertyVisualizer<MeshT>::mesh->halfedges_begin() ; he_it != OMPropertyVisualizer<MeshT>::mesh->halfedges_end() ; ++he_it){
284 min = std::min( min, getValue(prop, he_it));
285 max = std::max( max, getValue(prop, he_it));
286 }
287
288 // fixed range?
289 if( integerWidget->intFixedRange->isChecked())
290 {
291 min = integerWidget->intFixedRangeMin->value();
292 max = integerWidget->intFixedRangeMax->value();
293 }
294 else
295 {
296 integerWidget->intFixedRangeMin->setValue(min);
297 integerWidget->intFixedRangeMax->setValue(max);
298 }
299
300 unsigned int range = max - min;
301
302 if ( ! OMPropertyVisualizer<MeshT>::mesh->has_halfedge_colors() )
303 OMPropertyVisualizer<MeshT>::mesh->request_halfedge_colors();
304
305 for (typename MeshT::HalfedgeIter he_it = OMPropertyVisualizer<MeshT>::mesh->halfedges_begin() ; he_it != OMPropertyVisualizer<MeshT>::mesh->halfedges_end() ; ++he_it){
306
307 if (range == 0)
308 OMPropertyVisualizer<MeshT>::mesh->set_color(*he_it, colorMin);
309 else {
310
311 double pos = (getValue(prop, he_it) - min) / (double) range;
312
313 typename MeshT::Color color;
314
315 if (integerWidget->intColorCoder->isChecked())
316 {
317 color = cc.color_float4(pos);
318 }
319 else if ( !integerWidget->intRandom->isChecked() ){
320
321 color[0] = colorMin[0] * (1-pos) + pos * colorMax[0];
322 color[1] = colorMin[1] * (1-pos) + pos * colorMax[1];
323 color[2] = colorMin[2] * (1-pos) + pos * colorMax[2];
324 color[3] = 1.0;
325
326 } else {
327
328 if ( randomColor.find( getValue(prop, he_it) ) == randomColor.end() ){
329
330 color = mColorGenerator.generateNextColor();
331 color[3] = 1.0;
332
333 randomColor[ getValue(prop, he_it) ] = color;
334 }
335
336 color = randomColor[ getValue(prop, he_it) ];
337 }
338
339 OMPropertyVisualizer<MeshT>::mesh->set_color(*he_it, color);
340 }
341 }
342
343 if (_setDrawMode)
344 PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::HALFEDGES_COLORED);
345 }
346
347 template <typename MeshT, typename T>
348 void OMPropertyVisualizerInteger<MeshT, T>::visualizeVertexProp(bool _setDrawMode)
349 {
350 IntegerWidget* integerWidget = static_cast<IntegerWidget*>(PropertyVisualizer::widget);
351 typename MeshT::Color colorMin, colorMax;
352
353 colorMin = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMin->color());
354 colorMax = OMPropertyVisualizer<MeshT>::convertColor(integerWidget->intMax->color());
355
356 // color coder in [0,1]
357 ACG::ColorCoder cc;
358
359 std::map< int, typename MeshT::Color> randomColor;
360
361 if ( integerWidget->intRandom->isChecked() && integerWidget->intMapBlack->isChecked() )
362 randomColor[ integerWidget->intMapBlackValue->value() ] = typename MeshT::Color(0.0, 0.0, 0.0, 1.0);
363
364 //TODO check if this also works if the property is Vec3d
365 OpenMesh::VPropHandleT< T > prop;
366
367 if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
368 return;
369
370 T max = std::numeric_limits<T>::min();
371 T min = std::numeric_limits<T>::max();
372
373 for (typename MeshT::VertexIter v_it = OMPropertyVisualizer<MeshT>::mesh->vertices_begin() ; v_it != OMPropertyVisualizer<MeshT>::mesh->vertices_end() ; ++v_it){
374 min = std::min( min, getValue(prop, v_it));
375 max = std::max( max, getValue(prop, v_it));
376 }
377
378 // fixed range?
379 if( integerWidget->intFixedRange->isChecked())
380 {
381 min = integerWidget->intFixedRangeMin->value();
382 max = integerWidget->intFixedRangeMax->value();
383 }
384 else
385 {
386 integerWidget->intFixedRangeMin->setValue(min);
387 integerWidget->intFixedRangeMax->setValue(max);
388 }
389
390 unsigned int range = max - min;
391
392 if ( ! OMPropertyVisualizer<MeshT>::mesh->has_vertex_colors() )
393 OMPropertyVisualizer<MeshT>::mesh->request_vertex_colors();
394
395 for (typename MeshT::VertexIter v_it = OMPropertyVisualizer<MeshT>::mesh->vertices_begin() ; v_it != OMPropertyVisualizer<MeshT>::mesh->vertices_end() ; ++v_it){
396
397 if (range == 0)
398 OMPropertyVisualizer<MeshT>::mesh->set_color(*v_it, colorMin);
399 else {
400
401 double pos = (getValue(prop, v_it) - min) / (double) range;
402
403 typename MeshT::Color color;
404
405 if (integerWidget->intColorCoder->isChecked())
406 {
407 color = cc.color_float4(pos);
408 }
409 else if ( !integerWidget->intRandom->isChecked() ){
410
411 color[0] = colorMin[0] * (1-pos) + pos * colorMax[0];
412 color[1] = colorMin[1] * (1-pos) + pos * colorMax[1];
413 color[2] = colorMin[2] * (1-pos) + pos * colorMax[2];
414 color[3] = 1.0;
415
416 }
417 else
418 {
419
420 if ( randomColor.find( getValue(prop, v_it) ) == randomColor.end() ){
421
422 color = mColorGenerator.generateNextColor();
423 color[3] = 1.0;
424
425 randomColor[ getValue(prop, v_it) ] = color;
426 }
427
428 color = randomColor[ getValue(prop, v_it) ];
429 }
430
431 OMPropertyVisualizer<MeshT>::mesh->set_color(*v_it, color);
432 }
433 }
434
435 if (_setDrawMode)
436 PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::SOLID_POINTS_COLORED);
437
438 }
439
440 template <typename MeshT, typename T>
441 void OMPropertyVisualizerInteger<MeshT, T>::setFacePropertyFromText(unsigned int index, QString text)
442 {
443 OpenMesh::FPropHandleT< int > prop;
444 MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;
445
446 if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
447 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
448
449
450 typename MeshT::FaceHandle fh = mesh->face_handle(index);
451
452 T dummy = 0;
453 mesh->property(prop, fh) = this->strToT(text, dummy);
454 }
455
456 template <typename MeshT, typename T>
457 void OMPropertyVisualizerInteger<MeshT, T>::setEdgePropertyFromText(unsigned int index, QString text)
458 {
459 OpenMesh::EPropHandleT< int > prop;
460 MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;
461
462 if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
463 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
464
465 typename MeshT::EdgeHandle eh = mesh->edge_handle(index);
466
467 T dummy = 0;
468 mesh->property(prop, eh) = this->strToT(text, dummy);
469 }
470
471 template <typename MeshT, typename T>
472 void OMPropertyVisualizerInteger<MeshT, T>::setHalfedgePropertyFromText(unsigned int index, QString text)
473 {
474 OpenMesh::HPropHandleT< int > prop;
475 MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;
476
477 if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
478 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
479
480
481 typename MeshT::HalfedgeHandle heh = mesh->halfedge_handle(index);
482
483 T dummy = 0;
484 mesh->property(prop, heh) = this->strToT(text, dummy);
485 }
486
487 template <typename MeshT, typename T>
488 void OMPropertyVisualizerInteger<MeshT, T>::setVertexPropertyFromText(unsigned int index, QString text)
489 {
490 OpenMesh::VPropHandleT< int > prop;
491 MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;
492
493 if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
494 emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
495
496
497 typename MeshT::VertexHandle vh = mesh->vertex_handle(index);
498
499 T dummy = 0;
500 mesh->property(prop, vh) = this->strToT(text, dummy);
501 }
502
503 template<typename MeshT, typename T>
504 void OMPropertyVisualizerInteger<MeshT, T>::removeProperty()
505 {
506 OMPropertyVisualizer<MeshT>::template removeProperty_stage1<T>();
507 }
508
509 template<typename MeshT, typename T>
510 void OMPropertyVisualizerInteger<MeshT, T>::duplicateProperty()
511 {
512 OMPropertyVisualizer<MeshT>::template duplicateProperty_stage1<T>();
513 }
OpenMesh::Attributes::Color
Add colors to mesh item (vertices/faces/edges)
Definition: Attributes.hh:88
OpenMesh::HPropHandleT
Definition: Property.hh:501
ACG::SceneGraph::DrawModes::EDGES_COLORED
DrawMode EDGES_COLORED
draw edges with colors (without shading)
Definition: DrawModes.cc:83
LOGERR
Definition: LoggingInterface.hh:107
PluginFunctions::setDrawMode
void setDrawMode(const ACG::SceneGraph::DrawModes::DrawMode &_mode, int _viewer)
Set the draw Mode of a Viewer. .
Definition: PluginFunctions.cc:435
OpenMesh::EPropHandleT
Definition: Property.hh:515
OMPropertyVisualizerInteger::duplicateProperty
virtual void duplicateProperty()
Duplicates the property.
Definition: OMPropertyVisualizerIntegerT.cc:510
OMPropertyVisualizerInteger::removeProperty
virtual void removeProperty()
Removes the property.
Definition: OMPropertyVisualizerIntegerT.cc:504
OpenMesh::VPropHandleT
Definition: Property.hh:487
OMPropertyVisualizerInteger::getPropertyText
virtual QString getPropertyText(unsigned int index)
Returns the value of a property in text form.
Definition: OMPropertyVisualizerIntegerT.cc:71
OMPropertyVisualizerInteger
Definition: OMPropertyVisualizerInteger.hh:62
ACG::SceneGraph::DrawModes::SOLID_POINTS_COLORED
DrawMode SOLID_POINTS_COLORED
draw colored, but not lighted faces using interpolated vertex colors
Definition: DrawModes.cc:91
ACG::ColorCoder
Class for generating nice colors for doubles.
Definition: ColorCoder.hh:75
OMPropertyVisualizer
Definition: OMPropertyVisualizer.hh:61
ACG::SceneGraph::DrawModes::SOLID_FACES_COLORED
DrawMode SOLID_FACES_COLORED
draw colored, but not lighted faces using face colors
Definition: DrawModes.cc:90
OpenMesh::FPropHandleT
Definition: Property.hh:529
IntegerWidget
Definition: IntegerWidget.hh:62
PropertyInfo
Cellection of information about a property.
Definition: Utils.hh:115
ACG::SceneGraph::DrawModes::HALFEDGES_COLORED
DrawMode HALFEDGES_COLORED
draw halfedges with colors (without shading)
Definition: DrawModes.cc:109