Slic3r::AABBTreeIndirect::detail Namespace Reference

Classes
struct	RayIntersector
struct	RayIntersectorHits
struct	IndexedTriangleSetDistancer

Functions
template<typename Derivedsource, typename Deriveddir, typename Scalar>
bool	ray_box_intersect_invdir (const Eigen::MatrixBase< Derivedsource > &origin, const Eigen::MatrixBase< Deriveddir > &inv_dir, Eigen::AlignedBox< Scalar, 3 > box, const Scalar &t0, const Scalar &t1)
template<typename V, typename W>
std::enable_if_t< std::is_same< typename V::Scalar, double >::value &&std::is_same< typename W::Scalar, double >::value, bool >	intersect_triangle (const V &orig, const V &dir, const W &vert0, const W &vert1, const W &vert2, double &t, double &u, double &v, double eps)
template<typename V, typename W>
std::enable_if_t< std::is_same< typename V::Scalar, double >::value &&!std::is_same< typename W::Scalar, double >::value, bool >	intersect_triangle (const V &origin, const V &dir, const W &v0, const W &v1, const W &v2, double &t, double &u, double &v, double eps)
template<typename V, typename W>
std::enable_if_t<! std::is_same< typename V::Scalar, double >::value &&std::is_same< typename W::Scalar, double >::value, bool >	intersect_triangle (const V &origin, const V &dir, const W &v0, const W &v1, const W &v2, double &t, double &u, double &v, double eps)
template<typename V, typename W>
std::enable_if_t<! std::is_same< typename V::Scalar, double >::value &&! std::is_same< typename W::Scalar, double >::value, bool >	intersect_triangle (const V &origin, const V &dir, const W &v0, const W &v1, const W &v2, double &t, double &u, double &v, double eps)
template<typename Tree>
double	intersect_triangle_epsilon (const Tree &tree)
template<typename RayIntersectorType, typename Scalar>
static bool	intersect_ray_recursive_first_hit (RayIntersectorType &ray_intersector, size_t node_idx, Scalar min_t, igl::Hit< float > &hit)
template<typename RayIntersectorType>
static void	intersect_ray_recursive_all_hits (RayIntersectorType &ray_intersector, size_t node_idx)
template<typename Vector>
static Vector	closest_point_to_triangle (const Vector &p, const Vector &a, const Vector &b, const Vector &c)
template<typename IndexedPrimitivesDistancerType, typename Scalar>
static Scalar	squared_distance_to_indexed_primitives_recursive (IndexedPrimitivesDistancerType &distancer, size_t node_idx, Scalar low_sqr_d, Scalar up_sqr_d, size_t &i, Eigen::PlainObjectBase< typename IndexedPrimitivesDistancerType::VectorType > &c)
template<typename IndexedPrimitivesDistancerType, typename Scalar>
static void	indexed_primitives_within_distance_squared_recurisve (const IndexedPrimitivesDistancerType &distancer, size_t node_idx, Scalar squared_distance_limit, std::vector< size_t > &found_primitives_indices)
template<int Dims, typename T, typename Pred, typename Fn>
bool	traverse_recurse (const Tree< Dims, T > &tree, size_t idx, Pred &&pred, Fn &&callback)

---

Class Documentation

Slic3r::AABBTreeIndirect::detail::RayIntersector

struct Slic3r::AABBTreeIndirect::detail::RayIntersector

template<typename AVertexType, typename AIndexedFaceType, typename ATreeType, typename AVectorType>
struct Slic3r::AABBTreeIndirect::detail::RayIntersector< AVertexType, AIndexedFaceType, ATreeType, AVectorType >

Inheritance diagram for Slic3r::AABBTreeIndirect::detail::RayIntersector< AVertexType, AIndexedFaceType, ATreeType, AVectorType >:

Collaboration diagram for Slic3r::AABBTreeIndirect::detail::RayIntersector< AVertexType, AIndexedFaceType, ATreeType, AVectorType >:

Class Members
typedef AIndexedFaceType	IndexedFaceType AIndexedFaceType
typedef ATreeType	TreeType ATreeType
typedef AVectorType	VectorType AVectorType
typedef AVertexType	VertexType AVertexType

