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

Inheritance diagram for Slic3r::Arachne::DistributedBeadingStrategy:

Collaboration diagram for Slic3r::Arachne::DistributedBeadingStrategy:

Public Member Functions
	DistributedBeadingStrategy (coord_t optimal_width, coord_t default_transition_length, double transitioning_angle, double wall_split_middle_threshold, double wall_add_middle_threshold, int distribution_radius)

	~DistributedBeadingStrategy () override=default

Beading	compute (coord_t thickness, coord_t bead_count) const override

coord_t	getOptimalBeadCount (coord_t thickness) const override

virtual coord_t	getOptimalThickness (coord_t bead_count) const

virtual coord_t	getTransitionThickness (coord_t lower_bead_count) const

virtual coord_t	getTransitioningLength (coord_t lower_bead_count) const

virtual float	getTransitionAnchorPos (coord_t lower_bead_count) const

virtual std::vector< coord_t >	getNonlinearThicknesses (coord_t lower_bead_count) const

virtual std::string	toString () const

double	getSplitMiddleThreshold () const

double	getTransitioningAngle () const

Protected Attributes
float	one_over_distribution_radius_squared

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 beading strategy chooses a wall count that would make the line width deviate the least from the optimal line width, and then distributes the lines evenly among the thickness available.

Constructor & Destructor Documentation

◆ DistributedBeadingStrategy()

Slic3r::Arachne::DistributedBeadingStrategy::DistributedBeadingStrategy	(	coord_t	optimal_width,
		coord_t	default_transition_length,
		double	transitioning_angle,
		double	wall_split_middle_threshold,
		double	wall_add_middle_threshold,
		int	distribution_radius
	)

Parameters

distribution_radius the radius (in number of beads) over which to distribute the discrepancy between the feature size and the optimal thickness

    : BeadingStrategy(optimal_width, wall_split_middle_threshold, wall_add_middle_threshold, default_transition_length, transitioning_angle)
{
    if(distribution_radius >= 2)
        one_over_distribution_radius_squared = 1.0f / (distribution_radius - 1) * 1.0f / (distribution_radius - 1);
    else
        one_over_distribution_radius_squared = 1.0f / 1 * 1.0f / 1;
    name = "DistributedBeadingStrategy";
}

References Slic3r::Arachne::BeadingStrategy::name, and one_over_distribution_radius_squared.

◆ ~DistributedBeadingStrategy()

Slic3r::Arachne::DistributedBeadingStrategy::~DistributedBeadingStrategy ( )

overridedefault

Member Function Documentation

◆ compute()

DistributedBeadingStrategy::Beading Slic3r::Arachne::DistributedBeadingStrategy::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.

{
    Beading ret;
 
    ret.total_thickness = thickness;
    if (bead_count > 2) {
        const coord_t to_be_divided = thickness - bead_count * optimal_width;
        const float middle = static_cast<float>(bead_count - 1) / 2;
 
        const auto getWeight = [middle, this](coord_t bead_idx) {
            const float dev_from_middle = bead_idx - middle;
            return std::max(0.0f, 1.0f - one_over_distribution_radius_squared * dev_from_middle * dev_from_middle);
        };
 
        std::vector<float> weights;
        weights.resize(bead_count);
        for (coord_t bead_idx = 0; bead_idx < bead_count; bead_idx++)
            weights[bead_idx] = getWeight(bead_idx);
 
        const float total_weight      = std::accumulate(weights.cbegin(), weights.cend(), 0.f);
        coord_t     accumulated_width = 0;
        for (coord_t bead_idx = 0; bead_idx < bead_count; bead_idx++) {
            const float   weight_fraction          = weights[bead_idx] / total_weight;
            const coord_t splitup_left_over_weight = to_be_divided * weight_fraction;
            const coord_t width                    = (bead_idx == bead_count - 1) ? thickness - accumulated_width : optimal_width + splitup_left_over_weight;
 
            // Be aware that toolpath_locations is computed by dividing the width by 2, so toolpath_locations
            // could be off by 1 because of rounding errors.
            if (bead_idx == 0)
                ret.toolpath_locations.emplace_back(width / 2);
            else
                ret.toolpath_locations.emplace_back(ret.toolpath_locations.back() + (ret.bead_widths.back() + width) / 2);
            ret.bead_widths.emplace_back(width);
            accumulated_width += width;
        }
        ret.left_over = 0;
        assert((accumulated_width + ret.left_over) == thickness);
    } else if (bead_count == 2) {
        const coord_t outer_width = thickness / 2;
        ret.bead_widths.emplace_back(outer_width);
        ret.bead_widths.emplace_back(outer_width);
        ret.toolpath_locations.emplace_back(outer_width / 2);
        ret.toolpath_locations.emplace_back(thickness - outer_width / 2);
        ret.left_over = 0;
    } else if (bead_count == 1) {
        const coord_t outer_width = thickness;
        ret.bead_widths.emplace_back(outer_width);
        ret.toolpath_locations.emplace_back(outer_width / 2);
        ret.left_over = 0;
    } else {
        ret.left_over = thickness;
    }
 
    assert(([&ret = std::as_const(ret), thickness]() -> bool {
        coord_t total_bead_width = 0;
        for (const coord_t &bead_width : ret.bead_widths)
            total_bead_width += bead_width;
        return (total_bead_width + ret.left_over) == thickness;
    }()));
 
    return ret;
}

