Slic3r::IslandLocator Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/ConnectedBodies.hpp>

Collaboration diagram for Slic3r::IslandLocator:

Public Member Functions
	IslandLocator (const ExPolygons &islands, coord_t margin, bool tell_apart=true)
bool	holds (size_t island, const Point &point, bool strict=false) const
std::pair< int, double >	find (const Point &point, bool strict=false) const
const std::vector< BoundingBox > &	boxes () const

Private Attributes
const ExPolygons *	m_islands
std::vector< BoundingBox >	m_boxes
std::vector< bool >	m_alone

Detailed Description

Constructor & Destructor Documentation

IslandLocator()

Slic3r::IslandLocator::IslandLocator	(	const ExPolygons &	islands,
		coord_t	margin,
		bool	tell_apart = true )

    : m_islands(&islands), m_alone(islands.size(), true)
{
    m_boxes.reserve(islands.size());
    for (const ExPolygon &island : islands)
        m_boxes.emplace_back(get_extents(island).inflated(margin));
    if (!tell_apart)
        return;
    // Sweep the boxes along x, so that only those reaching each other are compared.
    std::vector<size_t> order(m_boxes.size());
    for (size_t i = 0; i < order.size(); ++i)
        order[i] = i;
    std::sort(order.begin(), order.end(), [this](size_t l, size_t r) { return m_boxes[l].min.x() < m_boxes[r].min.x(); });
    for (size_t a = 0; a < order.size(); ++a)
        for (size_t b = a + 1; b < order.size() && m_boxes[order[b]].min.x() <= m_boxes[order[a]].max.x(); ++b)
            if (m_boxes[order[a]].overlap(m_boxes[order[b]]))
                m_alone[order[a]] = m_alone[order[b]] = false;
}

References Slic3r::get_extents(), m_alone, m_boxes, and m_islands.

Here is the call graph for this function:

Member Function Documentation

boxes()

const std::vector< BoundingBox > & Slic3r::IslandLocator::boxes ( ) const

inline

{ return m_boxes; }

References m_boxes.

Referenced by Slic3r::set_mass_locator().

Here is the caller graph for this function:

find()

std::pair< int, double > Slic3r::IslandLocator::find	(	const Point &	point,
		bool	strict = false ) const

{
    int    nearest  = -1;
    double distance = std::numeric_limits<double>::max();
    for (size_t i = 0; i < m_boxes.size(); ++i)
        if (m_boxes[i].contains(point)) {
            if ((m_alone[i] && !strict) || (*m_islands)[i].contains(point))
                return { int(i), 0. };
            if (const double d = ((*m_islands)[i].point_projection(point) - point).cast<double>().squaredNorm(); d < distance) {
                distance = d;
                nearest  = int(i);
            }
        }
    return { nearest, distance };
}

References Slic3r::cast(), Slic3r::Geometry::contains(), m_alone, m_boxes, and m_islands.

Referenced by Slic3r::solid_bodies().

Here is the call graph for this function:

Here is the caller graph for this function:

holds()

bool Slic3r::IslandLocator::holds	(	size_t	island,
		const Point &	point,
		bool	strict = false ) const

{
    return m_boxes[island].contains(point) && ((m_alone[island] && !strict) || (*m_islands)[island].contains(point));
}

References m_alone, and m_boxes.

Member Data Documentation

m_alone

std::vector<bool> Slic3r::IslandLocator::m_alone

private

Referenced by IslandLocator(), find(), and holds().

m_boxes

std::vector<BoundingBox> Slic3r::IslandLocator::m_boxes

private

Referenced by IslandLocator(), boxes(), find(), and holds().

m_islands

const ExPolygons* Slic3r::IslandLocator::m_islands

private

Referenced by IslandLocator(), and find().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/ConnectedBodies.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/ConnectedBodies.cpp