OMPropertyVisualizerDoubleT.cc 18.3 KB
Newer Older
1
2
3
/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
Martin Schultz's avatar
Martin Schultz committed
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
39
40
41
*                                                                            *
\*===========================================================================*/

42
43
44
45
46
47
48
49
/*===========================================================================*\
*                                                                            *
*   $Revision$                                                       *
*   $LastChangedBy$                                                *
*   $Date$                     *
*                                                                            *
\*===========================================================================*/

50
51
#define OM_PROPERTY_VISUALIZER_DOUBLE_CC

52
#include <ACG/Utils/ColorConversion.hh>
53
54
55
56
57
58
59
60
61
62
#include "OMPropertyVisualizerDouble.hh"

template <typename MeshT>
OMPropertyVisualizerDouble<MeshT>::OMPropertyVisualizerDouble(MeshT* _mesh, PropertyInfo _propertyInfo)
    : OMPropertyVisualizer<MeshT>(_mesh, _propertyInfo)
{
    if (PropertyVisualizer::widget) delete PropertyVisualizer::widget;
    DoubleWidget* w = new DoubleWidget();
    w->paramDouble->setTitle(QString("Double Parameters of ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
    PropertyVisualizer::widget = w;
63
64
65
66
#ifdef ENABLE_PROPVIS_HISTOGRAMS
    this->connect(w->computeHistogramButton, &QPushButton::clicked,
                  [this, w](){this->template showHistogram<double>(w->histogram);});
#endif
67
68
69
}

template <typename MeshT>
70
void OMPropertyVisualizerDouble<MeshT>::visualizeFaceProp(bool _setDrawMode)
71
72
73
{
    DoubleWidget* doubleWidget = static_cast<DoubleWidget*>(PropertyVisualizer::widget);

74
    typename MeshT::Color colorMin = ACG::to_Vec4f(doubleWidget->doubleMin->color());
75

76
    // color coder in [0,1]
77
    ACG::IColorCoder *cc = doubleWidget->buildColorCoder();
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

    OpenMesh::FPropHandleT< double > prop;

    if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
        return;

    double min, max;

    if ( doubleWidget->doubleAbsolute->isChecked() ){
        min = FLT_MAX;
        max = 0.0;
    } else {
        min = FLT_MAX;
        max = FLT_MIN;
    }

    for (typename MeshT::FaceIter f_it = OMPropertyVisualizer<MeshT>::mesh->faces_begin() ; f_it != OMPropertyVisualizer<MeshT>::mesh->faces_end() ; ++f_it){
        if ( doubleWidget->doubleAbsolute->isChecked() ){
Matthias Möller's avatar
Matthias Möller committed
96
97
            min = std::min( min, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *f_it)));
            max = std::max( max, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *f_it)));
98
        } else {
Matthias Möller's avatar
Matthias Möller committed
99
100
            min = std::min( min, OMPropertyVisualizer<MeshT>::mesh->property(prop, *f_it));
            max = std::max( max, OMPropertyVisualizer<MeshT>::mesh->property(prop, *f_it));
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
        }
    }

    // fixed range?
    if( doubleWidget->doubleFixedRange->isChecked())
    {
        min = doubleWidget->doubleFixedRangeMin->value();
        max = doubleWidget->doubleFixedRangeMax->value();
    }
    else
    {
        doubleWidget->doubleFixedRangeMin->setValue(min);
        doubleWidget->doubleFixedRangeMax->setValue(max);
    }

    double range = max - min;

    if ( ! OMPropertyVisualizer<MeshT>::mesh->has_face_colors() )
        OMPropertyVisualizer<MeshT>::mesh->request_face_colors();

    for (typename MeshT::FaceIter f_it = OMPropertyVisualizer<MeshT>::mesh->faces_begin() ; f_it != OMPropertyVisualizer<MeshT>::mesh->faces_end() ; ++f_it){

        if (range == 0.0)
Matthias Möller's avatar
Matthias Möller committed
124
          OMPropertyVisualizer<MeshT>::mesh->set_color(*f_it, colorMin);
125
126
        else
        {
Matthias Möller's avatar
Matthias Möller committed
127
            double v = OMPropertyVisualizer<MeshT>::mesh->property(prop, *f_it);
128
129
130
131
132
133
134
135
136
137

            // absolut value?
            if ( doubleWidget->doubleAbsolute->isChecked())
                v = fabs(v);

            // clamping
            v = std::max(min,v);
            v = std::min(max,v);

            double t = (v-min)/range;
138
            typename MeshT::Color color = cc->color_float4(t);
139
140

              // set color
Matthias Möller's avatar
Matthias Möller committed
141
            OMPropertyVisualizer<MeshT>::mesh->set_color(*f_it, color);
142
143
        }
    }
