9#ifndef OPENVDB_TOOLS_DENSE_HAS_BEEN_INCLUDED 
   10#define OPENVDB_TOOLS_DENSE_HAS_BEEN_INCLUDED 
   19#include <tbb/parallel_for.h> 
   36template<
typename DenseT, 
typename Gr
idOrTreeT>
 
   39    const GridOrTreeT& sparse,
 
   50template<
typename DenseT, 
typename Gr
idOrTreeT>
 
   55    const typename GridOrTreeT::ValueType& tolerance,
 
   74template<
typename ValueT, MemoryLayout Layout> 
class DenseBase;
 
   79template<
typename ValueT>
 
   97      const size_t x = n / 
mX;
 
   99      const size_t y = n / 
mY;
 
 
 
  126template<
typename ValueT>
 
  144        const size_t z = n / 
mZ;
 
  146        const size_t y = n / 
mY;
 
 
 
  182template<
typename ValueT, MemoryLayout Layout = LayoutZYX>
 
  221        if (BaseT::mBBox.empty()) {
 
 
  244    inline ValueT* 
data() { 
return mData; }
 
  248    inline const ValueT* 
data()
 const { 
return mData; }
 
  261    inline void setValue(
size_t offset, 
const ValueT& value) { mData[offset] = value; }
 
  264    const ValueT& 
getValue(
size_t offset)
 const { 
return mData[offset]; }
 
  267    ValueT& 
getValue(
size_t offset) { 
return mData[offset]; }
 
  271    inline void setValue(
size_t i, 
size_t j, 
size_t k, 
const ValueT& value)
 
  273        mData[BaseT::coordToOffset(i,j,k)] = value;
 
 
  279    inline const ValueT& 
getValue(
size_t i, 
size_t j, 
size_t k)
 const 
  281        return mData[BaseT::coordToOffset(i,j,k)];
 
 
  287    inline ValueT& 
getValue(
size_t i, 
size_t j, 
size_t k)
 
  289        return mData[BaseT::coordToOffset(i,j,k)];
 
 
  315    inline void fill(
const ValueT& value)
 
  319        while(size--) *a++ = value;
 
 
  331        return BaseT::coordToOffset(
size_t(xyz[0]-BaseT::mBBox.min()[0]),
 
  332                                    size_t(xyz[1]-BaseT::mBBox.min()[1]),
 
  333                                    size_t(xyz[2]-BaseT::mBBox.min()[2]));
 
 
  345        return sizeof(*this) + BaseT::mBBox.volume() * 
sizeof(
ValueType);
 
 
  350    void print(
const std::string& name = 
"", std::ostream& os = std::cout)
 const 
  352        const Coord dim = BaseT::mBBox.dim();
 
  354        if (!name.empty()) os << 
" \"" << name << 
"\"";
 
  356        os << 
"  Dimensions of grid  :   " << dim[0] << 
" x " << dim[1] << 
" x " << dim[2] << 
"\n";
 
  358        os << 
"  Bounding box of voxels: " << BaseT::mBBox << 
"\n";
 
  359        os << 
"  Memory layout:          " << (Layout == 
LayoutZYX ? 
"ZYX (" : 
"XYZ (dis")
 
  360           << 
"similar to VDB)\n";
 
 
  367        if (BaseT::mBBox.empty()) {
 
  370        mArray.reset(
new ValueT[BaseT::mBBox.volume()]);
 
  371        mData = mArray.get();
 
  374    std::unique_ptr<ValueT[]> mArray;
 
 
  387template<
typename _TreeT, 
typename _DenseT = Dense<
typename _TreeT::ValueType> >
 
  393    using ValueT = 
typename TreeT::ValueType;
 
  396        : mRoot(&(
tree.root())), mDense(&dense) {}
 
 
  398    void copy(
bool serial = 
false)
 const 
  401            mRoot->copyToDense(mDense->bbox(), *mDense);
 
  403            tbb::parallel_for(mDense->bbox(), *
this);
 
 
  410        mRoot->copyToDense(bbox, *mDense);
 
 
  414    const typename TreeT::RootNodeType* mRoot;
 
 
  420template<
typename DenseT, 
typename Gr
idOrTreeT>
 
  425    using TreeT = 
typename Adapter::TreeType;
 
 
  444template<
typename _TreeT, 
typename _DenseT = Dense<
typename _TreeT::ValueType> >
 
  450    using ValueT = 
typename TreeT::ValueType;
 
  451    using LeafT = 
typename TreeT::LeafNodeType;
 
  458          mTolerance(tolerance),
 
 
  463        : mDense(other.mDense),
 
  465          mBlocks(other.mBlocks),
 
  466          mTolerance(other.mTolerance),
 
  467          mAccessor(other.mAccessor.get() == nullptr ? nullptr : new 
AccessorT(*mTree))
 
 
  474        mBlocks = 
new std::vector<Block>();
 
  478            for (sub.min()[1] = bbox.
min()[1]; sub.
min()[1] <= bbox.
max()[1];
 
  479                 sub.
min()[1] = sub.
max()[1] + 1)
 
  481                for (sub.min()[2] = bbox.
min()[2]; sub.
min()[2] <= bbox.
max()[2];
 
  482                     sub.
min()[2] = sub.
max()[2] + 1)
 
  485                        (sub.min()&(~(LeafT::DIM-1u))).
offsetBy(LeafT::DIM-1u));
 
  486                    mBlocks->push_back(Block(sub));
 
  493            (*this)(tbb::blocked_range<size_t>(0, mBlocks->size()));
 
  495            tbb::parallel_for(tbb::blocked_range<size_t>(0, mBlocks->size()), *
this);
 
  500        for (
size_t m=0, size = mBlocks->size(); m<size; ++m) {
 
  501            Block& block = (*mBlocks)[m];
 
  504            } 
else if (block.tile.second) {
 
  505                acc.
addTile(1, block.bbox.
min(), block.tile.first, 
true);
 
 
  521        for (
size_t m=r.begin(), n=0, end = r.end(); m != end; ++m, ++n) {
 
  523            Block& block = (*mBlocks)[m];
 
  526            if (mAccessor.get() == 
nullptr) {
 
  527                leaf->fill(mTree->background(), 
false);
 
  529                if (
const LeafT* target = mAccessor->probeConstLeaf(bbox.
min())) {
 
  533                    bool state = mAccessor->probeValue(bbox.
min(), value);
 
  534                    leaf->fill(value, state);
 
  538            leaf->copyFromDense(bbox, *mDense, mTree->background(), mTolerance);
 
  540            if (!leaf->isConstant(block.tile.first, block.tile.second, mTolerance)) {
 
  541                leaf->setOrigin(bbox.
min() & (~(LeafT::DIM - 1)));
 
 
  554        std::pair<ValueT, bool> tile;
 
  555        Block(
const CoordBBox& b) : bbox(b), leaf(nullptr) {}
 
  558    const DenseT*              mDense;
 
  560    std::vector<Block>*        mBlocks;
 
  562    std::unique_ptr<AccessorT> mAccessor;
 
 
  567template<
typename DenseT, 
typename Gr
idOrTreeT>
 
  570    const typename GridOrTreeT::ValueType& tolerance, 
bool serial)
 
  573    using TreeT = 
typename Adapter::TreeType;
 
 
#define OPENVDB_ASSERT(X)
Definition Assert.h:41
Defined various multi-threaded utility functions for trees.
ValueAccessors are designed to help accelerate accesses into the OpenVDB Tree structures by storing c...
Int32 ValueType
Definition Coord.h:33
void minComponent(const Coord &other)
Perform a component-wise minimum with the other Coord.
Definition Coord.h:176
Definition Exceptions.h:65
Axis-aligned bounding box of signed integer coordinates.
Definition Coord.h:252
const Coord & min() const
Definition Coord.h:324
const Coord & max() const
Definition Coord.h:325
Signed (x, y, z) 32-bit integer coordinates.
Definition Coord.h:26
Coord offsetBy(Int32 dx, Int32 dy, Int32 dz) const
Definition Coord.h:92
static Coord min()
Return the smallest possible coordinate.
Definition Coord.h:44
static Coord max()
Return the largest possible coordinate.
Definition Coord.h:47
void addLeaf(LeafNodeT *leaf)
Add the specified leaf to this tree, possibly creating a child branch in the process....
Definition ValueAccessor.h:729
void addTile(Index level, const Coord &xyz, const ValueType &value, bool state)
Add a tile at the specified tree level that contains the coordinate xyz, possibly deleting existing n...
Definition ValueAccessor.h:754
Definition PointDataGrid.h:170
ValueAccessorImpl< TreeType, IsSafe, MutexType, openvdb::make_index_sequence< CacheLevels > > ValueAccessor
Default alias for a ValueAccessor. This is simply a helper alias for the generic definition but takes...
Definition ValueAccessor.h:86
FormattedInt< IntT > formattedInt(IntT n)
Definition Formats.h:118
OPENVDB_API int printBytes(std::ostream &os, uint64_t bytes, const std::string &head="", const std::string &tail="\n", bool exact=false, int width=8, int precision=3)
constexpr T zeroVal()
Return the value of type T that corresponds to zero.
Definition Math.h:70
uint64_t Index64
Definition Types.h:53
std::shared_ptr< T > SharedPtr
Definition Types.h:114
Definition Exceptions.h:13
#define OPENVDB_THROW(exception, message)
Definition Exceptions.h:74
This adapter allows code that is templated on a Tree type to accept either a Tree type or a Grid type...
Definition Grid.h:1060
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition version.h.in:218