Slic3r::AABBTreeLines Namespace Reference

Namespaces
namespace	detail

Classes
class	LinesDistancer

Functions
template<typename LineType >
AABBTreeIndirect::Tree< LineType::Dim, typename LineType::Scalar >	build_aabb_tree_over_indexed_lines (const std::vector< LineType > &lines)
template<typename LineType , typename TreeType , typename VectorType >
VectorType::Scalar	squared_distance_to_indexed_lines (const std::vector< LineType > &lines, const TreeType &tree, const VectorType &point, size_t &hit_idx_out, Eigen::PlainObjectBase< VectorType > &hit_point_out, typename VectorType::Scalar max_sqr_dist=std::numeric_limits< typename VectorType::Scalar >::infinity())
template<typename LineType , typename TreeType , typename VectorType >
std::vector< size_t >	all_lines_in_radius (const std::vector< LineType > &lines, const TreeType &tree, const VectorType &point, typename VectorType::Scalar max_distance_squared)
template<typename LineType , typename TreeType , typename VectorType >
int	point_outside_closed_contours (const std::vector< LineType > &lines, const TreeType &tree, const VectorType &point)
template<bool sorted, typename VectorType , typename LineType , typename TreeType >
std::vector< std::pair< VectorType, size_t > >	get_intersections_with_line (const std::vector< LineType > &lines, const TreeType &tree, const LineType &line)

Function Documentation

all_lines_in_radius()

template<typename LineType , typename TreeType , typename VectorType >

std::vector< size_t > Slic3r::AABBTreeLines::all_lines_in_radius ( const std::vector< LineType > &  lines, const TreeType &  tree, const VectorType &  point, typename VectorType::Scalar  max_distance_squared  )

inline

{
    auto distancer = detail::IndexedLinesDistancer<LineType, TreeType, VectorType>{lines, tree, point};
 
    if (tree.empty()) { return {}; }
 
    std::vector<size_t> found_lines{};
    AABBTreeIndirect::detail::indexed_primitives_within_distance_squared_recurisve(distancer, size_t(0), max_distance_squared, found_lines);
    return found_lines;
}

References Slic3r::AABBTreeIndirect::detail::indexed_primitives_within_distance_squared_recurisve().

Referenced by Slic3r::AABBTreeLines::LinesDistancer< LineType >::all_lines_in_radius(), priv::collect_close_points(), and Slic3r::Emboss::divide_segments_for_close_point().

Here is the call graph for this function:

Here is the caller graph for this function:

build_aabb_tree_over_indexed_lines()

template<typename LineType >

AABBTreeIndirect::Tree< LineType::Dim, typename LineType::Scalar > Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines ( const std::vector< LineType > &  lines )

inline

{
    using TreeType = AABBTreeIndirect::Tree<LineType::Dim, typename LineType::Scalar>;
    //    using              CoordType      = typename TreeType::CoordType;
    using VectorType  = typename TreeType::VectorType;
    using BoundingBox = typename TreeType::BoundingBox;
 
    struct InputType
    {
        size_t             idx() const { return m_idx; }
        const BoundingBox &bbox() const { return m_bbox; }
        const VectorType  &centroid() const { return m_centroid; }
 
        size_t      m_idx;
        BoundingBox m_bbox;
        VectorType  m_centroid;
    };
 
    std::vector<InputType> input;
    input.reserve(lines.size());
    for (size_t i = 0; i < lines.size(); ++i) {
        const LineType &line = lines[i];
        InputType       n;
        n.m_idx      = i;
        n.m_centroid = (line.a + line.b) * 0.5;
        n.m_bbox     = BoundingBox(line.a, line.a);
        n.m_bbox.extend(line.b);
        input.emplace_back(n);
    }
 
    TreeType out;
    out.build(std::move(input));
    return out;
}

References input().

