Slic3r::ImexArranger Class Reference

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

Collaboration diagram for Slic3r::ImexArranger:

Classes
struct	Bed
struct	KeepOut

Public Member Functions
	ImexArranger (const ImexArrangeInput &input, const arrangement::ArrangeParams &params, const Points &bed)
bool	active () const
Points	bed_shape () const
void	add_keep_outs (arrangement::ArrangePolygons &fixed) const
void	finish (arrangement::ArrangePolygons &items, const arrangement::ArrangePolygons &before, const arrangement::ArrangePolygons &fixed, const arrangement::ArrangeParams &params) const

Private Member Functions
std::optional< BoundingBox >	room_in (const BoundingBoxf &zone) const
bool	crosses_keep_out (const arrangement::ArrangePolygon &part, int bed_idx) const

Private Attributes
Points	m_bed
BoundingBox	m_bed_bb
Point	m_margin
bool	m_adds_plates = false
std::vector< Bed >	m_beds
std::optional< BoundingBox >	m_shared_room
std::vector< KeepOut >	m_keep_outs

Detailed Description

---

Class Documentation

Slic3r::ImexArranger::Bed

struct Slic3r::ImexArranger::Bed

Collaboration diagram for Slic3r::ImexArranger::Bed:

Class Members
int	bed_idx
ImexArrangeZones	zones

Slic3r::ImexArranger::KeepOut

struct Slic3r::ImexArranger::KeepOut

Collaboration diagram for Slic3r::ImexArranger::KeepOut:

Class Members
int	bed_idx
BoundingBox	box
bool	fence

Constructor & Destructor Documentation

ImexArranger()

Slic3r::ImexArranger::ImexArranger	(	const ImexArrangeInput &	input,
		const arrangement::ArrangeParams &	params,
		const Points &	bed )

    : m_bed(bed)
    , m_bed_bb(bed)
    , m_margin(scaled(std::max(0.f, params.bed_shrink_x)), scaled(std::max(0.f, params.bed_shrink_y)))
    , m_adds_plates(input.adds_plates)
{
    for (size_t i = 0; i < input.beds.size(); ++i)
        if (input.beds[i])
            m_beds.push_back({int(i), *input.beds[i]});
 
    // The bed shape can be a zone only when every plate being arranged has it, and so does every
    // plate the arrange may add.
    const auto& first = input.beds.empty() ? std::nullopt : input.beds.front();
    if (first &&
        std::all_of(input.beds.begin(), input.beds.end(),
                    [&](const std::optional<ImexArrangeZones>& b) { return b && same_zone(b->primary_zone, first->primary_zone); }) &&
        (!input.adds_plates || (input.added_plate && same_zone(input.added_plate->primary_zone, first->primary_zone))))
        m_shared_room = room_in(first->primary_zone);
 
    // The beds past the plates being arranged become new plates.
    if (input.adds_plates && input.added_plate)
        for (int bed_idx = int(input.beds.size()); bed_idx < MAX_NUM_PLATES; ++bed_idx)
            m_beds.push_back({bed_idx, *input.added_plate});
 
    // A zone narrower than its margins leaves no room, and its fences then fill the whole bed.
    const Point strip_margin = m_margin + Point::Constant(scaled(input.brim));
    for (const Bed& b : m_beds) {
        if (!m_shared_room)
            for (const BoundingBox& box : boxes_around(m_bed_bb, inset(scaled(b.zones.primary_zone), m_margin)))
                m_keep_outs.push_back({b.bed_idx, box, true});
        for (const BoundingBoxf& strip : b.zones.collision_zones)
            m_keep_outs.push_back({b.bed_idx, inset(scaled(strip), -strip_margin), false});
    }
}

References Slic3r::ImexArrangeInput::added_plate, Slic3r::ImexArrangeInput::adds_plates, Slic3r::ImexArrangeInput::beds, Slic3r::ImexArrangeInput::brim, m_adds_plates, m_bed, m_bed_bb, m_beds, m_keep_outs, m_margin, m_shared_room, room_in(), and Slic3r::scaled().

Here is the call graph for this function:

Member Function Documentation

active()

bool Slic3r::ImexArranger::active ( ) const

inline

{ return !m_beds.empty(); }

References m_beds.

Referenced by Slic3r::GUI::ArrangeJob::process().

Here is the caller graph for this function:

add_keep_outs()

void Slic3r::ImexArranger::add_keep_outs

(

arrangement::ArrangePolygons &

fixed

)

const

{
    for (const KeepOut& keep_out : m_keep_outs) {
        arrangement::ArrangePolygon ap;
        ap.poly.contour   = keep_out.box.polygon();
        ap.is_virt_object = true;
        ap.bed_idx        = keep_out.bed_idx;
        ap.height         = 1;
        ap.name           = keep_out.fence ? kFenceName : kStripName;
        fixed.push_back(std::move(ap));
    }
}

References Slic3r::arrangement::ArrangePolygon::bed_idx, Slic3r::ExPolygon::contour, Slic3r::arrangement::ArrangePolygon::height, Slic3r::arrangement::ArrangePolygon::is_virt_object, m_keep_outs, Slic3r::arrangement::ArrangePolygon::name, and Slic3r::arrangement::ArrangePolygon::poly.

Referenced by Slic3r::GUI::ArrangeJob::process().

Here is the caller graph for this function:

bed_shape()

Points Slic3r::ImexArranger::bed_shape

(

)

const

{ return m_shared_room ? m_shared_room->polygon().points : m_bed; }

