OpenVDB  8.0.1
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
103  virtual GridBase::ConstPtr copyGridReplacingMetadata(const MetaMap& meta) const = 0;
110  virtual GridBase::ConstPtr copyGridReplacingTransform(math::Transform::Ptr xform) const = 0;
114  virtual GridBase::ConstPtr copyGridReplacingMetadataAndTransform(const MetaMap& meta,
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(); }
176  virtual TreeBase::ConstPtr constBaseTreePtr() const = 0;
177 
178 #if OPENVDB_ABI_VERSION_NUMBER >= 8
179  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 
293  GridClass getGridClass() const;
297  void setGridClass(GridClass);
299  void clearGridClass();
300 
302 
304  static std::string gridClassToString(GridClass);
306  static std::string gridClassToMenuName(GridClass);
311  static GridClass stringToGridClass(const std::string&);
312 
315 
319  VecType getVectorType() const;
323  void setVectorType(VecType);
325  void clearVectorType();
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 
377  virtual CoordBBox evalActiveVoxelBoundingBox() const = 0;
378 
380  virtual Coord evalActiveVoxelDim() const = 0;
381 
383  virtual Index64 memUsage() const = 0;
384 
389  void addStatsMetadata();
395  MetaMap::Ptr getStatsMetadata() const;
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
489  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
679  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
912 
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()
982  {
983  GridBase::registerGrid(Grid::gridType(), Grid::factory);
985  OPENVDB_LOG_WARN("delayed loading of grids of type " << Grid::gridType()
986  << " might not be threadsafe on this platform");
987  }
988  }
991 
993 
994 
995 private:
996 #if OPENVDB_ABI_VERSION_NUMBER >= 7
997  Grid(TreePtrType tree, const MetaMap& meta, math::Transform::Ptr xform);
999 #endif
1000 
1002  static GridBase::Ptr factory() { return Grid::create(); }
1003 
1004  TreePtrType mTree;
1005 }; // class Grid
1006 
1007 
1009 
1010 
1018 template<typename GridType>
1019 inline typename GridType::Ptr
1021 {
1022  return GridBase::grid<GridType>(grid);
1023 }
1024 
1025 
1034 template<typename GridType>
1035 inline typename GridType::ConstPtr
1037 {
1038  return GridBase::constGrid<GridType>(grid);
1039 }
1040 
1041 
1043 
1044 
1051 template<typename GridType>
1052 inline typename GridType::Ptr
1054 {
1055  if (!grid || !grid->isType<GridType>()) return typename GridType::Ptr();
1056  return gridPtrCast<GridType>(grid->deepCopyGrid());
1057 }
1058 
1059 
1060 template<typename GridType>
1061 inline typename GridType::Ptr
1063 {
1064  if (!grid.isType<GridType>()) return typename GridType::Ptr();
1065  return gridPtrCast<GridType>(grid.deepCopyGrid());
1066 }
1068 
1069 
1071 
1072 
1074 template<typename _TreeType>
1078 {
1079  using TreeType = _TreeType;
1080  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1081  using TreePtrType = typename TreeType::Ptr;
1082  using ConstTreePtrType = typename TreeType::ConstPtr;
1083  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1086  using GridPtrType = typename GridType::Ptr;
1089  using ValueType = typename TreeType::ValueType;
1093 
1094  static TreeType& tree(TreeType& t) { return t; }
1095  static TreeType& tree(GridType& g) { return g.tree(); }
1096  static const TreeType& tree(const TreeType& t) { return t; }
1097  static const TreeType& tree(const GridType& g) { return g.tree(); }
1098  static const TreeType& constTree(TreeType& t) { return t; }
1099  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1100  static const TreeType& constTree(const TreeType& t) { return t; }
1101  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1102 };
1103 
1104 
1106 template<typename _TreeType>
1107 struct TreeAdapter<Grid<_TreeType> >
1108 {
1109  using TreeType = _TreeType;
1110  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1111  using TreePtrType = typename TreeType::Ptr;
1112  using ConstTreePtrType = typename TreeType::ConstPtr;
1113  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1116  using GridPtrType = typename GridType::Ptr;
1119  using ValueType = typename TreeType::ValueType;
1123 
1124  static TreeType& tree(TreeType& t) { return t; }
1125  static TreeType& tree(GridType& g) { return g.tree(); }
1126  static const TreeType& tree(const TreeType& t) { return t; }
1127  static const TreeType& tree(const GridType& g) { return g.tree(); }
1128  static const TreeType& constTree(TreeType& t) { return t; }
1129  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1130  static const TreeType& constTree(const TreeType& t) { return t; }
1131  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1132 };
1133 
1135 template<typename _TreeType>
1136 struct TreeAdapter<tree::ValueAccessor<_TreeType> >
1137 {
1138  using TreeType = _TreeType;
1139  using NonConstTreeType = typename std::remove_const<TreeType>::type;
1140  using TreePtrType = typename TreeType::Ptr;
1141  using ConstTreePtrType = typename TreeType::ConstPtr;
1142  using NonConstTreePtrType = typename NonConstTreeType::Ptr;
1145  using GridPtrType = typename GridType::Ptr;
1148  using ValueType = typename TreeType::ValueType;
1152 
1153  static TreeType& tree(TreeType& t) { return t; }
1154  static TreeType& tree(GridType& g) { return g.tree(); }
1155  static TreeType& tree(AccessorType& a) { return a.tree(); }
1156  static const TreeType& tree(const TreeType& t) { return t; }
1157  static const TreeType& tree(const GridType& g) { return g.tree(); }
1158  static const TreeType& tree(const AccessorType& a) { return a.tree(); }
1159  static const TreeType& constTree(TreeType& t) { return t; }
1160  static const TreeType& constTree(GridType& g) { return g.constTree(); }
1161  static const TreeType& constTree(const TreeType& t) { return t; }
1162  static const TreeType& constTree(const GridType& g) { return g.constTree(); }
1163 };
1164 
1166 
1167 
1169 
1170 
1176 template<typename LeafNodeType>
1178  static const bool value = std::is_base_of<io::MultiPass, LeafNodeType>::value;
1179 };
1180 
1181 // Partial specialization for Tree types
1182 template<typename RootNodeType>
1183 struct HasMultiPassIO<tree::Tree<RootNodeType>> {
1184  // A tree is multi-pass if its (root node's) leaf node type is multi-pass.
1186 };
1187 
1188 // Partial specialization for Grid types
1189 template<typename TreeType>
1190 struct HasMultiPassIO<Grid<TreeType>> {
1191  // A grid is multi-pass if its tree's leaf node type is multi-pass.
1193 };
1194 
1195 
1197 
1198 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1200  : MetaMap(meta)
1201  , mTransform(xform)
1202 {
1203  if (!xform) OPENVDB_THROW(ValueError, "Transform pointer is null");
1204 }
1205 #endif
1206 
1207 template<typename GridType>
1208 inline typename GridType::Ptr
1210 {
1211  // The string comparison on type names is slower than a dynamic pointer cast, but
1212  // it is safer when pointers cross DSO boundaries, as they do in many Houdini nodes.
1213  if (grid && grid->type() == GridType::gridType()) {
1214  return StaticPtrCast<GridType>(grid);
1215  }
1216  return typename GridType::Ptr();
1217 }
1218 
1219 
1220 template<typename GridType>
1221 inline typename GridType::ConstPtr
1223 {
1224  return ConstPtrCast<const GridType>(
1225  GridBase::grid<GridType>(ConstPtrCast<GridBase>(grid)));
1226 }
1227 
1228 
1229 template<typename GridType>
1230 inline typename GridType::ConstPtr
1232 {
1233  return ConstPtrCast<const GridType>(GridBase::grid<GridType>(grid));
1234 }
1235 
1236 
1237 template<typename GridType>
1238 inline typename GridType::ConstPtr
1240 {
1241  return ConstPtrCast<const GridType>(
1242  GridBase::grid<GridType>(ConstPtrCast<GridBase>(grid)));
1243 }
1244 
1245 
1246 inline TreeBase::Ptr
1248 {
1249  return ConstPtrCast<TreeBase>(this->constBaseTreePtr());
1250 }
1251 
1252 
1253 inline void
1255 {
1256  if (!xform) OPENVDB_THROW(ValueError, "Transform pointer is null");
1257  mTransform = xform;
1258 }
1259 
1260 
1262 
1263 
1264 template<typename TreeT>
1265 inline Grid<TreeT>::Grid(): mTree(new TreeType)
1266 {
1267 }
1268 
1269 
1270 template<typename TreeT>
1271 inline Grid<TreeT>::Grid(const ValueType &background): mTree(new TreeType(background))
1272 {
1273 }
1274 
1275 
1276 template<typename TreeT>
1277 inline Grid<TreeT>::Grid(TreePtrType tree): mTree(tree)
1278 {
1279  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1280 }
1281 
1282 
1283 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1284 template<typename TreeT>
1285 inline Grid<TreeT>::Grid(TreePtrType tree, const MetaMap& meta, math::Transform::Ptr xform):
1286  GridBase(meta, xform),
1287  mTree(tree)
1288 {
1289  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1290 }
1291 #endif
1292 
1293 
1294 template<typename TreeT>
1295 inline Grid<TreeT>::Grid(const Grid& other):
1296  GridBase(other),
1297  mTree(StaticPtrCast<TreeType>(other.mTree->copy()))
1298 {
1299 }
1300 
1301 
1302 template<typename TreeT>
1303 template<typename OtherTreeType>
1305  GridBase(other),
1306  mTree(new TreeType(other.constTree()))
1307 {
1308 }
1309 
1310 
1311 template<typename TreeT>
1313  GridBase(other),
1314  mTree(other.mTree)
1315 {
1316 }
1317 
1318 
1319 template<typename TreeT>
1320 inline Grid<TreeT>::Grid(const GridBase& other):
1321  GridBase(other),
1322  mTree(new TreeType)
1323 {
1324 }
1325 
1326 
1327 //static
1328 template<typename TreeT>
1329 inline typename Grid<TreeT>::Ptr
1331 {
1332  return Grid::create(zeroVal<ValueType>());
1333 }
1334 
1335 
1336 //static
1337 template<typename TreeT>
1338 inline typename Grid<TreeT>::Ptr
1340 {
1341  return Ptr(new Grid(background));
1342 }
1343 
1344 
1345 //static
1346 template<typename TreeT>
1347 inline typename Grid<TreeT>::Ptr
1349 {
1350  return Ptr(new Grid(tree));
1351 }
1352 
1353 
1354 //static
1355 template<typename TreeT>
1356 inline typename Grid<TreeT>::Ptr
1358 {
1359  return Ptr(new Grid(other));
1360 }
1361 
1362 
1364 
1365 
1366 template<typename TreeT>
1367 inline typename Grid<TreeT>::ConstPtr
1369 {
1370  return ConstPtr{new Grid{*const_cast<Grid*>(this), ShallowCopy{}}};
1371 }
1372 
1373 
1374 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1375 template<typename TreeT>
1376 inline typename Grid<TreeT>::ConstPtr
1378 {
1379  math::Transform::Ptr transformPtr = ConstPtrCast<math::Transform>(
1380  this->constTransformPtr());
1381  TreePtrType treePtr = ConstPtrCast<TreeT>(this->constTreePtr());
1382  return ConstPtr{new Grid<TreeT>{treePtr, meta, transformPtr}};
1383 }
1384 
1385 template<typename TreeT>
1386 inline typename Grid<TreeT>::ConstPtr
1388 {
1389  return this->copyReplacingMetadataAndTransform(*this, xform);
1390 }
1391 
1392 template<typename TreeT>
1393 inline typename Grid<TreeT>::ConstPtr
1395  math::Transform::Ptr xform) const
1396 {
1397  TreePtrType treePtr = ConstPtrCast<TreeT>(this->constTreePtr());
1398  return ConstPtr{new Grid<TreeT>{treePtr, meta, xform}};
1399 }
1400 #endif
1401 
1402 
1403 template<typename TreeT>
1404 inline typename Grid<TreeT>::Ptr
1406 {
1407  return Ptr{new Grid{*this, ShallowCopy{}}};
1408 }
1409 
1410 
1411 template<typename TreeT>
1412 inline typename Grid<TreeT>::Ptr
1414 {
1415  Ptr result{new Grid{*const_cast<Grid*>(this), ShallowCopy{}}};
1416  result->newTree();
1417  return result;
1418 }
1419 
1420 
1421 template<typename TreeT>
1422 inline GridBase::Ptr
1424 {
1425  return this->copy();
1426 }
1427 
1428 template<typename TreeT>
1429 inline GridBase::ConstPtr
1431 {
1432  return this->copy();
1433 }
1434 
1435 #if OPENVDB_ABI_VERSION_NUMBER >= 7
1436 template<typename TreeT>
1437 inline GridBase::ConstPtr
1439 {
1440  return this->copyReplacingMetadata(meta);
1441 }
1442 
1443 template<typename TreeT>
1444 inline GridBase::ConstPtr
1446 {
1447  return this->copyReplacingTransform(xform);
1448 }
1449 
1450 template<typename TreeT>
1451 inline GridBase::ConstPtr
1453  math::Transform::Ptr xform) const
1454 {
1455  return this->copyReplacingMetadataAndTransform(meta, xform);
1456 }
1457 #endif
1458 
1459 template<typename TreeT>
1460 inline GridBase::Ptr
1462 {
1463  return this->copyWithNewTree();
1464 }
1465 
1466 
1468 
1469 
1470 template<typename TreeT>
1471 inline bool
1473 {
1474  return mTree.use_count() == 1;
1475 }
1476 
1477 
1478 template<typename TreeT>
1479 inline void
1481 {
1482  if (!tree) OPENVDB_THROW(ValueError, "Tree pointer is null");
1483  if (tree->type() != TreeType::treeType()) {
1484  OPENVDB_THROW(TypeError, "Cannot assign a tree of type "
1485  + tree->type() + " to a grid of type " + this->type());
1486  }
1487  mTree = StaticPtrCast<TreeType>(tree);
1488 }
1489 
1490 
1491 template<typename TreeT>
1492 inline void
1494 {
1495  mTree.reset(new TreeType(this->background()));
1496 }
1497 
1498 
1500 
1501 
1502 template<typename TreeT>
1503 inline void
1504 Grid<TreeT>::sparseFill(const CoordBBox& bbox, const ValueType& value, bool active)
1505 {
1506  tree().sparseFill(bbox, value, active);
1507 }
1508 
1509 
1510 template<typename TreeT>
1511 inline void
1512 Grid<TreeT>::fill(const CoordBBox& bbox, const ValueType& value, bool active)
1513 {
1514  this->sparseFill(bbox, value, active);
1515 }
1516 
1517 template<typename TreeT>
1518 inline void
1519 Grid<TreeT>::denseFill(const CoordBBox& bbox, const ValueType& value, bool active)
1520 {
1521  tree().denseFill(bbox, value, active);
1522 }
1523 
1524 template<typename TreeT>
1525 inline void
1526 Grid<TreeT>::pruneGrid(float tolerance)
1527 {
1528  const auto value = math::cwiseAdd(zeroVal<ValueType>(), tolerance);
1529  this->tree().prune(static_cast<ValueType>(value));
1530 }
1531 
1532 template<typename TreeT>
1533 inline void
1534 Grid<TreeT>::clip(const CoordBBox& bbox)
1535 {
1536  tree().clip(bbox);
1537 }
1538 
1539 template<typename TreeT>
1540 inline void
1542 {
1543  tree().merge(other.tree(), policy);
1544 }
1545 
1546 
1547 template<typename TreeT>
1548 template<typename OtherTreeType>
1549 inline void
1551 {
1552  tree().topologyUnion(other.tree());
1553 }
1554 
1555 
1556 template<typename TreeT>
1557 template<typename OtherTreeType>
1558 inline void
1560 {
1561  tree().topologyIntersection(other.tree());
1562 }
1563 
1564 
1565 template<typename TreeT>
1566 template<typename OtherTreeType>
1567 inline void
1569 {
1570  tree().topologyDifference(other.tree());
1571 }
1572 
1573 
1575 
1576 
1577 template<typename TreeT>
1578 inline void
1580 {
1581  tree().evalMinMax(minVal, maxVal);
1582 }
1583 
1584 
1585 template<typename TreeT>
1586 inline CoordBBox
1588 {
1589  CoordBBox bbox;
1590  tree().evalActiveVoxelBoundingBox(bbox);
1591  return bbox;
1592 }
1593 
1594 
1595 template<typename TreeT>
1596 inline Coord
1598 {
1599  Coord dim;
1600  const bool nonempty = tree().evalActiveVoxelDim(dim);
1601  return (nonempty ? dim : Coord());
1602 }
1603 
1604 
1606 
1607 
1610 
1611 template<typename TreeT>
1612 inline void
1613 Grid<TreeT>::readTopology(std::istream& is)
1614 {
1615  tree().readTopology(is, saveFloatAsHalf());
1616 }
1617 
1618 
1619 template<typename TreeT>
1620 inline void
1621 Grid<TreeT>::writeTopology(std::ostream& os) const
1622 {
1623  tree().writeTopology(os, saveFloatAsHalf());
1624 }
1625 
1626 
1627 template<typename TreeT>
1628 inline void
1629 Grid<TreeT>::readBuffers(std::istream& is)
1630 {
1632  tree().readBuffers(is, saveFloatAsHalf());
1633  } else {
1634  uint16_t numPasses = 1;
1635  is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
1637  assert(bool(meta));
1638  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1639  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1640  meta->setPass(pass);
1641  tree().readBuffers(is, saveFloatAsHalf());
1642  }
1643  }
1644 }
1645 
1646 
1649 template<typename TreeT>
1650 inline void
1651 Grid<TreeT>::readBuffers(std::istream& is, const CoordBBox& bbox)
1652 {
1654  tree().readBuffers(is, bbox, saveFloatAsHalf());
1655  } else {
1656  uint16_t numPasses = 1;
1657  is.read(reinterpret_cast<char*>(&numPasses), sizeof(uint16_t));
1659  assert(bool(meta));
1660  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1661  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1662  meta->setPass(pass);
1663  tree().readBuffers(is, saveFloatAsHalf());
1664  }
1665  // Cannot clip inside readBuffers() when using multiple passes,
1666  // so instead clip afterwards.
1667  tree().clip(bbox);
1668  }
1669 }
1670 
1671 
1672 template<typename TreeT>
1673 inline void
1675 {
1676  tree().readNonresidentBuffers();
1677 }
1678 
1679 
1680 template<typename TreeT>
1681 inline void
1682 Grid<TreeT>::writeBuffers(std::ostream& os) const
1683 {
1684  if (!hasMultiPassIO()) {
1685  tree().writeBuffers(os, saveFloatAsHalf());
1686  } else {
1687  // Determine how many leaf buffer passes are required for this grid
1689  assert(bool(meta));
1690  uint16_t numPasses = 1;
1691  meta->setCountingPasses(true);
1692  meta->setPass(0);
1693  tree().writeBuffers(os, saveFloatAsHalf());
1694  numPasses = static_cast<uint16_t>(meta->pass());
1695  os.write(reinterpret_cast<const char*>(&numPasses), sizeof(uint16_t));
1696  meta->setCountingPasses(false);
1697 
1698  // Save out the data blocks of the grid.
1699  for (uint16_t passIndex = 0; passIndex < numPasses; ++passIndex) {
1700  uint32_t pass = (uint32_t(numPasses) << 16) | uint32_t(passIndex);
1701  meta->setPass(pass);
1702  tree().writeBuffers(os, saveFloatAsHalf());
1703  }
1704  }
1705 }
1706 
1707 
1708 //static
1709 template<typename TreeT>
1710 inline bool
1712 {
1714 }
1715 
1716 
1717 template<typename TreeT>
1718 inline void
1719 Grid<TreeT>::print(std::ostream& os, int verboseLevel) const
1720 {
1721  tree().print(os, verboseLevel);
1722 
1723  if (metaCount() > 0) {
1724  os << "Additional metadata:" << std::endl;
1725  for (ConstMetaIterator it = beginMeta(), end = endMeta(); it != end; ++it) {
1726  os << " " << it->first;
1727  if (it->second) {
1728  const std::string value = it->second->str();
1729  if (!value.empty()) os << ": " << value;
1730  }
1731  os << "\n";
1732  }
1733  }
1734 
1735  os << "Transform:" << std::endl;
1736  transform().print(os, /*indent=*/" ");
1737  os << std::endl;
1738 }
1739 
1740 
1742 
1743 
1744 template<typename GridType>
1745 inline typename GridType::Ptr
1746 createGrid(const typename GridType::ValueType& background)
1747 {
1748  return GridType::create(background);
1749 }
1750 
1751 
1752 template<typename GridType>
1753 inline typename GridType::Ptr
1755 {
1756  return GridType::create();
1757 }
1758 
1759 
1760 template<typename TreePtrType>
1763 {
1764  using TreeType = typename TreePtrType::element_type;
1765  return Grid<TreeType>::create(tree);
1766 }
1767 
1768 
1769 template<typename GridType>
1770 typename GridType::Ptr
1772 {
1773  using ValueType = typename GridType::ValueType;
1774 
1775  // GridType::ValueType is required to be a floating-point scalar.
1776  static_assert(std::is_floating_point<ValueType>::value,
1777  "level-set grids must be floating-point-valued");
1778 
1779  typename GridType::Ptr grid = GridType::create(
1780  /*background=*/static_cast<ValueType>(voxelSize * halfWidth));
1781  grid->setTransform(math::Transform::createLinearTransform(voxelSize));
1782  grid->setGridClass(GRID_LEVEL_SET);
1783  return grid;
1784 }
1785 
1786 
1788 
1789 
1790 namespace internal {
1791 
1793 template<typename OpT, typename GridBaseT, typename T, typename ...Ts>
1794 struct GridApplyImpl { static bool apply(GridBaseT&, OpT&) { return false; } };
1795 
1796 // Partial specialization for (nonempty) TypeLists
1798 template<typename OpT, typename GridBaseT, typename GridT, typename ...GridTs>
1799 struct GridApplyImpl<OpT, GridBaseT, TypeList<GridT, GridTs...>>
1800 {
1801  static bool apply(GridBaseT& grid, OpT& op)
1802  {
1803  if (grid.template isType<GridT>()) {
1804  op(static_cast<typename CopyConstness<GridBaseT, GridT>::Type&>(grid));
1805  return true;
1806  }
1807  return GridApplyImpl<OpT, GridBaseT, TypeList<GridTs...>>::apply(grid, op);
1808  }
1809 };
1810 
1811 } // namespace internal
1812 
1813 
1814 template<typename GridTypeListT, typename OpT>
1815 inline bool
1816 GridBase::apply(OpT& op) const
1817 {
1818  return internal::GridApplyImpl<OpT, const GridBase, GridTypeListT>::apply(*this, op);
1819 }
1820 
1821 template<typename GridTypeListT, typename OpT>
1822 inline bool
1824 {
1825  return internal::GridApplyImpl<OpT, GridBase, GridTypeListT>::apply(*this, op);
1826 }
1827 
1828 template<typename GridTypeListT, typename OpT>
1829 inline bool
1830 GridBase::apply(const OpT& op) const
1831 {
1832  return internal::GridApplyImpl<const OpT, const GridBase, GridTypeListT>::apply(*this, op);
1833 }
1834 
1835 template<typename GridTypeListT, typename OpT>
1836 inline bool
1837 GridBase::apply(const OpT& op)
1838 {
1839  return internal::GridApplyImpl<const OpT, GridBase, GridTypeListT>::apply(*this, op);
1840 }
1841 
1842 } // namespace OPENVDB_VERSION_NAME
1843 } // namespace openvdb
1844 
1845 #endif // OPENVDB_GRID_HAS_BEEN_INCLUDED
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:1413
math::Transform::Ptr transformPtr()
Return a pointer to this grid&#39;s transform, which might be shared with other grids.
Definition: Grid.h:406
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1121
static GridType::ConstPtr constGrid(const GridBase::Ptr &)
Return the result of downcasting a GridBase pointer to a Grid pointer of the specified type...
Definition: Grid.h:1231
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1083
static bool isRegistered()
Return true if this grid type is registered.
Definition: Grid.h:979
const math::Transform & constTransform() const
Return a reference to this grid&#39;s transform, which might be shared with other grids.
Definition: Grid.h:417
typename _TreeType::ValueOffIter ValueOffIter
Definition: Grid.h:590
static const char *const META_GRID_CREATOR
Definition: Grid.h:356
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1149
#define OPENVDB_API
Helper macros for defining library symbol visibility.
Definition: Platform.h:208
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:1452
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
Index64 memUsage() const override
Definition: Grid.h:889
static const char *const META_FILE_COMPRESSION
Definition: Grid.h:363
Vec3d indexToWorld(const Vec3d &xyz) const
Apply this grid&#39;s transform to the given coordinates.
Definition: Grid.h:441
Index64 activeVoxelCount() const override
Return the number of active voxels.
Definition: Grid.h:879
std::set< GridBase::Ptr > GridPtrSet
Definition: Grid.h:524
void writeBuffers(std::ostream &) const override
Write out all data buffers for this grid.
Definition: Grid.h:1682
void clip(const CoordBBox &) override
Clip this grid to the given index-space bounding box.
Definition: Grid.h:1534
double Real
Definition: openvdb/Types.h:38
SharedPtr< Grid > Ptr
Definition: Grid.h:579
UnsafeAccessor getUnsafeAccessor()
Return an unsafe accessor that provides random read and write access to this grid&#39;s voxels...
Definition: Grid.h:748
void topologyUnion(const Grid< OtherTreeType > &other)
Union this grid&#39;s set of active values with the active values of the other grid, whose value type may...
Definition: Grid.h:1550
OPENVDB_API uint32_t getGridClass(std::ios_base &)
Return the class (GRID_LEVEL_SET, GRID_UNKNOWN, etc.) of the grid currently being read from or writte...
Ptr deepCopy() const
Return a new grid whose metadata, transform and tree are deep copies of this grid&#39;s.
Definition: Grid.h:709
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1160
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1088
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:1020
#define OPENVDB_THROW(exception, message)
Definition: openvdb/Exceptions.h:74
std::vector< GridBase::ConstPtr > GridCPtrVec
Definition: Grid.h:519
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:1377
SharedPtr< GridCPtrSet > GridCPtrSetPtr
Definition: Grid.h:532
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1161
GridPtrSet::iterator GridPtrSetIter
Definition: Grid.h:525
Abstract base class for typed grids.
Definition: Grid.h:77
typename _TreeType::ValueOnCIter ValueOnCIter
Definition: Grid.h:589
GridCPtrSet::iterator GridCPtrSetIter
Definition: Grid.h:530
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1150
static TreeType & tree(TreeType &t)
Definition: Grid.h:1124
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1159
Grid()
Construct a new grid with background value zero.
Definition: Grid.h:1265
_TreeType TreeType
Definition: Grid.h:1079
This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type...
Definition: Grid.h:1077
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1120
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:1771
Definition: openvdb/Exceptions.h:64
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1112
GridCPtrVec::const_iterator GridCPtrVecCIter
Definition: Grid.h:521
Definition: openvdb/Types.h:315
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1140
uint64_t Index64
Definition: openvdb/Types.h:31
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1129
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:1621
Container class that associates a tree with a transform and metadata.
Definition: Grid.h:28
void print(std::ostream &os=std::cout, const std::string &indent="") const
Print a description of this transform.
static void registerGrid(const Name &type, GridFactory)
Register a grid type along with a factory function.
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1127
const TreeType & constTree() const
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:919
CoordBBox evalActiveVoxelBoundingBox() const override
Return the axis-aligned bounding box of all active voxels.
Definition: Grid.h:1587
void pruneGrid(float tolerance=0.0) override
Reduce the memory footprint of this grid by increasing its sparseness.
Definition: Grid.h:1526
Coord evalActiveVoxelDim() const override
Return the dimensions of the axis-aligned bounding box of all active voxels.
Definition: Grid.h:1597
TreePtrType treePtr()
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:900
void readTransform(std::istream &is)
Read in the transform for this grid.
Definition: Grid.h:474
TreeBase::Ptr baseTreePtr()
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:1247
typename tree::ValueAccessor< TreeType > AccessorType
Definition: Grid.h:1090
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:1209
typename _TreeType::ValueOffCIter ValueOffCIter
Definition: Grid.h:591
Vec3< double > Vec3d
Definition: Vec3.h:668
tree::TreeBase TreeBase
Definition: Grid.h:26
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:1512
~Grid() override
Definition: Grid.h:646
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1092
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1100
VecType
Definition: openvdb/Types.h:343
GridPtrSet::const_iterator GridPtrSetCIter
Definition: Grid.h:526
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1126
typename tree::ValueAccessor< _TreeType, false > UnsafeAccessor
Definition: Grid.h:597
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:1405
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1142
static Ptr create()
Return a new grid with background value zero.
Definition: Grid.h:1330
static const TreeType & tree(const AccessorType &a)
Definition: Grid.h:1158
static const Real LEVEL_SET_HALF_WIDTH
Definition: openvdb/Types.h:321
Name type() const override
Return the name of this grid&#39;s type.
Definition: Grid.h:717
ValueOnIter beginValueOn()
Return an iterator over all of this grid&#39;s active values (tile and voxel).
Definition: Grid.h:763
Definition: openvdb/Types.h:367
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1128
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1157
Vec3d worldToIndex(const Vec3d &xyz) const
Apply the inverse of this grid&#39;s transform to the given coordinates.
Definition: Grid.h:445
typename _TreeType::ValueOnIter ValueOnIter
Definition: Grid.h:588
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1111
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1162
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.
typename GridType::Ptr GridPtrType
Definition: Grid.h:1145
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1141
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:1504
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1110
static Transform::Ptr createLinearTransform(double voxelSize=1.0)
Create and return a shared pointer to a new transform.
static const TreeType & constTree(GridType &g)
Definition: Grid.h:1099
GridBase::Ptr copyGrid() override
Return a new grid of the same type as this grid whose metadata is a deep copy of this grid&#39;s and whos...
Definition: Grid.h:1423
SharedPtr< TreeBase > Ptr
Definition: Tree.h:38
TreeBase::ConstPtr constBaseTreePtr() const override
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:903
const TreeBase & constBaseTree() const
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:197
Name valueType() const override
Return the name of the type of a voxel&#39;s value (e.g., "float" or "vec3d").
Definition: Grid.h:722
static const char *const META_FILE_VOXEL_COUNT
Definition: Grid.h:365
SharedPtr< Transform > Ptr
Definition: Transform.h:42
const TreeBase & baseTree() const
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:192
typename TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:1082
Container that maps names (strings) to values of arbitrary types.
Definition: MetaMap.h:19
static TreeType & tree(GridType &g)
Definition: Grid.h:1125
Mat3< Type1 > cwiseAdd(const Mat3< Type1 > &m, const Type2 s)
Definition: Mat3.h:820
bool saveFloatAsHalf() const
Return true if this grid should be written out with floating-point voxel values (including components...
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1147
MetaIterator beginMeta()
Definition: MetaMap.h:84
void writeTransform(std::ostream &os) const
Write out the transform for this grid.
Definition: Grid.h:476
_TreeType TreeType
Definition: Grid.h:582
typename TreeType::ValueType ValueType
Definition: Grid.h:1089
ValueAllCIter beginValueAll() const
Return an iterator over all of this grid&#39;s values (tile and voxel).
Definition: Grid.h:777
TreeType & tree()
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:917
openvdb::GridBase Grid
Definition: openvdb_houdini/openvdb_houdini/Utils.h:33
typename tree::ValueAccessor< const TreeType > ConstAccessorType
Definition: Grid.h:1091
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h:101
static const char *const META_FILE_DELAYED_LOAD
Definition: Grid.h:366
ValueOnCIter beginValueOn() const
Return an iterator over all of this grid&#39;s active values (tile and voxel).
Definition: Grid.h:765
static void unregisterGrid(const Name &type)
Remove a grid type from the registry.
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
Metafunction that specifies whether a given leaf node, tree, or grid type requires multiple passes to...
Definition: Grid.h:1177
const ValueType & background() const
Return this grid&#39;s background value.
Definition: Grid.h:730
GridCPtrSet::const_iterator GridCPtrSetCIter
Definition: Grid.h:531
GridPtrVec::iterator GridPtrVecIter
Definition: Grid.h:515
math::Transform::ConstPtr transformPtr() const
Return a pointer to this grid&#39;s transform, which might be shared with other grids.
Definition: Grid.h:407
Definition: ValueAccessor.h:182
bool empty() const override
Return true if this grid contains only inactive background voxels.
Definition: Grid.h:733
GridClass
Definition: openvdb/Types.h:313
static const char *const META_FILE_BBOX_MAX
Definition: Grid.h:362
ConstTreePtrType constTreePtr() const
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:902
SharedPtr< const TreeBase > ConstPtr
Definition: Tree.h:39
typename TreeType::ValueType ValueType
Definition: Grid.h:1148
static TreeType & tree(AccessorType &a)
Definition: Grid.h:1155
void setTransform(math::Transform::Ptr)
Associate the given transform with this grid, in place of its existing transform. ...
Definition: Grid.h:1254
SharedPtr< GridCPtrVec > GridCPtrVecPtr
Definition: Grid.h:522
GridBase()
Initialize with an identity linear transform.
Definition: Grid.h:486
SharedPtr< const Transform > ConstPtr
Definition: Transform.h:43
ValueOnCIter cbeginValueOn() const
Return an iterator over all of this grid&#39;s active values (tile and voxel).
Definition: Grid.h:767
size_t metaCount() const
Definition: MetaMap.h:91
ConstAccessor getConstAccessor() const
Return an accessor that provides random read-only access to this grid&#39;s voxels.
Definition: Grid.h:752
GridBase::Ptr deepCopyGrid() const override
Return a new grid whose metadata, transform and tree are deep copies of this grid&#39;s.
Definition: Grid.h:711
void setTree(TreeBase::Ptr) override
Associate the given tree with this grid, in place of its existing tree.
Definition: Grid.h:1480
typename _TreeType::ConstPtr ConstTreePtrType
Definition: Grid.h:584
void clear() override
Empty this grid, so that all voxels become inactive background voxels.
Definition: Grid.h:735
static Ptr createGrid(const Name &type)
Create a new grid of the given (registered) type.
ConstTreePtrType treePtr() const
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:901
typename _TreeType::ValueAllIter ValueAllIter
Definition: Grid.h:592
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:1438
void newTree() override
Associate a new, empty tree with this grid, in place of its existing tree.
Definition: Grid.h:1493
Definition: openvdb/Exceptions.h:13
static const TreeType & constTree(TreeType &t)
Definition: Grid.h:1098
void topologyIntersection(const Grid< OtherTreeType > &other)
Intersect this grid&#39;s set of active values with the active values of the other grid, whose value type may be different.
Definition: Grid.h:1559
typename tree::ValueAccessor< _TreeType, true > Accessor
Definition: Grid.h:595
Predicate functor that returns true for grids that have a specified name.
Definition: Grid.h:536
Accessor getAccessor()
Return an accessor that provides random read and write access to this grid&#39;s voxels.
Definition: Grid.h:740
Base class for typed trees.
Definition: Tree.h:35
static const char *const META_SAVE_HALF_FLOAT
Definition: Grid.h:358
GridPtrVec::const_iterator GridPtrVecCIter
Definition: Grid.h:516
SharedPtr< const Grid > ConstPtr
Definition: Grid.h:580
OPENVDB_API SharedPtr< StreamMetadata > getStreamMetadataPtr(std::ios_base &)
Return a shared pointer to an object that stores metadata (file format, compression scheme...
virtual TreeBase::ConstPtr constBaseTreePtr() const =0
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
ValueOffCIter cbeginValueOff() const
Return an iterator over all of this grid&#39;s inactive values (tile and voxel).
Definition: Grid.h:773
std::set< GridBase::ConstPtr > GridCPtrSet
Definition: Grid.h:529
void topologyDifference(const Grid< OtherTreeType > &other)
Difference this grid&#39;s set of active values with the active values of the other grid, whose value type may be different.
Definition: Grid.h:1568
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&#39;s transform, which might be shared with other grids.
Definition: Grid.h:408
void evalMinMax(ValueType &minVal, ValueType &maxVal) const
Return the minimum and maximum active values in this grid.
Definition: Grid.h:1579
const math::Transform & transform() const
Return a reference to this grid&#39;s transform, which might be shared with other grids.
Definition: Grid.h:416
Vec3d voxelSize(const Vec3d &xyz) const
Return the size of this grid&#39;s voxel at position (x, y, z).
Definition: Grid.h:437
bool isTreeUnique() const final
Return true if tree is not shared with another grid.
Definition: Grid.h:1472
bool operator()(const GridBase::ConstPtr &g) const
Definition: Grid.h:539
typename std::remove_const< ToType >::type Type
Definition: openvdb/Types.h:299
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
ConstAccessor getAccessor() const
Return an accessor that provides random read-only access to this grid&#39;s voxels.
Definition: Grid.h:750
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:1816
static const char *const META_GRID_NAME
Definition: Grid.h:357
Grid< typename TreePtrType::element_type >::Ptr createGrid(TreePtrType)
Create a new grid of the appropriate type that wraps the given tree.
Definition: Grid.h:1762
ValueAllIter beginValueAll()
Return an iterator over all of this grid&#39;s values (tile and voxel).
Definition: Grid.h:775
SharedPtr< const GridBase > ConstPtr
Definition: Grid.h:81
GridNamePred(const Name &_name)
Definition: Grid.h:538
static TreeType & tree(GridType &g)
Definition: Grid.h:1154
typename _TreeType::ValueType ValueType
Definition: Grid.h:585
typename GridType::Ptr GridPtrType
Definition: Grid.h:1086
Name name
Definition: Grid.h:540
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:1613
SharedPtr< GridBase > Ptr
Definition: Grid.h:80
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:1036
GridBase(GridBase &other, ShallowCopy)
Copy another grid&#39;s metadata but share its transform.
Definition: Grid.h:498
static const char *const META_FILE_MEM_BYTES
Definition: Grid.h:364
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:1461
Definition: openvdb/Exceptions.h:65
typename tree::ValueAccessor< const _TreeType, true > ConstAccessor
Definition: Grid.h:596
typename NonConstTreeType::Ptr NonConstTreePtrType
Definition: Grid.h:1113
static const char *const META_GRID_CLASS
Definition: Grid.h:355
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1117
GridType::Ptr deepCopyTypedGrid(const GridBase &grid)
Return a pointer to a deep copy of the given grid, provided that the grid&#39;s concrete type is GridType...
Definition: Grid.h:1062
Vec3d voxelSize() const
Return the size of this grid&#39;s voxels.
Definition: Grid.h:434
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:1519
static bool hasMultiPassIO()
Return true if grids of this type require multiple I/O passes to read and write data buffers...
Definition: Grid.h:1711
static const TreeType & constTree(const TreeType &t)
Definition: Grid.h:1130
Tag dispatch class that distinguishes shallow copy constructors from deep copy constructors.
Definition: openvdb/Types.h:539
SharedPtr< GridPtrSet > GridPtrSetPtr
Definition: Grid.h:527
typename TreeType::Ptr TreePtrType
Definition: Grid.h:1081
static bool isRegistered(const Name &type)
Return true if the given grid type name is registered.
ValueAllCIter cbeginValueAll() const
Return an iterator over all of this grid&#39;s values (tile and voxel).
Definition: Grid.h:779
static Name gridType()
Return the name of this type of grid.
Definition: Grid.h:719
#define OPENVDB_LOG_WARN(message)
Log a warning message of the form &#39;someVar << "some text" << ...&#39;.
Definition: logging.h:253
ValueOffIter beginValueOff()
Return an iterator over all of this grid&#39;s inactive values (tile and voxel).
Definition: Grid.h:769
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1151
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1139
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1131
static const char *const META_VECTOR_TYPE
Definition: Grid.h:360
SharedPtr< MetaMap > Ptr
Definition: MetaMap.h:22
typename tree::ValueAccessor< const _TreeType, false > ConstUnsafeAccessor
Definition: Grid.h:598
void merge(Grid &other, MergePolicy policy=MERGE_ACTIVE_STATES)
Efficiently merge another grid into this grid using one of several schemes.
Definition: Grid.h:1541
SharedPtr< StreamMetadata > Ptr
Definition: io.h:33
bool isType() const
Return true if this grid is of the same type as the template parameter.
Definition: Grid.h:148
SharedPtr< GridPtrVec > GridPtrVecPtr
Definition: Grid.h:517
std::string Name
Definition: Name.h:17
math::Transform & transform()
Return a reference to this grid&#39;s transform, which might be shared with other grids.
Definition: Grid.h:415
std::shared_ptr< T > SharedPtr
Definition: openvdb/Types.h:92
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:1394
static const TreeType & constTree(const GridType &g)
Definition: Grid.h:1101
virtual GridBase::Ptr deepCopyGrid() const =0
Return a new grid whose metadata, transform and tree are deep copies of this grid&#39;s.
GridCPtrVec::iterator GridCPtrVecIter
Definition: Grid.h:520
static void registerGrid()
Register this grid type along with a factory function.
Definition: Grid.h:981
typename TreeType::ValueType ValueType
Definition: Grid.h:1119
GridBase(const GridBase &other)
Deep copy another grid&#39;s metadata and transform.
Definition: Grid.h:495
OPENVDB_API void setGridClass(std::ios_base &, uint32_t)
Associate with the given stream the class (GRID_LEVEL_SET, GRID_UNKNOWN, etc.) of the grid currently ...
MetaIterator endMeta()
Definition: MetaMap.h:85
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:153
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, whose metadata is a deep copy of this grid&#39;s and whose transform is provided as an argument.
Definition: Grid.h:1445
typename GridType::ConstPtr ConstGridPtrType
Definition: Grid.h:1118
TreeBase::ConstPtr baseTreePtr() const
Return a pointer to this grid&#39;s tree, which might be shared with other grids. The pointer is guarante...
Definition: Grid.h:173
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1087
ValueOffCIter beginValueOff() const
Return an iterator over all of this grid&#39;s inactive values (tile and voxel).
Definition: Grid.h:771
typename _TreeType::BuildType BuildType
Definition: Grid.h:586
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:124
~GridBase() override
Definition: Grid.h:86
static TreeType & tree(TreeType &t)
Definition: Grid.h:1153
void print(std::ostream &=std::cout, int verboseLevel=1) const override
Output a human-readable description of this grid.
Definition: Grid.h:1719
Vec3d indexToWorld(const Coord &ijk) const
Apply this grid&#39;s transform to the given coordinates.
Definition: Grid.h:443
Definition: Transform.h:39
typename GridType::Ptr GridPtrType
Definition: Grid.h:1116
typename NonConstGridType::Ptr NonConstGridPtrType
Definition: Grid.h:1146
TreeBase & baseTree()
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:187
MetadataMap::const_iterator ConstMetaIterator
Definition: MetaMap.h:28
ValueConverter<T>::Type is the type of a grid having the same hierarchy as this grid but a different ...
Definition: Grid.h:607
std::vector< GridBase::Ptr > GridPtrVec
Definition: Grid.h:514
typename _TreeType::Ptr TreePtrType
Definition: Grid.h:583
typename _TreeType::ValueAllCIter ValueAllCIter
Definition: Grid.h:593
const TreeType & tree() const
Return a reference to this grid&#39;s tree, which might be shared with other grids.
Definition: Grid.h:918
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1156
typename tree::ValueAccessor< NonConstTreeType > NonConstAccessorType
Definition: Grid.h:1122
void readBuffers(std::istream &) override
Read all data buffers for this grid.
Definition: Grid.h:1629
MergePolicy
Definition: openvdb/Types.h:366
static TreeType & tree(TreeType &t)
Definition: Grid.h:1094
void readNonresidentBuffers() const override
Read all of this grid&#39;s data buffers that are not yet resident in memory (because delayed loading is ...
Definition: Grid.h:1674
static const char *const META_FILE_BBOX_MIN
Definition: Grid.h:361
typename std::remove_const< TreeType >::type NonConstTreeType
Definition: Grid.h:1080
static const TreeType & tree(const GridType &g)
Definition: Grid.h:1097
static TreeType & tree(GridType &g)
Definition: Grid.h:1095
static void unregisterGrid()
Remove this grid type from the registry.
Definition: Grid.h:990
static const TreeType & tree(const TreeType &t)
Definition: Grid.h:1096
static const char *const META_IS_LOCAL_SPACE
Definition: Grid.h:359
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, whose metadata is a deep copy of this grid&#39;s and whose transform is provided as an argument.
Definition: Grid.h:1387
_TreeType TreeType
Definition: Grid.h:1109
ConstUnsafeAccessor getConstUnsafeAccessor() const
Return an unsafe accessor that provides random read-only access to this grid&#39;s voxels.
Definition: Grid.h:760