Class Members
const VectorType	dir
const double	eps
const vector< IndexedFaceType > &	faces
const VectorType	invdir
const VectorType	origin
const TreeType &	tree
const vector< VertexType > &	vertices

Function Documentation

closest_point_to_triangle()

template<typename Vector>

Vector Slic3r::AABBTreeIndirect::detail::closest_point_to_triangle ( const Vector & p, const Vector & a, const Vector & b, const Vector & c )

inlinestatic

    {
        using Scalar = typename Vector::Scalar;
        // Check if P in vertex region outside A
        Vector ab = b - a;
        Vector ac = c - a;
        Vector ap = p - a;
        Scalar d1 = ab.dot(ap);
        Scalar d2 = ac.dot(ap);
        if (d1 <= 0 && d2 <= 0)
          return a;
        // Check if P in vertex region outside B
        Vector bp = p - b;
        Scalar d3 = ab.dot(bp);
        Scalar d4 = ac.dot(bp);
        if (d3 >= 0 && d4 <= d3)
          return b;
        // Check if P in edge region of AB, if so return projection of P onto AB
        Scalar vc = d1*d4 - d3*d2;
        if (a != b && vc <= 0 && d1 >= 0 && d3 <= 0) {
            Scalar v = d1 / (d1 - d3);
            return a + v * ab;
        }
        // Check if P in vertex region outside C
        Vector cp = p - c;
        Scalar d5 = ab.dot(cp);
        Scalar d6 = ac.dot(cp);
        if (d6 >= 0 && d5 <= d6)
          return c;
        // Check if P in edge region of AC, if so return projection of P onto AC
        Scalar vb = d5*d2 - d1*d6;
        if (vb <= 0 && d2 >= 0 && d6 <= 0) {
          Scalar w = d2 / (d2 - d6);
          return a + w * ac;
        }
        // Check if P in edge region of BC, if so return projection of P onto BC
        Scalar va = d3*d6 - d5*d4;
        if (va <= 0 && (d4 - d3) >= 0 && (d5 - d6) >= 0) {
          Scalar w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
          return b + w * (c - b);
        }
        // P inside face region. Compute Q through its barycentric coordinates (u,v,w)
        Scalar denom = Scalar(1.0) / (va + vb + vc);
        Scalar v = vb * denom;
        Scalar w = vc * denom;
        return a + ab * v + ac * w; // = u*a + v*b + w*c, u = va * denom = 1.0-v-w
    };

Referenced by Slic3r::AABBTreeIndirect::detail::IndexedTriangleSetDistancer< AVertexType, AIndexedFaceType, ATreeType, AVectorType >::closest_point_to_origin().

Here is the caller graph for this function:

indexed_primitives_within_distance_squared_recurisve()

template<typename IndexedPrimitivesDistancerType, typename Scalar>

void Slic3r::AABBTreeIndirect::detail::indexed_primitives_within_distance_squared_recurisve ( const IndexedPrimitivesDistancerType & distancer, size_t node_idx, Scalar squared_distance_limit, std::vector< size_t > & found_primitives_indices )

inlinestatic

    {
        const auto &node = distancer.tree.node(node_idx);
        assert(node.is_valid());
        if (node.is_leaf()) {
            Scalar sqr_dist;
            distancer.closest_point_to_origin(node.idx, sqr_dist);
            if (sqr_dist < squared_distance_limit) { found_primitives_indices.push_back(node.idx); }
        } else {
            size_t      left_node_idx  = node_idx * 2 + 1;
            size_t      right_node_idx = left_node_idx + 1;
            const auto &node_left      = distancer.tree.node(left_node_idx);
            const auto &node_right     = distancer.tree.node(right_node_idx);
            assert(node_left.is_valid());
            assert(node_right.is_valid());
 
            if (node_left.bbox.squaredExteriorDistance(distancer.origin) < squared_distance_limit) {
                indexed_primitives_within_distance_squared_recurisve(distancer, left_node_idx, squared_distance_limit,
                                                                     found_primitives_indices);
            }
            if (node_right.bbox.squaredExteriorDistance(distancer.origin) < squared_distance_limit) {
                indexed_primitives_within_distance_squared_recurisve(distancer, right_node_idx, squared_distance_limit,
                                                                     found_primitives_indices);
            }
        }
    }

