Slic3r::Arachne::LimitedBeadingStrategy Class Reference

#include <src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp>

Inheritance diagram for Slic3r::Arachne::LimitedBeadingStrategy:

Collaboration diagram for Slic3r::Arachne::LimitedBeadingStrategy:

Public Member Functions
	LimitedBeadingStrategy (coord_t max_bead_count, BeadingStrategyPtr parent)
	~LimitedBeadingStrategy () override=default
Beading	compute (coord_t thickness, coord_t bead_count) const override
coord_t	getOptimalThickness (coord_t bead_count) const override
coord_t	getTransitionThickness (coord_t lower_bead_count) const override
coord_t	getOptimalBeadCount (coord_t thickness) const override
std::string	toString () const override
coord_t	getTransitioningLength (coord_t lower_bead_count) const override
float	getTransitionAnchorPos (coord_t lower_bead_count) const override
virtual std::vector< coord_t >	getNonlinearThicknesses (coord_t lower_bead_count) const
double	getSplitMiddleThreshold () const
double	getTransitioningAngle () const

Protected Attributes
const coord_t	max_bead_count
const BeadingStrategyPtr	parent
std::string	name
coord_t	optimal_width
double	wall_split_middle_threshold
	Optimal bead width, nominal width off the walls in 'ideal' circumstances.
double	wall_add_middle_threshold
	Threshold when a middle wall should be split into two, as a ratio of the optimal wall width.
coord_t	default_transition_length
	Threshold when a new middle wall should be added between an even number of walls, as a ratio of the optimal wall width.
double	transitioning_angle
	The length of the region to smoothly transfer between bead counts.

Detailed Description

This is a meta-strategy that can be applied on top of any other beading strategy, which limits the thickness of the walls to the thickness that the lines can reasonably print.

The width of the wall is limited to the maximum number of contours times the maximum width of each of these contours.

If the width of the wall gets limited, this strategy outputs one additional bead with 0 width. This bead is used to denote the limits of the walled area. Other structures can then use this border to align their structures to, such as to create correctly overlapping infill or skin, or to align the infill pattern to any extra infill walls.

Constructor & Destructor Documentation

LimitedBeadingStrategy()

Slic3r::Arachne::LimitedBeadingStrategy::LimitedBeadingStrategy	(	coord_t	max_bead_count,
		BeadingStrategyPtr	parent
	)

    : BeadingStrategy(*parent)
    , max_bead_count(max_bead_count)
    , parent(std::move(parent))
{
    if (max_bead_count % 2 == 1)
    {
        BOOST_LOG_TRIVIAL(warning) << "LimitedBeadingStrategy with odd bead count is odd indeed!";
    }
}

References max_bead_count.

~LimitedBeadingStrategy()

Slic3r::Arachne::LimitedBeadingStrategy::~LimitedBeadingStrategy ( )

overridedefault

Member Function Documentation

compute()

LimitedBeadingStrategy::Beading Slic3r::Arachne::LimitedBeadingStrategy::compute ( coord_t  thickness, coord_t  bead_count  ) const

overridevirtual

Retrieve the bead widths with which to cover a given thickness.

Requirement: Given a constant bead_count the output of each bead width must change gradually along with the thickness.

Note

The bead_count might be different from the BeadingStrategy::optimal_bead_count

Implements Slic3r::Arachne::BeadingStrategy.

{
    if (bead_count <= max_bead_count)
    {
        Beading ret = parent->compute(thickness, bead_count);
        bead_count = ret.toolpath_locations.size();
 
        if (bead_count % 2 == 0 && bead_count == max_bead_count)
        {
            const coord_t innermost_toolpath_location = ret.toolpath_locations[max_bead_count / 2 - 1];
            const coord_t innermost_toolpath_width = ret.bead_widths[max_bead_count / 2 - 1];
            ret.toolpath_locations.insert(ret.toolpath_locations.begin() + max_bead_count / 2, innermost_toolpath_location + innermost_toolpath_width / 2);
            ret.bead_widths.insert(ret.bead_widths.begin() + max_bead_count / 2, 0);
        }
        return ret;
    }
    assert(bead_count == max_bead_count + 1);
    if(bead_count != max_bead_count + 1)
    {
        BOOST_LOG_TRIVIAL(warning) << "Too many beads! " << bead_count << " != " << max_bead_count + 1;
    }
 
    coord_t optimal_thickness = parent->getOptimalThickness(max_bead_count);
    Beading ret = parent->compute(optimal_thickness, max_bead_count);
    bead_count = ret.toolpath_locations.size();
    ret.left_over += thickness - ret.total_thickness;
    ret.total_thickness = thickness;
    
    // Enforce symmetry
    if (bead_count % 2 == 1) {
        ret.toolpath_locations[bead_count / 2] = thickness / 2;
        ret.bead_widths[bead_count / 2] = thickness - optimal_thickness;
    }
    for (coord_t bead_idx = 0; bead_idx < (bead_count + 1) / 2; bead_idx++)
        ret.toolpath_locations[bead_count - 1 - bead_idx] = thickness - ret.toolpath_locations[bead_idx];
 
    //Create a "fake" inner wall with 0 width to indicate the edge of the walled area.
    //This wall can then be used by other structures to e.g. fill the infill area adjacent to the variable-width walls.
    coord_t innermost_toolpath_location = ret.toolpath_locations[max_bead_count / 2 - 1];
    coord_t innermost_toolpath_width = ret.bead_widths[max_bead_count / 2 - 1];
    ret.toolpath_locations.insert(ret.toolpath_locations.begin() + max_bead_count / 2, innermost_toolpath_location + innermost_toolpath_width / 2);
    ret.bead_widths.insert(ret.bead_widths.begin() + max_bead_count / 2, 0);
 
    //Symmetry on both sides. Symmetry is guaranteed since this code is stopped early if the bead_count <= max_bead_count, and never reaches this point then.
    const size_t opposite_bead = bead_count - (max_bead_count / 2 - 1);
    innermost_toolpath_location = ret.toolpath_locations[opposite_bead];
    innermost_toolpath_width = ret.bead_widths[opposite_bead];
    ret.toolpath_locations.insert(ret.toolpath_locations.begin() + opposite_bead, innermost_toolpath_location - innermost_toolpath_width / 2);
    ret.bead_widths.insert(ret.bead_widths.begin() + opposite_bead, 0);
 
    return ret;
}