Referenced by Slic3r::AABBTreeLines::LinesDistancer< LineType >::LinesDistancer(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::LinesDistancer(), priv::collect_close_points(), priv::create_search_data(), Slic3r::Emboss::divide_segments_for_close_point(), and Slic3r::FFFTreeSupport::organic_smooth_branches_avoid_collisions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_intersections_with_line()

template<bool sorted, typename VectorType , typename LineType , typename TreeType >

std::vector< std::pair< VectorType, size_t > > Slic3r::AABBTreeLines::get_intersections_with_line ( const std::vector< LineType > &  lines, const TreeType &  tree, const LineType &  line  )

inline

{
    if (tree.empty()) {
        return {};
    }
    auto line_bb = typename TreeType::BoundingBox(line.a, line.a);
    line_bb.extend(line.b);
 
    auto intersections = detail::get_intersections_with_line<LineType, TreeType, VectorType>(0, tree, lines, line, line_bb);
    if (sorted) {
        using Floating =
            typename std::conditional<std::is_floating_point<typename LineType::Scalar>::value, typename LineType::Scalar, double>::type;
 
        std::vector<std::pair<Floating, std::pair<VectorType, size_t>>> points_with_sq_distance{};
        for (const auto &p : intersections) {
            points_with_sq_distance.emplace_back((p.first - line.a).template cast<Floating>().squaredNorm(), p);
        }
        std::sort(points_with_sq_distance.begin(), points_with_sq_distance.end(),
                  [](const std::pair<Floating, std::pair<VectorType, size_t>> &left,
                     std::pair<Floating, std::pair<VectorType, size_t>>       &right) { return left.first < right.first; });
        for (size_t i = 0; i < points_with_sq_distance.size(); i++) {
            intersections[i] = points_with_sq_distance[i].second;
        }
    }
 
    return intersections;
}

point_outside_closed_contours()

template<typename LineType , typename TreeType , typename VectorType >

int Slic3r::AABBTreeLines::point_outside_closed_contours ( const std::vector< LineType > &  lines, const TreeType &  tree, const VectorType &  point  )

inline

{
    if (tree.empty()) { return 1; }
 
    auto [hits_above, hits_below] = detail::coordinate_aligned_ray_hit_count<LineType, TreeType, VectorType, 0>(0, tree, lines, point);
    if (hits_above < 0 || hits_below < 0) {
        return 0;
    } else if (hits_above % 2 == 1 && hits_below % 2 == 1) {
        return -1;
    } else if (hits_above % 2 == 0 && hits_below % 2 == 0) {
        return 1;
    } else { // this should not happen with closed contours. lets check it in Y direction
        auto [hits_above, hits_below] = detail::coordinate_aligned_ray_hit_count<LineType, TreeType, VectorType, 1>(0, tree, lines, point);
        if (hits_above < 0 || hits_below < 0) {
            return 0;
        } else if (hits_above % 2 == 1 && hits_below % 2 == 1) {
            return -1;
        } else if (hits_above % 2 == 0 && hits_below % 2 == 0) {
            return 1;
        } else { // both results were unclear
            return 0;
        }
    }
}

Referenced by Slic3r::AABBTreeLines::LinesDistancer< LineType >::outside().

Here is the caller graph for this function:

squared_distance_to_indexed_lines()

template<typename LineType , typename TreeType , typename VectorType >

VectorType::Scalar Slic3r::AABBTreeLines::squared_distance_to_indexed_lines ( const std::vector< LineType > &  lines, const TreeType &  tree, const VectorType &  point, size_t &  hit_idx_out, Eigen::PlainObjectBase< VectorType > &  hit_point_out, typename VectorType::Scalar  max_sqr_dist = std::numeric_limits<typename VectorType::Scalar>::infinity()  )

inline

{
    using Scalar = typename VectorType::Scalar;
    if (tree.empty()) return Scalar(-1);
    auto distancer = detail::IndexedLinesDistancer<LineType, TreeType, VectorType>{lines, tree, point};
    return AABBTreeIndirect::detail::squared_distance_to_indexed_primitives_recursive(distancer, size_t(0), Scalar(0), max_sqr_dist,
                                                                                      hit_idx_out, hit_point_out);
}

References Slic3r::AABBTreeIndirect::detail::squared_distance_to_indexed_primitives_recursive().

Referenced by Slic3r::AABBTreeLines::LinesDistancer< LineType >::distance_from_lines_extra(), priv::find_closest_point_index(), and priv::find_closest_point_pair().

Here is the call graph for this function:

Here is the caller graph for this function: