Slic3r::arrangement::AutoArranger< TBin > Class Template Reference

Collaboration diagram for Slic3r::arrangement::AutoArranger< TBin >:

Public Types
using	Placer = typename placers::_NofitPolyPlacer<ExPolygon, TBin>
using	Selector = selections::_FirstFitSelection<ExPolygon>
using	Packer = _Nester<Placer, Selector>
using	PConfig = typename Packer::PlacementConfig
using	Distance = TCoord<PointImpl>

Public Member Functions
	AutoArranger (const TBin &bin, const ArrangeParams &params, std::function< void(unsigned, std::string)> progressind, std::function< bool(void)> stopcond)
template<class It>
void	operator() (It from, It to)
PConfig &	config ()
const PConfig &	config () const
void	preload (std::vector< Item > &fixeditems)

Public Attributes
std::vector< Item >	m_excluded_items_in_each_plate

Protected Member Functions
template<class T>
ArithmeticOnly< T, double >	norm (T val)
double	dist_for_BOTTOM_LEFT (Box ibb, const Slic3r::Point &origin_pack)
bool	corner_packing () const
double	belt_pos (const Box::PointType &pt) const
double	belt_start (const Box &bb) const
double	belt_end (const Box &bb) const
Box::PointType	belt_origin () const
double	dist_along_belt (const Box &ibb)
double	corner_bindist (const Box &ibb, const Slic3r::Point &origin_pack)
double	dist_to_bin (const Box &ibb, const Slic3r::Point &origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment)
std::tuple< double, Box >	objfunc (const Item &item, const Slic3r::Point &origin_pack)
std::function< double(const Item &, const ItemGroup &)>	get_objfn ()
std::function< double(const Item &, const ItemGroup &)>	get_objfn ()
std::function< double(const Item &, const ItemGroup &)>	get_objfn ()
std::function< double(const Item &, const ItemGroup &)>	get_objfn ()

Static Protected Member Functions
static double	at (const Box::PointType &pt, int i)

Protected Attributes
Packer	m_pck
PConfig	m_pconf
TBin	m_bin
double	m_bin_area
SpatIndex	m_rtree
SpatIndex	m_smallsrtree
double	m_norm
MultiPolygon	m_merged_pile
Box	m_pilebb
ItemGroup	m_remaining
ItemGroup	m_items
std::vector< Box >	m_excluded_and_extruCali_regions
size_t	m_item_count = 0
ArrangeParams	params

Detailed Description

template<class TBin>
class Slic3r::arrangement::AutoArranger< TBin >

Member Typedef Documentation

Distance

template<class TBin>

using Slic3r::arrangement::AutoArranger< TBin >::Distance = TCoord<PointImpl>

Packer

template<class TBin>

using Slic3r::arrangement::AutoArranger< TBin >::Packer = _Nester<Placer, Selector>

PConfig

template<class TBin>

using Slic3r::arrangement::AutoArranger< TBin >::PConfig = typename Packer::PlacementConfig

Placer

template<class TBin>

using Slic3r::arrangement::AutoArranger< TBin >::Placer = typename placers::_NofitPolyPlacer<ExPolygon, TBin>

Selector

template<class TBin>

using Slic3r::arrangement::AutoArranger< TBin >::Selector = selections::_FirstFitSelection<ExPolygon>

Constructor & Destructor Documentation

AutoArranger()

template<class TBin>

Slic3r::arrangement::AutoArranger< TBin >::AutoArranger ( const TBin & bin, const ArrangeParams & params, std::function< void(unsigned, std::string)> progressind, std::function< bool(void)> stopcond )

