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< Linef3 >::all_lines_in_radius(), 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;
    }

Referenced by Slic3r::AABBTreeLines::LinesDistancer< Linef3 >::LinesDistancer(), Slic3r::AABBTreeLines::LinesDistancer< Linef3 >::LinesDistancer(), anonymous_namespace{IntersectionPoints.cpp}::compute_intersections(), priv::create_search_data(), Slic3r::Emboss::divide_segments_for_close_point(), anonymous_namespace{GLGizmoSVG.cpp}::draw_filled(), Slic3r::SeamPlacerImpl::gather_enforcers_blockers(), Slic3r::TreeSupport3D::organic_smooth_branches_avoid_collisions(), and anonymous_namespace{TextLines.cpp}::select_closest_contour().

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;
    }

References Slic3r::cast(), and Slic3r::AABBTreeLines::detail::get_intersections_with_line().

Referenced by anonymous_namespace{IntersectionPoints.cpp}::compute_intersections(), anonymous_namespace{GLGizmoSVG.cpp}::draw_filled(), and Slic3r::AABBTreeLines::LinesDistancer< Linef3 >::intersections_with_line().

Here is the call graph for this function:

Here is the caller graph for this function:

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;
            }
        }
    }

References Slic3r::AABBTreeLines::detail::coordinate_aligned_ray_hit_count().

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

Here is the call graph for this function:

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< Linef3 >::distance_from_lines_extra(), priv::find_closest_point_index(), priv::find_closest_point_pair(), and anonymous_namespace{TextLines.cpp}::select_closest_contour().

Here is the call graph for this function:

Here is the caller graph for this function: