Collaboration diagram for Slic3r::PerExtruderAdjustments:

Public Member Functions
float	elapsed_time_total () const

float	maximum_time_after_slowdown (bool slowdown_external_perimeters) const

float	adjustable_time (bool slowdown_external_perimeters) const

float	non_adjustable_time (bool slowdown_external_perimeters) const

float	slowdown_to_minimum_feedrate (bool slowdown_external_perimeters)

float	slow_down_proportional (float factor, bool slowdown_external_perimeters)

void	sort_lines_by_decreasing_feedrate ()

float	time_stretch_when_slowing_down_to_feedrate (float min_feedrate) const

void	slow_down_to_feedrate (float min_feedrate)

Public Attributes
unsigned int	extruder_id = 0

bool	cooling_slow_down_enabled = false

float	slowdown_below_layer_time = 0.f

float	min_print_speed = 0.f

std::vector< CoolingLine >	lines

size_t	n_lines_adjustable = 0

float	time_non_adjustable = 0

float	time_total = 0

float	time_maximum = 0

size_t	idx_line_begin = 0

size_t	idx_line_end = 0

Detailed Description

Member Function Documentation

◆ adjustable_time()

float Slic3r::PerExtruderAdjustments::adjustable_time ( bool slowdown_external_perimeters ) const

inline

                                                                   {
        float time_total = 0.f;
        for (const CoolingLine &line : lines)
            if (line.adjustable(slowdown_external_perimeters))
                time_total += line.time;
        return time_total;
    }

References lines, and time_total.

◆ elapsed_time_total()

float Slic3r::PerExtruderAdjustments::elapsed_time_total ( ) const

inline

                                     {
        float time_total = 0.f;
        for (const CoolingLine &line : lines)
            time_total += line.time;
        return time_total;
    }

References lines, and time_total.

Referenced by Slic3r::CoolingBuffer::calculate_layer_slowdown().

Here is the caller graph for this function:

◆ maximum_time_after_slowdown()

float Slic3r::PerExtruderAdjustments::maximum_time_after_slowdown ( bool slowdown_external_perimeters ) const

inline

                                                                               {
        float time_total = 0.f;
        for (const CoolingLine &line : lines)
            if (line.adjustable(slowdown_external_perimeters)) {
                if (line.time_max == FLT_MAX)
                    return FLT_MAX;
                else
                    time_total += line.time_max;
            } else
                time_total += line.time;
        return time_total;
    }

References lines, and time_total.

◆ non_adjustable_time()

float Slic3r::PerExtruderAdjustments::non_adjustable_time ( bool slowdown_external_perimeters ) const

inline

                                                                       {
        float time_total = 0.f;
        for (const CoolingLine &line : lines)
            if (! line.adjustable(slowdown_external_perimeters))
                time_total += line.time;
        return time_total;
    }

References lines, and time_total.

◆ slow_down_proportional()

float Slic3r::PerExtruderAdjustments::slow_down_proportional	(	float	factor,
		bool	slowdown_external_perimeters
	)

inline

                                                                                  {
        assert(factor >= 1.f);
        float time_total = 0.f;
        for (CoolingLine &line : lines) {
            if (line.adjustable(slowdown_external_perimeters)) {
                line.slowdown = true;
                line.time     = std::min(line.time_max, line.time * factor);
                assert(line.time > 0);
                line.feedrate = line.length / line.time;
            }
            time_total += line.time;
        }
        return time_total;
    }

References lines, and time_total.

◆ slow_down_to_feedrate()

void Slic3r::PerExtruderAdjustments::slow_down_to_feedrate ( float min_feedrate )

inline

                                                   {
        assert(this->min_print_speed < min_feedrate + EPSILON);
        for (size_t i = 0; i < n_lines_adjustable; ++ i) {
            CoolingLine &line = lines[i];
            if (line.feedrate > min_feedrate) {
                assert(min_feedrate > 0);
                line.time *= std::max(1.f, line.feedrate / min_feedrate);
                line.feedrate = min_feedrate;
                line.slowdown = true;
            }
        }
    }

References EPSILON, Slic3r::CoolingLine::feedrate, lines, min_print_speed, n_lines_adjustable, Slic3r::CoolingLine::slowdown, and Slic3r::CoolingLine::time.

◆ slowdown_to_minimum_feedrate()

float Slic3r::PerExtruderAdjustments::slowdown_to_minimum_feedrate ( bool slowdown_external_perimeters )

inline

                                                                          {
        float time_total = 0.f;
        for (CoolingLine &line : lines) {
            if (line.adjustable(slowdown_external_perimeters)) {
                assert(line.time_max >= 0.f && line.time_max < FLT_MAX);
                line.slowdown = true;
                line.time     = line.time_max;
                assert(line.time > 0);
                line.feedrate = line.length / line.time;
            }
            time_total += line.time;
        }
        return time_total;
    }

References lines, and time_total.

◆ sort_lines_by_decreasing_feedrate()

void Slic3r::PerExtruderAdjustments::sort_lines_by_decreasing_feedrate ( )

inline

                                             {
        std::sort(lines.begin(), lines.end(), [](const CoolingLine &l1, const CoolingLine &l2) {
            bool adj1 = l1.adjustable();
            bool adj2 = l2.adjustable();
            return (adj1 == adj2) ? l1.feedrate > l2.feedrate : adj1;
        });
        for (n_lines_adjustable = 0; 
            n_lines_adjustable < lines.size() && this->lines[n_lines_adjustable].adjustable();
            ++ n_lines_adjustable);
        time_non_adjustable = 0.f;
        for (size_t i = n_lines_adjustable; i < lines.size(); ++ i)
            time_non_adjustable += lines[i].time;
    }

References Slic3r::l2(), lines, n_lines_adjustable, and time_non_adjustable.

Here is the call graph for this function:

◆ time_stretch_when_slowing_down_to_feedrate()

float Slic3r::PerExtruderAdjustments::time_stretch_when_slowing_down_to_feedrate ( float min_feedrate ) const

inline

                                                                               {
        float time_stretch = 0.f;
        assert(this->min_print_speed < min_feedrate + EPSILON);
        for (size_t i = 0; i < n_lines_adjustable; ++ i) {
            const CoolingLine &line = lines[i];
            if (line.feedrate > min_feedrate) {
                assert(min_feedrate > 0);
                time_stretch += line.time * (line.feedrate / min_feedrate - 1.f);
            }
        }
        return time_stretch;
    }