inline

        : m_pck(bin, params.min_obj_distance)
        , m_bin(bin)
    {
        m_bin_area = abs(sl::area(bin));  // due to clockwise or anti-clockwise, the result of sl::area may be negative
        m_norm = std::sqrt(m_bin_area);
        fill_config(m_pconf, params);
        this->params = params;
 
        // if best object center is not bed center, specify starting point here
        if (std::abs(this->params.align_center.x() - 0.5) > 0.001 || std::abs(this->params.align_center.y() - 0.5) > 0.001) {
            auto binbb = sl::boundingBox(m_bin);
            m_pconf.best_object_pos = binbb.minCorner() + Point{ binbb.width() * this->params.align_center.x(), binbb.height() * this->params.align_center.y() };
            m_pconf.alignment = PConfig::Alignment::USER_DEFINED;
        }
 
        for (auto& region : m_pconf.m_excluded_regions) {
            Box  bb = region.boundingBox();
            m_excluded_and_extruCali_regions.emplace_back(bb);
        }
        for (auto& region : m_pconf.m_nonprefered_regions) {
            Box  bb = region.boundingBox();
            m_excluded_and_extruCali_regions.emplace_back(bb);
        }
 
        // Set up a callback that is called just before arranging starts
        // This functionality is provided by the Nester class (m_pack).
        m_pconf.before_packing =
        [this](const MultiPolygon& merged_pile,            // merged pile
               const ItemGroup& items,             // packed items
               const ItemGroup& remaining)         // future items to be packed
        {
            m_items = items;
            m_merged_pile = merged_pile;
            m_remaining = remaining;
 
            m_pilebb.defined = false;
            if (!merged_pile.empty())
            {
                m_pilebb = sl::boundingBox(merged_pile);
                m_pilebb.defined = true;
            }
 
            m_rtree.clear();
            m_smallsrtree.clear();
 
            // We will treat big items (compared to the print bed) differently
            auto isBig = [this](double a) {
                return a / m_bin_area > BIG_ITEM_TRESHOLD ;
            };
 
            for(unsigned idx = 0; idx < items.size(); ++idx) {
                Item& itm = items[idx];
                if (itm.is_virt_object) continue;
                if(isBig(itm.area())) m_rtree.insert({itm.boundingBox(), idx});
                m_smallsrtree.insert({itm.boundingBox(), idx});
            }
        };
 
        m_pconf.object_function = get_objfn();
 
        // preload fixed items (and excluded regions) on plate
        m_pconf.on_preload = [this](const ItemGroup &items, PConfig &cfg) {
            if (items.empty()) return;
 
            auto binbb = sl::boundingBox(m_bin);
 
            auto starting_point = this->params.is_belt ? belt_origin() :
                cfg.starting_point == PConfig::Alignment::BOTTOM_LEFT ? binbb.minCorner() : binbb.center();
            // if we have wipe tower, items should be arranged around wipe tower
            for (Item itm : items) {
                if (itm.is_wipe_tower) {
                    starting_point = itm.boundingBox().center();
                    BOOST_LOG_TRIVIAL(debug) << "arrange we have wipe tower, change starting point to: " << starting_point;
                    break;
                }
            }
 
            cfg.object_function = [this, binbb, starting_point](const Item &item, const ItemGroup &packed_items) {
                return fixed_overfit(objfunc(item, starting_point), binbb);
            };
        };
 
        auto on_packed = params.on_packed;
 
        if (progressind || on_packed)
            m_pck.progressIndicator(
                [this, progressind, on_packed](unsigned num_finished) {
                    int last_bed = m_pck.lastPackedBinId();
                    if (last_bed >= 0) {
                        Item& last_packed = m_pck.lastResult()[last_bed].back();
                        ArrangePolygon ap;
                        ap.bed_idx = last_packed.binId();
                        ap.priority = last_packed.priority();
                        if (progressind) progressind(num_finished, last_packed.name);
                        if (on_packed)
                            on_packed(ap);
                        BOOST_LOG_TRIVIAL(debug) << "arrange " + last_packed.name + " succeed!"
                            << ", plate id=" << ap.bed_idx << ", pos=" << last_packed.translation()
                            << ", temp_type=" << last_packed.filament_temp_type;
                    }
                });
 
        m_pck.unfitIndicator([](std::string name) {
            BOOST_LOG_TRIVIAL(debug) << "arrange progress: " + name;
                });
 
        if (stopcond) m_pck.stopCondition(stopcond);
 
        m_pconf.sortfunc= [&params](Item& i1, Item& i2) {
            int p1 = i1.priority(), p2 = i2.priority();
            if (p1 != p2)
                return p1 > p2;
            if (params.is_seq_print) {
                return i1.bed_temp != i2.bed_temp                ? (i1.bed_temp > i2.bed_temp) :
                       i1.height != i2.height                    ? (i1.height < i2.height) :
                       std::abs(i1.area() / i2.area() - 1) > 0.2 ? (i1.area() > i2.area()) :
                                                                   i1.extrude_ids.front() < i2.extrude_ids.front();
            }
            else {
                return i1.bed_temp != i2.bed_temp ? (i1.bed_temp > i2.bed_temp) :
                    (i1.extrude_ids != i2.extrude_ids ? (i1.extrude_ids.front() < i2.extrude_ids.front()) : (i1.area() > i2.area()));
            }
        };
 
        m_pck.configure(m_pconf);
    }