144
    delete cc;
145

146
147
    if (_setDrawMode)
        PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::SOLID_FACES_COLORED);
148
149
150
}

template <typename MeshT>
151
void OMPropertyVisualizerDouble<MeshT>::visualizeEdgeProp(bool _setDrawMode)
152
153
{
    DoubleWidget* doubleWidget = static_cast<DoubleWidget*>(PropertyVisualizer::widget);
154
    typename MeshT::Color colorMin;
155

156
    colorMin = ACG::to_Vec4f(doubleWidget->doubleMin->color());
157

158
    // color coder in [0,1]
159
    ACG::IColorCoder *cc = doubleWidget->buildColorCoder();
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

    //TODO check if this also works if the property is Vec3d
    OpenMesh::EPropHandleT< double > prop;

    if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
        return;

    double min, max;

    if ( doubleWidget->doubleAbsolute->isChecked() ){
        min = FLT_MAX;
        max = 0.0;
    } else {
        min = FLT_MAX;
        max = FLT_MIN;
    }

    for (typename MeshT::EdgeIter e_it = OMPropertyVisualizer<MeshT>::mesh->edges_begin() ; e_it != OMPropertyVisualizer<MeshT>::mesh->edges_end() ; ++e_it){
        if ( doubleWidget->doubleAbsolute->isChecked() ){
Matthias Möller's avatar
Matthias Möller committed
179
180
            min = std::min( min, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *e_it)));
            max = std::max( max, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *e_it)));
181
        } else {
Matthias Möller's avatar
Matthias Möller committed
182
183
            min = std::min( min, OMPropertyVisualizer<MeshT>::mesh->property(prop, *e_it));
            max = std::max( max, OMPropertyVisualizer<MeshT>::mesh->property(prop, *e_it));
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
        }
    }

    // fixed range?
    if( doubleWidget->doubleFixedRange->isChecked())
    {
        min = doubleWidget->doubleFixedRangeMin->value();
        max = doubleWidget->doubleFixedRangeMax->value();
    }
    else
    {
        doubleWidget->doubleFixedRangeMin->setValue(min);
        doubleWidget->doubleFixedRangeMax->setValue(max);
    }


    double range = max - min;

    if ( ! OMPropertyVisualizer<MeshT>::mesh->has_edge_colors() )
        OMPropertyVisualizer<MeshT>::mesh->request_edge_colors();

    for (typename MeshT::EdgeIter e_it = OMPropertyVisualizer<MeshT>::mesh->edges_begin() ; e_it != OMPropertyVisualizer<MeshT>::mesh->edges_end() ; ++e_it){

        if (range == 0.0)
Matthias Möller's avatar
Matthias Möller committed
208
            OMPropertyVisualizer<MeshT>::mesh->set_color(*e_it, colorMin);
209
210
        else {

Matthias Möller's avatar
Matthias Möller committed
211
            double v = OMPropertyVisualizer<MeshT>::mesh->property(prop, *e_it);
212
213
214
215
216
217
218
219
220
221

            // absolut value?
            if ( doubleWidget->doubleAbsolute->isChecked())
            v = fabs(v);

            // clamping
            v = std::max(min,v);
            v = std::min(max,v);

            double t = (v-min)/range;
222
            typename MeshT::Color color = cc->color_float4(t);
223
224

            // set color
Matthias Möller's avatar
Matthias Möller committed
225
            OMPropertyVisualizer<MeshT>::mesh->set_color(*e_it, color);
226
227
        }
    }
228
    delete cc;
229
230
231

    if (_setDrawMode)
        PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::EDGES_COLORED);
232
233
234
235

}

template <typename MeshT>
236
void OMPropertyVisualizerDouble<MeshT>::visualizeHalfedgeProp(bool _setDrawMode)
237
238
239
{
    DoubleWidget* doubleWidget = static_cast<DoubleWidget*>(PropertyVisualizer::widget);

240
    typename MeshT::Color colorMin = ACG::to_Vec4f(doubleWidget->doubleMin->color());
241

242
    // color coder in [0,1]
243
    ACG::IColorCoder *cc = doubleWidget->buildColorCoder();
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

    //TODO check if this also works if the property is Vec3d
    OpenMesh::HPropHandleT< double > prop;

    if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
        return;

    double min, max;

    if ( doubleWidget->doubleAbsolute->isChecked() ){
        min = FLT_MAX;
        max = 0.0;
    } else {
        min = FLT_MAX;
        max = FLT_MIN;
    }

    for (typename MeshT::HalfedgeIter he_it = OMPropertyVisualizer<MeshT>::mesh->halfedges_begin() ; he_it != OMPropertyVisualizer<MeshT>::mesh->halfedges_end() ; ++he_it){
        if ( doubleWidget->doubleAbsolute->isChecked() ){
Matthias Möller's avatar
Matthias Möller committed
263
264
            min = std::min( min, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *he_it)));
            max = std::max( max, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *he_it)));