References indexed_primitives_within_distance_squared_recurisve().

Referenced by Slic3r::AABBTreeLines::all_lines_in_radius(), Slic3r::AABBTreeIndirect::all_triangles_in_radius(), and indexed_primitives_within_distance_squared_recurisve().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect_ray_recursive_all_hits()

template<typename RayIntersectorType>

void Slic3r::AABBTreeIndirect::detail::intersect_ray_recursive_all_hits ( RayIntersectorType & ray_intersector, size_t node_idx )

inlinestatic

  {
        using Scalar = typename RayIntersectorType::VectorType::Scalar;
 
    const auto &node = ray_intersector.tree.node(node_idx);
    assert(node.is_valid());
 
        if (! ray_box_intersect_invdir(ray_intersector.origin, ray_intersector.invdir, node.bbox.template cast<Scalar>(),
          Scalar(0), std::numeric_limits<Scalar>::infinity()))
      return;
 
      if (node.is_leaf()) {
            auto   face = ray_intersector.faces[node.idx];
        double t, u, v;
        if (intersect_triangle(
            ray_intersector.origin, ray_intersector.dir, 
            ray_intersector.vertices[face(0)], ray_intersector.vertices[face(1)], ray_intersector.vertices[face(2)], 
                    t, u, v, ray_intersector.eps)
          && t > 0.) {
                ray_intersector.hits.emplace_back(igl::Hit<float>{ int(node.idx), -1, float(u), float(v), float(t) });
      }
      } else {
      // Left / right child node index.
      size_t left  = node_idx * 2 + 1;
      size_t right = left + 1;
        intersect_ray_recursive_all_hits(ray_intersector, left);
        intersect_ray_recursive_all_hits(ray_intersector, right);
    }
  }

References Slic3r::cast(), intersect_ray_recursive_all_hits(), intersect_triangle(), and ray_box_intersect_invdir().

Referenced by Slic3r::AABBTreeIndirect::intersect_ray_all_hits(), and intersect_ray_recursive_all_hits().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect_ray_recursive_first_hit()

template<typename RayIntersectorType, typename Scalar>

bool Slic3r::AABBTreeIndirect::detail::intersect_ray_recursive_first_hit ( RayIntersectorType & ray_intersector, size_t node_idx, Scalar min_t, igl::Hit< float > & hit )

inlinestatic

  {
        const auto &node = ray_intersector.tree.node(node_idx);
        assert(node.is_valid());
    
        if (! ray_box_intersect_invdir(ray_intersector.origin, ray_intersector.invdir, node.bbox.template cast<Scalar>(), Scalar(0), min_t))
      return false;
 
      if (node.is_leaf()) {
        // shoot ray, record hit
            auto   face = ray_intersector.faces[node.idx];
        double t, u, v;
        if (intersect_triangle(
            ray_intersector.origin, ray_intersector.dir, 
            ray_intersector.vertices[face(0)], ray_intersector.vertices[face(1)], ray_intersector.vertices[face(2)], 
                    t, u, v, ray_intersector.eps)
          && t > 0.) {
                hit = igl::Hit<float> { int(node.idx), -1, float(u), float(v), float(t) };
        return true;
        } else
          return false;
      } else {
      // Left / right child node index.
      size_t left  = node_idx * 2 + 1;
      size_t right = left + 1;
      igl::Hit<float> left_hit;
      igl::Hit<float> right_hit;
          bool left_ret = intersect_ray_recursive_first_hit(ray_intersector, left,  min_t, left_hit);
      if (left_ret && left_hit.t < min_t) {
          min_t = left_hit.t;
          hit   = left_hit;
        } else
          left_ret = false;
          bool right_ret = intersect_ray_recursive_first_hit(ray_intersector, right, min_t, right_hit);
      if (right_ret && right_hit.t < min_t)
        hit = right_hit;
      else
        right_ret = false;
      return left_ret || right_ret;
    }
  }

References Slic3r::cast(), intersect_ray_recursive_first_hit(), intersect_triangle(), and ray_box_intersect_invdir().