References Slic3r::arrangement::ArrangeParams::align_center, Slic3r::arrangement::ArrangePolygon::bed_idx, belt_origin(), Slic3r::arrangement::BIG_ITEM_TRESHOLD, Slic3r::arrangement::fill_config(), Slic3r::arrangement::fixed_overfit(), get_objfn(), Slic3r::arrangement::ArrangeParams::is_belt, m_bin, m_bin_area, m_excluded_and_extruCali_regions, m_items, m_merged_pile, m_norm, m_pck, m_pconf, m_pilebb, m_remaining, m_rtree, m_smallsrtree, objfunc(), params, and Slic3r::arrangement::ArrangePolygon::priority.

Here is the call graph for this function:

Member Function Documentation

at()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::at ( const Box::PointType & pt, int i )

inlinestaticprotected

{ return double(i == 0 ? getX(pt) : getY(pt)); }

Referenced by belt_pos(), and dist_along_belt().

Here is the caller graph for this function:

belt_end()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::belt_end ( const Box & bb ) const

inlineprotected

{ return belt_pos(params.belt_reversed ? bb.minCorner() : bb.maxCorner()); }

References belt_pos(), and params.

Referenced by dist_along_belt(), and objfunc().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_origin()

template<class TBin>

Box::PointType Slic3r::arrangement::AutoArranger< TBin >::belt_origin ( ) const

inlineprotected

    {
        const Box bb = sl::boundingBox(m_bin);
        auto o = bb.minCorner();
        if (params.belt_reversed) {
            if (params.belt_axis == 0) setX(o, getX(bb.maxCorner()));
            else                       setY(o, getY(bb.maxCorner()));
        }
        return o;
    }

References m_bin, and params.

Referenced by AutoArranger().

Here is the caller graph for this function:

belt_pos()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::belt_pos ( const Box::PointType & pt ) const

inlineprotected

{ return params.belt_reversed ? -at(pt, params.belt_axis) : at(pt, params.belt_axis); }

References at(), and params.

Referenced by belt_end(), and belt_start().

Here is the call graph for this function:

Here is the caller graph for this function:

belt_start()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::belt_start ( const Box & bb ) const

inlineprotected

{ return belt_pos(params.belt_reversed ? bb.maxCorner() : bb.minCorner()); }

References belt_pos(), and params.

Referenced by dist_along_belt(), and objfunc().

Here is the call graph for this function:

Here is the caller graph for this function:

config() [1/2]

template<class TBin>

PConfig & Slic3r::arrangement::AutoArranger< TBin >::config ( )

inline

{ return m_pconf; }

References m_pconf.

config() [2/2]

template<class TBin>

const PConfig & Slic3r::arrangement::AutoArranger< TBin >::config ( ) const

inline

{ return m_pconf; }

References m_pconf.

corner_bindist()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::corner_bindist ( const Box & ibb, const Slic3r::Point & origin_pack )

inlineprotected

    {
        return params.is_belt ? dist_along_belt(ibb) : dist_for_BOTTOM_LEFT(ibb, origin_pack);
    }

References dist_along_belt(), dist_for_BOTTOM_LEFT(), and params.

Referenced by objfunc().

Here is the call graph for this function:

Here is the caller graph for this function:

corner_packing()

template<class TBin>

bool Slic3r::arrangement::AutoArranger< TBin >::corner_packing ( ) const

inlineprotected

{ return params.is_belt || m_pconf.starting_point == PConfig::Alignment::BOTTOM_LEFT; }

References m_pconf, and params.

Referenced by get_objfn(), and objfunc().

Here is the caller graph for this function:

dist_along_belt()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::dist_along_belt ( const Box & ibb )

inlineprotected

    {
        const Box    bin = sl::boundingBox(m_bin);
        const int    l   = 1 - params.belt_axis;
        const double lat = at(ibb.minCorner(), l) - at(bin.minCorner(), l);
        double       d   = belt_end(ibb) - belt_start(bin);
        d += lat < 0 ? 10 * -lat : 0.1 * lat;
        if (double behind = belt_start(ibb) - belt_start(bin); behind < 0)
            d += 10 * -behind;
        return norm(d);
    }

References at(), belt_end(), belt_start(), m_bin, norm(), and params.

Referenced by corner_bindist().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_for_BOTTOM_LEFT()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::dist_for_BOTTOM_LEFT ( Box ibb, const Slic3r::Point & origin_pack )