265
        } else {
Matthias Möller's avatar
Matthias Möller committed
266
267
            min = std::min( min, OMPropertyVisualizer<MeshT>::mesh->property(prop, *he_it));
            max = std::max( max, OMPropertyVisualizer<MeshT>::mesh->property(prop, *he_it));
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
        }
    }

    // fixed range?
    if( doubleWidget->doubleFixedRange->isChecked())
    {
        min = doubleWidget->doubleFixedRangeMin->value();
        max = doubleWidget->doubleFixedRangeMax->value();
    }
    else
    {
        doubleWidget->doubleFixedRangeMin->setValue(min);
        doubleWidget->doubleFixedRangeMax->setValue(max);
    }

    double range = max - min;

    if ( ! OMPropertyVisualizer<MeshT>::mesh->has_halfedge_colors() )
        OMPropertyVisualizer<MeshT>::mesh->request_halfedge_colors();

    for (typename MeshT::HalfedgeIter he_it = OMPropertyVisualizer<MeshT>::mesh->halfedges_begin() ; he_it != OMPropertyVisualizer<MeshT>::mesh->halfedges_end() ; ++he_it){

        if (range == 0.0)
Matthias Möller's avatar
Matthias Möller committed
291
            OMPropertyVisualizer<MeshT>::mesh->set_color(*he_it, colorMin);
292
293
        else {

Matthias Möller's avatar
Matthias Möller committed
294
            double v = OMPropertyVisualizer<MeshT>::mesh->property(prop, *he_it);
295
296
297
298
299
300
301
302
303
304

            // absolut value?
            if ( doubleWidget->doubleAbsolute->isChecked())
            v = fabs(v);

            // clamping
            v = std::max(min,v);
            v = std::min(max,v);

            double t = (v-min)/range;
305
            typename MeshT::Color color = cc->color_float4(t);
306
307

            // set color
Matthias Möller's avatar
Matthias Möller committed
308
            OMPropertyVisualizer<MeshT>::mesh->set_color(*he_it, color);
309
310
        }
    }
311
312
    if (_setDrawMode)
        PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::HALFEDGES_COLORED);
313
314
315
}

template <typename MeshT>
316
void OMPropertyVisualizerDouble<MeshT>::visualizeVertexProp(bool _setDrawMode)
317
318
319
{
    DoubleWidget* doubleWidget = static_cast<DoubleWidget*>(PropertyVisualizer::widget);

320
    typename MeshT::Color colorMin = ACG::to_Vec4f(doubleWidget->doubleMin->color());
321

322
    // color coder in [0,1]
323
    ACG::IColorCoder *cc = doubleWidget->buildColorCoder();
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

    //TODO check if this also works if the property is Vec3d
    OpenMesh::VPropHandleT< double > prop;

    if ( !OMPropertyVisualizer<MeshT>::mesh->get_property_handle(prop, OMPropertyVisualizer<MeshT>::propertyInfo.propName() ) )
        return;

    double min, max;

    if ( doubleWidget->doubleAbsolute->isChecked() ){
        min = FLT_MAX;
        max = 0.0;
    } else {
        min = FLT_MAX;
        max = FLT_MIN;
    }

    for (typename MeshT::VertexIter v_it = OMPropertyVisualizer<MeshT>::mesh->vertices_begin() ; v_it != OMPropertyVisualizer<MeshT>::mesh->vertices_end() ; ++v_it){
        if ( doubleWidget->doubleAbsolute->isChecked() ){
Matthias Möller's avatar
Matthias Möller committed
343
344
            min = std::min( min, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *v_it)));
            max = std::max( max, fabs(OMPropertyVisualizer<MeshT>::mesh->property(prop, *v_it)));
345
        } else {
Matthias Möller's avatar
Matthias Möller committed
346
347
            min = std::min( min, OMPropertyVisualizer<MeshT>::mesh->property(prop, *v_it));
            max = std::max( max, OMPropertyVisualizer<MeshT>::mesh->property(prop, *v_it));
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
        }
    }

    // fixed range?
    if( doubleWidget->doubleFixedRange->isChecked())
    {
        min = doubleWidget->doubleFixedRangeMin->value();
        max = doubleWidget->doubleFixedRangeMax->value();
    }
    else
    {
        doubleWidget->doubleFixedRangeMin->setValue(min);
        doubleWidget->doubleFixedRangeMax->setValue(max);
    }

    const double range = max - min;

    if ( ! OMPropertyVisualizer<MeshT>::mesh->has_vertex_colors() )
        OMPropertyVisualizer<MeshT>::mesh->request_vertex_colors();

    for (typename MeshT::VertexIter v_it = OMPropertyVisualizer<MeshT>::mesh->vertices_begin() ; v_it != OMPropertyVisualizer<MeshT>::mesh->vertices_end() ; ++v_it){

        if (range == 0.0)
Matthias Möller's avatar
Matthias Möller committed
371
            OMPropertyVisualizer<MeshT>::mesh->set_color(*v_it, colorMin);
372
373
        else {

Matthias Möller's avatar
Matthias Möller committed
374
            double v = OMPropertyVisualizer<MeshT>::mesh->property(prop, *v_it);
375
376
377
378
379
380
381
382
383
384

            // absolut value?
            if ( doubleWidget->doubleAbsolute->isChecked())
            v = fabs(v);

            // clamping
            v = std::max(min,v);
            v = std::min(max,v);

            double t = (v-min)/range;
385
            typename MeshT::Color color = cc->color_float4(t);
386
387

            // set color
Matthias Möller's avatar
Matthias Möller committed
388
            OMPropertyVisualizer<MeshT>::mesh->set_color(*v_it, color);
389
390
391
        }
    }

