Property.hh 17.4 KB
Newer Older
Jan Möbius's avatar
Jan Möbius committed
1
/* ========================================================================= *
Jan Möbius's avatar
Jan Möbius committed
2
3
 *                                                                           *
 *                               OpenMesh                                    *
Jan Möbius's avatar
Jan Möbius committed
4
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
Jan Möbius's avatar
Typo    
Jan Möbius committed
5
 *           Department of Computer Graphics and Multimedia                  *
Jan Möbius's avatar
Jan Möbius committed
6
7
 *                          All rights reserved.                             *
 *                            www.openmesh.org                               *
Jan Möbius's avatar
Jan Möbius committed
8
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
9
10
11
 *---------------------------------------------------------------------------*
 * This file is part of OpenMesh.                                            *
 *---------------------------------------------------------------------------*
Jan Möbius's avatar
Jan Möbius committed
12
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
13
14
15
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
Jan Möbius's avatar
Jan Möbius committed
16
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
17
18
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
Jan Möbius's avatar
Jan Möbius committed
19
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
20
21
22
 * 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.   *
Jan Möbius's avatar
Jan Möbius committed
23
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
24
25
26
 * 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.               *
27
 *                                                                           *
Jan Möbius's avatar
Jan Möbius committed
28
29
30
31
32
33
34
35
36
37
38
 * 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.              *
Jan Möbius's avatar
Jan Möbius committed
39
40
 *                                                                           *
 * ========================================================================= */
41

42

Jan Möbius's avatar
Jan Möbius committed
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#ifndef OPENMESH_PROPERTY_HH
#define OPENMESH_PROPERTY_HH


//== INCLUDES =================================================================


#include <OpenMesh/Core/System/config.h>
#include <OpenMesh/Core/Mesh/Handles.hh>
#include <OpenMesh/Core/Utils/BaseProperty.hh>
#include <vector>
#include <string>
#include <algorithm>


//== NAMESPACES ===============================================================

namespace OpenMesh {

//== CLASS DEFINITION =========================================================

/** \class PropertyT Property.hh <OpenMesh/Core/Utils/PropertyT.hh>
 *
 *  \brief Default property class for any type T.
 *
 *  The default property class for any type T.
 *
 *  The property supports persistency if T is a "fundamental" type:
 *  - integer fundamental types except bool:
 *    char, short, int, long, long long (__int64 for MS VC++) and
 *    their unsigned companions.
 *  - float fundamentals except <tt>long double</tt>:
 *    float, double
 *  - %OpenMesh vector types
 *
 *  Persistency of non-fundamental types is supported if and only if a
 *  specialization of struct IO::binary<> exists for the wanted type.
 */

// TODO: it might be possible to define Property using kind of a runtime info
// structure holding the size of T. Then reserve, swap, resize, etc can be written
// in pure malloc() style w/o virtual overhead. Template member function proved per
// element access to the properties, asserting dynamic_casts in debug

template <class T>
class PropertyT : public BaseProperty
{
public:

  typedef T                                       Value;
  typedef std::vector<T>                          vector_type;
  typedef T                                       value_type;
  typedef typename vector_type::reference         reference;
  typedef typename vector_type::const_reference   const_reference;

public:

  /// Default constructor
102
103
104
105
  explicit PropertyT(
            const std::string& _name = "<unknown>",
            const std::string& _internal_type_name = "<unknown>")
  : BaseProperty(_name, _internal_type_name)
Jan Möbius's avatar
Jan Möbius committed
106
107
108
109
110
111
112
113
  {}