inlineprotected

    {
        double dist_corner_y = ibb.minCorner().y() - origin_pack.y();
        double dist_corner_x = ibb.minCorner().x() - origin_pack.x();
        // occupy as few rows as possible if we have rotations
        double bindist       = double(ibb.maxCorner().y() - ibb.minCorner().y());
        if (dist_corner_x >= 0 && dist_corner_y >= 0)
            bindist += dist_corner_y + 1 * dist_corner_x;
        else {
            if (dist_corner_x < 0) bindist += 10 * (-dist_corner_x);
            if (dist_corner_y < 0) bindist += 10 * (-dist_corner_y);
            }
        bindist = norm(bindist);
        return bindist;
    }

References norm().

Referenced by corner_bindist().

Here is the call graph for this function:

Here is the caller graph for this function:

dist_to_bin()

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::dist_to_bin ( const Box & ibb, const Slic3r::Point & origin_pack, typename Packer::PlacementConfig::Alignment starting_point_alignment )

inlineprotected

    {
        double bindist = 0;
        if (starting_point_alignment == PConfig::Alignment::BOTTOM_LEFT)
            bindist = norm(pl::distance(ibb.minCorner(), origin_pack));
        else if (starting_point_alignment == PConfig::Alignment::TOP_RIGHT)
            bindist = norm(pl::distance(ibb.maxCorner(), origin_pack));
        else
            bindist = norm(pl::distance(ibb.center(), origin_pack));
        return bindist;
    }

References norm().

Referenced by objfunc().

Here is the call graph for this function:

Here is the caller graph for this function:

get_objfn() [1/4]

std::function< double(const Item &, const ItemGroup &)> Slic3r::arrangement::AutoArranger< ExPolygon >::get_objfn ( )

protected

{
    auto bb = sl::boundingBox(m_bin);
    auto origin_pack = m_pconf.starting_point == PConfig::Alignment::CENTER ? bb.center() : bb.minCorner();
    return [this, origin_pack](const Item &itm, const ItemGroup&) {
        auto result = objfunc(itm, origin_pack);
 
        double score = std::get<0>(result);
 
        auto mp = m_merged_pile;
        mp.emplace_back(itm.transformedShape());
        auto chull = sl::convexHull(mp);
        if (corner_packing())
        {
            if (!sl::isInside(chull, m_bin))
                score += LARGE_COST_TO_REJECT;
        }
        else
        {
            double miss = Placer::overfit(chull, m_bin);
            miss = miss > 0 ? miss : 0;
            score += miss * miss;
        }
 
        return score;
    };
}

References corner_packing(), get_objfn(), m_bin, m_merged_pile, m_pconf, and objfunc().

Here is the call graph for this function:

get_objfn() [2/4]

std::function< double(const Item &, const ItemGroup &)> Slic3r::arrangement::AutoArranger< Circle >::get_objfn ( )

protected

{
    auto bb = sl::boundingBox(m_bin);
    auto origin_pack = m_pconf.starting_point == PConfig::Alignment::CENTER ? bb.center() : bb.minCorner();
    return [this, origin_pack](const Item &item, const ItemGroup&) {
 
        auto result = objfunc(item, origin_pack);
 
        double score = std::get<0>(result);
 
        auto isBig = [this](const Item& itm) {
            return itm.area() / m_bin_area > BIG_ITEM_TRESHOLD ;
        };
 
        if(isBig(item)) {
            auto mp = m_merged_pile;
            mp.push_back(item.transformedShape());
            auto chull = sl::convexHull(mp);
            double miss = Placer::overfit(chull, m_bin);
            if(miss < 0) miss = 0;
            score += miss*miss;
        }
 
        return score;
    };
}

References Slic3r::arrangement::BIG_ITEM_TRESHOLD, get_objfn(), m_bin, m_bin_area, m_merged_pile, m_pconf, and objfunc().

Here is the call graph for this function:

get_objfn() [3/4]

std::function< double(const Item &, const ItemGroup &)> Slic3r::arrangement::AutoArranger< Box >::get_objfn ( )

protected

