Property.hh 17.3 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
Jan Möbius's avatar
Jan Möbius committed
102
  explicit PropertyT(const std::string& _name = "<unknown>")
Jan Möbius's avatar
Jan Möbius committed
103
104
105
106
107
108
109
110
111
  : BaseProperty(_name)
  {}

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

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
112
113
114
115
116
  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
117
  { std::swap(data_[_i0], data_[_i1]); }
Jan Möbius's avatar
Jan Möbius committed
118
  virtual void copy(size_t _i0, size_t _i1) override
119
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
120
121
122

public:

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

Jan Möbius's avatar
Jan Möbius committed
126
127
  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
128
129
130
131
132
133
134
135

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

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

Jan Möbius's avatar
Jan Möbius committed
146
  virtual size_t store( std::ostream& _ostr, bool _swap ) const override
Jan Möbius's avatar
Jan Möbius committed
147
148
149
150
151
152
153
154
155
  {
    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
156
  virtual size_t restore( std::istream& _istr, bool _swap ) override
Jan Möbius's avatar
Jan Möbius committed
157
158
159
160
161
162
163
164
165
166
167
168
  {
    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)
169
  const T* data() const {
Jan Möbius's avatar
Jan Möbius committed
170
171
172
173

    if( data_.empty() )
      return 0;

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

  /// 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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
  /// 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
202
  PropertyT<T>* clone() const override
Jan Möbius's avatar
Jan Möbius committed
203
204
205
206
207
208
209
210
211
212
213
214
215
216
  {
    PropertyT<T>* p = new PropertyT<T>( *this );
    return p;
  }


private:

  vector_type data_;
};

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


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

Jan Möbius's avatar
Jan Möbius committed
219
  The data will be stored as a bitset.
Jan Möbius's avatar
Jan Möbius committed
220
221
222
223
224
225
226
227
228
229
230
231
232
 */
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
233
  explicit PropertyT(const std::string& _name = "<unknown>")
Jan Möbius's avatar
Jan Möbius committed
234
235
236
237
238
    : BaseProperty(_name)
  { }

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
239
240
241
242
243
  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
244
  { bool t(data_[_i0]); data_[_i0]=data_[_i1]; data_[_i1]=t; }
Jan Möbius's avatar
Jan Möbius committed
245
  virtual void copy(size_t _i0, size_t _i1) override
246
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
247
248
249

public:

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

Jan Möbius's avatar
Jan Möbius committed
255
256
257
258
  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
259
260
261
262
  {
    return _n_elem / 8 + ((_n_elem % 8)!=0);
  }

Jan Möbius's avatar
Jan Möbius committed
263
  size_t store( std::ostream& _ostr, bool /* _swap */ ) const override
Jan Möbius's avatar
Jan Möbius committed
264
265
266
267
268
269
270
271
272
273
274
275
  {
    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
276
277
278
279
280
281
282
283
      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
284
285
286
287
288
289
290
291
      _ostr << bits;
    }
    bytes = N;

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

    assert( bytes == size_of() );

    return bytes;
  }

Jan Möbius's avatar
Jan Möbius committed
302
  size_t restore( std::istream& _istr, bool /* _swap */ ) override
Jan Möbius's avatar
Jan Möbius committed
303
304
305
306
307
308
309
310
311
312
313
314
315
  {
    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
316
317
318
319
320
321
322
323
      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
324
325
326
327
328
329
330
    }
    bytes = N;

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

    return bytes;
  }


public:
340
341
342
343
344
345
346
347
348
349
350

  /// 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
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
  /// 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
366
  PropertyT<bool>* clone() const override
Jan Möbius's avatar
Jan Möbius committed
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
  {
    PropertyT<bool>* p = new PropertyT<bool>( *this );
    return p;
  }


private:

  vector_type data_;
};


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


Jan Möbius's avatar
Jan Möbius committed
382
/** Property specialization for std::string type.
Jan Möbius's avatar
Jan Möbius committed
383
384
385
386
387
388
389
390
391
392
393
394
395
396
*/
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
397
  explicit PropertyT(const std::string& _name = "<unknown>")
Jan Möbius's avatar
Jan Möbius committed
398
399
400
401
402
    : BaseProperty(_name)
  { }

public: // inherited from BaseProperty

Jan Möbius's avatar
Jan Möbius committed
403
404
405
406
407
  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
408
409
    std::swap(data_[_i0], data_[_i1]);
  }
Jan Möbius's avatar
Jan Möbius committed
410
  virtual void copy(size_t _i0, size_t _i1) override
411
  { data_[_i1] = data_[_i0]; }
Jan Möbius's avatar
Jan Möbius committed
412
413
414

public:

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

Jan Möbius's avatar
Jan Möbius committed
418
419
420
  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
421
422
  { return IO::size_of( data_ ); }

Jan Möbius's avatar
Jan Möbius committed
423
  virtual size_t       size_of(size_t /* _n_elem */) const override
Jan Möbius's avatar
Jan Möbius committed
424
425
426
  { 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
427
  size_t store( std::ostream& _ostr, bool _swap ) const override
Jan Möbius's avatar
Jan Möbius committed
428
429
  { return IO::store( _ostr, data_, _swap ); }

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

public:

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

      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
454
  PropertyT<value_type>* clone() const override {
Jan Möbius's avatar
Jan Möbius committed
455
456
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
    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
//=============================================================================