  /// Copy constructor
  PropertyT(const PropertyT & _rhs)
      : BaseProperty( _rhs ), data_( _rhs.data_ ) {}

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
114
115
116
117
118
  virtual void reserve(size_t _n) override { data_.reserve(_n);    }
  virtual void resize(size_t _n) override  { data_.resize(_n);     }
  virtual void clear() override  { data_.clear(); vector_type().swap(data_);    }
  virtual void push_back() override        { data_.push_back(T()); }
  virtual void swap(size_t _i0, size_t _i1) override
Jan Möbius's avatar
Jan Möbius committed
119
  { std::swap(data_[_i0], data_[_i1]); }
Jan Möbius's avatar
Jan Möbius committed
120
  virtual void copy(size_t _i0, size_t _i1) override
121
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
122
123
124

public:

Jan Möbius's avatar
Jan Möbius committed
125
  virtual void set_persistent( bool _yn ) override
Jan Möbius's avatar
Jan Möbius committed
126
127
  { check_and_set_persistent<T>( _yn ); }

Jan Möbius's avatar
Jan Möbius committed
128
129
  virtual size_t       n_elements()   const override { return data_.size(); }
  virtual size_t       element_size() const override { return IO::size_of<T>(); }
Jan Möbius's avatar
Jan Möbius committed
130
131
132
133
134
135
136
137

#ifndef DOXY_IGNORE_THIS
  struct plus {
    size_t operator () ( size_t _b, const T& _v )
    { return _b + IO::size_of<T>(_v); }
  };
#endif

Jan Möbius's avatar
Jan Möbius committed
138
  virtual size_t size_of(void) const override
Jan Möbius's avatar
Jan Möbius committed
139
140
141
  {
    if (element_size() != IO::UnknownSize)
      return this->BaseProperty::size_of(n_elements());
142
    return std::accumulate(data_.begin(), data_.end(), size_t(0), plus());
Jan Möbius's avatar
Jan Möbius committed
143
144
  }

Jan Möbius's avatar
Jan Möbius committed
145
  virtual size_t size_of(size_t _n_elem) const override
Jan Möbius's avatar
Jan Möbius committed
146
147
  { return this->BaseProperty::size_of(_n_elem); }

Jan Möbius's avatar
Jan Möbius committed
148
  virtual size_t store( std::ostream& _ostr, bool _swap ) const override
Jan Möbius's avatar
Jan Möbius committed
149
150
151
152
153
154
155
156
157
  {
    if ( IO::is_streamable<vector_type>() )
      return IO::store(_ostr, data_, _swap );
    size_t bytes = 0;
    for (size_t i=0; i<n_elements(); ++i)
      bytes += IO::store( _ostr, data_[i], _swap );
    return bytes;
  }

Jan Möbius's avatar
Jan Möbius committed
158
  virtual size_t restore( std::istream& _istr, bool _swap ) override
Jan Möbius's avatar
Jan Möbius committed
159
160
161
162
163
164
165
166
167
168
169
170
  {
    if ( IO::is_streamable<vector_type>() )
      return IO::restore(_istr, data_, _swap );
    size_t bytes = 0;
    for (size_t i=0; i<n_elements(); ++i)
      bytes += IO::restore( _istr, data_[i], _swap );
    return bytes;
  }

public: // data access interface

  /// Get pointer to array (does not work for T==bool)
171
  const T* data() const {
Jan Möbius's avatar
Jan Möbius committed
172
173
174
175

    if( data_.empty() )
      return 0;

176
    return &data_[0];
Jan Möbius's avatar
Jan Möbius committed
177
  }
178
179
180
181
182
183
184
185
186
187
188

  /// Get reference to property vector (be careful, improper usage, e.g. resizing, may crash OpenMesh!!!)
  vector_type& data_vector() {
    return data_;
  }

  /// Const access to property vector
  const vector_type& data_vector() const {
    return data_;
  }

Jan Möbius's avatar
Jan Möbius committed
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
  /// Access the i'th element. No range check is performed!
  reference operator[](int _idx)
  {
    assert( size_t(_idx) < data_.size() );
    return data_[_idx];
  }

  /// Const access to the i'th element. No range check is performed!
  const_reference operator[](int _idx) const
  {
    assert( size_t(_idx) < data_.size());
    return data_[_idx];
  }

  /// Make a copy of self.
Jan Möbius's avatar
Jan Möbius committed
204
  PropertyT<T>* clone() const override
Jan Möbius's avatar
Jan Möbius committed
205
206
207
208
209
210
211
212
213
214
215
216
217
218
  {
    PropertyT<T>* p = new PropertyT<T>( *this );
    return p;
  }


private:

  vector_type data_;
};

//-----------------------------------------------------------------------------


Jan Möbius's avatar
Jan Möbius committed
219
/** Property specialization for bool type. 
Jan Möbius's avatar
Jan Möbius committed
220

Jan Möbius's avatar
Jan Möbius committed
221
  The data will be stored as a bitset.
Jan Möbius's avatar
Jan Möbius committed
222
223
224
225
226
227
228
229
230
231
232
233
234
 */
template <>
class PropertyT<bool> : public BaseProperty
{
public:

  typedef std::vector<bool>                       vector_type;
  typedef bool                                    value_type;
  typedef vector_type::reference                  reference;
  typedef vector_type::const_reference            const_reference;

public:

Jan Möbius's avatar
Jan Möbius committed
235
  explicit PropertyT(const std::string& _name = "<unknown>")
Jan Möbius's avatar
Jan Möbius committed
236
237
238
239
240
    : BaseProperty(_name)
  { }

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
241
242
243
244
245
  virtual void reserve(size_t _n) override { data_.reserve(_n);    }
  virtual void resize(size_t _n) override  { data_.resize(_n);     }
  virtual void clear() override  { data_.clear(); vector_type().swap(data_);    }
  virtual void push_back() override        { data_.push_back(bool()); }
  virtual void swap(size_t _i0, size_t _i1) override
Jan Möbius's avatar
Jan Möbius committed
246
  { bool t(data_[_i0]); data_[_i0]=data_[_i1]; data_[_i1]=t; }
Jan Möbius's avatar
Jan Möbius committed
247
  virtual void copy(size_t _i0, size_t _i1) override
248
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
249
250
251

public:

Jan Möbius's avatar
Jan Möbius committed
252
  virtual void set_persistent( bool _yn ) override
Jan Möbius's avatar
Jan Möbius committed
253
254
255
256
  {
    check_and_set_persistent<bool>( _yn );
  }

Jan Möbius's avatar
Jan Möbius committed
257
258
259
260
  virtual size_t       n_elements()   const override { return data_.size();  }
  virtual size_t       element_size() const override { return UnknownSize;    }
  virtual size_t       size_of() const override      { return size_of( n_elements() ); }
  virtual size_t       size_of(size_t _n_elem) const override
Jan Möbius's avatar
Jan Möbius committed
261
262
263
264
  {
    return _n_elem / 8 + ((_n_elem % 8)!=0);
  }

Jan Möbius's avatar
Jan Möbius committed
265
  size_t store( std::ostream& _ostr, bool /* _swap */ ) const override
Jan Möbius's avatar
Jan Möbius committed
266
267
268
269
270
271
272
273
274
275
276
277
  {
    size_t bytes = 0;

    size_t N = data_.size() / 8;
    size_t R = data_.size() % 8;

    size_t        idx;  // element index
    size_t        bidx;
    unsigned char bits; // bitset

    for (bidx=idx=0; idx < N; ++idx, bidx+=8)
    {
Matthias Möller's avatar
Matthias Möller committed
278
279
280
281
282
283
284
285
      bits = static_cast<unsigned char>(data_[bidx])
        | (static_cast<unsigned char>(data_[bidx+1]) << 1)
        | (static_cast<unsigned char>(data_[bidx+2]) << 2)
        | (static_cast<unsigned char>(data_[bidx+3]) << 3)
        | (static_cast<unsigned char>(data_[bidx+4]) << 4)
        | (static_cast<unsigned char>(data_[bidx+5]) << 5)
        | (static_cast<unsigned char>(data_[bidx+6]) << 6)
        | (static_cast<unsigned char>(data_[bidx+7]) << 7);
Jan Möbius's avatar
Jan Möbius committed
286
287
288
289
290
291
292
293
      _ostr << bits;
    }
    bytes = N;

    if (R)
    {
      bits = 0;
      for (idx=0; idx < R; ++idx)
294
        bits |= static_cast<unsigned char>(data_[bidx+idx]) << idx;
Jan Möbius's avatar
Jan Möbius committed
295
296
297
298
299
300
301
302
303
      _ostr << bits;
      ++bytes;
    }

    assert( bytes == size_of() );

    return bytes;
  }

Jan Möbius's avatar
Jan Möbius committed
304
  size_t restore( std::istream& _istr, bool /* _swap */ ) override
Jan Möbius's avatar
Jan Möbius committed
305
306
307
308
309
310
311
312
313
314
315
316
317
  {
    size_t bytes = 0;

    size_t N = data_.size() / 8;
    size_t R = data_.size() % 8;

    size_t        idx;  // element index
    size_t        bidx; //
    unsigned char bits; // bitset

    for (bidx=idx=0; idx < N; ++idx, bidx+=8)
    {
      _istr >> bits;
Matthias Möller's avatar
Matthias Möller committed
318
319
320
321
322
323
324
325
      data_[bidx+0] = (bits & 0x01) != 0;
      data_[bidx+1] = (bits & 0x02) != 0;
      data_[bidx+2] = (bits & 0x04) != 0;
      data_[bidx+3] = (bits & 0x08) != 0;
      data_[bidx+4] = (bits & 0x10) != 0;
      data_[bidx+5] = (bits & 0x20) != 0;
      data_[bidx+6] = (bits & 0x40) != 0;
      data_[bidx+7] = (bits & 0x80) != 0;
Jan Möbius's avatar
Jan Möbius committed
326
327
328
329
330
331
332
    }
    bytes = N;

    if (R)
    {
      _istr >> bits;
      for (idx=0; idx < R; ++idx)
333
        data_[bidx+idx] = (bits & (1<<idx)) != 0;
Jan Möbius's avatar
Jan Möbius committed
334
335
336
337
338
339
340
341
      ++bytes;
    }

    return bytes;
  }


public:
342
343
344
345
346
347
348
349
350
351
352

  /// Get reference to property vector (be careful, improper usage, e.g. resizing, may crash OpenMesh!!!)
  vector_type& data_vector() {
    return data_;
  }

  /// Const access to property vector
  const vector_type& data_vector() const {
    return data_;
  }

Jan Möbius's avatar
Jan Möbius committed
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
  /// Access the i'th element. No range check is performed!
  reference operator[](int _idx)
  {
    assert( size_t(_idx) < data_.size() );
    return data_[_idx];
  }

  /// Const access to the i'th element. No range check is performed!
  const_reference operator[](int _idx) const
  {
    assert( size_t(_idx) < data_.size());
    return data_[_idx];
  }

  /// Make a copy of self.
Jan Möbius's avatar
Jan Möbius committed
368
  PropertyT<bool>* clone() const override
Jan Möbius's avatar
Jan Möbius committed
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
  {
    PropertyT<bool>* p = new PropertyT<bool>( *this );
    return p;
  }


private:

  vector_type data_;
};


//-----------------------------------------------------------------------------


Jan Möbius's avatar
Jan Möbius committed
384
/** Property specialization for std::string type.
Jan Möbius's avatar
Jan Möbius committed
385
386
387
388
389
390
391
392
393
394
395
396
397
398
*/
template <>
class PropertyT<std::string> : public BaseProperty
{
public:

  typedef std::string                             Value;
  typedef std::vector<std::string>                vector_type;
  typedef std::string                             value_type;
  typedef vector_type::reference                  reference;
  typedef vector_type::const_reference            const_reference;

public:

Jan Möbius's avatar
Jan Möbius committed
399
  explicit PropertyT(const std::string& _name = "<unknown>")
Jan Möbius's avatar
Jan Möbius committed
400
401
402
403
404
    : BaseProperty(_name)
  { }

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
405
406
407
408
409
  virtual void reserve(size_t _n) override { data_.reserve(_n);    }
  virtual void resize(size_t _n) override  { data_.resize(_n);     }
  virtual void clear() override  { data_.clear(); vector_type().swap(data_);    }
  virtual void push_back() override        { data_.push_back(std::string()); }
  virtual void swap(size_t _i0, size_t _i1) override {
Jan Möbius's avatar
Jan Möbius committed
410
411
    std::swap(data_[_i0], data_[_i1]);
  }
Jan Möbius's avatar
Jan Möbius committed
412
  virtual void copy(size_t _i0, size_t _i1) override
413
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
414
415
416

public:

Jan Möbius's avatar
Jan Möbius committed
417
  virtual void set_persistent( bool _yn ) override
Jan Möbius's avatar
Jan Möbius committed
418
419
  { check_and_set_persistent<std::string>( _yn ); }

Jan Möbius's avatar
Jan Möbius committed
420
421
422
  virtual size_t       n_elements()   const override { return data_.size();  }
  virtual size_t       element_size() const override { return UnknownSize;    }
  virtual size_t       size_of() const override
Jan Möbius's avatar
Jan Möbius committed
423
424
  { return IO::size_of( data_ ); }

Jan Möbius's avatar
Jan Möbius committed
425
  virtual size_t       size_of(size_t /* _n_elem */) const override
Jan Möbius's avatar
Jan Möbius committed
426
427
428
  { return UnknownSize; }