{
    auto origin_pack = m_pconf.starting_point == PConfig::Alignment::CENTER ? m_bin.center() :
        m_pconf.starting_point == PConfig::Alignment::TOP_RIGHT ? m_bin.maxCorner() : m_bin.minCorner();
 
    return [this, origin_pack](const Item &itm, const ItemGroup&) {
        auto result = objfunc(itm, origin_pack);
 
        double score = std::get<0>(result);
        auto& fullbb = std::get<1>(result);
 
        //if (m_pconf.starting_point == PConfig::Alignment::BOTTOM_LEFT)
        //{
        //    if (!sl::isInside(fullbb, m_bin))
        //        score += LARGE_COST_TO_REJECT;
        //}
        //else
        {
            double miss = Placer::overfit(fullbb, m_bin);
            miss = miss > 0 ? miss : 0;
            score += miss * miss;
            if (score > LARGE_COST_TO_REJECT)
                score = 1.5 * LARGE_COST_TO_REJECT;
        }
 
        return score;
    };
}

References get_objfn(), m_bin, m_pconf, and objfunc().

Here is the call graph for this function:

get_objfn() [4/4]

template<class TBin>

std::function< double(const Item &, const ItemGroup &)> Slic3r::arrangement::AutoArranger< TBin >::get_objfn ( )

protected

Referenced by AutoArranger(), and get_objfn().

Here is the caller graph for this function:

norm()

template<class TBin>

template<class T>

ArithmeticOnly< T, double > Slic3r::arrangement::AutoArranger< TBin >::norm ( T val )

inlineprotected

    {
        return double(val) / m_norm;
    }

References m_norm.

Referenced by dist_along_belt(), dist_for_BOTTOM_LEFT(), dist_to_bin(), and objfunc().

Here is the caller graph for this function:

objfunc()

template<class TBin>

std::tuple< double, Box > Slic3r::arrangement::AutoArranger< TBin >::objfunc ( const Item & item, const Slic3r::Point & origin_pack )