References m_bed, and m_shared_room.

Referenced by Slic3r::GUI::ArrangeJob::process().

Here is the caller graph for this function:

crosses_keep_out()

bool Slic3r::ImexArranger::crosses_keep_out ( const arrangement::ArrangePolygon & part, int bed_idx ) const

private

{
    const Polygon hull = part.transformed_poly().contour;
    return std::any_of(m_keep_outs.begin(), m_keep_outs.end(), [&](const KeepOut& keep_out) {
        return keep_out.bed_idx == bed_idx && !intersection(hull, keep_out.box.polygon()).empty();
    });
}

References Slic3r::ExPolygon::contour, m_keep_outs, and Slic3r::arrangement::ArrangePolygon::transformed_poly().

Referenced by finish().

Here is the call graph for this function:

Here is the caller graph for this function:

finish()

void Slic3r::ImexArranger::finish	(	arrangement::ArrangePolygons &	items,
		const arrangement::ArrangePolygons &	before,
		const arrangement::ArrangePolygons &	fixed,
		const arrangement::ArrangeParams &	params ) const

{
    for (arrangement::ArrangePolygon& part : items)
        if (crosses_keep_out(part, part.bed_idx))
            part.bed_idx = arrangement::UNARRANGED;
 
    // Only fenced plates need centering, and arranging one plate never fences.
    if (m_shared_room || !m_adds_plates)
        return;
 
    arrangement::ArrangeParams one_plate = params;
    one_plate.progressind                = {};
    for (const Bed& b : m_beds) {
        const std::optional<BoundingBox> room = room_in(b.zones.primary_zone);
        std::vector<size_t>              on_bed;
        for (size_t i = 0; i < items.size(); ++i)
            if (items[i].bed_idx == b.bed_idx)
                on_bed.push_back(i);
        if (on_bed.empty() || !room)
            continue;
 
        arrangement::ArrangePolygons parts, bed_fixed;
        // Bed 0, where the nester takes a part as placeable rather than as one that does not fit.
        for (size_t i : on_bed) {
            parts.push_back(before[i]);
            parts.back().bed_idx = 0;
        }
        for (const arrangement::ArrangePolygon& ap : fixed)
            if (ap.bed_idx == b.bed_idx && ap.name != kFenceName) {
                bed_fixed.push_back(ap);
                bed_fixed.back().bed_idx = 0;
            }
        arrangement::arrange(parts, bed_fixed, room->polygon().points, one_plate);
        // A canceled pass leaves parts it never reached on bed 0 with their old ids.
        if (one_plate.stopcondition && one_plate.stopcondition())
            return;
 
        // Keep the first layout when this one does not fit.
        if (!std::all_of(parts.begin(), parts.end(), [&](const arrangement::ArrangePolygon& part) {
                return part.bed_idx == 0 && !crosses_keep_out(part, b.bed_idx);
            }))
            continue;
 
        // By-object printing follows the packing order, which this pass numbered 0..n-1: carry
        // it over onto the ids the first pass gave these parts.
        std::vector<int> ids;
        for (size_t i : on_bed)
            ids.push_back(items[i].itemid);
        std::sort(ids.begin(), ids.end());
        for (size_t k = 0; k < on_bed.size(); ++k) {
            items[on_bed[k]].translation = parts[k].translation;
            items[on_bed[k]].rotation    = parts[k].rotation;
            items[on_bed[k]].itemid      = ids[parts[k].itemid];
        }
    }
}

References Slic3r::arrangement::arrange(), crosses_keep_out(), m_adds_plates, m_beds, m_shared_room, Slic3r::arrangement::ArrangeParams::progressind, room_in(), Slic3r::arrangement::ArrangeParams::stopcondition, and Slic3r::arrangement::UNARRANGED.

Referenced by Slic3r::GUI::ArrangeJob::process().

Here is the call graph for this function:

Here is the caller graph for this function:

room_in()

std::optional< BoundingBox > Slic3r::ImexArranger::room_in ( const BoundingBoxf & zone ) const

private

{
    BoundingBox room = inset(scaled(zone), m_margin);
    room.min         = room.min.cwiseMax(m_bed_bb.min);
    room.max         = room.max.cwiseMin(m_bed_bb.max);
    if (room.min.x() >= room.max.x() || room.min.y() >= room.max.y())
        return std::nullopt;
    return room;
}

References m_bed_bb, m_margin, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::scaled().

Referenced by ImexArranger(), and finish().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_adds_plates

bool Slic3r::ImexArranger::m_adds_plates = false

private

Referenced by ImexArranger(), and finish().

m_bed

Points Slic3r::ImexArranger::m_bed

private

Referenced by ImexArranger(), and bed_shape().

m_bed_bb

BoundingBox Slic3r::ImexArranger::m_bed_bb

private

Referenced by ImexArranger(), and room_in().

m_beds

std::vector<Bed> Slic3r::ImexArranger::m_beds

private

Referenced by ImexArranger(), active(), and finish().

m_keep_outs

std::vector<KeepOut> Slic3r::ImexArranger::m_keep_outs

private

Referenced by ImexArranger(), add_keep_outs(), and crosses_keep_out().

m_margin

Point Slic3r::ImexArranger::m_margin

private

Referenced by ImexArranger(), and room_in().

m_shared_room

std::optional<BoundingBox> Slic3r::ImexArranger::m_shared_room

private

Referenced by ImexArranger(), bed_shape(), and finish().

---

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

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