  /// Store self as one binary block. Max. length of a string is 65535 bytes.
Jan Möbius's avatar
Jan Möbius committed
429
  size_t store( std::ostream& _ostr, bool _swap ) const override
Jan Möbius's avatar
Jan Möbius committed
430
431
  { return IO::store( _ostr, data_, _swap ); }

Jan Möbius's avatar
Jan Möbius committed
432
  size_t restore( std::istream& _istr, bool _swap ) override
Jan Möbius's avatar
Jan Möbius committed
433
434
435
436
437
438
  { return IO::restore( _istr, data_, _swap ); }

public:

  const value_type* data() const {
      if( data_.empty() )
Jan Möbius's avatar
Jan Möbius committed
439
	  return nullptr;
Jan Möbius's avatar
Jan Möbius committed
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455

      return (value_type*) &data_[0];
  }

  /// Access the i'th element. No range check is performed!
  reference operator[](int _idx) {
    assert( size_t(_idx) < data_.size());
    return ((value_type*) &data_[0])[_idx];
  }

  /// Const access the i'th element. No range check is performed!
  const_reference operator[](int _idx) const {
    assert( size_t(_idx) < data_.size());
    return ((value_type*) &data_[0])[_idx];
  }

Jan Möbius's avatar
Jan Möbius committed
456
  PropertyT<value_type>* clone() const override {
Jan Möbius's avatar
Jan Möbius committed
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
    PropertyT<value_type>* p = new PropertyT<value_type>( *this );
    return p;
  }
private:

  vector_type data_;

};

/// Base property handle.
template <class T>
struct BasePropHandleT : public BaseHandle
{
  typedef T                                       Value;
  typedef std::vector<T>                          vector_type;
  typedef T                                       value_type;
  typedef typename vector_type::reference         reference;
  typedef typename vector_type::const_reference   const_reference;

  explicit BasePropHandleT(int _idx=-1) : BaseHandle(_idx) {}
};


/** \ingroup mesh_property_handle_group
 *  Handle representing a vertex property
 */
template <class T>
struct VPropHandleT : public BasePropHandleT<T>
{
  typedef T                       Value;
  typedef T                       value_type;

  explicit VPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
  explicit VPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};


/** \ingroup mesh_property_handle_group
 *  Handle representing a halfedge property
 */
template <class T>
struct HPropHandleT : public BasePropHandleT<T>
{
  typedef T                       Value;
  typedef T                       value_type;

  explicit HPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
  explicit HPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};


/** \ingroup mesh_property_handle_group
 *  Handle representing an edge property
 */
template <class T>
struct EPropHandleT : public BasePropHandleT<T>
{
  typedef T                       Value;
  typedef T                       value_type;

  explicit EPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
  explicit EPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};


/** \ingroup mesh_property_handle_group
 *  Handle representing a face property
 */
template <class T>
struct FPropHandleT : public BasePropHandleT<T>
{
  typedef T                       Value;
  typedef T                       value_type;

  explicit FPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
  explicit FPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};


/** \ingroup mesh_property_handle_group
 *  Handle representing a mesh property
 */
template <class T>
struct MPropHandleT : public BasePropHandleT<T>
{
  typedef T                       Value;
  typedef T                       value_type;

  explicit MPropHandleT(int _idx=-1) : BasePropHandleT<T>(_idx) {}
  explicit MPropHandleT(const BasePropHandleT<T>& _b) : BasePropHandleT<T>(_b) {}
};

} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_PROPERTY_HH defined
//=============================================================================