Referenced by Slic3r::AABBTreeIndirect::intersect_ray_first_hit(), and intersect_ray_recursive_first_hit().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect_triangle() [1/4]

template<typename V, typename W>

std::enable_if_t< std::is_same< typename V::Scalar, double >::value &&std::is_same< typename W::Scalar, double >::value, bool > Slic3r::AABBTreeIndirect::detail::intersect_triangle	(	const V &	orig,
		const V &	dir,
		const W &	vert0,
		const W &	vert1,
		const W &	vert2,
		double &	t,
		double &	u,
		double &	v,
		double	eps )

  {
     // find vectors for two edges sharing vert0
     const V      edge1 = vert1 - vert0;
     const V      edge2 = vert2 - vert0;
     // begin calculating determinant - also used to calculate U parameter
     const V      pvec  = dir.cross(edge2);
     // if determinant is near zero, ray lies in plane of triangle
     const double det   = edge1.dot(pvec);
     V          qvec;
 
     if (det > eps) {
          // calculate distance from vert0 to ray origin
          V tvec = orig - vert0;
          // calculate U parameter and test bounds
          u = tvec.dot(pvec);
      if (u < 0.0 || u > det)
        return false;
          // prepare to test V parameter
          qvec = tvec.cross(edge1);
          // calculate V parameter and test bounds
          v = dir.dot(qvec);
          if (v < 0.0 || u + v > det)
        return false;
     } else if (det < -eps) {
          // calculate distance from vert0 to ray origin
          V tvec = orig - vert0;
          // calculate U parameter and test bounds
          u = tvec.dot(pvec);
          if (u > 0.0 || u < det)
        return false;
          // prepare to test V parameter
          qvec = tvec.cross(edge1);
          // calculate V parameter and test bounds
          v = dir.dot(qvec);
          if (v > 0.0 || u + v < det)
        return false;
     } else 
        // ray is parallel to the plane of the triangle
        return false;
 
     double inv_det = 1.0 / det;
     // calculate t, ray intersects triangle
     t = edge2.dot(qvec) * inv_det;
     u *= inv_det;
     v *= inv_det;
     return true;
  }

Referenced by intersect_ray_recursive_all_hits(), intersect_ray_recursive_first_hit(), intersect_triangle(), and Slic3r::anonymous_namespace{Model.cpp}::mesh_contains_point_linear().

Here is the caller graph for this function:

intersect_triangle() [2/4]

template<typename V, typename W>

std::enable_if_t<! std::is_same< typename V::Scalar, double >::value &&! std::is_same< typename W::Scalar, double >::value, bool > Slic3r::AABBTreeIndirect::detail::intersect_triangle	(	const V &	origin,
		const V &	dir,
		const W &	v0,
		const W &	v1,
		const W &	v2,
		double &	t,
		double &	u,
		double &	v,
		double	eps )

                                                                                                                                        {
      return intersect_triangle(origin.template cast<double>(), dir.template cast<double>(), v0.template cast<double>(), v1.template cast<double>(), v2.template cast<double>(), t, u, v, eps);
  }

References Slic3r::cast(), and intersect_triangle().

Here is the call graph for this function:

intersect_triangle() [3/4]

template<typename V, typename W>

std::enable_if_t<! std::is_same< typename V::Scalar, double >::value &&std::is_same< typename W::Scalar, double >::value, bool > Slic3r::AABBTreeIndirect::detail::intersect_triangle	(	const V &	origin,
		const V &	dir,
		const W &	v0,
		const W &	v1,
		const W &	v2,
		double &	t,
		double &	u,
		double &	v,
		double	eps )

                                                                                                                                        {
        return intersect_triangle(origin.template cast<double>(), dir.template cast<double>(), v0, v1, v2, t, u, v, eps);
  }

References Slic3r::cast(), and intersect_triangle().

Here is the call graph for this function:

intersect_triangle() [4/4]

template<typename V, typename W>