inlineprotected

    {
        const double bin_area = m_bin_area;
        const SpatIndex& spatindex = m_rtree;
        const SpatIndex& smalls_spatindex = m_smallsrtree;
 
        // We will treat big items (compared to the print bed) differently
        auto isBig = [bin_area](double a) {
            return a/bin_area > BIG_ITEM_TRESHOLD ;
        };
 
        // Candidate item bounding box
        auto ibb = item.boundingBox();
 
        // Calculate the full bounding box of the pile with the candidate item
        auto fullbb = sl::boundingBox(m_pilebb, ibb);
 
        // The bounding box of the big items (they will accumulate in the center
        // of the pile
        Box bigbb;
        if(spatindex.empty()) bigbb = fullbb;
        else {
            auto boostbb = spatindex.bounds();
            boost::geometry::convert(boostbb, bigbb);
        }
 
        // Will hold the resulting score
        double score = 0;
 
        // Density is the pack density: how big is the arranged pile
        double density = 0;
 
        // Distinction of cases for the arrangement scene
        enum e_cases {
            // This branch is for big items in a mixed (big and small) scene
            // OR for all items in a small-only scene.
            BIG_ITEM,
 
            // This branch is for the last big item in a mixed scene
            LAST_BIG_ITEM,
 
            // For small items in a mixed scene.
            SMALL_ITEM
        } compute_case;
 
        bool bigitems = isBig(item.area()) || spatindex.empty();
        if(!params.is_seq_print && bigitems && !m_remaining.empty()) compute_case = BIG_ITEM;  // do not use so complicated logic for sequential printing
        else if (bigitems && m_remaining.empty()) compute_case = LAST_BIG_ITEM;
        else compute_case = SMALL_ITEM;
 
        switch (compute_case) {
        case BIG_ITEM: {
            const Point& minc = ibb.minCorner(); // bottom left corner
            const Point& maxc = ibb.maxCorner(); // top right corner
 
            // top left and bottom right corners
            Point top_left{getX(minc), getY(maxc)};
            Point bottom_right{getX(maxc), getY(minc)};
 
            // Now the distance of the gravity center will be calculated to the
            // five anchor points and the smallest will be chosen.
            std::array<double, 5> dists;
            auto cc = fullbb.center(); // The gravity center
            dists[0] = pl::distance(minc, cc);
            dists[1] = pl::distance(maxc, cc);
            dists[2] = pl::distance(ibb.center(), cc);
            dists[3] = pl::distance(top_left, cc);
            dists[4] = pl::distance(bottom_right, cc);
 
            // The smalles distance from the arranged pile center:
            double dist = norm(*(std::min_element(dists.begin(), dists.end())));
            if (corner_packing()) {
                double bindist = corner_bindist(ibb, origin_pack);
                score = 0.2 * dist + 0.8 * bindist;
            }
            else {
                double bindist = dist_to_bin(ibb, origin_pack, m_pconf.starting_point);
                dist = 0.8 * dist + 0.2 * bindist;
 
 
                // Prepare a variable for the alignment score.
                // This will indicate: how well is the candidate item
                // aligned with its neighbors. We will check the alignment
                // with all neighbors and return the score for the best
                // alignment. So it is enough for the candidate to be
                // aligned with only one item.
                auto alignment_score = 1.0;
 
                auto query = bgi::intersects(ibb);
                auto& index = isBig(item.area()) ? spatindex : smalls_spatindex;
 
                // Query the spatial index for the neighbors
                std::vector<SpatElement> result;
                result.reserve(index.size());
 
                index.query(query, std::back_inserter(result));
 
                // now get the score for the best alignment
                for (auto& e : result) {
                    auto idx = e.second;
                    Item& p = m_items[idx];
                    auto parea = p.area();
                    if (std::abs(1.0 - parea / item.area()) < 1e-6) {
                        auto bb = sl::boundingBox(p.boundingBox(), ibb);
                        auto bbarea = bb.area();
                        auto ascore = 1.0 - (item.area() + parea) / bbarea;
 
                        if (ascore < alignment_score) alignment_score = ascore;
                    }
                }
 
                density = std::sqrt(norm(fullbb.width()) * norm(fullbb.height()));
                double R = double(m_remaining.size()) / m_item_count;
                // alighment score is more important for rectangle items
                double alignment_weight = std::max(0.3, 0.6 * item.area() / ibb.area());
 
                // The final mix of the score is the balance between the
                // distance from the full pile center, the pack density and
                // the alignment with the neighbors
                if (result.empty())
                    score = 0.50 * dist + 0.50 * density;
                else
                    // Let the density matter more when fewer objects remain
                    score = (1 - 0.2 - alignment_weight) * dist + (1.0 - R) * 0.20 * density +
                    alignment_weight * alignment_score;
            }
            break;
        }
        case LAST_BIG_ITEM: {
            if (corner_packing()) {
                score = corner_bindist(ibb, origin_pack);
            }
            else {
                if (m_pilebb.defined)
                    score = 0.5 * norm(pl::distance(ibb.center(), m_pilebb.center()));
                else
                    score = 0.5 * norm(pl::distance(ibb.center(), origin_pack));
            }
            break;
        }
        case SMALL_ITEM: {
            // Here there are the small items that should be placed around the
            // already processed bigger items.
            // No need to play around with the anchor points, the center will be
            // just fine for small items
            if (corner_packing())
                score = corner_bindist(ibb, origin_pack);
            else {
                // Align mainly around existing items
                score = 0.8 * norm(pl::distance(ibb.center(), bigbb.center()))+ 0.2*norm(pl::distance(ibb.center(), origin_pack));
                // Align to 135 degree line {calc distance to the line x+y-(xc+yc)=0}
                //auto ic = ibb.center(), bigbbc = origin_pack;// bigbb.center();
                //score = norm(std::abs(ic.x() + ic.y() - bigbbc.x() - bigbbc.y()));
            }
 
            break;
        }
        }
 
 
        if (params.is_seq_print) {
            double clearance_height_to_lid = params.clearance_height_to_lid;
            double clearance_height_to_rod = params.clearance_height_to_rod;
            bool hasRowHeightConflict = false;
            bool hasLidHeightConflict = false;
            auto iy1 = item.boundingBox().minCorner().y();
            auto iy2 = item.boundingBox().maxCorner().y();
            auto ix1 = item.boundingBox().minCorner().x();
 
            for (int i = 0; i < m_items.size(); i++) {
                Item& p = m_items[i];
                if (p.is_virt_object) continue;
                auto px1 = p.boundingBox().minCorner().x();
                auto py1 = p.boundingBox().minCorner().y();
                auto py2 = p.boundingBox().maxCorner().y();
                auto inter_min = std::max(iy1, py1); // min y of intersection
                auto inter_max = std::min(iy2, py2); // max y of intersection. length=max_y-min_y>0 means intersection exists
                // if this item is lower than existing ones, this item will be printed first, so should not exceed height_to_rod
                if (iy2 < py1) { hasRowHeightConflict |= (item.height > clearance_height_to_rod); }
                else if (inter_max - inter_min > 0) {
                    // if they inter, the one on the left will be printed first
                    double h = ix1 < px1 ? item.height : p.height;
                    hasRowHeightConflict |= (h > clearance_height_to_rod);
                }
                // only last item can be heigher than clearance_height_to_lid, so if the existing items are higher than clearance_height_to_lid, there is height conflict
                hasLidHeightConflict |= (p.height > clearance_height_to_lid);
            }
 
            double lambda3 = LARGE_COST_TO_REJECT*1.1;
            double lambda4 = LARGE_COST_TO_REJECT*1.2;
            for (int i = 0; i < m_items.size(); i++) {
                Item& p = m_items[i];
                if (p.is_virt_object) continue;
                //score += lambda3 * (item.bed_temp - p.vitrify_temp > VITRIFY_TEMP_DIFF_THRSH);
                if (!Print::is_filaments_compatible({item.filament_temp_type,p.filament_temp_type}))
                    score += lambda3;
            }
            //score += lambda3 * (item.bed_temp - item.vitrify_temp > VITRIFY_TEMP_DIFF_THRSH);
            score += lambda4 * hasRowHeightConflict + lambda4 * hasLidHeightConflict;
        }
        else {
            int valid_items_cnt = 0;
            double height_score = 0;
            for (int i = 0; i < m_items.size(); i++) {
                Item& p = m_items[i];
                if (!p.is_virt_object) {
                    valid_items_cnt++;
                    // 高度接近的件尽量摆到一起
                    height_score += (1- std::abs(item.height - p.height) / params.printable_height)
                        * norm(pl::distance(ibb.center(), p.boundingBox().center()));
                    //score += LARGE_COST_TO_REJECT * (item.bed_temp - p.bed_temp != 0);
                    if (!Print::is_filaments_compatible({ item.filament_temp_type,p.filament_temp_type })) {
                        score += LARGE_COST_TO_REJECT;
                        break;
                    }
                }
            }
            if (valid_items_cnt > 0)
                score += height_score / valid_items_cnt;
        }
 
        std::set<int> extruder_ids;
        for (int i = 0; i < m_items.size(); i++) {
            Item& p = m_items[i];
            if (p.is_virt_object) continue;
            extruder_ids.insert(p.extrude_ids.begin(),p.extrude_ids.end());
        }
 
        // add a large cost if not multi materials on same plate is not allowed
        if (!params.allow_multi_materials_on_same_plate) {
            // it's the first object, which can be multi-color
            bool first_object                 = extruder_ids.empty();
            // the two objects (previously packed items and the current item) are considered having same color if either one's colors are a subset of the other
            std::set<int> item_extruder_ids(item.extrude_ids.begin(), item.extrude_ids.end());
            bool same_color_with_previous_items = std::includes(item_extruder_ids.begin(), item_extruder_ids.end(), extruder_ids.begin(), extruder_ids.end())
                || std::includes(extruder_ids.begin(), extruder_ids.end(), item_extruder_ids.begin(), item_extruder_ids.end());
            if (!(first_object || same_color_with_previous_items)) score += LARGE_COST_TO_REJECT * 1.3;
        }
        // for layered printing, we want extruder change as few as possible
        // this has very weak effect, CAN NOT use a large weight
        int last_extruder_cnt = extruder_ids.size();
        extruder_ids.insert(item.extrude_ids.begin(), item.extrude_ids.end());
        int new_extruder_cnt= extruder_ids.size();
        if (!params.is_seq_print) {
            score += 1 * (new_extruder_cnt-last_extruder_cnt);
        }
 
        // On a belt the parts print in belt order, so every colour change between
        // parts is a filament change. Items arrive sorted by extruder and the pile
        // grows from the leading end; keep each colour's run contiguous by charging
        // an item for every packed item of another colour it does not fully follow,
        // counting the tilted layers that reach belt_tilt_slope * height past that
        // item's far edge.
        if (params.is_belt && !params.is_seq_print) {
            const std::set<int> item_colours(item.extrude_ids.begin(), item.extrude_ids.end());
            const double        item_start = belt_start(ibb);
            for (Item &p : m_items) {
                if (p.is_virt_object)
                    continue;
                const std::set<int> p_colours(p.extrude_ids.begin(), p.extrude_ids.end());
                const bool same_colour = std::includes(item_colours.begin(), item_colours.end(), p_colours.begin(), p_colours.end())
                                      || std::includes(p_colours.begin(), p_colours.end(), item_colours.begin(), item_colours.end());
                if (same_colour)
                    continue;
                if (item_start < belt_end(p.boundingBox()) + scaled(p.height * params.belt_tilt_slope))
                    score += 10.;
            }
        }
 
        return std::make_tuple(score, fullbb);
    }

