OpenVDB: MultiResGrid.h Source File

OpenVDB 7.0.0

MultiResGrid.h
Go to the documentation of this file.
1 // Copyright Contributors to the OpenVDB Project
2 // SPDX-License-Identifier: MPL-2.0
3
24
25 #ifndef OPENVDB_TOOLS_MULTIRESGRID_HAS_BEEN_INCLUDED
26 #define OPENVDB_TOOLS_MULTIRESGRID_HAS_BEEN_INCLUDED
27
28 #include <openvdb/Grid.h>
29 #include <openvdb/math/FiniteDifference.h>
30 #include <openvdb/math/Math.h>
31 #include <openvdb/math/Operators.h>
32 #include <openvdb/math/Stencils.h>
33 #include <openvdb/Metadata.h>
34 #include <openvdb/tree/LeafManager.h>
35 #include <openvdb/tree/NodeManager.h>
36 #include "Interpolation.h"
37 #include "Morphology.h"
38 #include "Prune.h"
39 #include "SignedFloodFill.h"
40 #include "ValueTransformer.h"
41
42 #include <tbb/blocked_range.h>
43 #include <tbb/enumerable_thread_specific.h>
44 #include <tbb/parallel_for.h>
45
46 #include <iostream>
47 #include <sstream>
48 #include <string>
49 #include <vector>
50
51
52 namespace openvdb {
53 OPENVDB_USE_VERSION_NAMESPACE
54 namespace OPENVDB_VERSION_NAME {
55 namespace tools {
56
57 template<typename TreeType>
58 class MultiResGrid: public MetaMap
59 {
60 public:
61 using Ptr = SharedPtr<MultiResGrid>;
62 using ConstPtr = SharedPtr<const MultiResGrid>;
63
64 using ValueType = typename TreeType::ValueType;
65 using ValueOnCIter = typename TreeType::ValueOnCIter;
66 using ValueOnIter = typename TreeType::ValueOnIter;
67 using TreePtr = typename TreeType::Ptr;
68 using ConstTreePtr = typename TreeType::ConstPtr;
69 using GridPtr = typename Grid<TreeType>::Ptr;
70 using ConstGridPtr = typename Grid<TreeType>::ConstPtr;
71
73
79 MultiResGrid(size_t levels, ValueType background, double voxelSize = 1.0);
80
89 MultiResGrid(size_t levels, const Grid<TreeType> &grid, bool useInjection = false);
90
99 MultiResGrid(size_t levels, GridPtr grid, bool useInjection = false);
100
102
106 size_t numLevels() const { return mTrees.size(); }
107
109 static size_t finestLevel() { return 0; }
110
112 size_t coarsestLevel() const { return mTrees.size()-1; }
113
115
119 TreeType& tree(size_t level);
120
124 const TreeType& constTree(size_t level) const;
125
129 TreePtr treePtr(size_t level);
130
134 ConstTreePtr constTreePtr(size_t level) const;
135
137 TreeType& finestTree() { return *mTrees.front(); }
138
140 const TreeType& finestConstTree() const { return *mTrees.front(); }
141
143 TreePtr finestTreePtr() { return mTrees.front(); }
144
146 ConstTreePtr finestConstTreePtr() const { return mTrees.front(); }
147
149 TreeType& coarsestTree() { return *mTrees.back(); }
150
152 const TreeType& coarsestConstTree() const { return *mTrees.back(); }
153
155 TreePtr coarsestTreePtr() { return mTrees.back(); }
156
158 ConstTreePtr coarsestConstTreePtr() const { return mTrees.back(); }
159
161
165 GridPtr grid(size_t level);
166
170 ConstGridPtr grid(size_t level) const;
171
179 template<Index Order>
180 GridPtr createGrid(float level, size_t grainSize = 1) const;
181
185 GridPtrVecPtr grids();
186
190 GridCPtrVecPtr grids() const;
191
193
195 math::Transform& transform() { return *mTransform; }
201 const math::Transform& transform() const { return *mTransform; }
202 const math::Transform& constTransform() const { return *mTransform; }
204
206
208 static Vec3R xyz(const Coord& in_ijk, size_t in_level, size_t out_level);
211 static Vec3R xyz(const Vec3R& in_xyz, size_t in_level, size_t out_level);
212 static Vec3R xyz(const Vec3R& in_xyz, double in_level, double out_level);
214
216
217
218
220 template<Index Order>
230 ValueType sampleValue(const Coord& in_ijk, size_t in_level, size_t out_level) const;
231 template<Index Order>
232 ValueType sampleValue(const Vec3R& in_ijk, size_t in_level, size_t out_level) const;
234
241 template<Index Order>
242 ValueType sampleValue(const Coord& ijk, double level) const;
243
251 template<Index Order>
252 ValueType sampleValue(const Vec3R& xyz, double level) const;
253
255
262 ValueType prolongateVoxel(const Coord& coords, const size_t level) const;
263
264
268 void prolongateActiveVoxels(size_t destlevel, size_t grainSize = 1);
269
271
276 ValueType restrictVoxel(Coord ijk, const size_t level, bool useInjection = false) const;
277
284 void restrictActiveVoxels(size_t destlevel, size_t grainSize = 1);
285
287 void print(std::ostream& = std::cout, int verboseLevel = 1) const;
288
290 std::string getName() const
291 {
292 if (Metadata::ConstPtr meta = (*this)[GridBase::META_GRID_NAME]) return meta->str();
293 return "";
294 }
295
297 void setName(const std::string& name)
298 {
299 this->removeMeta(GridBase::META_GRID_NAME);
300 this->insertMeta(GridBase::META_GRID_NAME, StringMetadata(name));
301 }
302
304 GridClass getGridClass() const
305 {
306 typename StringMetadata::ConstPtr s =
307 this->getMetadata<StringMetadata>(GridBase::META_GRID_CLASS);
308 return s ? GridBase::stringToGridClass(s->value()) : GRID_UNKNOWN;
309 }
310
312 void setGridClass(GridClass cls)
313 {
314 this->insertMeta(GridBase::META_GRID_CLASS, StringMetadata(GridBase::gridClassToString(cls)));
315 }
316
318 void clearGridClass() { this->removeMeta(GridBase::META_GRID_CLASS); }
319
320 private:
321
322 MultiResGrid(const MultiResGrid& other);//disallow copy construction
323 MultiResGrid& operator=(const MultiResGrid& other);//disallow copy assignment
324
325 // For optimal performance we disable registration of the ValueAccessor
326 using Accessor = tree::ValueAccessor<TreeType, false>;
327 using ConstAccessor = tree::ValueAccessor<const TreeType, false>;
328
329 void topDownRestrict(bool useInjection);
330
331 inline void initMeta();
332
333 // Private struct that concurrently creates a mask of active voxel
334 // in a coarse tree from the active voxels in a fine tree
335 struct MaskOp;
336
338 struct RestrictOp;
339
341 struct ProlongateOp;
342
343 // Private struct that performs multi-threaded computation of grids a fraction levels
344 template<Index Order>
345 struct FractionOp;
346
348 template<typename OpType> struct CookOp;
349
350 // Array of shared pointer to trees, level 0 has the highest resolution.
351 std::vector<TreePtr> mTrees;
352 // Shared pointer to a transform associated with the finest level grid
353 typename math::Transform::Ptr mTransform;
354 };// MultiResGrid
355
356 template<typename TreeType>
357 MultiResGrid<TreeType>::
358 MultiResGrid(size_t levels, ValueType background, double voxelSize)
359 : mTrees(levels)
360 , mTransform(math::Transform::createLinearTransform( voxelSize ))
361 {
362 this->initMeta();
363 for (size_t i=0; i<levels; ++i) mTrees[i] = TreePtr(new TreeType(background));
364 }
365
366 template<typename TreeType>
367 MultiResGrid<TreeType>::
368 MultiResGrid(size_t levels, const Grid<TreeType> &grid, bool useInjection)
369 : MetaMap(grid)
370 , mTrees(levels)
371 , mTransform( grid.transform().copy() )
372 {
373 this->initMeta();
374 mTrees[0].reset( new TreeType( grid.tree() ) );// deep copy input tree
375 mTrees[0]->voxelizeActiveTiles();
376 this->topDownRestrict(useInjection);
377 }
378
379 template<typename TreeType>
380 MultiResGrid<TreeType>::
381 MultiResGrid(size_t levels, GridPtr grid, bool useInjection)
382 : MetaMap(*grid)
383 , mTrees(levels)
384 , mTransform( grid->transform().copy() )
385 {
386 this->initMeta();
387 mTrees[0] = grid->treePtr();// steal tree from input grid
388 mTrees[0]->voxelizeActiveTiles();
389 grid->newTree();
390 this->topDownRestrict(useInjection);
391 }
392
393 template<typename TreeType>
394 inline TreeType& MultiResGrid<TreeType>::
395 tree(size_t level)
396 {
397 assert( level < mTrees.size() );
398 return *mTrees[level];
399 }
400
401 template<typename TreeType>
402 inline const TreeType& MultiResGrid<TreeType>::
403 constTree(size_t level) const
404 {
405 assert( level < mTrees.size() );
406 return *mTrees[level];
407 }
408
409 template<typename TreeType>
410 inline typename TreeType::Ptr MultiResGrid<TreeType>::
411 treePtr(size_t level)
412 {
413 assert( level < mTrees.size() );
414 return mTrees[level];
415 }
416
417 template<typename TreeType>
418 inline typename TreeType::ConstPtr MultiResGrid<TreeType>::
419 constTreePtr(size_t level) const
420 {
421 assert( level < mTrees.size() );
422 return mTrees[level];
423 }
424
425 template<typename TreeType>
426 typename Grid<TreeType>::Ptr MultiResGrid<TreeType>::
427 grid(size_t level)
428 {
429 typename Grid<TreeType>::Ptr grid = Grid<TreeType>::create(this->treePtr(level));
430 math::Transform::Ptr xform = mTransform->copy();
431 if (level>0) xform->preScale( Real(1 << level) );
432 grid->setTransform( xform );
433 grid->insertMeta( *this->copyMeta() );
434 grid->insertMeta( "MultiResGrid_Level", Int64Metadata(level));
435 std::stringstream ss;
436 ss << this->getName() << "_level_" << level;
437 grid->setName( ss.str() );
438 return grid;
439 }
440
441 template<typename TreeType>
442 inline typename Grid<TreeType>::ConstPtr MultiResGrid<TreeType>::
443 grid(size_t level) const
444 {
445 return const_cast<MultiResGrid*>(this)->grid(level);
446 }
447
448 template<typename TreeType>
449 template<Index Order>
450 typename Grid<TreeType>::Ptr MultiResGrid<TreeType>::
451 createGrid(float level, size_t grainSize) const
452 {
453 assert( level >= 0.0f && level <= float(mTrees.size()-1) );
454
455 typename Grid<TreeType>::Ptr grid(new Grid<TreeType>(this->constTree(0).background()));
456 math::Transform::Ptr xform = mTransform->copy();
457 xform->preScale( math::Pow(2.0f, level) );
458 grid->setTransform( xform );
459 grid->insertMeta( *(this->copyMeta()) );
460 grid->insertMeta( "MultiResGrid_Level", FloatMetadata(level) );
461 std::stringstream ss;
462 ss << this->getName() << "_level_" << level;
463 grid->setName( ss.str() );
464
465 if ( size_t(floorf(level)) == size_t(ceilf(level)) ) {
466 grid->setTree( this->constTree( size_t(floorf(level))).copy() );
467 } else {
468 FractionOp<Order> tmp(*this, grid->tree(), level, grainSize);
469 if ( grid->getGridClass() == GRID_LEVEL_SET ) {
470 signedFloodFill( grid->tree() );
471 pruneLevelSet( grid->tree() );//only creates inactive tiles
472 }
473 }
474
475 return grid;
476 }
477
478 template<typename TreeType>
479 GridPtrVecPtr MultiResGrid<TreeType>::
480 grids()
481 {
482 GridPtrVecPtr grids( new GridPtrVec );
483 for (size_t level=0; level<mTrees.size(); ++level) grids->push_back(this->grid(level));
484 return grids;
485 }
486
487 template<typename TreeType>
488 GridCPtrVecPtr MultiResGrid<TreeType>::
489 grids() const
490 {
491 GridCPtrVecPtr grids( new GridCPtrVec );
492 for (size_t level=0; level<mTrees.size(); ++level) grids->push_back(this->grid(level));
493 return grids;
494 }
495
496 template<typename TreeType>
497 Vec3R MultiResGrid<TreeType>::
498 xyz(const Coord& in_ijk, size_t in_level, size_t out_level)
499 {
500 return Vec3R( in_ijk.data() ) * Real(1 << in_level) / Real(1 << out_level);
501 }
502
503 template<typename TreeType>
504 Vec3R MultiResGrid<TreeType>::
505 xyz(const Vec3R& in_xyz, size_t in_level, size_t out_level)
506 {
507 return in_xyz * Real(1 << in_level) / Real(1 << out_level);
508 }
509
510 template<typename TreeType>
511 Vec3R MultiResGrid<TreeType>::
512 xyz(const Vec3R& in_xyz, double in_level, double out_level)
513 {
514 return in_xyz * math::Pow(2.0, in_level - out_level);
515
516 }
517
518 template<typename TreeType>
519 template<Index Order>
520 typename TreeType::ValueType MultiResGrid<TreeType>::
521 sampleValue(const Coord& in_ijk, size_t in_level, size_t out_level) const
522 {
523 assert( in_level >= 0 && in_level < mTrees.size() );
524 assert( out_level >= 0 && out_level < mTrees.size() );
525 const ConstAccessor acc(*mTrees[out_level]);// has disabled registration!
526 return tools::Sampler<Order>::sample( acc, this->xyz(in_ijk, in_level, out_level) );
527 }
528
529 template<typename TreeType>
530 template<Index Order>
531 typename TreeType::ValueType MultiResGrid<TreeType>::
532 sampleValue(const Vec3R& in_xyz, size_t in_level, size_t out_level) const
533 {
534 assert( in_level >= 0 && in_level < mTrees.size() );
535 assert( out_level >= 0 && out_level < mTrees.size() );
536 const ConstAccessor acc(*mTrees[out_level]);// has disabled registration!
537 return tools::Sampler<Order>::sample( acc, this->xyz(in_xyz, in_level, out_level) );
538 }
539
540 template<typename TreeType>
541 template<Index Order>
542 typename TreeType::ValueType MultiResGrid<TreeType>::
543 sampleValue(const Coord& ijk, double level) const
544 {
545 assert( level >= 0.0 && level <= double(mTrees.size()-1) );
546 const size_t level0 = size_t(floor(level)), level1 = size_t(ceil(level));
547 const ValueType v0 = this->template sampleValue<Order>( ijk, 0, level0 );
548 if ( level0 == level1 ) return v0;
549 assert( level1 - level0 == 1 );
550 const ValueType v1 = this->template sampleValue<Order>( ijk, 0, level1 );
551 OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
552 const ValueType a = ValueType(level1 - level);
553 OPENVDB_NO_TYPE_CONVERSION_WARNING_END
554 return a * v0 + (ValueType(1) - a) * v1;
555 }
556
557 template<typename TreeType>
558 template<Index Order>
559 typename TreeType::ValueType MultiResGrid<TreeType>::
560 sampleValue(const Vec3R& xyz, double level) const
561 {
562 assert( level >= 0.0 && level <= double(mTrees.size()-1) );
563 const size_t level0 = size_t(floor(level)), level1 = size_t(ceil(level));
564 const ValueType v0 = this->template sampleValue<Order>( xyz, 0, level0 );
565 if ( level0 == level1 ) return v0;
566 assert( level1 - level0 == 1 );
567 const ValueType v1 = this->template sampleValue<Order>( xyz, 0, level1 );
568 OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
569 const ValueType a = ValueType(level1 - level);
570 OPENVDB_NO_TYPE_CONVERSION_WARNING_END
571 return a * v0 + (ValueType(1) - a) * v1;
572 }
573
574 template<typename TreeType>
575 typename TreeType::ValueType MultiResGrid<TreeType>::
576 prolongateVoxel(const Coord& ijk, const size_t level) const
577 {
578 assert( level+1 < mTrees.size() );
579 const ConstAccessor acc(*mTrees[level + 1]);// has disabled registration!
580 return ProlongateOp::run(ijk, acc);
581 }
582
583 template<typename TreeType>
584 void MultiResGrid<TreeType>::
585 prolongateActiveVoxels(size_t destlevel, size_t grainSize)
586 {
587 assert( destlevel < mTrees.size()-1 );
588 TreeType &fineTree = *mTrees[ destlevel ];
589 const TreeType &coarseTree = *mTrees[ destlevel+1 ];
590 CookOp<ProlongateOp> tmp( coarseTree, fineTree, grainSize );
591 }
592
593 template<typename TreeType>
594 typename TreeType::ValueType MultiResGrid<TreeType>::
595 restrictVoxel(Coord ijk, const size_t destlevel, bool useInjection) const
596 {
597 assert( destlevel > 0 && destlevel < mTrees.size() );
598 const TreeType &fineTree = *mTrees[ destlevel-1 ];
599 if ( useInjection ) return fineTree.getValue(ijk<<1);
600 const ConstAccessor acc( fineTree );// has disabled registration!
601 return RestrictOp::run( ijk, acc);
602 }
603
604 template<typename TreeType>
605 void MultiResGrid<TreeType>::
606 restrictActiveVoxels(size_t destlevel, size_t grainSize)
607 {
608 assert( destlevel > 0 && destlevel < mTrees.size() );
609 const TreeType &fineTree = *mTrees[ destlevel-1 ];
610 TreeType &coarseTree = *mTrees[ destlevel ];
611 CookOp<RestrictOp> tmp( fineTree, coarseTree, grainSize );
612 }
613
614 template<typename TreeType>
615 void MultiResGrid<TreeType>::
616 print(std::ostream& os, int verboseLevel) const
617 {
618 os << "MultiResGrid with " << mTrees.size() << " levels\n";
619 for (size_t i=0; i<mTrees.size(); ++i) {
620 os << "Level " << i << ": ";
621 mTrees[i]->print(os, verboseLevel);
622 }
623
624 if ( MetaMap::metaCount() > 0) {
625 os << "Additional metadata:" << std::endl;
626 for (ConstMetaIterator it = beginMeta(), end = endMeta(); it != end; ++it) {
627 os << " " << it->first;
628 if (it->second) {
629 const std::string value = it->second->str();
630 if (!value.empty()) os << ": " << value;
631 }
632 os << "\n";
633 }
634 }
635
636 os << "Transform:" << std::endl;
637 transform().print(os, /*indent=*/" ");
638 os << std::endl;
639 }
640
641 template<typename TreeType>
642 void MultiResGrid<TreeType>::
643 initMeta()
644 {
645 const size_t levels = this->numLevels();
646 if (levels < 2) {
647 OPENVDB_THROW(ValueError, "MultiResGrid: at least two levels are required");
648 }
649 this->insertMeta("MultiResGrid_Levels", Int64Metadata( levels ) );
650 }
651
652 template<typename TreeType>
653 void MultiResGrid<TreeType>::
654 topDownRestrict(bool useInjection)
655 {
656 const bool isLevelSet = this->getGridClass() == GRID_LEVEL_SET;
657 for (size_t n=1; n<mTrees.size(); ++n) {
658 const TreeType &fineTree = *mTrees[n-1];
659 mTrees[n] = TreePtr(new TreeType( fineTree.background() ) );// empty tree
660 TreeType &coarseTree = *mTrees[n];
661 if (useInjection) {// Restriction by injection
662 for (ValueOnCIter it = fineTree.cbeginValueOn(); it; ++it) {
663 const Coord ijk = it.getCoord();
664 if ( (ijk[0] & 1) || (ijk[1] & 1) || (ijk[2] & 1) ) continue;
665 coarseTree.setValue( ijk >> 1, *it );
666 }
667 } else {// Restriction by full-weighting
668 MaskOp tmp(fineTree, coarseTree, 128);
669 this->restrictActiveVoxels(n, 64);
670 }
671 if ( isLevelSet ) {
672 tools::signedFloodFill( coarseTree );
673 tools::pruneLevelSet( coarseTree );//only creates inactive tiles
674 }
675 }// loop over grid levels
676 }
677
678 template<typename TreeType>
679 struct MultiResGrid<TreeType>::MaskOp
680 {
681 using MaskT = typename TreeType::template ValueConverter<ValueMask>::Type;
682 using PoolType = tbb::enumerable_thread_specific<TreeType>;
683 using ManagerT = tree::LeafManager<const MaskT>;
684 using RangeT = typename ManagerT::LeafRange;
685 using VoxelIterT = typename ManagerT::LeafNodeType::ValueOnCIter;
686
687 MaskOp(const TreeType& fineTree, TreeType& coarseTree, size_t grainSize = 1)
688 : mPool(new PoolType( coarseTree ) )// empty coarse tree acts as examplar
689 {
690 assert( coarseTree.empty() );
691
692 // Create Mask of restruction performed on fineTree
693 MaskT mask(fineTree, false, true, TopologyCopy() );
694
695 // Muli-threaded dilation which also linearizes the tree to leaf nodes
696 tools::dilateActiveValues(mask, 1, NN_FACE_EDGE_VERTEX, EXPAND_TILES);
697
698 // Restriction by injection using thread-local storage of coarse tree masks
699 ManagerT leafs( mask );
700 tbb::parallel_for(leafs.leafRange( grainSize ), *this);
701
702 // multithreaded union of thread-local coarse tree masks with the coarse tree
703 using IterT = typename PoolType::const_iterator;
704 for (IterT it=mPool->begin(); it!=mPool->end(); ++it) coarseTree.topologyUnion( *it );
705 delete mPool;
706 }
707 void operator()(const RangeT& range) const
708 {
709 Accessor coarseAcc( mPool->local() );// disabled registration
710 for (typename RangeT::Iterator leafIter = range.begin(); leafIter; ++leafIter) {
711 for (VoxelIterT voxelIter = leafIter->cbeginValueOn(); voxelIter; ++voxelIter) {
712 Coord ijk = voxelIter.getCoord();
713 if ( (ijk[2] & 1) || (ijk[1] & 1) || (ijk[0] & 1) ) continue;//no overlap
714 coarseAcc.setValueOn( ijk >> 1 );//injection from fine to coarse level
715 }//loop over active voxels in the fine tree
716 }// loop over leaf nodes in the fine tree
717 }
718 PoolType* mPool;
719 };// MaskOp
720
721 template<typename TreeType>
722 template<Index Order>
723 struct MultiResGrid<TreeType>::FractionOp
724 {
725 using MaskT = typename TreeType::template ValueConverter<ValueMask>::Type;
726 using PoolType = tbb::enumerable_thread_specific<MaskT>;
727 using PoolIterT = typename PoolType::iterator;
728 using Manager1 = tree::LeafManager<const TreeType>;
729 using Manager2 = tree::LeafManager<TreeType>;
730 using Range1 = typename Manager1::LeafRange;
731 using Range2 = typename Manager2::LeafRange;
732
733 FractionOp(const MultiResGrid& parent,
734 TreeType& midTree,
735 float level,
736 size_t grainSize = 1)
737 : mLevel( level )
738 , mPool(nullptr)
739 , mTree0( &*(parent.mTrees[size_t(floorf(level))]) )//high-resolution
740 , mTree1( &*(parent.mTrees[size_t(ceilf(level))]) ) //low-resolution
741 {
742 assert( midTree.empty() );
743 assert( mTree0 != mTree1 );
744
745 // Create a pool of thread-local masks
746 MaskT examplar( false );
747 mPool = new PoolType( examplar );
748
749 {// create mask from re-mapping coarse tree to mid-level tree
750 tree::LeafManager<const TreeType> manager( *mTree1 );
751 tbb::parallel_for( manager.leafRange(grainSize), *this );
752 }
753
754 // Multi-threaded dilation of mask
755 tbb::parallel_for(tbb::blocked_range<PoolIterT>(mPool->begin(),mPool->end(),1), *this);
756
757 // Union thread-local coarse tree masks into the coarse tree
758 for (PoolIterT it=mPool->begin(); it!=mPool->end(); ++it) midTree.topologyUnion( *it );
759 delete mPool;
760
761 {// Interpolate values into the static mid level tree
762 Manager2 manager( midTree );
763 tbb::parallel_for(manager.leafRange(grainSize), *this);
764 }
765 }
766 void operator()(const Range1& range) const
767 {
768 using VoxelIter = typename Manager1::LeafNodeType::ValueOnCIter;
769 // Let mLevel = level + frac, where
770 // level is integer part of mLevel and frac is the fractional part
771 // low-res voxel size in world units = dx1 = 2^(level + 1)
772 // mid-res voxel size in world units = dx = 2^(mLevel) = 2^(level + frac)
773 // low-res index -> world: ijk * dx1
774 // world -> mid-res index: world / dx
775 // low-res index -> mid-res index: (ijk * dx1) / dx = ijk * scale where
776 // scale = dx1/dx = 2^(level+1)/2^(level+frac) = 2^(1-frac)
777 const float scale = math::Pow(2.0f, 1.0f - math::FractionalPart(mLevel));
778 tree::ValueAccessor<MaskT, false> acc( mPool->local() );// disabled registration
779 for (typename Range1::Iterator leafIter = range.begin(); leafIter; ++leafIter) {
780 for (VoxelIter voxelIter = leafIter->cbeginValueOn(); voxelIter; ++voxelIter) {
781 Coord ijk = voxelIter.getCoord();
782 OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
783 const auto value0 = ijk[0] * scale;
784 const auto value1 = ijk[1] * scale;
785 const auto value2 = ijk[2] * scale;
786 OPENVDB_NO_TYPE_CONVERSION_WARNING_END
787 ijk[0] = int(math::Round(value0));
788 ijk[1] = int(math::Round(value1));
789 ijk[2] = int(math::Round(value2));
790
791 acc.setValueOn( ijk );
792 }//loop over active voxels in the fine tree
793 }// loop over leaf nodes in the fine tree
794 }
795 void operator()(const tbb::blocked_range<PoolIterT>& range) const
796 {
797 for (PoolIterT it=range.begin(); it!=range.end(); ++it) {
798 tools::dilateVoxels( *it, 1, NN_FACE_EDGE_VERTEX);
799 }
800 }
801 void operator()(const Range2 &r) const
802 {
803 using VoxelIter = typename TreeType::LeafNodeType::ValueOnIter;
804 // Let mLevel = level + frac, where
805 // level is integer part of mLevel and frac is the fractional part
806 // high-res voxel size in world units = dx0 = 2^(level)
807 // low-res voxel size in world units = dx1 = 2^(level+1)
808 // mid-res voxel size in world units = dx = 2^(mLevel) = 2^(level + frac)
809 // mid-res index -> world: ijk * dx
810 // world -> high-res index: world / dx0
811 // world -> low-res index: world / dx1
812 // mid-res index -> high-res index: (ijk * dx) / dx0 = ijk * scale0 where
813 // scale0 = dx/dx0 = 2^(level+frac)/2^(level) = 2^(frac)
814 // mid-res index -> low-res index: (ijk * dx) / dx1 = ijk * scale1 where
815 // scale1 = dx/dx1 = 2^(level+frac)/2^(level+1) = 2^(frac-1)
816 const float b = math::FractionalPart(mLevel), a = 1.0f - b;
817 const float scale0 = math::Pow( 2.0f, b );
818 const float scale1 = math::Pow( 2.0f,-a );
819 ConstAccessor acc0( *mTree0 ), acc1( *mTree1 );
820 for (typename Range2::Iterator leafIter = r.begin(); leafIter; ++leafIter) {
821 for (VoxelIter voxelIter = leafIter->beginValueOn(); voxelIter; ++voxelIter) {
822 const Vec3R xyz = Vec3R( voxelIter.getCoord().data() );// mid level coord
823 const ValueType v0 = tools::Sampler<Order>::sample( acc0, xyz * scale0 );
824 const ValueType v1 = tools::Sampler<Order>::sample( acc1, xyz * scale1 );
825 OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
826 const auto value0 = a*v0;
827 const auto value1 = b*v1;
828 OPENVDB_NO_TYPE_CONVERSION_WARNING_END
829 voxelIter.setValue( ValueType(value0 + value1) );
830 }
831 }
832 }
833 const float mLevel;
834 PoolType* mPool;
835 const TreeType *mTree0, *mTree1;
836 };// FractionOp
837
838
839 template<typename TreeType>
840 template<typename OperatorType>
841 struct MultiResGrid<TreeType>::CookOp
842 {
843 using ManagerT = tree::LeafManager<TreeType>;
844 using RangeT = typename ManagerT::LeafRange;
845
846 CookOp(const TreeType& srcTree, TreeType& dstTree, size_t grainSize): acc(srcTree)
847 {
848 ManagerT leafs(dstTree);
849 tbb::parallel_for(leafs.leafRange(grainSize), *this);
850 }
851 CookOp(const CookOp &other): acc(other.acc.tree()) {}
852
853 void operator()(const RangeT& range) const
854 {
855 for (auto leafIt = range.begin(); leafIt; ++leafIt) {
856 auto& phi = leafIt.buffer(0);
857 for (auto voxelIt = leafIt->beginValueOn(); voxelIt; ++voxelIt) {
858 phi.setValue(voxelIt.pos(), OperatorType::run(voxelIt.getCoord(), acc));
859 }
860 }
861 }
862
863 const ConstAccessor acc;
864 };// CookOp
865
866
867 template<typename TreeType>
868 struct MultiResGrid<TreeType>::RestrictOp
869 {
873 static ValueType run(Coord ijk, const ConstAccessor &acc)
874 {
875 ijk <<= 1;
876 // Overlapping grid point
877 ValueType v = 8*acc.getValue(ijk);
878 // neighbors in one axial direction
879 v += 4*(acc.getValue(ijk.offsetBy(-1, 0, 0)) + acc.getValue(ijk.offsetBy( 1, 0, 0)) +// x
880 acc.getValue(ijk.offsetBy( 0,-1, 0)) + acc.getValue(ijk.offsetBy( 0, 1, 0)) +// y
881 acc.getValue(ijk.offsetBy( 0, 0,-1)) + acc.getValue(ijk.offsetBy( 0, 0, 1)));// z
882 // neighbors in two axial directions
883 v += 2*(acc.getValue(ijk.offsetBy(-1,-1, 0)) + acc.getValue(ijk.offsetBy(-1, 1, 0)) +// xy
884 acc.getValue(ijk.offsetBy( 1,-1, 0)) + acc.getValue(ijk.offsetBy( 1, 1, 0)) +// xy
885 acc.getValue(ijk.offsetBy(-1, 0,-1)) + acc.getValue(ijk.offsetBy(-1, 0, 1)) +// xz
886 acc.getValue(ijk.offsetBy( 1, 0,-1)) + acc.getValue(ijk.offsetBy( 1, 0, 1)) +// xz
887 acc.getValue(ijk.offsetBy( 0,-1,-1)) + acc.getValue(ijk.offsetBy( 0,-1, 1)) +// yz
888 acc.getValue(ijk.offsetBy( 0, 1,-1)) + acc.getValue(ijk.offsetBy( 0, 1, 1)));// yz
889 // neighbors in three axial directions
890 for (int i=-1; i<=1; i+=2) {
891 for (int j=-1; j<=1; j+=2) {
892 for (int k=-1; k<=1; k+=2) v += acc.getValue(ijk.offsetBy(i,j,k));// xyz
893 }
894 }
895 v *= ValueType(1.0f/64.0f);
896 return v;
897 }
898 };// RestrictOp
899
900 template<typename TreeType>
901 struct MultiResGrid<TreeType>::ProlongateOp
902 {
906 static ValueType run(const Coord& ijk, const ConstAccessor &acc)
907 {
908 switch ( (ijk[0] & 1) | ((ijk[1] & 1) << 1) | ((ijk[2] & 1) << 2) ) {
909 case 0:// all even
910 return acc.getValue(ijk>>1);
911 case 1:// x is odd
912 return ValueType(0.5)*(acc.getValue(ijk.offsetBy(-1,0,0)>>1) +
913 acc.getValue(ijk.offsetBy( 1,0,0)>>1));
914 case 2:// y is odd
915 return ValueType(0.5)*(acc.getValue(ijk.offsetBy(0,-1,0)>>1) +
916 acc.getValue(ijk.offsetBy(0, 1,0)>>1));
917 case 3:// x&y are odd
918 return ValueType(0.25)*(acc.getValue(ijk.offsetBy(-1,-1,0)>>1) +
919 acc.getValue(ijk.offsetBy(-1, 1,0)>>1) +
920 acc.getValue(ijk.offsetBy( 1,-1,0)>>1) +
921 acc.getValue(ijk.offsetBy( 1, 1,0)>>1));
922 case 4:// z is odd
923 return ValueType(0.5)*(acc.getValue(ijk.offsetBy(0,0,-1)>>1) +
924 acc.getValue(ijk.offsetBy(0,0, 1)>>1));
925 case 5:// x&z are odd
926 return ValueType(0.25)*(acc.getValue(ijk.offsetBy(-1,0,-1)>>1) +
927 acc.getValue(ijk.offsetBy(-1,0, 1)>>1) +
928 acc.getValue(ijk.offsetBy( 1,0,-1)>>1) +
929 acc.getValue(ijk.offsetBy( 1,0, 1)>>1));
930 case 6:// y&z are odd
931 return ValueType(0.25)*(acc.getValue(ijk.offsetBy(0,-1,-1)>>1) +
932 acc.getValue(ijk.offsetBy(0,-1, 1)>>1) +
933 acc.getValue(ijk.offsetBy(0, 1,-1)>>1) +
934 acc.getValue(ijk.offsetBy(0, 1, 1)>>1));
935 }
936 // all are odd
937 ValueType v = zeroVal<ValueType>();
938 for (int i=-1; i<=1; i+=2) {
939 for (int j=-1; j<=1; j+=2) {
940 for (int k=-1; k<=1; k+=2) v += acc.getValue(ijk.offsetBy(i,j,k)>>1);// xyz
941 }
942 }
943 return ValueType(0.125) * v;
944 }
945 };// ProlongateOp
946
947 } // namespace tools
948 } // namespace OPENVDB_VERSION_NAME
949 } // namespace openvdb
950
951 #endif // OPENVDB_TOOLS_MULTIRESGRID_HAS_BEEN_INCLUDED
openvdb::v7_0::tools::MultiResGrid::finestConstTree
const TreeType & finestConstTree() const
Return a const reference to the tree at the finest level.
Definition: MultiResGrid.h:140
openvdb::v7_0::Int64Metadata
TypedMetadata< int64_t > Int64Metadata
Definition: Metadata.h:385
OPENVDB_NO_TYPE_CONVERSION_WARNING_END
#define OPENVDB_NO_TYPE_CONVERSION_WARNING_END
Definition: Platform.h:197
NodeManager.h
NodeManager produces linear arrays of all tree nodes allowing for efficient threading and bottom-up p...
openvdb::v7_0::tools::MultiResGrid::TreePtr
typename TreeType::Ptr TreePtr
Definition: MultiResGrid.h:67
openvdb::v7_0::tools::MultiResGrid::numLevels
size_t numLevels() const
Return the number of levels, i.e. trees, in this MultiResGrid.
Definition: MultiResGrid.h:106
Metadata.h
openvdb::v7_0::tools::MultiResGrid::ConstGridPtr
typename Grid< TreeType >::ConstPtr ConstGridPtr
Definition: MultiResGrid.h:70
openvdb::v7_0::math::Transform::Ptr
SharedPtr< Transform > Ptr
Definition: Transform.h:42
openvdb::v7_0::Vec3R
math::Vec3< Real > Vec3R
Definition: Types.h:49
openvdb::v7_0::Metadata::ConstPtr
SharedPtr< const Metadata > ConstPtr
Definition: Metadata.h:27
openvdb::v7_0::StringMetadata
TypedMetadata< std::string > StringMetadata
Definition: Metadata.h:386
openvdb::v7_0::tools::MultiResGrid::constTree
const TreeType & constTree(size_t level) const
Return a const reference to the tree at the specified level.
Definition: MultiResGrid.h:403
openvdb::v7_0::MetaMap::metaCount
size_t metaCount() const
Definition: MetaMap.h:91
openvdb::v7_0::math::Round
float Round(float x)
Return x rounded to the nearest integer.
Definition: Math.h:766
openvdb::v7_0::tools::MultiResGrid::setName
void setName(const std::string &name)
Set the name of this MultiResGrid.
Definition: MultiResGrid.h:297
openvdb::v7_0::math::Coord
Signed (x, y, z) 32-bit integer coordinates.
Definition: Coord.h:25
openvdb::v7_0::tree::ValueAccessor::setValueOn
void setValueOn(const Coord &xyz, const ValueType &value)
Definition: ValueAccessor.h:266
openvdb::v7_0::tools::MultiResGrid::ProlongateOp::run
static ValueType run(const Coord &ijk, const ConstAccessor &acc)
Interpolate values from a coarse grid (acc) into the index space (ijk) of a fine grid.
Definition: MultiResGrid.h:906
openvdb::v7_0::tree::LeafManager::leafRange
LeafRange leafRange(size_t grainsize=1) const
Return a TBB-compatible LeafRange.
Definition: LeafManager.h:358
openvdb::v7_0::math::FractionalPart
Type FractionalPart(Type x)
Return the fractional part of x.
Definition: Math.h:790
openvdb::v7_0::tools::MultiResGrid::finestLevel
static size_t finestLevel()
Return the level of the finest grid (always 0)
Definition: MultiResGrid.h:109
openvdb::v7_0::tools::MultiResGrid::MaskOp::mPool
PoolType * mPool
Definition: MultiResGrid.h:718
openvdb::v7_0::tools::MultiResGrid::restrictVoxel
ValueType restrictVoxel(Coord ijk, const size_t level, bool useInjection=false) const
Definition: MultiResGrid.h:595
openvdb::v7_0::tree::ValueAccessor
Definition: ValueAccessor.h:193
openvdb::v7_0::Grid::Ptr
SharedPtr< Grid > Ptr
Definition: Grid.h:574
openvdb::v7_0::tools::MultiResGrid::getGridClass
GridClass getGridClass() const
Return the class of volumetric data (level set, fog volume, etc.) stored in this grid.
Definition: MultiResGrid.h:304
openvdb::v7_0::GridCPtrVec
std::vector< GridBase::ConstPtr > GridCPtrVec
Definition: Grid.h:514
openvdb::v7_0::tools::MultiResGrid::ConstTreePtr
typename TreeType::ConstPtr ConstTreePtr
Definition: MultiResGrid.h:68
openvdb::v7_0::tools::MultiResGrid::print
void print(std::ostream &=std::cout, int verboseLevel=1) const
Output a human-readable description of this MultiResGrid.
Definition: MultiResGrid.h:616
openvdb::v7_0::tools::MultiResGrid::RestrictOp
Definition: MultiResGrid.h:868
openvdb::v7_0::tools::MultiResGrid::ValueOnIter
typename TreeType::ValueOnIter ValueOnIter
Definition: MultiResGrid.h:66
openvdb::v7_0::tools::MultiResGrid::MaskOp
Definition: MultiResGrid.h:679
openvdb::v7_0::FloatMetadata
TypedMetadata< float > FloatMetadata
Definition: Metadata.h:383
openvdb::v7_0::tools::MultiResGrid::finestTreePtr
TreePtr finestTreePtr()
Return a shared pointer to the tree at the finest level.
Definition: MultiResGrid.h:143
openvdb::v7_0::TypedMetadata::ConstPtr
SharedPtr< const TypedMetadata< T > > ConstPtr
Definition: Metadata.h:148
Grid.h
openvdb::v7_0::SharedPtr
std::shared_ptr< T > SharedPtr
Definition: Types.h:91
openvdb::v7_0::Real
double Real
Definition: Types.h:37
openvdb::v7_0::tools::MultiResGrid::createGrid
GridPtr createGrid(float level, size_t grainSize=1) const
Return a shared pointer to a new grid at the specified floating-point level.
openvdb::v7_0::tools::MultiResGrid::MaskOp::VoxelIterT
typename ManagerT::LeafNodeType::ValueOnCIter VoxelIterT
Definition: MultiResGrid.h:685
openvdb::v7_0::math::Pow
Type Pow(Type x, int n)
Return xn.
Definition: Math.h:508
openvdb::v7_0::math::Coord::offsetBy
Coord offsetBy(Int32 dx, Int32 dy, Int32 dz) const
Definition: Coord.h:92
openvdb::v7_0::tools::MultiResGrid::setGridClass
void setGridClass(GridClass cls)
Specify the class of volumetric data (level set, fog volume, etc.) stored in this grid.
Definition: MultiResGrid.h:312
openvdb::v7_0::tree::ValueAccessor::getValue
const ValueType & getValue(const Coord &xyz) const
Return the value of the voxel at the given coordinates.
Definition: ValueAccessor.h:230
openvdb::v7_0::tools::MultiResGrid::finestTree
TreeType & finestTree()
Return a reference to the tree at the finest level.
Definition: MultiResGrid.h:137
openvdb::v7_0::tools::MultiResGrid
Definition: MultiResGrid.h:58
openvdb::v7_0::GridCPtrVecPtr
SharedPtr< GridCPtrVec > GridCPtrVecPtr
Definition: Grid.h:517
openvdb::v7_0::Grid
Container class that associates a tree with a transform and metadata.
Definition: Grid.h:28
openvdb::v7_0::tools::MultiResGrid::ValueOnCIter
typename TreeType::ValueOnCIter ValueOnCIter
Definition: MultiResGrid.h:65
openvdb::v7_0::MetaMap::Ptr
SharedPtr< MetaMap > Ptr
Definition: MetaMap.h:22
openvdb::v7_0::tools::MultiResGrid::grid
GridPtr grid(size_t level)
Return a shared pointer to the grid at the specified integer level.
Definition: MultiResGrid.h:427
openvdb::v7_0::Grid::create
static Ptr create()
Return a new grid with background value zero.
Definition: Grid.h:1318
FiniteDifference.h
openvdb::v7_0::MetaMap
Container that maps names (strings) to values of arbitrary types.
Definition: MetaMap.h:19
Math.h
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
openvdb::v7_0::Grid::setTree
void setTree(TreeBase::Ptr) override
Associate the given tree with this grid, in place of its existing tree.
Definition: Grid.h:1460
openvdb::v7_0::tree::LeafManager::LeafRange
Definition: LeafManager.h:99
openvdb::v7_0::tools::MultiResGrid::tree
TreeType & tree(size_t level)
Return a reference to the tree at the specified level.
Definition: MultiResGrid.h:395
openvdb::v7_0::tools::MultiResGrid::getName
std::string getName() const
Return a string with the name of this MultiResGrid.
Definition: MultiResGrid.h:290
openvdb::v7_0::tools::pruneLevelSet
void pruneLevelSet(TreeT &tree, bool threaded=true, size_t grainSize=1)
Reduce the memory footprint of a tree by replacing nodes whose values are all inactive with inactive ...
Definition: Prune.h:389
Prune.h
Defined various multi-threaded utility functions for trees.
openvdb::v7_0::tools::MultiResGrid::constTreePtr
ConstTreePtr constTreePtr(size_t level) const
Return a const shared pointer to the tree at the specified level.
Definition: MultiResGrid.h:419
openvdb::v7_0::tools::MultiResGrid::prolongateActiveVoxels
void prolongateActiveVoxels(size_t destlevel, size_t grainSize=1)
Definition: MultiResGrid.h:585
openvdb::v7_0::tools::MultiResGrid::xyz
static Vec3R xyz(const Coord &in_ijk, size_t in_level, size_t out_level)
Return the floating-point index coordinate at out_level given the index coordinate in_xyz at in_level...
Definition: MultiResGrid.h:498
openvdb::v7_0::tools::MultiResGrid::prolongateVoxel
ValueType prolongateVoxel(const Coord &coords, const size_t level) const
Return the value at coordinate location in level tree from the coarser tree at level+1 using trilinea...
Definition: MultiResGrid.h:576
ValueTransformer.h
openvdb::v7_0::tree::LeafManager
This class manages a linear array of pointers to a given tree's leaf nodes, as well as optional auxil...
Definition: LeafManager.h:82
openvdb::v7_0::tools::MultiResGrid::clearGridClass
void clearGridClass()
Remove the setting specifying the class of this grid's volumetric data.
Definition: MultiResGrid.h:318
openvdb::v7_0::TopologyCopy
Tag dispatch class that distinguishes topology copy constructors from deep copy constructors.
Definition: Types.h:681
openvdb::v7_0::tools::MultiResGrid::coarsestConstTreePtr
ConstTreePtr coarsestConstTreePtr() const
Return a const shared pointer to the tree at the coarsest level.
Definition: MultiResGrid.h:158
openvdb::v7_0::GRID_UNKNOWN
@ GRID_UNKNOWN
Definition: Types.h:453
openvdb::v7_0::math::Vec3< Real >
openvdb::v7_0::tools::MultiResGrid::finestConstTreePtr
ConstTreePtr finestConstTreePtr() const
Return a const shared pointer to the tree at the finest level.
Definition: MultiResGrid.h:146
openvdb::v7_0::tools::MultiResGrid::MaskOp::MaskOp
MaskOp(const TreeType &fineTree, TreeType &coarseTree, size_t grainSize=1)
Definition: MultiResGrid.h:687
openvdb::v7_0::tools::MultiResGrid::coarsestTree
TreeType & coarsestTree()
Return a reference to the tree at the coarsest level.
Definition: MultiResGrid.h:149
openvdb::v7_0::tools::MultiResGrid::ValueType
typename TreeType::ValueType ValueType
Definition: MultiResGrid.h:64
openvdb::v7_0::tools::MultiResGrid::transform
const math::Transform & transform() const
Definition: MultiResGrid.h:201
Interpolation.h
openvdb::v7_0::tools::MultiResGrid::GridPtr
typename Grid< TreeType >::Ptr GridPtr
Definition: MultiResGrid.h:69
openvdb::v7_0::tools::MultiResGrid::grids
GridPtrVecPtr grids()
Return a shared pointer to a vector of all the base grids in this instance of the MultiResGrid.
Definition: MultiResGrid.h:480
openvdb::v7_0::tools::dilateVoxels
void dilateVoxels(TreeType &tree, int iterations=1, NearestNeighbors nn=NN_FACE)
Topologically dilate all leaf-level active voxels in a tree using one of three nearest neighbor conne...
Definition: Morphology.h:826
openvdb::v7_0::tools::MultiResGrid::coarsestTreePtr
TreePtr coarsestTreePtr()
Return a shared pointer to the tree at the coarsest level.
Definition: MultiResGrid.h:155
openvdb::v7_0::tools::dilateActiveValues
void dilateActiveValues(TreeType &tree, int iterations=1, NearestNeighbors nn=NN_FACE, TilePolicy mode=PRESERVE_TILES)
Topologically dilate all active values (i.e. both voxels and tiles) in a tree using one of three near...
Definition: Morphology.h:1047
OPENVDB_USE_VERSION_NAMESPACE
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:154
openvdb::v7_0::tools::MultiResGrid::ProlongateOp
Definition: MultiResGrid.h:901
openvdb::v7_0::tools::MultiResGrid::treePtr
TreePtr treePtr(size_t level)
Return a shared pointer to the tree at the specified level.
Definition: MultiResGrid.h:411
openvdb::v7_0::MetaMap::ConstMetaIterator
MetadataMap::const_iterator ConstMetaIterator
Definition: MetaMap.h:28
openvdb::v7_0::tools::MultiResGrid::coarsestLevel
size_t coarsestLevel() const
Return the level of the coarsest grid, i.e. numLevels()-1.
Definition: MultiResGrid.h:112
openvdb::v7_0::tools::NN_FACE_EDGE_VERTEX
@ NN_FACE_EDGE_VERTEX
Definition: Morphology.h:60
LeafManager.h
A LeafManager manages a linear array of pointers to a given tree's leaf nodes, as well as optional au...
openvdb::v7_0::tools::Sampler::sample
static bool sample(const TreeT &inTree, const Vec3R &inCoord, typename TreeT::ValueType &result)
Sample inTree at the floating-point index coordinate inCoord and store the result in result.
openvdb::v7_0::tools::MultiResGrid::RestrictOp::run
static ValueType run(Coord ijk, const ConstAccessor &acc)
Static method that performs restriction by full weighting.
Definition: MultiResGrid.h:873
OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
#define OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN
Bracket code with OPENVDB_NO_TYPE_CONVERSION_WARNING_BEGIN/_END, to inhibit warnings about type conve...
Definition: Platform.h:196
openvdb::v7_0::tools::MultiResGrid::MaskOp::operator()
void operator()(const RangeT &range) const
Definition: MultiResGrid.h:707
SignedFloodFill.h
Propagate the signs of distance values from the active voxels in the narrow band to the inactive valu...
openvdb::v7_0::tools::MultiResGrid::sampleValue
ValueType sampleValue(const Coord &in_ijk, size_t in_level, size_t out_level) const
Return the value at the specified coordinate position using interpolation of the specified order into...
openvdb::v7_0::tools::MultiResGrid::MaskOp::MaskT
typename TreeType::template ValueConverter< ValueMask >::Type MaskT
Definition: MultiResGrid.h:681
openvdb::v7_0::math::Transform
Definition: Transform.h:39
Morphology.h
Implementation of morphological dilation and erosion.
openvdb::v7_0::tools::MultiResGrid::constTransform
const math::Transform & constTransform() const
Definition: MultiResGrid.h:202
Stencils.h
Defines various finite difference stencils by means of the "curiously recurring template pattern" on ...
openvdb::v7_0::tools::MultiResGrid::restrictActiveVoxels
void restrictActiveVoxels(size_t destlevel, size_t grainSize=1)
Definition: MultiResGrid.h:606
openvdb::v7_0::tools::MultiResGrid::coarsestConstTree
const TreeType & coarsestConstTree() const
Return a const reference to the tree at the coarsest level.
Definition: MultiResGrid.h:152
OPENVDB_VERSION_NAME
#define OPENVDB_VERSION_NAME
Definition: version.h:108
openvdb::v7_0::MetaMap::ConstPtr
SharedPtr< const MetaMap > ConstPtr
Definition: MetaMap.h:23
openvdb::v7_0::math::scale
MatType scale(const Vec3< typename MatType::value_type > &s)
Return a matrix that scales by s.
Definition: Mat.h:620
openvdb::v7_0::GridPtrVec
std::vector< GridBase::Ptr > GridPtrVec
Definition: Grid.h:509
openvdb::v7_0::io::getGridClass
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...
openvdb::v7_0::ValueError
Definition: Exceptions.h:65
openvdb::v7_0::GridClass
GridClass
Definition: Types.h:452
openvdb::v7_0::GRID_LEVEL_SET
@ GRID_LEVEL_SET
Definition: Types.h:454
openvdb::v7_0::GridPtrVecPtr
SharedPtr< GridPtrVec > GridPtrVecPtr
Definition: Grid.h:512
openvdb
Definition: Exceptions.h:13
openvdb::v7_0::Grid::ConstPtr
SharedPtr< const Grid > ConstPtr
Definition: Grid.h:575
openvdb::v7_0::tools::EXPAND_TILES
@ EXPAND_TILES
Definition: Morphology.h:75
openvdb::v7_0::createGrid
GridType::Ptr createGrid(const typename GridType::ValueType &background)
Create a new grid of type GridType with a given background value.
Definition: Grid.h:1728
Operators.h
openvdb::v7_0::tools::MultiResGrid::MultiResGrid
MultiResGrid(size_t levels, ValueType background, double voxelSize=1.0)
Constructor of empty grids.
Definition: MultiResGrid.h:358
OPENVDB_THROW
#define OPENVDB_THROW(exception, message)
Definition: Exceptions.h:82
openvdb::v7_0::tools::signedFloodFill
void signedFloodFill(TreeOrLeafManagerT &tree, bool threaded=true, size_t grainSize=1, Index minLevel=0)
Set the values of all inactive voxels and tiles of a narrow-band level set from the signs of the acti...
Definition: SignedFloodFill.h:266
openvdb::v7_0::Grid::tree
TreeType & tree()
Return a reference to this grid's tree, which might be shared with other grids.
Definition: Grid.h:905
openvdb::v7_0::tools::MultiResGrid::MaskOp::RangeT
typename ManagerT::LeafRange RangeT
Definition: MultiResGrid.h:684
openvdb::v7_0::math::Coord::data
const Int32 * data() const
Definition: Coord.h:140
openvdb::v7_0::tools::MultiResGrid::MaskOp::PoolType
tbb::enumerable_thread_specific< TreeType > PoolType
Definition: MultiResGrid.h:682