OpenVDB  9.1.1
AttributeGroup.h
Go to the documentation of this file.
1 // Copyright Contributors to the OpenVDB Project
2 // SPDX-License-Identifier: MPL-2.0
3 
4 /// @file points/AttributeGroup.h
5 ///
6 /// @author Dan Bailey
7 ///
8 /// @brief Attribute Group access and filtering for iteration.
9 
10 #ifndef OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
11 #define OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
12 
13 #include "AttributeArray.h"
14 #include "AttributeSet.h"
15 #include <memory>
16 
17 namespace openvdb {
19 namespace OPENVDB_VERSION_NAME {
20 namespace points {
21 
22 
23 ////////////////////////////////////////
24 
25 
26 struct GroupCodec
27 {
30 
31  template <typename T>
32  struct Storage { using Type = StorageType; };
33 
34  static void decode(const StorageType&, ValueType&);
35  static void encode(const ValueType&, StorageType&);
36  static const char* name() { return "grp"; }
37 };
38 
39 
41 
42 
43 ////////////////////////////////////////
44 
45 
46 inline void
47 GroupCodec::decode(const StorageType& data, ValueType& val)
48 {
49  val = data;
50 }
51 
52 
53 inline void
54 GroupCodec::encode(const ValueType& val, StorageType& data)
55 {
56  data = val;
57 }
58 
59 
60 ////////////////////////////////////////
61 
62 
63 inline bool isGroup(const AttributeArray& array)
64 {
65  return array.isType<GroupAttributeArray>();
66 }
67 
68 
69 ////////////////////////////////////////
70 
71 
73 {
74 public:
75  using Ptr = std::shared_ptr<GroupHandle>;
76  using UniquePtr = std::unique_ptr<GroupHandle>;
77 
78  // Dummy class that distinguishes an offset from a bitmask on construction
79  struct BitMask { };
80 
81  using GroupIndex = std::pair<Index, uint8_t>;
82 
83  GroupHandle(const GroupAttributeArray& array, const GroupType& offset);
84  GroupHandle(const GroupAttributeArray& array, const GroupType& bitMask, BitMask);
85 
86  Index size() const { return mArray.size(); }
87  bool isUniform() const { return mArray.isUniform(); }
88 
89  bool get(Index n) const;
90  bool getUnsafe(Index n) const;
91 
92 protected:
95 }; // class GroupHandle
96 
97 
98 ////////////////////////////////////////
99 
100 
102 {
103 public:
104  using Ptr = std::shared_ptr<GroupWriteHandle>;
105  using UniquePtr = std::unique_ptr<GroupWriteHandle>;
106 
107  GroupWriteHandle(GroupAttributeArray& array, const GroupType& offset);
108 
109  /// Set @a on at the given index @a n
110  void set(Index n, bool on);
111  /// Set @a on at the given index @a n (assumes in-core and non-uniform)
112  void setUnsafe(Index n, bool on);
113 
114  /// @brief Set membership for the whole array and attempt to collapse
115  ///
116  /// @param on True or false for inclusion in group
117  ///
118  /// @note This method guarantees that all attributes will have group membership
119  /// changed according to the input bool, however compaction will not be performed
120  /// if other groups that share the same underlying array are non-uniform.
121  /// The return value indicates if the group array ends up being uniform.
122  bool collapse(bool on);
123 
124  /// Compact the existing array to become uniform if all values are identical
125  bool compact();
126 
127 }; // class GroupWriteHandle
128 
129 
130 ////////////////////////////////////////
131 
132 
133 /// Index filtering on group membership
135 {
136 public:
137  GroupFilter(const Name& name, const AttributeSet& attributeSet)
138  : mIndex(attributeSet.groupIndex(name)) { }
139 
140  explicit GroupFilter(const AttributeSet::Descriptor::GroupIndex& index)
141  : mIndex(index) { }
142 
143  inline bool initialized() const { return bool(mHandle); }
144 
145  static index::State state() { return index::PARTIAL; }
146  template <typename LeafT>
147  static index::State state(const LeafT&) { return index::PARTIAL; }
148 
149  template <typename LeafT>
150  void reset(const LeafT& leaf) {
151  mHandle.reset(new GroupHandle(leaf.groupHandle(mIndex)));
152  }
153 
154  template <typename IterT>
155  bool valid(const IterT& iter) const {
156  assert(mHandle);
157  return mHandle->getUnsafe(*iter);
158  }
159 
160 private:
161  const AttributeSet::Descriptor::GroupIndex mIndex;
162  GroupHandle::Ptr mHandle;
163 }; // class GroupFilter
164 
165 
166 ////////////////////////////////////////
167 
168 
169 } // namespace points
170 
171 } // namespace OPENVDB_VERSION_NAME
172 } // namespace openvdb
173 
174 
175 #endif // OPENVDB_POINTS_ATTRIBUTE_GROUP_HAS_BEEN_INCLUDED
const GroupType mBitMask
Definition: AttributeGroup.h:94
#define OPENVDB_API
Definition: Platform.h:249
Index32 Index
Definition: Types.h:54
Ordered collection of uniquely-named attribute arrays.
Definition: AttributeSet.h:38
StorageType Type
Definition: AttributeGroup.h:32
std::shared_ptr< GroupHandle > Ptr
Definition: AttributeGroup.h:75
Definition: IndexIterator.h:41
bool isUniform() const
Definition: AttributeGroup.h:87
Attribute Array storage templated on type and compression codec.
const GroupAttributeArray & mArray
Definition: AttributeGroup.h:93
Definition: AttributeGroup.h:101
void reset(const LeafT &leaf)
Definition: AttributeGroup.h:150
Definition: AttributeGroup.h:26
Definition: AttributeGroup.h:79
GroupType StorageType
Definition: AttributeGroup.h:28
static const char * name()
Definition: AttributeGroup.h:36
GroupType ValueType
Definition: AttributeGroup.h:29
std::unique_ptr< GroupHandle > UniquePtr
Definition: AttributeGroup.h:76
bool valid(const IterT &iter) const
Definition: AttributeGroup.h:155
bool isGroup(const AttributeArray &array)
Definition: AttributeGroup.h:63
uint8_t GroupType
Definition: AttributeSet.h:31
bool isType() const
Return true if this attribute is of the same type as the template parameter.
Definition: AttributeArray.h:222
Definition: Exceptions.h:13
Index filtering on group membership.
Definition: AttributeGroup.h:134
Index size() const
Definition: AttributeGroup.h:86
GroupFilter(const AttributeSet::Descriptor::GroupIndex &index)
Definition: AttributeGroup.h:140
std::pair< Index, uint8_t > GroupIndex
Definition: AttributeGroup.h:81
Definition: AttributeGroup.h:32
static index::State state()
Definition: AttributeGroup.h:145
Base class for storing attribute data.
Definition: AttributeArray.h:92
std::string Name
Definition: Name.h:17
Typed class for storing attribute data.
Definition: AttributeArray.h:538
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:116
State
Definition: IndexIterator.h:39
Set of Attribute Arrays which tracks metadata about each array.
static index::State state(const LeafT &)
Definition: AttributeGroup.h:147
Definition: AttributeGroup.h:72
GroupFilter(const Name &name, const AttributeSet &attributeSet)
Definition: AttributeGroup.h:137
bool initialized() const
Definition: AttributeGroup.h:143
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:202