References Slic3r::Arachne::BeadingStrategy::Beading::bead_widths, Slic3r::Arachne::BeadingStrategy::Beading::left_over, max_bead_count, parent, Slic3r::Arachne::BeadingStrategy::Beading::toolpath_locations, and Slic3r::Arachne::BeadingStrategy::Beading::total_thickness.

getNonlinearThicknesses()

std::vector< coord_t > Slic3r::Arachne::BeadingStrategy::getNonlinearThicknesses ( coord_t  lower_bead_count ) const

virtualinherited

Get the locations in a bead count region where BeadingStrategy::compute exhibits a bend in the widths. Ordered from lower thickness to higher.

This is used to insert extra support bones into the skeleton, so that the resulting beads in long trapezoids don't linearly change between the two ends.

Reimplemented in Slic3r::Arachne::WideningBeadingStrategy.

{
    return {};
}

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::generateExtraRibs().

Here is the caller graph for this function:

getOptimalBeadCount()

coord_t Slic3r::Arachne::LimitedBeadingStrategy::getOptimalBeadCount ( coord_t  thickness ) const

overridevirtual

The number of beads should we ideally usefor a given model thickness

Implements Slic3r::Arachne::BeadingStrategy.

{
    coord_t parent_bead_count = parent->getOptimalBeadCount(thickness);
    if (parent_bead_count <= max_bead_count) {
        return parent->getOptimalBeadCount(thickness);
    } else if (parent_bead_count == max_bead_count + 1) {
        if (thickness < parent->getOptimalThickness(max_bead_count + 1) - scaled<coord_t>(0.01))
            return max_bead_count;
        else 
            return max_bead_count + 1;
    }
    else return max_bead_count + 1;
}

References getOptimalThickness(), max_bead_count, and parent.

Here is the call graph for this function:

getOptimalThickness()

coord_t Slic3r::Arachne::LimitedBeadingStrategy::getOptimalThickness ( coord_t  bead_count ) const

overridevirtual

The ideal thickness for a given

Parameters

bead_count

Reimplemented from Slic3r::Arachne::BeadingStrategy.

{
    if (bead_count <= max_bead_count)
        return parent->getOptimalThickness(bead_count);
    assert(false);
    return scaled<coord_t>(1000.); // 1 meter (Cura was returning 10 meter)
}

References max_bead_count, and parent.

Referenced by getOptimalBeadCount().

Here is the caller graph for this function:

getSplitMiddleThreshold()

double Slic3r::Arachne::BeadingStrategy::getSplitMiddleThreshold ( ) const

inherited

{
    return wall_split_middle_threshold;
}

References Slic3r::Arachne::BeadingStrategy::wall_split_middle_threshold.

getTransitionAnchorPos()

float Slic3r::Arachne::LimitedBeadingStrategy::getTransitionAnchorPos ( coord_t  lower_bead_count ) const

overridevirtual

The fraction of the transition length to put between the lower end of the transition and the point where the unsmoothed bead count jumps.

Transitions are used to smooth out the jumps in integer bead count; the jumps turn into ramps which could be positioned relative to the jump location.

Reimplemented from Slic3r::Arachne::BeadingStrategy.

{
    return parent->getTransitionAnchorPos(lower_bead_count);
}

References parent.

getTransitioningAngle()

double Slic3r::Arachne::BeadingStrategy::getTransitioningAngle ( ) const

inherited