References belt_end(), belt_start(), Slic3r::arrangement::BIG_ITEM_TRESHOLD, corner_bindist(), corner_packing(), Slic3r::Geometry::dist(), dist_to_bin(), Slic3r::Print::is_filaments_compatible(), m_bin_area, m_item_count, m_items, m_pconf, m_pilebb, m_remaining, m_rtree, m_smallsrtree, norm(), params, and Slic3r::scaled().

Referenced by AutoArranger(), and get_objfn().

Here is the call graph for this function:

Here is the caller graph for this function:

operator()()

template<class TBin>

template<class It>

void Slic3r::arrangement::AutoArranger< TBin >::operator() ( It from, It to )

inline

                                                              {
        m_rtree.clear();
        m_item_count += size_t(to - from);
        m_pck.execute(from, to);
        m_item_count = 0;
    }

References m_item_count, m_pck, and m_rtree.

preload()

template<class TBin>

void Slic3r::arrangement::AutoArranger< TBin >::preload ( std::vector< Item > & fixeditems )

inline

                                                     {
        for(unsigned idx = 0; idx < fixeditems.size(); ++idx) {
            Item& itm = fixeditems[idx];
            itm.markAsFixedInBin(itm.binId());
        }
 
        m_item_count += fixeditems.size();
    }