References Slic3r::Arachne::BeadingStrategy::Beading::bead_widths, Slic3r::Arachne::BeadingStrategy::Beading::left_over, one_over_distribution_radius_squared, Slic3r::Arachne::BeadingStrategy::optimal_width, 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::DistributedBeadingStrategy::getOptimalBeadCount ( coord_t thickness ) const

overridevirtual

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

Implements Slic3r::Arachne::BeadingStrategy.

{
    const coord_t naive_count        = thickness / optimal_width;               // How many lines we can fit in for sure.
    const coord_t remainder          = thickness - naive_count * optimal_width; // Space left after fitting that many lines.
    const coord_t minimum_line_width = optimal_width * (naive_count % 2 == 1 ? wall_split_middle_threshold : wall_add_middle_threshold);
    return naive_count + (remainder >= minimum_line_width); // If there's enough space, fit an extra one.
}

References Slic3r::Arachne::BeadingStrategy::optimal_width, Slic3r::Arachne::BeadingStrategy::wall_add_middle_threshold, and Slic3r::Arachne::BeadingStrategy::wall_split_middle_threshold.

◆ getOptimalThickness()

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

virtualinherited

The ideal thickness for a given

Parameters

bead_count

Reimplemented in Slic3r::Arachne::LimitedBeadingStrategy, Slic3r::Arachne::OuterWallInsetBeadingStrategy, Slic3r::Arachne::RedistributeBeadingStrategy, and Slic3r::Arachne::WideningBeadingStrategy.

{
    return optimal_width * bead_count;
}

References Slic3r::Arachne::BeadingStrategy::optimal_width.

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

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::BeadingStrategy::getTransitionAnchorPos ( coord_t lower_bead_count ) const

virtualinherited

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 in Slic3r::Arachne::LimitedBeadingStrategy, Slic3r::Arachne::RedistributeBeadingStrategy, and Slic3r::Arachne::WideningBeadingStrategy.

{
    coord_t lower_optimum = getOptimalThickness(lower_bead_count);
    coord_t transition_point = getTransitionThickness(lower_bead_count);
    coord_t upper_optimum = getOptimalThickness(lower_bead_count + 1);
    return 1.0 - float(transition_point - lower_optimum) / float(upper_optimum - lower_optimum);
}

References Slic3r::Arachne::BeadingStrategy::getOptimalThickness(), and Slic3r::Arachne::BeadingStrategy::getTransitionThickness().

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::filterTransitionMids(), and Slic3r::Arachne::SkeletalTrapezoidation::generateTransitionEnds().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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::BeadingStrategy::getTransitioningLength ( coord_t lower_bead_count ) const

virtualinherited

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 in Slic3r::Arachne::LimitedBeadingStrategy, Slic3r::Arachne::OuterWallInsetBeadingStrategy, Slic3r::Arachne::RedistributeBeadingStrategy, and Slic3r::Arachne::WideningBeadingStrategy.

{
    if (lower_bead_count == 0)
        return scaled<coord_t>(0.01);
    return default_transition_length;
}

References Slic3r::Arachne::BeadingStrategy::default_transition_length.

Referenced by Slic3r::Arachne::SkeletalTrapezoidation::dissolveNearbyTransitions(), Slic3r::Arachne::SkeletalTrapezoidation::filterTransitionMids(), and Slic3r::Arachne::SkeletalTrapezoidation::generateTransitionEnds().

Here is the caller graph for this function:

◆ getTransitionThickness()

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

virtualinherited

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

Reimplemented in Slic3r::Arachne::LimitedBeadingStrategy, Slic3r::Arachne::OuterWallInsetBeadingStrategy, Slic3r::Arachne::RedistributeBeadingStrategy, and Slic3r::Arachne::WideningBeadingStrategy.

{
    const coord_t lower_ideal_width  = getOptimalThickness(lower_bead_count);
    const coord_t higher_ideal_width = getOptimalThickness(lower_bead_count + 1);
    const double  threshold          = lower_bead_count % 2 == 1 ? wall_split_middle_threshold : wall_add_middle_threshold;
    return lower_ideal_width + threshold * (higher_ideal_width - lower_ideal_width);
}