OpenVDB  8.1.0
Grid.h
Go to the documentation of this file.
1 // Copyright Contributors to the OpenVDB Project
2 // SPDX-License-Identifier: MPL-2.0
3 
4 #ifndef OPENVDB_GRID_HAS_BEEN_INCLUDED
5 #define OPENVDB_GRID_HAS_BEEN_INCLUDED
6 
7 #include "Exceptions.h"
8 #include "MetaMap.h"
9 #include "Types.h"
10 #include "io/io.h"
11 #include "math/Transform.h"
12 #include "tree/Tree.h"
13 #include "util/logging.h"
14 #include "util/Name.h"
15 #include <cassert>
16 #include <iostream>
17 #include <set>
18 #include <type_traits>
19 #include <vector>
20 
21 
22 namespace openvdb {
24 namespace OPENVDB_VERSION_NAME {
25 
27 
28 template<typename> class Grid; // forward declaration
29 
30 
35 template<typename GridType>
36 inline typename GridType::Ptr createGrid(const typename GridType::ValueType& background);
37 
38 
42 template<typename GridType>
43 inline typename GridType::Ptr createGrid();
44 
45 
50 template<typename TreePtrType>
52 
53 
68 template<typename GridType>
69 typename GridType::Ptr createLevelSet(
70  Real voxelSize = 1.0, Real halfWidth = LEVEL_SET_HALF_WIDTH);
71 
72 
74 
75 
78 {
79 public:
82 
83  using GridFactory = Ptr (*)();
84 
85 
86  ~GridBase() override {}
87 
88 
91 
94  virtual GridBase::Ptr copyGrid() = 0;
97  virtual GridBase::ConstPtr copyGrid() const = 0;
100  virtual GridBase::Ptr copyGridWithNewTree() const = 0;
101 
102 #if OPENVDB_ABI_VERSION_NUMBER >= 7
105  virtual GridBase::ConstPtr copyGridReplacingMetadata(const MetaMap& meta) const = 0;
115  math::Transform::Ptr xform) const = 0;
116 #endif
117 
119  virtual GridBase::Ptr deepCopyGrid() const = 0;
120 
122 
123 
126 
128  static Ptr createGrid(const Name& type);
129 
131  static bool isRegistered(const Name &type);
132 
134  static void clearRegistry();
135 
137 
140 
142  virtual Name type() const = 0;
144  virtual Name valueType() const = 0;
145 
147  template<typename GridType>
148  bool isType() const { return (this->type() == GridType::gridType()); }
149 
151 
153  template<typename GridType>
156  static typename GridType::Ptr grid(const GridBase::Ptr&);
157  template<typename GridType>
158  static typename GridType::ConstPtr grid(const GridBase::ConstPtr&);
159  template<typename GridType>
160  static typename GridType::ConstPtr constGrid(const GridBase::Ptr&);
161  template<typename GridType>
162  static typename GridType::ConstPtr constGrid(const GridBase::ConstPtr&);
164 
167 
170  TreeBase::Ptr baseTreePtr();
173  TreeBase::ConstPtr baseTreePtr() const { return this->constBaseTreePtr(); }
177 
178 #if OPENVDB_ABI_VERSION_NUMBER >= 8
180  virtual bool isTreeUnique() const = 0;
181 #endif
182 
187  TreeBase& baseTree() { return const_cast<TreeBase&>(this->constBaseTree()); }
192  const TreeBase& baseTree() const { return this->constBaseTree(); }
197  const TreeBase& constBaseTree() const { return *(this->constBaseTreePtr()); }
198 
205  virtual void setTree(TreeBase::Ptr) = 0;
206 
208  virtual void newTree() = 0;
209 
211 
213  virtual bool empty() const = 0;
215  virtual void clear() = 0;
216 
217 
220 
226  virtual void pruneGrid(float tolerance = 0.0) = 0;
227 
232  void clipGrid(const BBoxd&);
233 
238  virtual void clip(const CoordBBox&) = 0;
239 
241 
266  template<typename GridTypeListT, typename OpT> inline bool apply(OpT&) const;
267  template<typename GridTypeListT, typename OpT> inline bool apply(OpT&);
268  template<typename GridTypeListT, typename OpT> inline bool apply(const OpT&) const;
269  template<typename GridTypeListT, typename OpT> inline bool apply(const OpT&);
271 
274 
276  std::string getName() const;
278  void setName(const std::string&);
279 
281  std::string getCreator() const;
283  void setCreator(const std::string&);
284 
287  bool saveFloatAsHalf() const;
288  void setSaveFloatAsHalf(bool);
289 
300 
302 
304  static std::string gridClassToString(GridClass);
306  static std::string gridClassToMenuName(GridClass);
311  static GridClass stringToGridClass(const std::string&);
312 
315 
326 
328 
330  static std::string vecTypeToString(VecType);
333  static std::string vecTypeExamples(VecType);
336  static std::string vecTypeDescription(VecType);
337  static VecType stringToVecType(const std::string&);
338 
341 
345  bool isInWorldSpace() const;
347  void setIsInWorldSpace(bool);
348 
350 
351  // Standard metadata field names
352  // (These fields should normally not be accessed directly, but rather
353  // via the accessor methods above, when available.)
354  // Note: Visual C++ requires these declarations to be separate statements.
355  static const char* const META_GRID_CLASS;
356  static const char* const META_GRID_CREATOR;
357  static const char* const META_GRID_NAME;
358  static const char* const META_SAVE_HALF_FLOAT;
359  static const char* const META_IS_LOCAL_SPACE;
360  static const char* const META_VECTOR_TYPE;
361  static const char* const META_FILE_BBOX_MIN;
362  static const char* const META_FILE_BBOX_MAX;
363  static const char* const META_FILE_COMPRESSION;
364  static const char* const META_FILE_MEM_BYTES;
365  static const char* const META_FILE_VOXEL_COUNT;
366  static const char* const META_FILE_DELAYED_LOAD;
367 
368 
371 
373  virtual Index64 activeVoxelCount() const = 0;
374 
378 
380  virtual Coord evalActiveVoxelDim() const = 0;
381 
383  virtual Index64 memUsage() const = 0;
384 
396 
398 
399 
402 
404  math::Transform::Ptr transformPtr() { return mTransform; }
407  math::Transform::ConstPtr transformPtr() const { return mTransform; }
408  math::Transform::ConstPtr constTransformPtr() const { return mTransform; }
410 
411  math::Transform& transform() { return *mTransform; }
416  const math::Transform& transform() const { return *mTransform; }
417  const math::Transform& constTransform() const { return *mTransform; }
419 
421 
424 
431  void setTransform(math::Transform::Ptr);
432 
434  Vec3d voxelSize() const { return transform().voxelSize(); }
437  Vec3d voxelSize(const Vec3d& xyz) const { return transform().voxelSize(xyz); }
439  bool hasUniformVoxels() const { return mTransform->hasUniformScale(); }
441  Vec3d indexToWorld(const Vec3d& xyz) const { return transform().indexToWorld(xyz); }
443  Vec3d indexToWorld(const Coord& ijk) const { return transform().indexToWorld(ijk); }
445  Vec3d worldToIndex(const Vec3d& xyz) const { return transform().worldToIndex(xyz); }
446 
448 
449 
452 
455  virtual void readTopology(std::istream&) = 0;
458  virtual void writeTopology(std::ostream&) const = 0;
459 
461  virtual void readBuffers(std::istream&) = 0;
463  virtual void readBuffers(std::istream&, const CoordBBox&) = 0;
469  virtual void readNonresidentBuffers() const = 0;
471  virtual void writeBuffers(std::ostream&) const = 0;
472 
474  void readTransform(std::istream& is) { transform().read(is); }
476  void writeTransform(std::ostream& os) const { transform().write(os); }
477 
479  virtual void print(std::ostream& = std::cout, int verboseLevel = 1) const = 0;
480 
482 
483 
484 protected:
486  GridBase(): mTransform(math::Transform::createLinearTransform()) {}
487 
488 #if OPENVDB_ABI_VERSION_NUMBER >= 7
491  GridBase(const MetaMap& meta, math::Transform::Ptr xform);
492 #endif
493 
495  GridBase(const GridBase& other): MetaMap(other), mTransform(other.mTransform->copy()) {}
496 
498  GridBase(GridBase& other, ShallowCopy): MetaMap(other), mTransform(other.mTransform) {}
499 
501  static void registerGrid(const Name& type, GridFactory);
503  static void unregisterGrid(const Name& type);
504 
505 
506 private:
507  math::Transform::Ptr mTransform;
508 }; // class GridBase
509 
510 
512 
513 
514 using GridPtrVec = std::vector<GridBase::Ptr>;
515 using GridPtrVecIter = GridPtrVec::iterator;
516 using GridPtrVecCIter = GridPtrVec::const_iterator;
518 
519 using GridCPtrVec = std::vector<GridBase::ConstPtr>;
520 using GridCPtrVecIter = GridCPtrVec::iterator;
521 using GridCPtrVecCIter = GridCPtrVec::const_iterator;
523 
524 using GridPtrSet = std::set<GridBase::Ptr>;
525 using GridPtrSetIter = GridPtrSet::iterator;
526 using GridPtrSetCIter = GridPtrSet::const_iterator;
528 
529 using GridCPtrSet = std::set<GridBase::ConstPtr>;
530 using GridCPtrSetIter = GridCPtrSet::iterator;
531 using GridCPtrSetCIter = GridCPtrSet::const_iterator;
533 
534 
537 {
538  GridNamePred(const Name& _name): name(_name) {}
539  bool operator()(const GridBase::ConstPtr& g) const { return g && g->getName() == name; }
541 };
542 
544 template<typename GridPtrContainerT>
545 inline typename GridPtrContainerT::value_type
546 findGridByName(const GridPtrContainerT& container, const Name& name)
547 {
548  using GridPtrT = typename GridPtrContainerT::value_type;
549  typename GridPtrContainerT::const_iterator it =
550  std::find_if(container.begin(), container.end(), GridNamePred(name));
551  return (it == container.end() ? GridPtrT() : *it);
552 }
553 
555 template<typename KeyT, typename GridPtrT>
556 inline GridPtrT
557 findGridByName(const std::map<KeyT, GridPtrT>& container, const Name& name)
558 {
559  using GridPtrMapT = std::map<KeyT, GridPtrT>;
560  for (typename GridPtrMapT::const_iterator it = container.begin(), end = container.end();
561  it != end; ++it)
562  {
563  const GridPtrT& grid = it->second;
564  if (grid && grid->getName() == name) return grid;
565  }
566  return GridPtrT();
567 }
569 
570 
572 
573 
575 template<typename _TreeType>
576 class Grid: public GridBase
577 {
578 public:
581 
582  using TreeType = _TreeType;
583  using TreePtrType = typename _TreeType::Ptr;
584  using ConstTreePtrType = typename _TreeType::ConstPtr;
585  using ValueType = typename _TreeType::ValueType;
586  using BuildType = typename _TreeType::BuildType;
587 
588  using ValueOnIter = typename _TreeType::ValueOnIter;
589  using ValueOnCIter = typename _TreeType::ValueOnCIter;
590  using ValueOffIter = typename _TreeType::ValueOffIter;
591  using ValueOffCIter = typename _TreeType::ValueOffCIter;
592  using ValueAllIter = typename _TreeType::ValueAllIter;
593  using ValueAllCIter = typename _TreeType::ValueAllCIter;
594 
599 
606  template<typename OtherValueType>
607  struct ValueConverter {
609  };
610 
612  static Ptr create(const ValueType& background);
614  static Ptr create();
617  static Ptr create(TreePtrType);
620  static Ptr create(const GridBase& other);
621 
622 
624  Grid();
626  explicit Grid(const ValueType& background);
630  explicit Grid(TreePtrType);
632  Grid(const Grid&);
638  template<typename OtherTreeType>
639  explicit Grid(const Grid<OtherTreeType>&);
641  Grid(Grid&, ShallowCopy);
644  explicit Grid(const GridBase&);
645 
646  ~Grid() override {}
647 
649  Grid& operator=(const Grid&) = delete;
650 
653 
656  Ptr copy();
659  ConstPtr copy() const;
662  Ptr copyWithNewTree() const;
663 
666  GridBase::Ptr copyGrid() override;
669  GridBase::ConstPtr copyGrid() const override;
672  GridBase::Ptr copyGridWithNewTree() const override;
674 
677 
678 #if OPENVDB_ABI_VERSION_NUMBER >= 7
681  ConstPtr copyReplacingMetadata(const MetaMap& meta) const;
686  ConstPtr copyReplacingTransform(math::Transform::Ptr xform) const;
690  ConstPtr copyReplacingMetadataAndTransform(const MetaMap& meta,
691  math::Transform::Ptr xform) const;
692 
695  GridBase::ConstPtr copyGridReplacingMetadata(const MetaMap& meta) const override;
700  GridBase::ConstPtr copyGridReplacingTransform(math::Transform::Ptr xform) const override;
704  GridBase::ConstPtr copyGridReplacingMetadataAndTransform(const MetaMap& meta,
705  math::Transform::Ptr xform) const override;
706 #endif
707 
709  Ptr deepCopy() const { return Ptr(new Grid(*this)); }
711  GridBase::Ptr deepCopyGrid() const override { return this->deepCopy(); }
712 
714 
715 
717  Name type() const override { return this->gridType(); }
719  static Name gridType() { return TreeType::treeType(); }
720 
722  Name valueType() const override { return tree().valueType(); }
723 
724 
727 
730  const ValueType& background() const { return mTree->background(); }
731 
733  bool empty() const override { return tree().empty(); }
735  void clear() override { tree().clear(); }
736 
740  Accessor getAccessor() { return Accessor(tree()); }
750  ConstAccessor getAccessor() const { return ConstAccessor(tree()); }
752  ConstAccessor getConstAccessor() const { return ConstAccessor(tree()); }
761 
763  ValueOnIter beginValueOn() { return tree().beginValueOn(); }
765  ValueOnCIter beginValueOn() const { return tree().cbeginValueOn(); }
767  ValueOnCIter cbeginValueOn() const { return tree().cbeginValueOn(); }
769  ValueOffIter beginValueOff() { return tree().beginValueOff(); }
771  ValueOffCIter beginValueOff() const { return tree().cbeginValueOff(); }
773  ValueOffCIter cbeginValueOff() const { return tree().cbeginValueOff(); }
775  ValueAllIter beginValueAll() { return tree().beginValueAll(); }
777  ValueAllCIter beginValueAll() const { return tree().cbeginValueAll(); }
779  ValueAllCIter cbeginValueAll() const { return tree().cbeginValueAll(); }
780 
782 
785 
794  void sparseFill(const CoordBBox& bbox, const ValueType& value, bool active = true);
803  void fill(const CoordBBox& bbox, const ValueType& value, bool active = true);
804 
811  void denseFill(const CoordBBox& bbox, const ValueType& value, bool active = true);
812 
814  void pruneGrid(float tolerance = 0.0) override;
815 
820  void clip(const CoordBBox&) override;
821 
827  void merge(Grid& other, MergePolicy policy = MERGE_ACTIVE_STATES);
828 
842  template<typename OtherTreeType>
843  void topologyUnion(const Grid<OtherTreeType>& other);
844 
857  template<typename OtherTreeType>
858  void topologyIntersection(const Grid<OtherTreeType>& other);
859 
870  template<typename OtherTreeType>
871  void topologyDifference(const Grid<OtherTreeType>& other);
872 
874 
877 
879  Index64 activeVoxelCount() const override { return tree().activeVoxelCount(); }
881  CoordBBox evalActiveVoxelBoundingBox() const override;
883  Coord evalActiveVoxelDim() const override;
885  void evalMinMax(ValueType& minVal, ValueType& maxVal) const;
886 
889  Index64 memUsage() const override { return tree().memUsage(); }
890 
892 
893 
896 
898  TreePtrType treePtr() { return mTree; }
901  ConstTreePtrType treePtr() const { return mTree; }
902  ConstTreePtrType constTreePtr() const { return mTree; }
903  TreeBase::ConstPtr constBaseTreePtr() const override { return mTree; }
905 #if OPENVDB_ABI_VERSION_NUMBER >= 8
908  bool isTreeUnique() const final;
909 #else
910  bool isTreeUnique() const;
911 #endif
913  TreeType& tree() { return *mTree; }
918  const TreeType& tree() const { return *mTree; }
919  const TreeType& constTree() const { return *mTree; }
921 
923 
926 
932  void setTree(TreeBase::Ptr) override;
933 
936  void newTree() override;
937 
939 
940 
943 
946  void readTopology(std::istream&) override;
949  void writeTopology(std::ostream&) const override;
950 
952  void readBuffers(std::istream&) override;
954  void readBuffers(std::istream&, const CoordBBox&) override;
960  void readNonresidentBuffers() const override;
962  void writeBuffers(std::ostream&) const override;
963 
965  void print(std::ostream& = std::cout, int verboseLevel = 1) const override;
966 
968 
972  static inline bool hasMultiPassIO();
973 
974 
977 
981  static void registerGrid() { GridBase::registerGrid(Grid::gridType(), Grid::factory); }
984 
986 
987 
988 private:
989 #if OPENVDB_ABI_VERSION_NUMBER >= 7
991  Grid(TreePtrType tree, const MetaMap& meta, math::Transform::Ptr xform);
992 #endif
993 
995  static GridBase::Ptr factory() { return Grid::create(); }
996 
997  TreePtrType mTree;
998 }; // class Grid
999 
1000 
1002 
1003 
1011 template<typename GridType>
1012 inline typename GridType::Ptr
1014 {
1015  return GridBase::grid<GridType>(grid);
1016 }
1017 
1018 
1027 template<typename GridType>
1028 inline typename GridType::ConstPtr
1030 {
1031  return GridBase::constGrid<GridType>(grid);
1032 }
1033 
1034 
1036 
1037 
1044 template<typename GridType>
1045 inline typename GridType::Ptr
1047 {
1048  if (!grid || !grid->isType<GridType>()) return typename GridType::Ptr();
1049  return gridPtrCast<GridType>(grid->deepCopyGrid());
1050 }
1051 
1052 
1053 template<typename GridType>
1054 inline typename GridType::Ptr
1056 {
1057  if (!grid.isType<GridType>()) return typename GridType::Ptr();
1058  return gridPtrCast<GridType>(grid.deepCopyGrid());
1059 }
1061 
1062 
1064 
1065 
1067 template<typename _TreeType>
1071 {
1072  using TreeType = _TreeType;
1073  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1074  using TreePtrType = typename TreeType::Ptr;
1075  using ConstTreePtrType = typename TreeType::ConstPtr;
1076  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1079  using GridPtrType = typename GridType::Ptr;
1082  using ValueType = typename TreeType::ValueType;
1086 
1087  static TreeType& tree(TreeType& t) { return t; }
1088  static TreeType& tree(GridType& g) { return g.tree(); }
1089  static const TreeType& tree(const TreeType& t) { return t; }
1090  static const TreeType& tree(const GridType& g) { return g.tree(); }
1091  static const TreeType& constTree(TreeType& t) { return t; }
1092  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1093  static const TreeType& constTree(const TreeType& t) { return t; }
1094  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1095 };
1096 
1097 
1099 template<typename _TreeType>
1100 struct TreeAdapter<Grid<_TreeType> >
1101 {
1102  using TreeType = _TreeType;
1103  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1104  using TreePtrType = typename TreeType::Ptr;
1105  using ConstTreePtrType = typename TreeType::ConstPtr;
1106  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1109  using GridPtrType = typename GridType::Ptr;
1112  using ValueType = typename TreeType::ValueType;
1116 
1117  static TreeType& tree(TreeType& t) { return t; }
1118  static TreeType& tree(GridType& g) { return g.tree(); }
1119  static const TreeType& tree(const TreeType& t) { return t; }
1120  static const TreeType& tree(const GridType& g) { return g.tree(); }
1121  static const TreeType& constTree(TreeType& t) { return t; }
1122  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1123  static const TreeType& constTree(const TreeType& t) { return t; }
1124  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1125 };
1126 
1128 template<typename _TreeType>
1129 struct TreeAdapter<tree::ValueAccessor<_TreeType> >
1130 {
1131  using TreeType = _TreeType;
1132  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1133  using TreePtrType = typename TreeType::Ptr;
1134  using ConstTreePtrType = typename TreeType::ConstPtr;
1135  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1138  using GridPtrType = typename GridType::Ptr;
1141  using ValueType = typename TreeType::ValueType;
1145 
1146  static TreeType& tree(TreeType& t) { return t; }
1147  static TreeType& tree(GridType& g) { return g.tree(); }
1148  static TreeType& tree(AccessorType& a) { return a.tree(); }
1149  static const TreeType& tree(const TreeType& t) { return t; }
1150  static const TreeType& tree(const GridType& g) { return g.tree(); }
1151  static const TreeType& tree(const AccessorType& a) { return a.tree(); }
1152  static const TreeType& constTree(TreeType& t) { return t; }
1153  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1154  static const TreeType& constTree(const TreeType& t) { return t; }
1155  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1156 };
1157 
1159 
1160 
1162 
1163 
1169 template<typename LeafNodeType>
1171  static const bool value = std::is_base_of<io::MultiPass, LeafNodeType>::value;
1172 };
1173 
1174 // Partial specialization for Tree types
1175 template<typename RootNodeType>
1176 struct HasMultiPassIO<tree::Tree<RootNodeType>> {
1177  // A tree is multi-pass if its (root node's) leaf node type is multi-pass.
1179 };
1180 
1181 // Partial specialization for Grid types
1182 template<typename TreeType>
1183 struct HasMultiPassIO<Grid<TreeType>> {
1184  // A grid is multi-pass if its tree's leaf node type is multi-pass.
1186 };
1187 
1188 
1190 
1191 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1193  : MetaMap(meta)
1194  , mTransform(xform)
1195 {
1196  if (!xform) OPENVDB_THROW(ValueError, "Transform pointer is null");
1197 }
1198 #endif
1199 
1200 template<typename GridType>
1201 inline typename GridType::Ptr
1203 {
1204  // The string comparison on type names is slower than a dynamic pointer cast, but
1205  // it is safer when pointers cross DSO boundaries, as they do in many Houdini nodes.
1206  if (grid && grid->type() == GridType::gridType()) {
1207  return StaticPtrCast<GridType>(grid);
1208  }
1209  return typename GridType::Ptr();
1210 }
1211 
1212 
1213 template<typename GridType>
1214 inline typename GridType::ConstPtr
1216 {
1217  return ConstPtrCast<const GridType>(
1218  GridBase::grid<GridType>(ConstPtrCast<GridBase>(grid)));
1219 }
1220 
1221 
1222 template<typename GridType>
1223 inline typename GridType::ConstPtr
1225 {
1226  return ConstPtrCast<const GridType>(GridBase::grid<GridType>(grid));
1227 }
1228 
1229 
1230 template<typename GridType>
1231 inline typename GridType::ConstPtr
1233 {
1234  return ConstPtrCast<const GridType>(
1235  GridBase::grid<GridType>(ConstPtrCast<GridBase>(grid)));
1236 }
1237 
1238 
1239 inline TreeBase::Ptr
1241 {
1242  return ConstPtrCast<TreeBase>(this->constBaseTreePtr());
1243 }
1244 
1245 
1246 inline void
1248 {
1249  if (!xform) OPENVDB_THROW(ValueError, "Transform pointer is null");
1250  mTransform = xform;
1251 }
1252 
1253 
1255 
1256 
1257 template<typename TreeT>
1258 inline Grid<TreeT>::Grid(): mTree(new TreeType)
1259 {
1260 }
1261 
1262 
1263 template<typename TreeT>
1264 inline Grid<TreeT>::Grid(const ValueType &background): mTree(new TreeType(background))
1265 {
1266 }
1267 
1268 
1269 template<typename TreeT>
1270 inline Grid<TreeT>::Grid(TreePtrType tree): mTree(tree)
1271 {
1272  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1273 }
1274 
1275 
1276 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1277 template<typename TreeT>
1278 inline Grid<TreeT>::Grid(TreePtrType tree, const MetaMap& meta, math::Transform::Ptr xform):
1279  GridBase(meta, xform),
1280  mTree(tree)
1281 {
1282  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1283 }
1284 #endif
1285 
1286 
1287 template<typename TreeT>
1288 inline Grid<TreeT>::Grid(const Grid& other):
1289  GridBase(other),
1290  mTree(StaticPtrCast<TreeType>(other.mTree->copy()))
1291 {
1292 }
1293 
1294 
1295 template<typename TreeT>
1296 template<typename OtherTreeType>
1298  GridBase(other),
1299  mTree(new TreeType(other.constTree()))
1300 {
1301 }
1302 
1303 
1304 template<typename TreeT>
1306  GridBase(other),
1307  mTree(other.mTree)
1308 {
1309 }
1310 
1311 
1312 template<typename TreeT>
1313 inline Grid<TreeT>::Grid(const GridBase& other):
1314  GridBase(other),
1315  mTree(new TreeType)
1316 {
1317 }
1318 
1319 
1320 //static
1321 template<typename TreeT>
1322 inline typename Grid<TreeT>::Ptr
1324 {
1325  return Grid::create(zeroVal<ValueType>());
1326 }
1327 
1328 
1329 //static
1330 template<typename TreeT>
1331 inline typename Grid<TreeT>::Ptr
1332 Grid<TreeT>::create(const ValueType& background)
1333 {
1334  return Ptr(new Grid(background));
1335 }
1336 
1337 
1338 //static
1339 template<typename TreeT>
1340 inline typename Grid<TreeT>::Ptr
1342 {
1343  return Ptr(new Grid(tree));
1344 }
1345 
1346 
1347 //static
1348 template<typename TreeT>
1349 inline typename Grid<TreeT>::Ptr
1351 {
1352  return Ptr(new Grid(other));
1353 }
1354 
1355 
1357 
1358 
1359 template<typename TreeT>
1360 inline typename Grid<TreeT>::ConstPtr
1362 {
1363  return ConstPtr{new Grid{*const_cast<Grid*>(this), ShallowCopy{}}};
1364 }
1365 
1366 
1367 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1368 template<typename TreeT>
1369 inline typename Grid<TreeT>::ConstPtr
1371 {
1372  math::Transform::Ptr transformPtr = ConstPtrCast<math::Transform>(
1373  this->constTransformPtr());
1374  TreePtrType treePtr = ConstPtrCast<TreeT>(this->constTreePtr());
1375  return ConstPtr{new Grid<TreeT>{treePtr, meta, transformPtr}};
1376 }
1377 
1378 template<typename TreeT>
1379 inline typename Grid<TreeT>::ConstPtr
1381 {
1382  return this->copyReplacingMetadataAndTransform(*this, xform);
1383 }
1384 
1385 template<typename TreeT>
1386 inline typename Grid<TreeT>::ConstPtr
1388  math::Transform::Ptr xform) const
1389 {
1390  TreePtrType treePtr = ConstPtrCast<TreeT>(this->constTreePtr());
1391  return ConstPtr{new Grid<TreeT>{treePtr, meta, xform}};
1392 }
1393 #endif
1394 
1395 
1396 template<typename TreeT>
1397 inline typename Grid<TreeT>::Ptr
1399 {
1400  return Ptr{new Grid{*this, ShallowCopy{}}};
1401 }
1402 
1403 
1404 template<typename TreeT>
1405 inline typename Grid<TreeT>::Ptr
1407 {
1408  Ptr result{new Grid{*const_cast<Grid*>(this), ShallowCopy{}}};
1409  result->newTree();
1410  return result;
1411 }
1412 
1413 
1414 template<typename TreeT>
1415 inline GridBase::Ptr
1417 {
1418  return this->copy();
1419 }
1420 
1421 template<typename TreeT>
1422 inline GridBase::ConstPtr
1424 {
1425  return this->copy();
1426 }
1427 
1428 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1429 template<typename TreeT>
1430 inline GridBase::ConstPtr
1432 {
1433  return this->copyReplacingMetadata(meta);
1434 }
1435 
1436 template<typename TreeT>
1437 inline GridBase::ConstPtr
1439 {
1440  return this->copyReplacingTransform(xform);
1441 }
1442 
1443 template<typename TreeT>
1444 inline GridBase::ConstPtr
1446  math::Transform::Ptr xform) const
1447 {
1448  return this->copyReplacingMetadataAndTransform(meta, xform);
1449 }
1450 #endif
1451 
1452 template<typename TreeT>
1453 inline GridBase::Ptr
1455 {
1456  return this->copyWithNewTree();
1457 }
1458 
1459 
1461 
1462 
1463 template<typename TreeT>
1464 inline bool
1466 {
1467  return mTree.use_count() == 1;
1468 }
1469 
1470 
1471 template<typename TreeT>
1472 inline void
1474 {
1475  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1476  if (tree->type() != TreeType::treeType()) {
1477  OPENVDB_THROW(TypeError, "Cannot assign a tree of type "
1478  + tree->type() + " to a grid of type " + this->type());
1479  }
1480  mTree = StaticPtrCast<TreeType>(tree);
1481 }
1482 
1483 
1484 template<typename TreeT>
1485 inline void
1487 {
1488  mTree.reset(new TreeType(this->background()));
1489 }
1490 
1491 
1493 
1494 
1495 template<typename TreeT>
1496 inline void
1497 Grid<TreeT>::sparseFill(const CoordBBox& bbox, const ValueType& value, bool active)
1498 {
1499  tree().sparseFill(bbox, value, active);
1500 }
1501 
1502 
1503 template<typename TreeT>
1504 inline void
1505 Grid<TreeT>::fill(const CoordBBox& bbox, const ValueType& value, bool active)
1506 {
1507  this->sparseFill(bbox, value, active);
1508 }
1509 
1510 template<typename TreeT>
1511 inline void
1512 Grid<TreeT>::denseFill(const CoordBBox& bbox, const ValueType& value, bool active)
1513 {
1514  tree().denseFill(bbox, value, active);
1515 }
1516 
1517 template<typename TreeT>
1518 inline void
1519 Grid<TreeT>::pruneGrid(float tolerance)
1520 {
1521  const auto value = math::cwiseAdd(zeroVal<ValueType>(), tolerance);
1522  this->tree().prune(static_cast<ValueType>(value));
1523 }
1524 
1525 template<typename TreeT>
1526 inline void
1528 {
1529  tree().clip(bbox);
1530 }
1531 
1532 template<typename TreeT>
1533 inline void
1535 {
1536  tree().merge(other.tree(), policy);
1537 }
1538 
1539 
1540 template<typename TreeT>
1541 template<typename OtherTreeType>
1542 inline void
1544 {
1545  tree().topologyUnion(other.tree());
1546 }
1547 
1548 
1549 template<typename TreeT>
1550 template<typename OtherTreeType>
1551 inline void
1553 {
1554  tree().topologyIntersection(other.tree());
1555 }
1556 
1557 
1558 template<typename TreeT>
1559 template<typename OtherTreeType>
1560 inline void
1562 {
1563  tree().topologyDifference(other.tree());
1564 }
1565 
1566 
1568 
1569 
1570 template<typename TreeT>
1571 inline void
1573 {
1574  tree().evalMinMax(minVal, maxVal);
1575 }
1576 
1577 
1578 template<typename TreeT>
1579 inline CoordBBox
1581 {
1582  CoordBBox bbox;
1583  tree().evalActiveVoxelBoundingBox(bbox);
1584  return bbox;
1585 }
1586 
1587 
1588 template<typename TreeT>
1589 inline Coord
1591 {
1592  Coord dim;
1593  const bool nonempty = tree().evalActiveVoxelDim(dim);
1594  return (nonempty ? dim : Coord());
1595 }
1596 
1597 
1599 
1600 
1603 
1604 template<typename TreeT>
1605 inline void
1606 Grid<TreeT>::readTopology(std::istream& is)
1607 {
1608  tree().readTopology(is, saveFloatAsHalf());
1609 }
1610 
1611 
1612 template<typename TreeT>
1613 inline void
1614 Grid<TreeT>::writeTopology(std::ostream& os) const
1615 {
1616  tree().writeTopology(os, saveFloatAsHalf());
1617 }
1618 
1619 
1620 template<typename TreeT>
1621 inline void
1622 Grid<TreeT>::readBuffers(std::istream& is)
1623 {
1624  if (!hasMultiPassIO() || (io::getFormatVersion(is) < OPENVDB_FILE_VERSION_MULTIPASS_IO)) {
1625  tree().readBuffers(is, saveFloatAsHalf());
1626  } else {
1627  uint16_t numPasses = 1;
1628  is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
1630  assert(bool(meta));
1631  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1632  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1633  meta->setPass(pass);
1634  tree().readBuffers(is, saveFloatAsHalf());
1635  }
1636  }
1637 }
1638 
1639 
1642 template<typename TreeT>
1643 inline void
1644 Grid<TreeT>::readBuffers(std::istream& is, const CoordBBox& bbox)
1645 {
1646  if (!hasMultiPassIO() || (io::getFormatVersion(is) < OPENVDB_FILE_VERSION_MULTIPASS_IO)) {
1647  tree().readBuffers(is, bbox, saveFloatAsHalf());
1648  } else {
1649  uint16_t numPasses = 1;
1650  is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
1652  assert(bool(meta));
1653  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1654  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1655  meta->setPass(pass);
1656  tree().readBuffers(is, saveFloatAsHalf());
1657  }
1658  // Cannot clip inside readBuffers() when using multiple passes,
1659  // so instead clip afterwards.
1660  tree().clip(bbox);
1661  }
1662 }
1663 
1664 
1665 template<typename TreeT>
1666 inline void
1668 {
1669  tree().readNonresidentBuffers();
1670 }
1671 
1672 
1673 template<typename TreeT>
1674 inline void
1675 Grid<TreeT>::writeBuffers(std::ostream& os) const
1676 {
1677  if (!hasMultiPassIO()) {
1678  tree().writeBuffers(os, saveFloatAsHalf());
1679  } else {
1680  // Determine how many leaf buffer passes are required for this grid
1682  assert(bool(meta));
1683  uint16_t numPasses = 1;
1684  meta->setCountingPasses(true);
1685  meta->setPass(0);
1686  tree().writeBuffers(os, saveFloatAsHalf());
1687  numPasses = static_cast<uint16_t>(meta->pass());
1688  os.write(reinterpret_cast<const char*>(&numPasses), sizeof(uint16_t));
1689  meta->setCountingPasses(false);
1690 
1691  // Save out the data blocks of the grid.
1692  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1693  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1694  meta->setPass(pass);
1695  tree().writeBuffers(os, saveFloatAsHalf());
1696  }
1697  }
1698 }
1699 
1700 
1701 //static
1702 template<typename TreeT>
1703 inline bool
1705 {
1707 }
1708 
1709 
1710 template<typename TreeT>
1711 inline void
1712 Grid<TreeT>::print(std::ostream& os, int verboseLevel) const
1713 {
1714  tree().print(os, verboseLevel);
1715 
1716  if (metaCount() > 0) {
1717  os << "Additional metadata:" << std::endl;
1718  for (ConstMetaIterator it = beginMeta(), end = endMeta(); it != end; ++it) {
1719  os << " " << it->first;
1720  if (it->second) {
1721  const std::string value = it->second->str();
1722  if (!value.empty()) os << ": " << value;
1723  }
1724  os << "\n";
1725  }
1726  }
1727 
1728  os << "Transform:" << std::endl;
1729  transform().print(os, /*indent=*/" ");
1730  os << std::endl;
1731 }
1732 
1733 
1735 
1736 
1737 template<typename GridType>
1738 inline typename GridType::Ptr
1739 createGrid(const typename GridType::ValueType& background)
1740 {
1741  return GridType::create(background);
1742 }
1743 
1744 
1745 template<typename GridType>
1746 inline typename GridType::Ptr
1748 {
1749  return GridType::create();
1750 }
1751 
1752 
1753 template<typename TreePtrType>
1755 createGrid(TreePtrType tree)
1756 {
1757  using TreeType = typename TreePtrType::element_type;
1758  return Grid<TreeType>::create(tree);
1759 }
1760 
1761 
1762 template<typename GridType>
1763 typename GridType::Ptr
1764 createLevelSet(Real voxelSize, Real halfWidth)
1765 {
1766  using ValueType = typename GridType::ValueType;
1767 
1768  // GridType::ValueType is required to be a floating-point scalar.
1769  static_assert(std::is_floating_point<ValueType>::value,
1770  "level-set grids must be floating-point-valued");
1771 
1772  typename GridType::Ptr grid = GridType::create(
1773  /*background=*/static_cast<ValueType>(voxelSize * halfWidth));
1774  grid->setTransform(math::Transform::createLinearTransform(voxelSize));
1775  grid->setGridClass(GRID_LEVEL_SET);
1776  return grid;
1777 }
1778 
1779 
1781 
1782 
1783 namespace internal {
1784 
1786 template<typename OpT, typename GridBaseT, typename T, typename ...Ts>
1787 struct GridApplyImpl { static bool apply(GridBaseT&, OpT&) { return false; } };
1788 
1789 // Partial specialization for (nonempty) TypeLists
1791 template<typename OpT, typename GridBaseT, typename GridT, typename ...GridTs>
1792 struct GridApplyImpl<OpT, GridBaseT, TypeList<GridT, GridTs...>>
1793 {
1794  static bool apply(GridBaseT& grid, OpT& op)
1795  {
1796  if (grid.template isType<GridT>()) {
1797  op(static_cast<typename CopyConstness<GridBaseT, GridT>::Type&>(grid));
1798  return true;
1799  }
1800  return GridApplyImpl<OpT, GridBaseT, TypeList<GridTs...>>::apply(grid, op);
1801  }
1802 };
1803 
1804 } // namespace internal
1805 
1806 
1807 template<typename GridTypeListT, typename OpT>
1808 inline bool
1809 GridBase::apply(OpT& op) const
1810 {
1811  return internal::GridApplyImpl<OpT, const GridBase, GridTypeListT>::apply(*this, op);
1812 }
1813 
1814 template<typename GridTypeListT, typename OpT>
1815 inline bool
1817 {
1818  return internal::GridApplyImpl<OpT, GridBase, GridTypeListT>::apply(*this, op);
1819 }
1820 
1821 template<typename GridTypeListT, typename OpT>
1822 inline bool
1823 GridBase::apply(const OpT& op) const
1824 {
1825  return internal::GridApplyImpl<const OpT, const GridBase, GridTypeListT>::apply(*this, op);
1826 }
1827 
1828 template<typename GridTypeListT, typename OpT>
1829 inline bool
1830 GridBase::apply(const OpT& op)
1831 {
1832  return internal::GridApplyImpl<const OpT, GridBase, GridTypeListT>::apply(*this, op);
1833 }
1834 
1835 } // namespace OPENVDB_VERSION_NAME
1836 } // namespace openvdb
1837 
1838 #endif // OPENVDB_GRID_HAS_BEEN_INCLUDED
#define OPENVDB_API
Helper macros for defining library symbol visibility.
Definition: Platform.h:240
OpenVDB AX Exceptions.
Consolidated llvm types for most supported types.
Abstract base class for typed grids.
Definition: Grid.h:78
virtual Name valueType() const =0
Return the name of the type of a voxel's value (e.g., "float" or "vec3d").
virtual GridBase::Ptr copyGrid()=0
Return a new grid of the same type as this grid whose metadata is a deep copy of this grid's and whos...
virtual GridBase::ConstPtr copyGridReplacingMetadataAndTransform(const MetaMap &meta, math::Transform::Ptr xform) const =0
Return a new grid of the same type as this grid whose tree is shared with this grid and whose transfo...
virtual GridBase::ConstPtr copyGridReplacingMetadata(const MetaMap &meta) const =0
Return a new grid of the same type as this grid whose tree and transform is shared with this grid and...
static const char *const META_FILE_MEM_BYTES
Definition: Grid.h:364
const TreeBase & baseTree() const
Return a reference to this grid's tree, which might be shared with other grids.
Definition: Grid.h:192
Ptr(*)() GridFactory
Definition: Grid.h:83
static GridType::Ptr grid(const GridBase::Ptr &)
Return the result of downcasting a GridBase pointer to a Grid pointer of the specified type,...
Definition: Grid.h:1202
static const char *const META_FILE_BBOX_MAX
Definition: Grid.h:362
virtual void readBuffers(std::istream &)=0
Read all data buffers for this grid.
virtual void writeBuffers(std::ostream &) const =0
Write out all data buffers for this grid.
static std::string gridClassToMenuName(GridClass)
Return a formatted string version of the grid class.
bool hasUniformVoxels() const
Return true if the voxels in world space are uniformly sized cubes.
Definition: Grid.h:439
math::Transform::ConstPtr constTransformPtr() const
Return a pointer to this grid's transform, which might be shared with other grids.
Definition: Grid.h:408
void setSaveFloatAsHalf(bool)
Return this grid's user-specified name.
~GridBase() override
Definition: Grid.h:86
virtual GridBase::ConstPtr copyGridReplacingTransform(math::Transform::Ptr xform) const =0
Return a new grid of the same type as this grid whose tree is shared with this grid,...
Vec3d indexToWorld(const Coord &ijk) const
Apply this grid's transform to the given coordinates.
Definition: Grid.h:443
Vec3d voxelSize() const
Return the size of this grid's voxels.
Definition: Grid.h:434
static std::string vecTypeDescription(VecType)
Return a string describing how the given type of vector data is affected by transformations (e....
void setName(const std::string &)
Specify a name for this grid.
static const char *const META_FILE_DELAYED_LOAD
Definition: Grid.h:366
Vec3d indexToWorld(const Vec3d &xyz) const
Apply this grid's transform to the given coordinates.
Definition: Grid.h:441
void clearGridClass()
Remove the setting specifying the class of this grid's volumetric data.
const TreeBase & constBaseTree() const
Return a reference to this grid's tree, which might be shared with other grids.
Definition: Grid.h:197
virtual bool isTreeUnique() const =0
Return true if tree is not shared with another grid.
bool isType() const
Return true if this grid is of the same type as the template parameter.
Definition: Grid.h:148
static std::string vecTypeToString(VecType)
Return the metadata string value for the given type of vector data.
static const char *const META_IS_LOCAL_SPACE
Definition: Grid.h:359
Vec3d worldToIndex(const Vec3d &xyz) const
Apply the inverse of this grid's transform to the given coordinates.
Definition: Grid.h:445
SharedPtr< const GridBase > ConstPtr
Definition: Grid.h:81
virtual GridBase::Ptr copyGridWithNewTree() const =0
Return a new grid of the same type as this grid whose metadata and transform are deep copies of this ...
GridBase(GridBase &other, ShallowCopy)
Copy another grid's metadata but share its transform.
Definition: Grid.h:498
static const char *const META_SAVE_HALF_FLOAT
Definition: Grid.h:358
virtual void clear()=0
Empty this grid, setting all voxels to the background.
const math::Transform & transform() const
Return a pointer to this grid's transform, which might be shared with other grids.
Definition: Grid.h:416
void setGridClass(GridClass)
Specify the class of volumetric data (level set, fog volume, etc.) that is stored in this grid.
virtual void writeTopology(std::ostream &) const =0
Write the grid topology to a stream. This will write only the grid structure, not the actual data buf...
TreeBase::ConstPtr baseTreePtr() const
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:173
void addStatsMetadata()
Add metadata to this grid comprising the current values of statistics like the active voxel count and...
void clearVectorType()
Remove the setting specifying the type of vector data stored in this grid.
virtual void newTree()=0
Set a new tree with the same background value as the previous tree.
static const char *const META_FILE_COMPRESSION
Definition: Grid.h:363
virtual TreeBase::ConstPtr constBaseTreePtr() const =0
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
static std::string vecTypeExamples(VecType)
void clipGrid(const BBoxd &)
Clip this grid to the given world-space bounding box.
virtual CoordBBox evalActiveVoxelBoundingBox() const =0
static const char *const META_FILE_BBOX_MIN
Definition: Grid.h:361
virtual Index64 memUsage() const =0
Return the number of bytes of memory used by this grid.
void setVectorType(VecType)
Specify the type of vector data (invariant, covariant, etc.) stored in this grid, assuming that this ...
virtual Index64 activeVoxelCount() const =0
Return the number of active voxels.
static bool isRegistered(const Name &type)
Return true if the given grid type name is registered.
Vec3d voxelSize(const Vec3d &xyz) const
Return the size of this grid's voxel at position (x, y, z).
Definition: Grid.h:437
std::string getName() const
Return this grid's user-specified name.
virtual void print(std::ostream &=std::cout, int verboseLevel=1) const =0
Output a human-readable description of this grid.
void setTransform(math::Transform::Ptr)
Associate the given transform with this grid, in place of its existing transform.
Definition: Grid.h:1247
virtual void pruneGrid(float tolerance=0.0)=0
Reduce the memory footprint of this grid by increasing its sparseness either losslessly (tolerance = ...
bool apply(OpT &) const
If this grid resolves to one of the listed grid types, invoke the given functor on the resolved grid.
Definition: Grid.h:1809
static GridType::ConstPtr constGrid(const GridBase::Ptr &)
Definition: Grid.h:1224
GridClass getGridClass() const
Return the class of volumetric data (level set, fog volume, etc.) that is stored in this grid.
static VecType stringToVecType(const std::string &)
TreeBase & baseTree()
Return a reference to this grid's tree, which might be shared with other grids.
Definition: Grid.h:187
static void unregisterGrid(const Name &type)
Remove a grid type from the registry.
virtual void readNonresidentBuffers() const =0
Read all of this grid's data buffers that are not yet resident in memory (because delayed loading is ...
static const char *const META_GRID_CREATOR
Definition: Grid.h:356
void readTransform(std::istream &is)
Read in the transform for this grid.
Definition: Grid.h:474
static const char *const META_GRID_NAME
Definition: Grid.h:357
static const char *const META_GRID_CLASS
Definition: Grid.h:355
GridBase(const GridBase &other)
Deep copy another grid's metadata and transform.
Definition: Grid.h:495
static const char *const META_VECTOR_TYPE
Definition: Grid.h:360
const math::Transform & constTransform() const
Return a pointer to this grid's transform, which might be shared with other grids.
Definition: Grid.h:417
static GridClass stringToGridClass(const std::string &)
Return the class of volumetric data specified by the given string.
virtual Coord evalActiveVoxelDim() const =0
Return the dimensions of the axis-aligned bounding box of all active voxels.
void setCreator(const std::string &)
Provide a description of this grid's creator.
bool saveFloatAsHalf() const
Return true if this grid should be written out with floating-point voxel values (including components...
MetaMap::Ptr getStatsMetadata() const
Return a new MetaMap containing just the metadata that was added to this grid with addStatsMetadata.
static std::string gridClassToString(GridClass)
Return the metadata string value for the given class of volumetric data.
virtual void clip(const CoordBBox &)=0
Clip this grid to the given index-space bounding box.
virtual Name type() const =0
Return the name of this grid's type.
virtual void readTopology(std::istream &)=0
Read the grid topology from a stream. This will read only the grid structure, not the actual data buf...
virtual void readBuffers(std::istream &, const CoordBBox &)=0
Read all of this grid's data buffers that intersect the given index-space bounding box.
static void clearRegistry()
Clear the grid type registry.
std::string getCreator() const
Return the user-specified description of this grid's creator.
void writeTransform(std::ostream &os) const
Write out the transform for this grid.
Definition: Grid.h:476
VecType getVectorType() const
Return the type of vector data (invariant, covariant, etc.) stored in this grid, assuming that this g...
static Ptr createGrid(const Name &type)
Create a new grid of the given (registered) type.
SharedPtr< GridBase > Ptr
Definition: Grid.h:80
static void registerGrid(const Name &type, GridFactory)
Register a grid type along with a factory function.
TreeBase::Ptr baseTreePtr()
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:1240
virtual bool empty() const =0
Return true if this grid contains only background voxels.
static const char *const META_FILE_VOXEL_COUNT
Definition: Grid.h:365
virtual void setTree(TreeBase::Ptr)=0
Associate the given tree with this grid, in place of its existing tree.
virtual GridBase::Ptr deepCopyGrid() const =0
Return a new grid whose metadata, transform and tree are deep copies of this grid's.
virtual GridBase::ConstPtr copyGrid() const =0
Return a new grid of the same type as this grid whose metadata is a deep copy of this grid's and whos...
GridBase()
Initialize with an identity linear transform.
Definition: Grid.h:486
bool isInWorldSpace() const
math::Transform::ConstPtr transformPtr() const
Return a pointer to this grid's transform, which might be shared with other grids.
Definition: Grid.h:407
void setIsInWorldSpace(bool)
Specify whether this grid's voxel values are in world space or in local space.
Container class that associates a tree with a transform and metadata.
Definition: Grid.h:577
typename tree::ValueAccessor< const _TreeType, false > ConstUnsafeAccessor
Definition: Grid.h:598
typename _TreeType::Ptr TreePtrType
Definition: Grid.h:583
Grid()
Construct a new grid with background value zero.
Definition: Grid.h:1258
typename _TreeType::ValueOffCIter ValueOffCIter
Definition: Grid.h:591
void evalMinMax(ValueType &minVal, ValueType &maxVal) const
Return the minimum and maximum active values in this grid.
Definition: Grid.h:1572
typename tree::ValueAccessor< _TreeType, false > UnsafeAccessor
Definition: Grid.h:597
bool empty() const override
Return true if this grid contains only inactive background voxels.
Definition: Grid.h:733
typename _TreeType::ValueOffIter ValueOffIter
Definition: Grid.h:590
void topologyIntersection(const Grid< OtherTreeType > &other)
Intersect this grid's set of active values with the active values of the other grid,...
Definition: Grid.h:1552
const ValueType & background() const
Return this grid's background value.
Definition: Grid.h:730
ValueOffCIter cbeginValueOff() const
Return an iterator over all of this grid's inactive values (tile and voxel).
Definition: Grid.h:773
void readBuffers(std::istream &) override
Read all data buffers for this grid.
Definition: Grid.h:1622
static Name gridType()
Return the name of this type of grid.
Definition: Grid.h:719
Index64 memUsage() const override
Definition: Grid.h:889
void writeBuffers(std::ostream &) const override
Write out all data buffers for this grid.
Definition: Grid.h:1675
static bool hasMultiPassIO()
Return true if grids of this type require multiple I/O passes to read and write data buffers.
Definition: Grid.h:1704
ConstPtr copyReplacingTransform(math::Transform::Ptr xform) const
Return a new grid of the same type as this grid whose tree is shared with this grid,...
Definition: Grid.h:1380
Ptr copy()
Return a new grid of the same type as this grid whose metadata and transform are deep copies of this ...
Definition: Grid.h:1398
bool isTreeUnique() const final
Return true if tree is not shared with another grid.
Definition: Grid.h:1465
void pruneGrid(float tolerance=0.0) override
Reduce the memory footprint of this grid by increasing its sparseness.
Definition: Grid.h:1519
void clip(const CoordBBox &) override
Clip this grid to the given index-space bounding box.
Definition: Grid.h:1527
ValueAllCIter cbeginValueAll() const
Return an iterator over all of this grid's values (tile and voxel).
Definition: Grid.h:779
ConstTreePtrType constTreePtr() const
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:902
Coord evalActiveVoxelDim() const override
Return the dimensions of the axis-aligned bounding box of all active voxels.
Definition: Grid.h:1590
ValueOnCIter beginValueOn() const
Return an iterator over all of this grid's active values (tile and voxel).
Definition: Grid.h:765
typename tree::ValueAccessor< _TreeType, true > Accessor
Definition: Grid.h:595
void setTree(TreeBase::Ptr) override
Associate the given tree with this grid, in place of its existing tree.
Definition: Grid.h:1473
Ptr copyWithNewTree() const
Return a new grid of the same type as this grid whose metadata and transform are deep copies of this ...
Definition: Grid.h:1406
GridBase::Ptr copyGridWithNewTree() const override
Return a new grid of the same type as this grid whose metadata and transform are deep copies of this ...
Definition: Grid.h:1454
typename tree::ValueAccessor< const _TreeType, true > ConstAccessor
Definition: Grid.h:596
~Grid() override
Definition: Grid.h:646
Name type() const override
Return the name of this grid's type.
Definition: Grid.h:717
void print(std::ostream &=std::cout, int verboseLevel=1) const override
Output a human-readable description of this grid.
Definition: Grid.h:1712
GridBase::ConstPtr copyGridReplacingMetadata(const MetaMap &meta) const override
Return a new grid of the same type as this grid whose tree and transform is shared with this grid and...
Definition: Grid.h:1431
typename _TreeType::ValueAllCIter ValueAllCIter
Definition: Grid.h:593
Index64 activeVoxelCount() const override
Return the number of active voxels.
Definition: Grid.h:879
ConstAccessor getAccessor() const
Return an accessor that provides random read-only access to this grid's voxels.
Definition: Grid.h:750
GridBase::Ptr deepCopyGrid() const override
Return a new grid whose metadata, transform and tree are deep copies of this grid's.
Definition: Grid.h:711
void fill(const CoordBBox &bbox, const ValueType &value, bool active=true)
Set all voxels within a given axis-aligned box to a constant value.
Definition: Grid.h:1505
ValueOffCIter beginValueOff() const
Return an iterator over all of this grid's inactive values (tile and voxel).
Definition: Grid.h:771
UnsafeAccessor getUnsafeAccessor()
Return an unsafe accessor that provides random read and write access to this grid's voxels.
Definition: Grid.h:748
GridBase::Ptr copyGrid() override
Return a new grid of the same type as this grid whose metadata is a deep copy of this grid's and whos...
Definition: Grid.h:1416
typename _TreeType::ValueType ValueType
Definition: Grid.h:585
typename _TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:584
ValueOnIter beginValueOn()
Return an iterator over all of this grid's active values (tile and voxel).
Definition: Grid.h:763
typename _TreeType::ValueOnCIter ValueOnCIter
Definition: Grid.h:589
SharedPtr< const Grid > ConstPtr
Definition: Grid.h:580
const TreeType & constTree() const
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:919
Grid & operator=(const Grid &)=delete
Disallow assignment, since it wouldn't be obvious whether the copy is deep or shallow.
void readTopology(std::istream &) override
Read the grid topology from a stream. This will read only the grid structure, not the actual data buf...
Definition: Grid.h:1606
static void registerGrid()
Register this grid type along with a factory function.
Definition: Grid.h:981
TreeType & tree()
Return a reference to this grid's tree, which might be shared with other grids.
Definition: Grid.h:917
ValueOnCIter cbeginValueOn() const
Return an iterator over all of this grid's active values (tile and voxel).
Definition: Grid.h:767
ConstPtr copyReplacingMetadataAndTransform(const MetaMap &meta, math::Transform::Ptr xform) const
Return a new grid of the same type as this grid whose tree is shared with this grid and whose transfo...
Definition: Grid.h:1387
static bool isRegistered()
Return true if this grid type is registered.
Definition: Grid.h:979
typename _TreeType::ValueOnIter ValueOnIter
Definition: Grid.h:588
void readNonresidentBuffers() const override
Read all of this grid's data buffers that are not yet resident in memory (because delayed loading is ...
Definition: Grid.h:1667
GridBase::ConstPtr copyGridReplacingMetadataAndTransform(const MetaMap &meta, math::Transform::Ptr xform) const override
Return a new grid of the same type as this grid whose tree is shared with this grid and whose transfo...
Definition: Grid.h:1445
typename _TreeType::BuildType BuildType
Definition: Grid.h:586
ConstAccessor getConstAccessor() const
Return an accessor that provides random read-only access to this grid's voxels.
Definition: Grid.h:752
void denseFill(const CoordBBox &bbox, const ValueType &value, bool active=true)
Set all voxels within a given axis-aligned box to a constant value and ensure that those voxels are a...
Definition: Grid.h:1512
ConstTreePtrType treePtr() const
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:901
const TreeType & tree() const
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:918
void topologyDifference(const Grid< OtherTreeType > &other)
Difference this grid's set of active values with the active values of the other grid,...
Definition: Grid.h:1561
TreeBase::ConstPtr constBaseTreePtr() const override
Return a pointer to this grid's tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:903
GridBase::ConstPtr copyGridReplacingTransform(math::Transform::Ptr xform) const override
Return a new grid of the same type as this grid whose tree is shared with this grid,...
Definition: Grid.h:1438
CoordBBox evalActiveVoxelBoundingBox() const override
Return the axis-aligned bounding box of all active voxels.
Definition: Grid.h:1580
Ptr deepCopy() const
Return a new grid whose metadata, transform and tree are deep copies of this grid's.
Definition: Grid.h:709
ValueOffIter beginValueOff()
Return an iterator over all of this grid's inactive values (tile and voxel).
Definition: Grid.h:769
void sparseFill(const CoordBBox &bbox, const ValueType &value, bool active=true)
Set all voxels within a given axis-aligned box to a constant value.
Definition: Grid.h:1497
void writeTopology(std::ostream &) const override
Write the grid topology to a stream. This will write only the grid structure, not the actual data buf...
Definition: Grid.h:1614
void merge(Grid &other, MergePolicy policy=MERGE_ACTIVE_STATES)
Efficiently merge another grid into this grid using one of several schemes.
Definition: Grid.h:1534
static void unregisterGrid()
Remove this grid type from the registry.
Definition: Grid.h:983
ConstPtr copyReplacingMetadata(const MetaMap &meta) const
Return a new grid of the same type as this grid whose tree and transform is shared with this grid and...
Definition: Grid.h:1370
typename _TreeType::ValueAllIter ValueAllIter
Definition: Grid.h:592
_TreeType TreeType
Definition: Grid.h:582
Name valueType() const override
Return the name of the type of a voxel's value (e.g., "float" or "vec3d").
Definition: Grid.h:722
void clear() override
Empty this grid, so that all voxels become inactive background voxels.
Definition: Grid.h:735
ValueAllCIter beginValueAll() const
Return an iterator over all of this grid's values (tile and voxel).
Definition: Grid.h:777
void newTree() override
Associate a new, empty tree with this grid, in place of its existing tree.
Definition: Grid.h:1486
ConstUnsafeAccessor getConstUnsafeAccessor() const
Return an unsafe accessor that provides random read-only access to this grid's voxels.
Definition: Grid.h:760
void topologyUnion(const Grid< OtherTreeType > &other)
Union this grid's set of active values with the active values of the other grid, whose value type may...
Definition: Grid.h:1543
SharedPtr< Grid > Ptr
Definition: Grid.h:579
Accessor getAccessor()
Return an accessor that provides random read and write access to this grid's voxels.
Definition: Grid.h:740
ValueAllIter beginValueAll()
Return an iterator over all of this grid's values (tile and voxel).
Definition: Grid.h:775
static Ptr create()
Return a new grid with background value zero.
Definition: Grid.h:1323
Container that maps names (strings) to values of arbitrary types.
Definition: MetaMap.h:20
MetadataMap::const_iterator ConstMetaIterator
Definition: MetaMap.h:28
SharedPtr< MetaMap > Ptr
Definition: MetaMap.h:22
Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors.
Definition: openvdb/Types.h:557
Definition: openvdb/Exceptions.h:64
Definition: openvdb/Exceptions.h:65
SharedPtr< StreamMetadata > Ptr
Definition: io.h:33
Axis-aligned bounding box of signed integer coordinates.
Definition: Coord.h:249
Signed (x, y, z) 32-bit integer coordinates.
Definition: Coord.h:26
Definition: Transform.h:40
SharedPtr< const Transform > ConstPtr
Definition: Transform.h:43
SharedPtr< Transform > Ptr
Definition: Transform.h:42
static Transform::Ptr createLinearTransform(double voxelSize=1.0)
Create and return a shared pointer to a new transform.
Base class for typed trees.
Definition: Tree.h:37
SharedPtr< TreeBase > Ptr
Definition: Tree.h:39
SharedPtr< const TreeBase > ConstPtr
Definition: Tree.h:40
Definition: ValueAccessor.h:183
void print(const ast::Node &node, const bool numberStatements=true, std::ostream &os=std::cout, const char *indent=" ")
Writes a descriptive printout of a Node hierarchy into a target stream.
OPENVDB_API SharedPtr< StreamMetadata > getStreamMetadataPtr(std::ios_base &)
Return a shared pointer to an object that stores metadata (file format, compression scheme,...
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
Vec3< double > Vec3d
Definition: Vec3.h:668
Mat3< Type1 > cwiseAdd(const Mat3< Type1 > &m, const Type2 s)
Definition: Mat3.h:820
GridType::Ptr clip(const GridType &grid, const BBoxd &bbox, bool keepInterior=true)
Clip the given grid against a world-space bounding box and return a new grid containing the result.
Definition: Clip.h:348
std::string Name
Definition: Name.h:17
static const Real LEVEL_SET_HALF_WIDTH
Definition: openvdb/Types.h:339
GridPtrVec::const_iterator GridPtrVecCIter
Definition: Grid.h:516
std::vector< GridBase::Ptr > GridPtrVec
Definition: Grid.h:514
SharedPtr< GridPtrSet > GridPtrSetPtr
Definition: Grid.h:527
GridType::Ptr deepCopyTypedGrid(const GridBase &grid)
Return a pointer to a deep copy of the given grid, provided that the grid's concrete type is GridType...
Definition: Grid.h:1055
GridCPtrSet::iterator GridCPtrSetIter
Definition: Grid.h:530
SharedPtr< GridCPtrSet > GridCPtrSetPtr
Definition: Grid.h:532
double Real
Definition: openvdb/Types.h:56
GridClass
Definition: openvdb/Types.h:331
@ GRID_LEVEL_SET
Definition: openvdb/Types.h:333
std::set< GridBase::ConstPtr > GridCPtrSet
Definition: Grid.h:529
std::set< GridBase::Ptr > GridPtrSet
Definition: Grid.h:524
SharedPtr< GridCPtrVec > GridCPtrVecPtr
Definition: Grid.h:522
SharedPtr< T > StaticPtrCast(const SharedPtr< U > &ptr)
Return a new shared pointer that points to the same object as the given pointer after a static_cast.
Definition: openvdb/Types.h:142
GridCPtrVec::iterator GridCPtrVecIter
Definition: Grid.h:520
SharedPtr< GridPtrVec > GridPtrVecPtr
Definition: Grid.h:517
GridCPtrVec::const_iterator GridCPtrVecCIter
Definition: Grid.h:521
GridPtrSet::iterator GridPtrSetIter
Definition: Grid.h:525
GridCPtrSet::const_iterator GridCPtrSetCIter
Definition: Grid.h:531
GridPtrT findGridByName(const std::map< KeyT, GridPtrT > &container, const Name &name)
Return the first grid in the given map whose name is name.
Definition: Grid.h:557
GridPtrSet::const_iterator GridPtrSetCIter
Definition: Grid.h:526
@ OPENVDB_FILE_VERSION_MULTIPASS_IO
Definition: version.h.in:225
GridType::Ptr createLevelSet(Real voxelSize=1.0, Real halfWidth=LEVEL_SET_HALF_WIDTH)
Create a new grid of type GridType classified as a "Level Set", i.e., a narrow-band level set.
Definition: Grid.h:1764
GridType::Ptr createGrid(const typename GridType::ValueType &background)
Create a new grid of type GridType with a given background value.
Definition: Grid.h:1739
uint64_t Index64
Definition: openvdb/Types.h:49
tree::TreeBase TreeBase
Definition: Grid.h:26
GridPtrVec::iterator GridPtrVecIter
Definition: Grid.h:515
std::shared_ptr< T > SharedPtr
Definition: openvdb/Types.h:110
MergePolicy
Definition: openvdb/Types.h:384
@ MERGE_ACTIVE_STATES
Definition: openvdb/Types.h:385
Grid< typename TreePtrType::element_type >::Ptr createGrid(TreePtrType)
Create a new grid of the appropriate type that wraps the given tree.
Definition: Grid.h:1755
VecType
Definition: openvdb/Types.h:361
std::vector< GridBase::ConstPtr > GridCPtrVec
Definition: Grid.h:519
GridType::ConstPtr gridConstPtrCast(const GridBase::ConstPtr &grid)
Cast a generic const grid pointer to a const pointer to a grid of a concrete class.
Definition: Grid.h:1029
GridType::Ptr gridPtrCast(const GridBase::Ptr &grid)
Cast a generic grid pointer to a pointer to a grid of a concrete class.
Definition: Grid.h:1013
openvdb::GridBase Grid
Definition: openvdb_houdini/openvdb_houdini/Utils.h:33
Definition: openvdb/Exceptions.h:13
#define OPENVDB_THROW(exception, message)
Definition: openvdb/Exceptions.h:74
typename std::remove_const< ToType >::type Type
Definition: openvdb/Types.h:317
Predicate functor that returns true for grids that have a specified name.
Definition: Grid.h:537
Name name
Definition: Grid.h:540
GridNamePred(const Name &_name)
Definition: Grid.h:538
bool operator()(const GridBase::ConstPtr &g) const
Definition: Grid.h:539
ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different ...
Definition: Grid.h:607
Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to...
Definition: Grid.h:1170
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1103
typename TreeType::ValueType ValueType
Definition: Grid.h:1112
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1119
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1115
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1114
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1120
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1122
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1106
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1105
static TreeType & tree(TreeType &t)
Definition: Grid.h:1117
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1124
typename GridType::Ptr GridPtrType
Definition: Grid.h:1109
static TreeType & tree(GridType &g)
Definition: Grid.h:1118
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1123
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1111
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1104
_TreeType TreeType
Definition: Grid.h:1102
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1110
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1121
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1113
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1132
typename TreeType::ValueType ValueType
Definition: Grid.h:1141
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1149
static const TreeType & tree(const AccessorType &a)
Definition: Grid.h:1151
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1144
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1143
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1150
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1153
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1135
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1134
static TreeType & tree(TreeType &t)
Definition: Grid.h:1146
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1155
typename GridType::Ptr GridPtrType
Definition: Grid.h:1138
static TreeType & tree(GridType &g)
Definition: Grid.h:1147
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1154
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1140
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1133
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1139
static TreeType & tree(AccessorType &a)
Definition: Grid.h:1148
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1152
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1142
This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type...
Definition: Grid.h:1071
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1073
typename TreeType::ValueType ValueType
Definition: Grid.h:1082
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1089
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1085
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1084
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1090
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1092
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1076
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1075
static TreeType & tree(TreeType &t)
Definition: Grid.h:1087
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1094
typename GridType::Ptr GridPtrType
Definition: Grid.h:1079
static TreeType & tree(GridType &g)
Definition: Grid.h:1088
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1093
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1081
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1074
_TreeType TreeType
Definition: Grid.h:1072
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1080
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1091
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1083
A list of types (not necessarily unique)
Definition: TypeList.h:366
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:116
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:178