References m_item_count.

Referenced by Slic3r::arrangement::_arrange().

Here is the caller graph for this function:

Member Data Documentation

m_bin

template<class TBin>

TBin Slic3r::arrangement::AutoArranger< TBin >::m_bin

protected

Referenced by AutoArranger(), belt_origin(), dist_along_belt(), and get_objfn().

m_bin_area

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::m_bin_area

protected

Referenced by AutoArranger(), get_objfn(), and objfunc().

m_excluded_and_extruCali_regions

template<class TBin>

std::vector<Box> Slic3r::arrangement::AutoArranger< TBin >::m_excluded_and_extruCali_regions

protected

Referenced by AutoArranger().

m_excluded_items_in_each_plate

template<class TBin>

std::vector<Item> Slic3r::arrangement::AutoArranger< TBin >::m_excluded_items_in_each_plate

m_item_count

template<class TBin>

size_t Slic3r::arrangement::AutoArranger< TBin >::m_item_count = 0

protected

Referenced by objfunc(), operator()(), and preload().

m_items

template<class TBin>

ItemGroup Slic3r::arrangement::AutoArranger< TBin >::m_items

protected

Referenced by AutoArranger(), and objfunc().

m_merged_pile

template<class TBin>

MultiPolygon Slic3r::arrangement::AutoArranger< TBin >::m_merged_pile

protected

Referenced by AutoArranger(), and get_objfn().

m_norm

template<class TBin>

double Slic3r::arrangement::AutoArranger< TBin >::m_norm

protected

Referenced by AutoArranger(), and norm().

m_pck

template<class TBin>

Packer Slic3r::arrangement::AutoArranger< TBin >::m_pck

protected

Referenced by AutoArranger(), and operator()().

m_pconf

template<class TBin>

PConfig Slic3r::arrangement::AutoArranger< TBin >::m_pconf

protected

Referenced by AutoArranger(), config(), config(), corner_packing(), get_objfn(), and objfunc().

m_pilebb

template<class TBin>

Box Slic3r::arrangement::AutoArranger< TBin >::m_pilebb

protected

Referenced by AutoArranger(), and objfunc().

m_remaining

template<class TBin>

ItemGroup Slic3r::arrangement::AutoArranger< TBin >::m_remaining

protected

Referenced by AutoArranger(), and objfunc().

m_rtree

template<class TBin>

SpatIndex Slic3r::arrangement::AutoArranger< TBin >::m_rtree

protected

Referenced by AutoArranger(), objfunc(), and operator()().

m_smallsrtree

template<class TBin>

SpatIndex Slic3r::arrangement::AutoArranger< TBin >::m_smallsrtree

protected

Referenced by AutoArranger(), and objfunc().

params

template<class TBin>

ArrangeParams Slic3r::arrangement::AutoArranger< TBin >::params

protected

Referenced by AutoArranger(), belt_end(), belt_origin(), belt_pos(), belt_start(), corner_bindist(), corner_packing(), dist_along_belt(), and objfunc().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Arrange.cpp