9#ifndef OPENVDB_TOOLS_GRID_OPERATORS_HAS_BEEN_INCLUDED
10#define OPENVDB_TOOLS_GRID_OPERATORS_HAS_BEEN_INCLUDED
15#include "openvdb/thread/Threading.h"
21#include <tbb/parallel_for.h>
34 typedef typename VectorGridType::template ValueConverter<VecComponentValueT>::Type
Type;
43 typedef typename ScalarGridType::template ValueConverter<VectorValueT>::Type
Type;
53template<
typename Gr
idType,
typename InterruptT>
55cpt(
const GridType& grid,
bool threaded, InterruptT* interrupt);
57template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
59cpt(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
61template<
typename Gr
idType>
65 return cpt<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
68template<
typename Gr
idType,
typename MaskT>
69typename ScalarToVectorConverter<GridType>::Type::Ptr
70cpt(
const GridType& grid,
const MaskT& mask,
bool threaded =
true)
72 return cpt<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
81template<
typename Gr
idType,
typename InterruptT>
83curl(
const GridType& grid,
bool threaded, InterruptT* interrupt);
85template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
87curl(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
89template<
typename Gr
idType>
93 return curl<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
96template<
typename Gr
idType,
typename MaskT>
100 return curl<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
110template<
typename Gr
idType,
typename InterruptT>
111typename VectorToScalarConverter<GridType>::Type::Ptr
114template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
115typename VectorToScalarConverter<GridType>::Type::Ptr
116divergence(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
118template<
typename Gr
idType>
119typename VectorToScalarConverter<GridType>::Type::Ptr
122 return divergence<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
125template<
typename Gr
idType,
typename MaskT>
126typename VectorToScalarConverter<GridType>::Type::Ptr
129 return divergence<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
139template<
typename Gr
idType,
typename InterruptT>
140typename ScalarToVectorConverter<GridType>::Type::Ptr
143template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
144typename ScalarToVectorConverter<GridType>::Type::Ptr
145gradient(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
147template<
typename Gr
idType>
148typename ScalarToVectorConverter<GridType>::Type::Ptr
151 return gradient<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
154template<
typename Gr
idType,
typename MaskT>
155typename ScalarToVectorConverter<GridType>::Type::Ptr
158 return gradient<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
167template<
typename Gr
idType,
typename InterruptT>
168typename GridType::Ptr
171template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
172typename GridType::Ptr
173laplacian(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
175template<
typename Gr
idType>
176typename GridType::Ptr
179 return laplacian<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
182template<
typename Gr
idType,
typename MaskT>
183typename GridType::Ptr
186 return laplacian<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
195template<
typename Gr
idType,
typename InterruptT>
196typename GridType::Ptr
199template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
200typename GridType::Ptr
203template<
typename Gr
idType>
204typename GridType::Ptr
207 return meanCurvature<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
210template<
typename Gr
idType,
typename MaskT>
211typename GridType::Ptr
214 return meanCurvature<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
224template<
typename Gr
idType,
typename InterruptT>
225typename VectorToScalarConverter<GridType>::Type::Ptr
228template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
229typename VectorToScalarConverter<GridType>::Type::Ptr
230magnitude(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
232template<
typename Gr
idType>
233typename VectorToScalarConverter<GridType>::Type::Ptr
236 return magnitude<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
239template<
typename Gr
idType,
typename MaskT>
240typename VectorToScalarConverter<GridType>::Type::Ptr
243 return magnitude<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
252template<
typename Gr
idType,
typename InterruptT>
253typename GridType::Ptr
256template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
257typename GridType::Ptr
258normalize(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt);
260template<
typename Gr
idType>
261typename GridType::Ptr
264 return normalize<GridType, util::NullInterrupter>(grid, threaded,
nullptr);
267template<
typename Gr
idType,
typename MaskT>
268typename GridType::Ptr
271 return normalize<GridType, MaskT, util::NullInterrupter>(grid, mask, threaded,
nullptr);
283template<
typename Gr
idType>
296 typename MaskGridType,
308 GridOperator(
const InGridT& grid,
const MaskGridType* mask,
const MapT& map,
309 InterruptT* interrupt =
nullptr,
bool densify =
true)
310 : mAcc(grid.getConstAccessor())
312 , mInterrupt(interrupt)
321 typename OutGridT::Ptr
process(
bool threaded =
true)
323 if (mInterrupt) mInterrupt->start(
"Processing grid");
326 typename InGridT::TreeType tmp(mAcc.tree().background());
327 typename OutGridT::ValueType backg = OperatorT::result(mMap, tmp,
math::Coord(0));
335 if (mDensify) tree->voxelizeActiveTiles();
338 typename OutGridT::Ptr result(
new OutGridT(tree));
342 result->topologyIntersection(*mMask);
351 tbb::parallel_for(leafManager.
leafRange(), *
this);
358 using TileIter =
typename OutTreeT::ValueOnIter;
360 TileIter tileIter = tree->beginValueOn();
361 tileIter.setMaxDepth(tileIter.getLeafDepth() - 1);
364 auto tileOp = [
this, inAcc](
const TileIter& it) {
367 it.setValue(OperatorT::result(this->mMap, inAcc, it.getCoord()));
375 if (mDensify) tree->prune();
377 if (mInterrupt) mInterrupt->end();
389 thread::cancelGroupExecution();
392 for (
typename LeafManagerT::LeafRange::Iterator leaf=range.
begin(); leaf; ++leaf) {
393 for (
typename OutLeafT::ValueOnIter
value=leaf->beginValueOn();
value; ++
value) {
394 value.setValue(OperatorT::result(mMap, mAcc,
value.getCoord()));
426 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
430 Cpt(
const InGridType& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
431 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
435 typename OutGridType::Ptr
process(
bool threaded =
true,
bool useWorldTransform =
true)
437 Functor functor(mInputGrid, mMask, threaded, useWorldTransform, mInterrupt);
440 return functor.mOutputGrid;
446 template<
typename MapT,
typename AccT>
447 static typename OutGridType::ValueType
448 result(
const MapT& map,
const AccT& acc,
const Coord& xyz)
455 template<
typename MapT,
typename AccT>
456 static typename OutGridType::ValueType
457 result(
const MapT& map,
const AccT& acc,
const Coord& xyz)
464 Functor(
const InGridType& grid,
const MaskGridType* mask,
465 bool threaded,
bool worldspace, InterruptT* interrupt)
466 : mThreaded(threaded)
467 , mWorldSpace(worldspace)
469 , mInterrupt(interrupt)
473 template<
typename MapT>
474 void operator()(
const MapT& map)
477 gridop::GridOperator<InGridType, MaskGridType, OutGridType, MapT, WsOpT, InterruptT>
478 op(mInputGrid, mMask, map, mInterrupt,
false);
479 mOutputGrid = op.process(mThreaded);
481 gridop::GridOperator<InGridType, MaskGridType, OutGridType, MapT, IsOpT, InterruptT>
482 op(mInputGrid, mMask, map, mInterrupt,
false);
483 mOutputGrid = op.process(mThreaded);
486 const bool mThreaded;
487 const bool mWorldSpace;
488 const InGridType& mInputGrid;
489 typename OutGridType::Ptr mOutputGrid;
490 InterruptT* mInterrupt;
491 const MaskGridType* mMask;
493 const InGridType& mInputGrid;
494 InterruptT* mInterrupt;
495 const MaskGridType* mMask;
505 typename MaskGridType =
typename gridop::ToMaskGrid<GridT>::Type,
506 typename InterruptT = util::NullInterrupter>
513 Curl(
const GridT& grid, InterruptT* interrupt =
nullptr):
514 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
518 Curl(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
519 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
523 typename GridT::Ptr
process(
bool threaded =
true)
525 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
527 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
528 return functor.mOutputGrid;
534 Functor(
const GridT& grid,
const MaskGridType* mask,
535 bool threaded, InterruptT* interrupt):
536 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
538 template<
typename MapT>
539 void operator()(
const MapT& map)
542 gridop::GridOperator<GridT, MaskGridType, GridT, MapT, OpT, InterruptT>
543 op(mInputGrid, mMask, map, mInterrupt);
544 mOutputGrid = op.process(mThreaded);
547 const bool mThreaded;
548 const GridT& mInputGrid;
549 typename GridT::Ptr mOutputGrid;
550 InterruptT* mInterrupt;
551 const MaskGridType* mMask;
554 const GridT& mInputGrid;
555 InterruptT* mInterrupt;
556 const MaskGridType* mMask;
566 typename MaskGridType =
typename gridop::ToMaskGrid<InGridT>::Type,
567 typename InterruptT = util::NullInterrupter>
574 Divergence(
const InGridT& grid, InterruptT* interrupt =
nullptr):
575 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
579 Divergence(
const InGridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
580 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
584 typename OutGridType::Ptr
process(
bool threaded =
true)
589 return functor.mOutputGrid;
593 return functor.mOutputGrid;
598 template<math::DScheme DiffScheme>
601 Functor(
const InGridT& grid,
const MaskGridType* mask,
602 bool threaded, InterruptT* interrupt):
603 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
605 template<
typename MapT>
610 op(mInputGrid, mMask, map, mInterrupt);
611 mOutputGrid = op.
process(mThreaded);
641 Gradient(
const InGridT& grid, InterruptT* interrupt =
nullptr):
642 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
646 Gradient(
const InGridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
647 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
651 typename OutGridType::Ptr
process(
bool threaded =
true)
653 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
655 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
656 return functor.mOutputGrid;
662 Functor(
const InGridT& grid,
const MaskGridType* mask,
663 bool threaded, InterruptT* interrupt):
664 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
666 template<
typename MapT>
671 op(mInputGrid, mMask, map, mInterrupt);
672 mOutputGrid = op.
process(mThreaded);
701 Laplacian(
const GridT& grid, InterruptT* interrupt =
nullptr):
702 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
706 Laplacian(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
707 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
711 typename GridT::Ptr
process(
bool threaded =
true)
713 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
715 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
716 return functor.mOutputGrid;
722 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
723 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
725 template<
typename MapT>
730 op(mInputGrid, mMask, map, mInterrupt);
731 mOutputGrid = op.
process(mThreaded);
761 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
765 MeanCurvature(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
766 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
770 typename GridT::Ptr
process(
bool threaded =
true)
772 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
774 if (functor.mOutputGrid) functor.mOutputGrid->setVectorType(
VEC_COVARIANT);
775 return functor.mOutputGrid;
781 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
782 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
784 template<
typename MapT>
789 op(mInputGrid, mMask, map, mInterrupt);
790 mOutputGrid = op.
process(mThreaded);
820 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
825 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
829 typename OutGridType::Ptr
process(
bool threaded =
true)
831 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
833 return functor.mOutputGrid;
839 template<
typename MapT,
typename AccT>
840 static typename OutGridType::ValueType
841 result(
const MapT&,
const AccT& acc,
const Coord& xyz) {
return acc.getValue(xyz).length();}
845 Functor(
const InGridT& grid,
const MaskGridType* mask,
846 bool threaded, InterruptT* interrupt):
847 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
849 template<
typename MapT>
853 op(mInputGrid, mMask, map, mInterrupt,
false);
854 mOutputGrid = op.
process(mThreaded);
883 Normalize(
const GridT& grid, InterruptT* interrupt =
nullptr):
884 mInputGrid(grid), mInterrupt(interrupt), mMask(nullptr)
888 Normalize(
const GridT& grid,
const MaskGridType& mask, InterruptT* interrupt =
nullptr):
889 mInputGrid(grid), mInterrupt(interrupt), mMask(&mask)
893 typename GridT::Ptr
process(
bool threaded =
true)
895 Functor functor(mInputGrid, mMask, threaded, mInterrupt);
897 if (
typename GridT::Ptr outGrid = functor.mOutputGrid) {
898 const VecType vecType = mInputGrid.getVectorType();
902 outGrid->setVectorType(vecType);
905 return functor.mOutputGrid;
911 template<
typename MapT,
typename AccT>
912 static typename OutGridType::ValueType
915 typename OutGridType::ValueType vec = acc.getValue(xyz);
916 if ( !vec.normalize() ) vec.setZero();
922 Functor(
const GridT& grid,
const MaskGridType* mask,
bool threaded, InterruptT* interrupt):
923 mThreaded(threaded), mInputGrid(grid), mInterrupt(interrupt), mMask(mask) {}
925 template<
typename MapT>
929 op(mInputGrid, mMask, map, mInterrupt,
false);
930 mOutputGrid = op.
process(mThreaded);
949template<
typename Gr
idType,
typename InterruptT>
957template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
958typename ScalarToVectorConverter<GridType>::Type::Ptr
959cpt(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
965template<
typename Gr
idType,
typename InterruptT>
966typename GridType::Ptr
973template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
974typename GridType::Ptr
975curl(
const GridType& grid,
const MaskT& mask,
bool threaded, InterruptT* interrupt)
981template<
typename Gr
idType,
typename InterruptT>
982typename VectorToScalarConverter<GridType>::Type::Ptr
990template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
991typename VectorToScalarConverter<GridType>::Type::Ptr
998template<
typename Gr
idType,
typename InterruptT>
999typename ScalarToVectorConverter<GridType>::Type::Ptr
1003 op(grid, interrupt);
1007template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
1008typename ScalarToVectorConverter<GridType>::Type::Ptr
1015template<
typename Gr
idType,
typename InterruptT>
1016typename GridType::Ptr
1020 op(grid, interrupt);
1024template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
1025typename GridType::Ptr
1032template<
typename Gr
idType,
typename InterruptT>
1033typename GridType::Ptr
1037 op(grid, interrupt);
1041template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
1042typename GridType::Ptr
1049template<
typename Gr
idType,
typename InterruptT>
1050typename VectorToScalarConverter<GridType>::Type::Ptr
1054 op(grid, interrupt);
1058template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
1059typename VectorToScalarConverter<GridType>::Type::Ptr
1066template<
typename Gr
idType,
typename InterruptT>
1067typename GridType::Ptr
1071 op(grid, interrupt);
1075template<
typename Gr
idType,
typename MaskT,
typename InterruptT>
1076typename GridType::Ptr
1088#ifdef OPENVDB_USE_EXPLICIT_INSTANTIATION
1090#ifdef OPENVDB_INSTANTIATE_GRIDOPERATORS
1094#define _FUNCTION(TreeT) \
1095 ScalarToVectorConverter<Grid<TreeT>>::Type::Ptr cpt(const Grid<TreeT>&, bool, util::NullInterrupter*)
1099#define _FUNCTION(TreeT) \
1100 ScalarToVectorConverter<Grid<TreeT>>::Type::Ptr cpt(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1104#define _FUNCTION(TreeT) \
1105 Grid<TreeT>::Ptr curl(const Grid<TreeT>&, bool, util::NullInterrupter*)
1109#define _FUNCTION(TreeT) \
1110 Grid<TreeT>::Ptr curl(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1114#define _FUNCTION(TreeT) \
1115 VectorToScalarConverter<Grid<TreeT>>::Type::Ptr divergence(const Grid<TreeT>&, bool, util::NullInterrupter*)
1119#define _FUNCTION(TreeT) \
1120 VectorToScalarConverter<Grid<TreeT>>::Type::Ptr divergence(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1124#define _FUNCTION(TreeT) \
1125 ScalarToVectorConverter<Grid<TreeT>>::Type::Ptr gradient(const Grid<TreeT>&, bool, util::NullInterrupter*)
1129#define _FUNCTION(TreeT) \
1130 ScalarToVectorConverter<Grid<TreeT>>::Type::Ptr gradient(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1134#define _FUNCTION(TreeT) \
1135 Grid<TreeT>::Ptr laplacian(const Grid<TreeT>&, bool, util::NullInterrupter*)
1139#define _FUNCTION(TreeT) \
1140 Grid<TreeT>::Ptr laplacian(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1144#define _FUNCTION(TreeT) \
1145 Grid<TreeT>::Ptr meanCurvature(const Grid<TreeT>&, bool, util::NullInterrupter*)
1149#define _FUNCTION(TreeT) \
1150 Grid<TreeT>::Ptr meanCurvature(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1154#define _FUNCTION(TreeT) \
1155 VectorToScalarConverter<Grid<TreeT>>::Type::Ptr magnitude(const Grid<TreeT>&, bool, util::NullInterrupter*)
1159#define _FUNCTION(TreeT) \
1160 VectorToScalarConverter<Grid<TreeT>>::Type::Ptr magnitude(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
1164#define _FUNCTION(TreeT) \
1165 Grid<TreeT>::Ptr normalize(const Grid<TreeT>&, bool, util::NullInterrupter*)
1169#define _FUNCTION(TreeT) \
1170 Grid<TreeT>::Ptr normalize(const Grid<TreeT>&, const BoolGrid&, bool, util::NullInterrupter*)
ValueT value
Definition: GridBuilder.h:1287
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
GridType
List of types that are currently supported by NanoVDB.
Definition: NanoVDB.h:216
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
Base class for interrupters.
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:202
#define OPENVDB_NUMERIC_TREE_INSTANTIATE(Function)
Definition: version.h.in:148
#define OPENVDB_REAL_TREE_INSTANTIATE(Function)
Definition: version.h.in:147
#define OPENVDB_VEC3_TREE_INSTANTIATE(Function)
Definition: version.h.in:149