Merge pull request #1493 from danrbailey/remove_deprecated_methods

Remove all functionality deprecated prior to VDB 9.0

Author: danrbailey

openvdb/openvdb/tools/FindActiveValues.h

@@ -179,15 +179,6 @@ class FindActiveValues
     ///        between active tiles in the tree and the specified bounding box.
     std::vector<TileDataT> activeTiles(const CoordBBox &bbox) const;
 
-    OPENVDB_DEPRECATED_MESSAGE("Use anyActiveValues() instead") inline bool any(const CoordBBox &bbox, bool useAccessor = false) const
-    {
-        return this->anyActiveValues(bbox, useAccessor);
-    }
-    OPENVDB_DEPRECATED_MESSAGE("Use noActiveValues() instead") inline bool none(const CoordBBox &bbox, bool useAccessor = false) const
-    {
-        return this->noActiveValues(bbox, useAccessor);
-    }
-
 private:
 
     // Cleans up internal data structures

openvdb/openvdb/tools/Morphology.h

@@ -1182,97 +1182,6 @@ void erodeActiveValues(TreeOrLeafManagerT& treeOrLeafM,
 }
 
 
-/////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////
-
-
-/// @brief Topologically dilate all leaf-level active voxels in a tree
-/// using one of three nearest neighbor connectivity patterns.
-/// @warning This method is NOT multi-threaded and ignores active tiles!
-///
-/// @param tree          tree to be dilated
-/// @param iterations    number of iterations to apply the dilation
-/// @param nn            connectivity pattern of the dilation: either
-///     face-adjacent (6 nearest neighbors), face- and edge-adjacent
-///     (18 nearest neighbors) or face-, edge- and vertex-adjacent (26
-///     nearest neighbors).
-///
-/// @note The values of any voxels are unchanged.
-template<typename TreeType>
-OPENVDB_DEPRECATED_MESSAGE("Switch to tools::dilateActiveValues. Use tools::IGNORE_TILES to maintain same (but perhaps unintended) behaviour")
-inline void dilateVoxels(TreeType& tree,
-                         int iterations = 1,
-                         NearestNeighbors nn = NN_FACE)
-{
-    if (iterations <= 0) return;
-    morphology::Morphology<TreeType> morph(tree);
-    morph.setThreaded(false); // backwards compatible
-    // This will also sync the leaf manager
-    morph.dilateVoxels(static_cast<size_t>(iterations), nn, /*prune=*/false);
-}
-
-/// @brief Topologically dilate all leaf-level active voxels in a tree
-/// using one of three nearest neighbor connectivity patterns.
-/// @warning This method is NOT multi-threaded and ignores active tiles!
-///
-/// @param manager       LeafManager containing the tree to be dilated.
-///                      On exit it is updated to include all the leaf
-///                      nodes of the dilated tree.
-/// @param iterations    number of iterations to apply the dilation
-/// @param nn           connectivity pattern of the dilation: either
-///     face-adjacent (6 nearest neighbors), face- and edge-adjacent
-///     (18 nearest neighbors) or face-, edge- and vertex-adjacent (26
-///     nearest neighbors).
-///
-/// @note The values of any voxels are unchanged.
-template<typename TreeType>
-OPENVDB_DEPRECATED_MESSAGE("Switch to tools::dilateActiveValues. Use tools::IGNORE_TILES to maintain same (but perhaps unintended) behaviour")
-inline void dilateVoxels(tree::LeafManager<TreeType>& manager,
-                         int iterations = 1,
-                         NearestNeighbors nn = NN_FACE)
-{
-    if (iterations <= 0) return;
-    morphology::Morphology<TreeType> morph(manager);
-    morph.setThreaded(false);
-    morph.dilateVoxels(static_cast<size_t>(iterations), nn, /*prune=*/false);
-}
-
-//@{
-/// @brief Topologically erode all leaf-level active voxels in the given tree.
-/// @details That is, shrink the set of active voxels by @a iterations voxels
-/// in the +x, -x, +y, -y, +z and -z directions, but don't change the values
-/// of any voxels, only their active states.
-/// @todo Currently operates only on leaf voxels; need to extend to tiles.
-template<typename TreeType>
-OPENVDB_DEPRECATED_MESSAGE("Switch to tools::erodeActiveValues. Use tools::IGNORE_TILES to maintain same (but perhaps unintended) behaviour")
-inline void erodeVoxels(TreeType& tree,
-                        int iterations=1,
-                        NearestNeighbors nn = NN_FACE)
-{
-    if (iterations > 0) {
-        morphology::Morphology<TreeType> morph(tree);
-        morph.setThreaded(true);
-        morph.erodeVoxels(static_cast<size_t>(iterations), nn, /*prune=*/false);
-    }
-
-    tools::pruneLevelSet(tree); // matches old behaviour
-}
-
-template<typename TreeType>
-OPENVDB_DEPRECATED_MESSAGE("Switch to tools::erodeActiveValues. Use tools::IGNORE_TILES to maintain same (but perhaps unintended) behaviour")
-inline void erodeVoxels(tree::LeafManager<TreeType>& manager,
-                        int iterations = 1,
-                        NearestNeighbors nn = NN_FACE)
-{
-    if (iterations <= 0) return;
-    morphology::Morphology<TreeType> morph(manager);
-    morph.setThreaded(true);
-    morph.erodeVoxels(static_cast<size_t>(iterations), nn, /*prune=*/false);
-    tools::pruneLevelSet(manager.tree()); // matches old behaviour
-}
-//@}
-
-
 ////////////////////////////////////////
 
 

openvdb/openvdb/tree/InternalNode.h

@@ -568,25 +568,6 @@ class InternalNode
     template<typename CombineOp, typename OtherValueType>
     void combine2(const InternalNode& other, const OtherValueType&, bool valIsActive, CombineOp&);
 
-    /// @brief Calls the templated functor BBoxOp with bounding box
-    /// information for all active tiles and leaf nodes in this node.
-    /// An additional level argument is provided for each callback.
-    ///
-    /// @note The bounding boxes are guaranteed to be non-overlapping.
-    template<typename BBoxOp> void visitActiveBBox(BBoxOp&) const;
-
-    template<typename VisitorOp> void visit(VisitorOp&);
-    template<typename VisitorOp> void visit(VisitorOp&) const;
-
-    template<typename OtherNodeType, typename VisitorOp>
-    void visit2Node(OtherNodeType& other, VisitorOp&);
-    template<typename OtherNodeType, typename VisitorOp>
-    void visit2Node(OtherNodeType& other, VisitorOp&) const;
-    template<typename IterT, typename VisitorOp>
-    void visit2(IterT& otherIter, VisitorOp&, bool otherIsLHS = false);
-    template<typename IterT, typename VisitorOp>
-    void visit2(IterT& otherIter, VisitorOp&, bool otherIsLHS = false) const;
-
     /// Set all voxels that lie outside the given axis-aligned box to the background.
     void clip(const CoordBBox&, const ValueType& background);
 
@@ -791,17 +772,6 @@ class InternalNode
     void resetChildNode(Index i, ChildNodeType* child);//checks for an existing child
     ChildNodeType* unsetChildNode(Index i, const ValueType& value);
 
-    template<typename NodeT, typename VisitorOp, typename ChildAllIterT>
-    static inline void doVisit(NodeT&, VisitorOp&);
-
-    template<typename NodeT, typename OtherNodeT, typename VisitorOp,
-        typename ChildAllIterT, typename OtherChildAllIterT>
-    static inline void doVisit2Node(NodeT&, OtherNodeT&, VisitorOp&);
-
-    template<typename NodeT, typename VisitorOp,
-        typename ChildAllIterT, typename OtherChildAllIterT>
-    static inline void doVisit2(NodeT&, OtherChildAllIterT&, VisitorOp&, bool otherIsLHS);
-
     ///@{
     /// @brief Returns a pointer to the child node at the linear offset n.
     /// @warning This protected method assumes that a child node exists at