392
393
    if (_setDrawMode)
        PluginFunctions::setDrawMode(ACG::SceneGraph::DrawModes::SOLID_POINTS_COLORED);
394
395
396
397
398
399
400
401
402
}

template <typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::setFacePropertyFromText(unsigned int index, QString text)
{
    OpenMesh::FPropHandleT< double > prop;
    MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;

    if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
403
        emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
404
405
406
407
408
409
410
411
412
413
414
415
416
417


    typename MeshT::FaceHandle fh = mesh->face_handle(index);

    mesh->property(prop, fh) = this->strToDouble(text);
}

template <typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::setEdgePropertyFromText(unsigned int index, QString text)
{
    OpenMesh::EPropHandleT< double > prop;
    MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;

    if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
418
        emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
419
420
421
422
423
424
425
426
427
428
429
430
431
432


    typename MeshT::EdgeHandle eh = mesh->edge_handle(index);

    mesh->property(prop, eh) = this->strToDouble(text);
}

template <typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::setHalfedgePropertyFromText(unsigned int index, QString text)
{
    OpenMesh::HPropHandleT< double > prop;
    MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;

    if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
433
        emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
434
435
436
437
438
439
440
441
442
443
444
445
446
447


    typename MeshT::HalfedgeHandle heh = mesh->halfedge_handle(index);

    mesh->property(prop, heh) = this->strToDouble(text);
}

template <typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::setVertexPropertyFromText(unsigned int index, QString text)
{
    OpenMesh::VPropHandleT< double > prop;
    MeshT* mesh = OMPropertyVisualizer<MeshT>::mesh;

    if ( !mesh->get_property_handle(prop, PropertyVisualizer::propertyInfo.propName() ) )
448
        emit this->log(LOGERR, QObject::tr("Error: No property with name ").append(PropertyVisualizer::propertyInfo.propName().c_str()));
449
450
451
452
453
454
455


    typename MeshT::VertexHandle vh = mesh->vertex_handle(index);

    mesh->property(prop, vh) = this->strToDouble(text);
}

456
457
458
459
460
461
462
template<typename MeshT>
ACG::IColorCoder *OMPropertyVisualizerDouble<MeshT>::buildColorCoder()
{
    DoubleWidget* doubleWidget = static_cast<DoubleWidget*>(PropertyVisualizer::widget);
    return doubleWidget->buildColorCoder();
}

463
464
465
466
467
468
469
470
471
472
473
474
475

template<typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::removeProperty()
{
    OMPropertyVisualizer<MeshT>::template removeProperty_stage1<double>();
}

template<typename MeshT>
void OMPropertyVisualizerDouble<MeshT>::duplicateProperty()
{
    OMPropertyVisualizer<MeshT>::template duplicateProperty_stage1<double>();
}