std::enable_if_t< std::is_same< typename V::Scalar, double >::value &&!std::is_same< typename W::Scalar, double >::value, bool > Slic3r::AABBTreeIndirect::detail::intersect_triangle	(	const V &	origin,
		const V &	dir,
		const W &	v0,
		const W &	v1,
		const W &	v2,
		double &	t,
		double &	u,
		double &	v,
		double	eps )

                                                                                                                                        {
        return intersect_triangle(origin, dir, v0.template cast<double>(), v1.template cast<double>(), v2.template cast<double>(), t, u, v, eps);
  }

References Slic3r::cast(), and intersect_triangle().

Here is the call graph for this function:

intersect_triangle_epsilon()

template<typename Tree>

double Slic3r::AABBTreeIndirect::detail::intersect_triangle_epsilon

(

const Tree &

tree

)

                                                      {
    double eps = 0.000001;
    if (! tree.empty()) {
      const typename Tree::BoundingBox &bbox = tree.nodes().front().bbox;
      double l = (bbox.max() - bbox.min()).cwiseMax();
      if (l > 0)
        eps /= (l * l);
    }
    return eps;
  }

References Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::empty(), and Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::nodes().

Here is the call graph for this function:

ray_box_intersect_invdir()

template<typename Derivedsource, typename Deriveddir, typename Scalar>

bool Slic3r::AABBTreeIndirect::detail::ray_box_intersect_invdir ( const Eigen::MatrixBase< Derivedsource > & origin, const Eigen::MatrixBase< Deriveddir > & inv_dir, Eigen::AlignedBox< Scalar, 3 > box, const Scalar & t0, const Scalar & t1 )

inline

                                     {
    // http://people.csail.mit.edu/amy/papers/box-jgt.pdf
    // "An Efficient and Robust Ray–Box Intersection Algorithm"
    if (inv_dir.x() < 0)
      std::swap(box.min().x(), box.max().x());
    if (inv_dir.y() < 0)
      std::swap(box.min().y(), box.max().y());
        Scalar tmin = (box.min().x() - origin.x()) * inv_dir.x();
    Scalar tymax = (box.max().y() - origin.y()) * inv_dir.y();
    if (tmin > tymax)
      return false;
        Scalar tmax = (box.max().x() - origin.x()) * inv_dir.x();
    Scalar tymin = (box.min().y()  - origin.y()) * inv_dir.y();
    if (tymin > tmax)
      return false;
    if (tymin > tmin)
      tmin = tymin;
    if (tymax < tmax)
      tmax = tymax;
    if (inv_dir.z() < 0)
      std::swap(box.min().z(), box.max().z());
    Scalar tzmin = (box.min().z()  - origin.z()) * inv_dir.z();
    if (tzmin > tmax)
      return false;
    Scalar tzmax = (box.max().z() - origin.z()) * inv_dir.z();
    if (tmin > tzmax)
      return false;
    if (tzmin > tmin)
      tmin = tzmin;
    if (tzmax < tmax)
      tmax = tzmax;
        return tmin < t1 && tmax > t0;
  }

Referenced by intersect_ray_recursive_all_hits(), and intersect_ray_recursive_first_hit().

Here is the caller graph for this function:

squared_distance_to_indexed_primitives_recursive()

template<typename IndexedPrimitivesDistancerType, typename Scalar>

Scalar Slic3r::AABBTreeIndirect::detail::squared_distance_to_indexed_primitives_recursive ( IndexedPrimitivesDistancerType & distancer, size_t node_idx, Scalar low_sqr_d, Scalar up_sqr_d, size_t & i, Eigen::PlainObjectBase< typename IndexedPrimitivesDistancerType::VectorType > & c )