@@ -2886,173 +2856,6 @@ InternalNode<ChildT, Log2Dim>::combine2(const InternalNode& other, const OtherVa
 ////////////////////////////////////////
 
 
-template<typename ChildT, Index Log2Dim>
-template<typename BBoxOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visitActiveBBox(BBoxOp& op) const
-{
-    for (ValueOnCIter i = this->cbeginValueOn(); i; ++i) {
-        op.template operator()<LEVEL>(CoordBBox::createCube(i.getCoord(), ChildNodeType::DIM));
-    }
-    if (op.template descent<LEVEL>()) {
-        for (ChildOnCIter i = this->cbeginChildOn(); i; ++i) i->visitActiveBBox(op);
-    } else {
-        for (ChildOnCIter i = this->cbeginChildOn(); i; ++i) {
-            op.template operator()<LEVEL>(i->getNodeBoundingBox());
-        }
-    }
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit(VisitorOp& op)
-{
-    doVisit<InternalNode, VisitorOp, ChildAllIter>(*this, op);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit(VisitorOp& op) const
-{
-    doVisit<const InternalNode, VisitorOp, ChildAllCIter>(*this, op);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename NodeT, typename VisitorOp, typename ChildAllIterT>
-inline void
-InternalNode<ChildT, Log2Dim>::doVisit(NodeT& self, VisitorOp& op)
-{
-    typename NodeT::ValueType val;
-    for (ChildAllIterT iter = self.beginChildAll(); iter; ++iter) {
-        if (op(iter)) continue;
-        if (typename ChildAllIterT::ChildNodeType* child = iter.probeChild(val)) {
-            child->visit(op);
-        }
-    }
-}
-
-
-////////////////////////////////////////
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename OtherNodeType, typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit2Node(OtherNodeType& other, VisitorOp& op)
-{
-    doVisit2Node<InternalNode, OtherNodeType, VisitorOp, ChildAllIter,
-        typename OtherNodeType::ChildAllIter>(*this, other, op);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename OtherNodeType, typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit2Node(OtherNodeType& other, VisitorOp& op) const
-{
-    doVisit2Node<const InternalNode, OtherNodeType, VisitorOp, ChildAllCIter,
-        typename OtherNodeType::ChildAllCIter>(*this, other, op);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<
-    typename NodeT,
-    typename OtherNodeT,
-    typename VisitorOp,
-    typename ChildAllIterT,
-    typename OtherChildAllIterT>
-inline void
-InternalNode<ChildT, Log2Dim>::doVisit2Node(NodeT& self, OtherNodeT& other, VisitorOp& op)
-{
-    // Allow the two nodes to have different ValueTypes, but not different dimensions.
-    static_assert(OtherNodeT::NUM_VALUES == NodeT::NUM_VALUES,
-        "visit2() requires nodes to have the same dimensions");
-    static_assert(OtherNodeT::LEVEL == NodeT::LEVEL,
-        "visit2() requires nodes to be at the same tree level");
-
-    typename NodeT::ValueType val;
-    typename OtherNodeT::ValueType otherVal;
-
-    ChildAllIterT iter = self.beginChildAll();
-    OtherChildAllIterT otherIter = other.beginChildAll();
-
-    for ( ; iter && otherIter; ++iter, ++otherIter)
-    {
-        const size_t skipBranch = static_cast<size_t>(op(iter, otherIter));
-
-        typename ChildAllIterT::ChildNodeType* child =
-            (skipBranch & 1U) ? nullptr : iter.probeChild(val);
-        typename OtherChildAllIterT::ChildNodeType* otherChild =
-            (skipBranch & 2U) ? nullptr : otherIter.probeChild(otherVal);
-
-        if (child != nullptr && otherChild != nullptr) {
-            child->visit2Node(*otherChild, op);
-        } else if (child != nullptr) {
-            child->visit2(otherIter, op);
-        } else if (otherChild != nullptr) {
-            otherChild->visit2(iter, op, /*otherIsLHS=*/true);
-        }
-    }
-}
-
-
-////////////////////////////////////////
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename OtherChildAllIterType, typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit2(OtherChildAllIterType& otherIter,
-    VisitorOp& op, bool otherIsLHS)
-{
-    doVisit2<InternalNode, VisitorOp, ChildAllIter, OtherChildAllIterType>(
-        *this, otherIter, op, otherIsLHS);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename OtherChildAllIterType, typename VisitorOp>
-inline void
-InternalNode<ChildT, Log2Dim>::visit2(OtherChildAllIterType& otherIter,
-    VisitorOp& op, bool otherIsLHS) const
-{
-    doVisit2<const InternalNode, VisitorOp, ChildAllCIter, OtherChildAllIterType>(
-        *this, otherIter, op, otherIsLHS);
-}
-
-
-template<typename ChildT, Index Log2Dim>
-template<typename NodeT, typename VisitorOp, typename ChildAllIterT, typename OtherChildAllIterT>
-inline void
-InternalNode<ChildT, Log2Dim>::doVisit2(NodeT& self, OtherChildAllIterT& otherIter,
-    VisitorOp& op, bool otherIsLHS)
-{
-    if (!otherIter) return;
-
-    const size_t skipBitMask = (otherIsLHS ? 2U : 1U);
-
-    typename NodeT::ValueType val;
-    for (ChildAllIterT iter = self.beginChildAll(); iter; ++iter) {
-        const size_t skipBranch = static_cast<size_t>(
-            otherIsLHS ? op(otherIter, iter) : op(iter, otherIter));
-
-        typename ChildAllIterT::ChildNodeType* child =
-            (skipBranch & skipBitMask) ? nullptr : iter.probeChild(val);
-
-        if (child != nullptr) child->visit2(otherIter, op, otherIsLHS);
-    }
-}
-
-
-////////////////////////////////////////
-
-
 template<typename ChildT, Index Log2Dim>
 inline void
 InternalNode<ChildT, Log2Dim>::writeBuffers(std::ostream& os, bool toHalf) const

openvdb/openvdb/tree/LeafManager.h

@@ -535,42 +535,6 @@ class LeafManager
         transform.run(this->leafRange(grainSize), threaded);
     }
 
-    template<typename ArrayT>
-    OPENVDB_DEPRECATED_MESSAGE("Use Tree::getNodes()") void getNodes(ArrayT& array)
-    {
-        using T = typename ArrayT::value_type;
-        static_assert(std::is_pointer<T>::value, "argument to getNodes() must be a pointer array");
-        using LeafT = typename std::conditional<std::is_const<
-            typename std::remove_pointer<T>::type>::value, const LeafType, LeafType>::type;
-
-        OPENVDB_NO_UNREACHABLE_CODE_WARNING_BEGIN
-        if (std::is_same<T, LeafT*>::value) {
-            array.resize(mLeafCount);
-            for (size_t i=0; i<mLeafCount; ++i) array[i] = reinterpret_cast<T>(mLeafs[i]);
-        } else {
-            mTree->getNodes(array);
-        }
-        OPENVDB_NO_UNREACHABLE_CODE_WARNING_END
-    }
-
-    template<typename ArrayT>
-    OPENVDB_DEPRECATED_MESSAGE("Use Tree::getNodes()") void getNodes(ArrayT& array) const
-    {
-        using T = typename ArrayT::value_type;
-        static_assert(std::is_pointer<T>::value, "argument to getNodes() must be a pointer array");
-        static_assert(std::is_const<typename std::remove_pointer<T>::type>::value,
-            "argument to getNodes() must be an array of const node pointers");
-
-        OPENVDB_NO_UNREACHABLE_CODE_WARNING_BEGIN
-        if (std::is_same<T, const LeafType*>::value) {
-            array.resize(mLeafCount);
-            for (size_t i=0; i<mLeafCount; ++i) array[i] = reinterpret_cast<T>(mLeafs[i]);
-        } else {
-            mTree->getNodes(array);
-        }
-        OPENVDB_NO_UNREACHABLE_CODE_WARNING_END
-    }
-
     /// @brief Generate a linear array of prefix sums of offsets into the
     /// active voxels in the leafs. So @a offsets[n]+m is the offset to the
     /// mth active voxel in the nth leaf node (useful for