{
    return transitioning_angle;
}

References Slic3r::Arachne::BeadingStrategy::transitioning_angle.

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::updateIsCentral().

Here is the caller graph for this function:

getTransitioningLength()

coord_t Slic3r::Arachne::LimitedBeadingStrategy::getTransitioningLength ( coord_t  lower_bead_count ) const

overridevirtual

The length of the transitioning region along the marked / significant regions of the skeleton.

Transitions are used to smooth out the jumps in integer bead count; the jumps turn into ramps with some incline defined by their length.

Reimplemented from Slic3r::Arachne::BeadingStrategy.

{
    return parent->getTransitioningLength(lower_bead_count);
}

References parent.

getTransitionThickness()

coord_t Slic3r::Arachne::LimitedBeadingStrategy::getTransitionThickness ( coord_t  lower_bead_count ) const

overridevirtual

The model thickness at which BeadingStrategy::optimal_bead_count transitions from lower_bead_count to lower_bead_count + 1

Reimplemented from Slic3r::Arachne::BeadingStrategy.

{
    if (lower_bead_count < max_bead_count)
        return parent->getTransitionThickness(lower_bead_count);
 
    if (lower_bead_count == max_bead_count)
        return parent->getOptimalThickness(lower_bead_count + 1) - scaled<coord_t>(0.01);
 
    assert(false);
    return scaled<coord_t>(900.); // 0.9 meter;
}

References max_bead_count, and parent.

toString()

std::string Slic3r::Arachne::LimitedBeadingStrategy::toString ( ) const

overridevirtual

Reimplemented from Slic3r::Arachne::BeadingStrategy.

{
    return std::string("LimitedBeadingStrategy+") + parent->toString();
}

References parent.

Member Data Documentation

default_transition_length

coord_t Slic3r::Arachne::BeadingStrategy::default_transition_length

protectedinherited

Threshold when a new middle wall should be added between an even number of walls, as a ratio of the optimal wall width.

Referenced by Slic3r::Arachne::BeadingStrategy::getTransitioningLength().

max_bead_count

const coord_t Slic3r::Arachne::LimitedBeadingStrategy::max_bead_count

protected

Referenced by LimitedBeadingStrategy(), compute(), getOptimalBeadCount(), getOptimalThickness(), and getTransitionThickness().

name

std::string Slic3r::Arachne::BeadingStrategy::name

protectedinherited

Referenced by Slic3r::Arachne::BeadingStrategy::BeadingStrategy(), Slic3r::Arachne::DistributedBeadingStrategy::DistributedBeadingStrategy(), Slic3r::Arachne::OuterWallInsetBeadingStrategy::OuterWallInsetBeadingStrategy(), Slic3r::Arachne::RedistributeBeadingStrategy::RedistributeBeadingStrategy(), and Slic3r::Arachne::BeadingStrategy::toString().

optimal_width

coord_t Slic3r::Arachne::BeadingStrategy::optimal_width

protectedinherited

Referenced by Slic3r::Arachne::DistributedBeadingStrategy::compute(), Slic3r::Arachne::WideningBeadingStrategy::compute(), Slic3r::Arachne::DistributedBeadingStrategy::getOptimalBeadCount(), and Slic3r::Arachne::BeadingStrategy::getOptimalThickness().

parent

const BeadingStrategyPtr Slic3r::Arachne::LimitedBeadingStrategy::parent

protected

Referenced by compute(), getOptimalBeadCount(), getOptimalThickness(), getTransitionAnchorPos(), getTransitioningLength(), getTransitionThickness(), and toString().

transitioning_angle

double Slic3r::Arachne::BeadingStrategy::transitioning_angle

protectedinherited

The length of the region to smoothly transfer between bead counts.

The maximum angle between outline segments smaller than which we are going to add transitions Equals 180 - the "limit bisector angle" from the paper

Referenced by Slic3r::Arachne::BeadingStrategy::getTransitioningAngle().

wall_add_middle_threshold

double Slic3r::Arachne::BeadingStrategy::wall_add_middle_threshold

protectedinherited

Threshold when a middle wall should be split into two, as a ratio of the optimal wall width.

Referenced by Slic3r::Arachne::DistributedBeadingStrategy::getOptimalBeadCount(), and Slic3r::Arachne::BeadingStrategy::getTransitionThickness().

wall_split_middle_threshold

double Slic3r::Arachne::BeadingStrategy::wall_split_middle_threshold

protectedinherited

Optimal bead width, nominal width off the walls in 'ideal' circumstances.

Referenced by Slic3r::Arachne::DistributedBeadingStrategy::getOptimalBeadCount(), Slic3r::Arachne::BeadingStrategy::getSplitMiddleThreshold(), and Slic3r::Arachne::BeadingStrategy::getTransitionThickness().

---

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

• src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.hpp
• src/libslic3r/Arachne/BeadingStrategy/LimitedBeadingStrategy.cpp