9 #ifndef OPENVDB_TOOLS_GRID_OPERATORS_HAS_BEEN_INCLUDED
10 #define OPENVDB_TOOLS_GRID_OPERATORS_HAS_BEEN_INCLUDED
15 #include "openvdb/thread/Threading.h"
20 #include <tbb/parallel_for.h>
33 typedef typename VectorGridType::template ValueConverter<VecComponentValueT>::Type
Type;
42 typedef typename ScalarGridType::template ValueConverter<VectorValueT>::Type
Type;
52 template<
typename Gr
idType,
typename InterruptT>
inline
54 cpt(
const GridType& grid,
bool threaded, InterruptT* interrupt);
56 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
58 cpt(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
60 template<
typename Gr
idType>
inline
62 cpt(
const GridType& grid,
bool threaded =
true)
64 return cpt<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
67 template<
typename Gr
idType,
typename MaskT>
inline
68 typename ScalarToVectorConverter<GridType>::Type::Ptr
69 cpt(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
71 return cpt<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
80 template<
typename Gr
idType,
typename InterruptT>
inline
81 typename GridType::Ptr
82 curl(
const GridType& grid,
bool threaded, InterruptT* interrupt);
84 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
85 typename GridType::Ptr
86 curl(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
88 template<
typename Gr
idType>
inline
89 typename GridType::Ptr
90 curl(
const GridType& grid,
bool threaded =
true)
92 return curl<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
95 template<
typename Gr
idType,
typename MaskT>
inline
96 typename GridType::Ptr
97 curl(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
99 return curl<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
109 template<
typename Gr
idType,
typename InterruptT>
inline
110 typename VectorToScalarConverter<GridType>::Type::Ptr
111 divergence(
const GridType& grid,
bool threaded, InterruptT* interrupt);
113 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
114 typename VectorToScalarConverter<GridType>::Type::Ptr
115 divergence(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
117 template<
typename Gr
idType>
inline
118 typename VectorToScalarConverter<GridType>::Type::Ptr
121 return divergence<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
124 template<
typename Gr
idType,
typename MaskT>
inline
125 typename VectorToScalarConverter<GridType>::Type::Ptr
126 divergence(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
128 return divergence<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
138 template<
typename Gr
idType,
typename InterruptT>
inline
139 typename ScalarToVectorConverter<GridType>::Type::Ptr
140 gradient(
const GridType& grid,
bool threaded, InterruptT* interrupt);
142 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
143 typename ScalarToVectorConverter<GridType>::Type::Ptr
144 gradient(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
146 template<
typename Gr
idType>
inline
147 typename ScalarToVectorConverter<GridType>::Type::Ptr
148 gradient(
const GridType& grid,
bool threaded =
true)
150 return gradient<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
153 template<
typename Gr
idType,
typename MaskT>
inline
154 typename ScalarToVectorConverter<GridType>::Type::Ptr
155 gradient(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
157 return gradient<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
166 template<
typename Gr
idType,
typename InterruptT>
inline
167 typename GridType::Ptr
168 laplacian(
const GridType& grid,
bool threaded, InterruptT* interrupt);
170 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
171 typename GridType::Ptr
172 laplacian(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
174 template<
typename Gr
idType>
inline
175 typename GridType::Ptr
178 return laplacian<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
181 template<
typename Gr
idType,
typename MaskT>
inline
182 typename GridType::Ptr
183 laplacian(
const GridType& grid,
const MaskT mask,
bool threaded =
true)
185 return laplacian<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
194 template<
typename Gr
idType,
typename InterruptT>
inline
195 typename GridType::Ptr
196 meanCurvature(
const GridType& grid,
bool threaded, InterruptT* interrupt);
198 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
199 typename GridType::Ptr
200 meanCurvature(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
202 template<
typename Gr
idType>
inline
203 typename GridType::Ptr
206 return meanCurvature<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
209 template<
typename Gr
idType,
typename MaskT>
inline
210 typename GridType::Ptr
211 meanCurvature(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
213 return meanCurvature<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
223 template<
typename Gr
idType,
typename InterruptT>
inline
224 typename VectorToScalarConverter<GridType>::Type::Ptr
225 magnitude(
const GridType& grid,
bool threaded, InterruptT* interrupt);
227 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
228 typename VectorToScalarConverter<GridType>::Type::Ptr
229 magnitude(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
231 template<
typename Gr
idType>
inline
232 typename VectorToScalarConverter<GridType>::Type::Ptr
235 return magnitude<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
238 template<
typename Gr
idType,
typename MaskT>
inline
239 typename VectorToScalarConverter<GridType>::Type::Ptr
240 magnitude(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
242 return magnitude<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
251 template<
typename Gr
idType,
typename InterruptT>
inline
252 typename GridType::Ptr
253 normalize(
const GridType& grid,
bool threaded, InterruptT* interrupt);
255 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
256 typename GridType::Ptr
257 normalize(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
259 template<
typename Gr
idType>
inline
260 typename GridType::Ptr
263 return normalize<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
266 template<
typename Gr
idType,
typename MaskT>
inline
267 typename GridType::Ptr
268 normalize(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
270 return normalize<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
282 template<
typename Gr
idType>
295 typename MaskGridType,
307 GridOperator(
const InGridT& grid,
const MaskGridType* mask,
const MapT& map,
308 InterruptT* interrupt =
nullptr,
bool densify =
true)
309 : mAcc(grid.getConstAccessor())
311 , mInterrupt(interrupt)
320 typename OutGridT::Ptr
process(
bool threaded =
true)
322 if (mInterrupt) mInterrupt->start(
"Processing grid");
325 typename InGridT::TreeType tmp(mAcc.tree().background());
326 typename OutGridT::ValueType backg = OperatorT::result(mMap, tmp,
math::Coord(0));
334 if (mDensify) tree->voxelizeActiveTiles();
337 typename OutGridT::Ptr result(
new OutGridT(tree));
341 result->topologyIntersection(*mMask);
350 tbb::parallel_for(leafManager.
leafRange(), *
this);
357 using TileIter =
typename OutTreeT::ValueOnIter;
359 TileIter tileIter = tree->beginValueOn();
360 tileIter.setMaxDepth(tileIter.getLeafDepth() - 1);
363 auto tileOp = [
this, inAcc](
const TileIter& it) {
366 it.setValue(OperatorT::result(this->mMap, inAcc, it.getCoord()));
374 if (mDensify) tree->prune();
376 if (mInterrupt) mInterrupt->end();
388 thread::cancelGroupExecution();
391 for (
typename LeafManagerT::LeafRange::Iterator leaf=range.
begin(); leaf; ++leaf) {
392 for (
typename OutLeafT::ValueOnIter value=leaf->beginValueOn(); value; ++value) {
393 value.setValue(OperatorT::result(mMap, mAcc, value.getCoord()));
425 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
429 Cpt(
const InGridType& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
430 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
434 typename OutGridType::Ptr
process(
bool threaded =
true,
bool useWorldTransform =
true)
436 Functor functor(mInputGrid, mMask, threaded, useWorldTransform, mInterrupt);
439 return functor.mOutputGrid;
445 template<
typename MapT,
typename AccT>
446 static typename OutGridType::ValueType
447 result(
const MapT& map,
const AccT& acc,
const Coord& xyz)
454 template<
typename MapT,
typename AccT>
455 static typename OutGridType::ValueType
456 result(
const MapT& map,
const AccT& acc,
const Coord& xyz)
463 Functor(
const InGridType& grid,
const MaskGridType* mask,
464 bool threaded,
bool worldspace, InterruptT* interrupt)
465 : mThreaded(threaded)
466 , mWorldSpace(worldspace)
468 , mInterrupt(interrupt)
472 template<
typename MapT>
473 void operator()(
const MapT& map)
476 gridop::GridOperator<InGridType, MaskGridType, OutGridType, MapT, WsOpT, InterruptT>
477 op(mInputGrid, mMask, map, mInterrupt,
false);
478 mOutputGrid = op.process(mThreaded);
480 gridop::GridOperator<InGridType, MaskGridType, OutGridType, MapT, IsOpT, InterruptT>
481 op(mInputGrid, mMask, map, mInterrupt,
false);
482 mOutputGrid = op.process(mThreaded);
485 const bool mThreaded;
486 const bool mWorldSpace;
487 const InGridType& mInputGrid;
488 typename OutGridType::Ptr mOutputGrid;
489 InterruptT* mInterrupt;
490 const MaskGridType* mMask;
492 const InGridType& mInputGrid;
493 InterruptT* mInterrupt;
494 const MaskGridType* mMask;
504 typename MaskGridType =
typename gridop::ToMaskGrid<GridT>::Type,
505 typename InterruptT = util::NullInterrupter>
512 Curl(
const GridT& grid, InterruptT* interrupt =
nullptr):
513 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
517 Curl(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
518 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
522 typename GridT::Ptr
process(
bool threaded =
true)
524 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
526 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
527 return functor.mOutputGrid;
533 Functor(
const GridT& grid,
const MaskGridType* mask,
534 bool threaded, InterruptT* interrupt):
535 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
537 template<
typename MapT>
538 void operator()(
const MapT& map)
541 gridop::GridOperator<GridT, MaskGridType, GridT, MapT, OpT, InterruptT>
542 op(mInputGrid, mMask, map, mInterrupt);
543 mOutputGrid = op.process(mThreaded);
546 const bool mThreaded;
547 const GridT& mInputGrid;
548 typename GridT::Ptr mOutputGrid;
549 InterruptT* mInterrupt;
550 const MaskGridType* mMask;
553 const GridT& mInputGrid;
554 InterruptT* mInterrupt;
555 const MaskGridType* mMask;
565 typename MaskGridType =
typename gridop::ToMaskGrid<InGridT>::Type,
566 typename InterruptT = util::NullInterrupter>
573 Divergence(
const InGridT& grid, InterruptT* interrupt =
nullptr):
574 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
578 Divergence(
const InGridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
579 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
583 typename OutGridType::Ptr
process(
bool threaded =
true)
588 return functor.mOutputGrid;
592 return functor.mOutputGrid;
597 template<math::DScheme DiffScheme>
600 Functor(
const InGridT& grid,
const MaskGridType* mask,
601 bool threaded, InterruptT* interrupt):
602 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
604 template<
typename MapT>
609 op(mInputGrid, mMask, map, mInterrupt);
610 mOutputGrid = op.
process(mThreaded);
640 Gradient(
const InGridT& grid, InterruptT* interrupt =
nullptr):
641 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
645 Gradient(
const InGridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
646 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
650 typename OutGridType::Ptr
process(
bool threaded =
true)
652 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
654 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
655 return functor.mOutputGrid;
661 Functor(
const InGridT& grid,
const MaskGridType* mask,
662 bool threaded, InterruptT* interrupt):
663 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
665 template<
typename MapT>
670 op(mInputGrid, mMask, map, mInterrupt);
671 mOutputGrid = op.
process(mThreaded);
700 Laplacian(
const GridT& grid, InterruptT* interrupt =
nullptr):
701 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
705 Laplacian(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
706 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
710 typename GridT::Ptr
process(
bool threaded =
true)
712 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
714 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
715 return functor.mOutputGrid;
721 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
722 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
724 template<
typename MapT>
729 op(mInputGrid, mMask, map, mInterrupt);
730 mOutputGrid = op.
process(mThreaded);
760 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
764 MeanCurvature(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
765 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
769 typename GridT::Ptr
process(
bool threaded =
true)
771 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
773 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
774 return functor.mOutputGrid;
780 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
781 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
783 template<
typename MapT>
788 op(mInputGrid, mMask, map, mInterrupt);
789 mOutputGrid = op.
process(mThreaded);
819 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
824 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
828 typename OutGridType::Ptr
process(
bool threaded =
true)
830 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
832 return functor.mOutputGrid;
838 template<
typename MapT,
typename AccT>
839 static typename OutGridType::ValueType
840 result(
const MapT&,
const AccT& acc,
const Coord& xyz) {
return acc.getValue(xyz).length();}
844 Functor(
const InGridT& grid,
const MaskGridType* mask,
845 bool threaded, InterruptT* interrupt):
846 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
848 template<
typename MapT>
852 op(mInputGrid, mMask, map, mInterrupt,
false);
853 mOutputGrid = op.
process(mThreaded);
882 Normalize(
const GridT& grid, InterruptT* interrupt =
nullptr):
883 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
887 Normalize(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
888 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
892 typename GridT::Ptr
process(
bool threaded =
true)
894 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
896 if (
typename GridT::Ptr outGrid = functor.mOutputGrid) {
897 const VecType vecType = mInputGrid.getVectorType();
901 outGrid->setVectorType(vecType);
904 return functor.mOutputGrid;
910 template<
typename MapT,
typename AccT>
911 static typename OutGridType::ValueType
914 typename OutGridType::ValueType vec = acc.getValue(xyz);
915 if ( !vec.normalize() ) vec.setZero();
921 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
922 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
924 template<
typename MapT>
928 op(mInputGrid, mMask, map, mInterrupt,
false);
929 mOutputGrid = op.
process(mThreaded);
948 template<
typename Gr
idType,
typename InterruptT>
inline
950 cpt(
const GridType& grid,
bool threaded, InterruptT* interrupt)
956 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
957 typename ScalarToVectorConverter<GridType>::Type::Ptr
958 cpt(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
964 template<
typename Gr
idType,
typename InterruptT>
inline
965 typename GridType::Ptr
966 curl(
const GridType& grid,
bool threaded, InterruptT* interrupt)
972 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
973 typename GridType::Ptr
974 curl(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
980 template<
typename Gr
idType,
typename InterruptT>
inline
981 typename VectorToScalarConverter<GridType>::Type::Ptr
982 divergence(
const GridType& grid,
bool threaded, InterruptT* interrupt)
989 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
990 typename VectorToScalarConverter<GridType>::Type::Ptr
991 divergence(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
997 template<
typename Gr
idType,
typename InterruptT>
inline
998 typename ScalarToVectorConverter<GridType>::Type::Ptr
999 gradient(
const GridType& grid,
bool threaded, InterruptT* interrupt)
1002 op(grid, interrupt);
1006 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
1007 typename ScalarToVectorConverter<GridType>::Type::Ptr
1008 gradient(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
1014 template<
typename Gr
idType,
typename InterruptT>
inline
1015 typename GridType::Ptr
1016 laplacian(
const GridType& grid,
bool threaded, InterruptT* interrupt)
1019 op(grid, interrupt);
1023 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
1024 typename GridType::Ptr
1025 laplacian(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
1031 template<
typename Gr
idType,
typename InterruptT>
inline
1032 typename GridType::Ptr
1036 op(grid, interrupt);
1040 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
1041 typename GridType::Ptr
1042 meanCurvature(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
1048 template<
typename Gr
idType,
typename InterruptT>
inline
1049 typename VectorToScalarConverter<GridType>::Type::Ptr
1050 magnitude(
const GridType& grid,
bool threaded, InterruptT* interrupt)
1053 op(grid, interrupt);
1057 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
1058 typename VectorToScalarConverter<GridType>::Type::Ptr
1059 magnitude(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
1065 template<
typename Gr
idType,
typename InterruptT>
inline
1066 typename GridType::Ptr
1067 normalize(
const GridType& grid,
bool threaded, InterruptT* interrupt)
1070 op(grid, interrupt);
1074 template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
inline
1075 typename GridType::Ptr
1076 normalize(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
A LeafManager manages a linear array of pointers to a given tree's leaf nodes, as well as optional au...
Container class that associates a tree with a transform and metadata.
Definition: Grid.h:577
Tag dispatch class that distinguishes topology copy constructors from deep copy constructors.
Definition: Types.h:564
Signed (x, y, z) 32-bit integer coordinates.
Definition: Coord.h:25
Definition: LeafManager.h:102
Iterator begin() const
Definition: LeafManager.h:155
This class manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxil...
Definition: LeafManager.h:85
LeafRange leafRange(size_t grainsize=1) const
Return a TBB-compatible LeafRange.
Definition: LeafManager.h:345
bool processTypedMap(TransformType &transform, OpType &op)
Utility function that, given a generic map pointer, calls a functor on the fully-resoved map.
Definition: Transform.h:233
bool wasInterrupted(T *i, int percent=-1)
Definition: NullInterrupter.h:49
@ GRID_STAGGERED
Definition: Types.h:339
VecType
Definition: Types.h:365
@ VEC_CONTRAVARIANT_ABSOLUTE
Definition: Types.h:370
@ VEC_COVARIANT
Definition: Types.h:367
@ VEC_COVARIANT_NORMALIZE
Definition: Types.h:368
Definition: Exceptions.h:13
Compute the closest-point transform to a level set.
Definition: Operators.h:1719
Compute the closest-point transform to a level set.
Definition: Operators.h:1666
Compute the curl of a vector-valued grid using differencing of various orders in the space defined by...
Definition: Operators.h:1275
Compute the divergence of a vector-valued grid using differencing of various orders,...
Definition: Operators.h:950
Center difference gradient operators, defined with respect to the range-space of the map.
Definition: Operators.h:620
Compute the Laplacian at a given location in a grid using finite differencing of various orders....
Definition: Operators.h:1420
Compute the mean curvature.
Definition: Operators.h:1762
Dummy NOOP interrupter class defining interface.
Definition: NullInterrupter.h:26
#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:180