inlinestatic

  {
    using Vector = typename IndexedPrimitivesDistancerType::VectorType;
 
      if (low_sqr_d > up_sqr_d)
      return low_sqr_d;
    
      // Save the best achieved hit.
        auto set_min = [&i, &c, &up_sqr_d](const Scalar sqr_d_candidate, const size_t i_candidate, const Vector &c_candidate) {
      if (sqr_d_candidate < up_sqr_d) {
        i        = i_candidate;
        c        = c_candidate;
        up_sqr_d = sqr_d_candidate;
      }
        };
 
    const auto &node = distancer.tree.node(node_idx);
    assert(node.is_valid());
      if (node.is_leaf()) 
      {
            Scalar sqr_dist;
            Vector c_candidate = distancer.closest_point_to_origin(node.idx, sqr_dist);
            set_min(sqr_dist, node.idx, c_candidate);
      } 
      else
      {
      size_t left_node_idx  = node_idx * 2 + 1;
            size_t right_node_idx = left_node_idx + 1;
      const auto &node_left  = distancer.tree.node(left_node_idx);
      const auto &node_right = distancer.tree.node(right_node_idx);
      assert(node_left.is_valid());
      assert(node_right.is_valid());
 
      bool   looked_left    = false;
      bool   looked_right   = false;
      const auto &look_left = [&]()
      {
                size_t  i_left;
                Vector  c_left = c;
                Scalar  sqr_d_left = squared_distance_to_indexed_primitives_recursive(distancer, left_node_idx, low_sqr_d, up_sqr_d, i_left, c_left);
        set_min(sqr_d_left, i_left, c_left);
        looked_left = true;
      };
      const auto &look_right = [&]()
      {
                size_t  i_right;
                Vector  c_right = c;
                Scalar  sqr_d_right = squared_distance_to_indexed_primitives_recursive(distancer, right_node_idx, low_sqr_d, up_sqr_d, i_right, c_right);
        set_min(sqr_d_right, i_right, c_right);
        looked_right = true;
      };
 
      // must look left or right if in box
            using BBoxScalar = typename IndexedPrimitivesDistancerType::TreeType::BoundingBox::Scalar;
            if (node_left.bbox.contains(distancer.origin.template cast<BBoxScalar>()))
          look_left();
            if (node_right.bbox.contains(distancer.origin.template cast<BBoxScalar>()))
          look_right();
      // if haven't looked left and could be less than current min, then look
      Scalar left_up_sqr_d  = node_left.bbox.squaredExteriorDistance(distancer.origin);
      Scalar right_up_sqr_d = node_right.bbox.squaredExteriorDistance(distancer.origin);
      if (left_up_sqr_d < right_up_sqr_d) {
          if (! looked_left && left_up_sqr_d < up_sqr_d)
            look_left();
          if (! looked_right && right_up_sqr_d < up_sqr_d)
            look_right();
      } else {
          if (! looked_right && right_up_sqr_d < up_sqr_d)
            look_right();
          if (! looked_left && left_up_sqr_d < up_sqr_d)
            look_left();
      }
    }
    return up_sqr_d;
  }

References Slic3r::cast(), and squared_distance_to_indexed_primitives_recursive().

Referenced by Slic3r::AABBTreeIndirect::is_any_triangle_in_radius(), Slic3r::AABBTreeLines::squared_distance_to_indexed_lines(), squared_distance_to_indexed_primitives_recursive(), and Slic3r::AABBTreeIndirect::squared_distance_to_indexed_triangle_set().

Here is the call graph for this function:

Here is the caller graph for this function:

traverse_recurse()

template<int Dims, typename T, typename Pred, typename Fn>

bool Slic3r::AABBTreeIndirect::detail::traverse_recurse	(	const Tree< Dims, T > &	tree,
		size_t	idx,
		Pred &&	pred,
		Fn &&	callback )

{
    assert(tree.node(idx).is_valid());
 
    if (!pred(tree.node(idx))) 
      // Continue traversal.
      return true;
 
    if (tree.node(idx).is_leaf()) {
      // Callback returns true to continue traversal, false to stop traversal.
        return callback(tree.node(idx));
    } else {
 
        // call this with left and right node idx:
        auto trv = [&](size_t idx) -> bool {
            return traverse_recurse(tree, idx, std::forward<Pred>(pred),
                                    std::forward<Fn>(callback));
        };
 
        // Left / right child node index.
        // Returns true if both children allow the traversal to continue.
        return trv(Tree<Dims, T>::left_child_idx(idx)) &&
             trv(Tree<Dims, T>::right_child_idx(idx));
    }
}

References Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::Node::is_leaf(), Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::Node::is_valid(), Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::left_child_idx(), Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::node(), Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::right_child_idx(), and traverse_recurse().

Referenced by Slic3r::AABBTreeIndirect::traverse(), and traverse_recurse().

Here is the call graph for this function:

Here is the caller graph for this function: