Collaboration diagram for Slic3r::GCodeProcessor::TimeMachine:

Classes
struct	State
struct	CustomGCodeTime
struct	G1LinesCacheItem
struct	ActualSpeedMove
struct	StopTime

Public Types
using	AdditionalBufferBlock = std::pair<EMoveType, float>
using	AdditionalBuffer = std::vector<AdditionalBufferBlock>

Public Member Functions
void	reset ()
size_t	plan_klipper (bool lazy)
void	calculate_time (GCodeProcessorResult &result, PrintEstimatedStatistics::ETimeMode mode, size_t keep_last_n_blocks=0, float additional_time=0.0f, EMoveType target_move_type=EMoveType::Noop, bool is_final=false)

Static Public Member Functions
static AdditionalBuffer	merge_adjacent_additional_time_blocks (const AdditionalBuffer &buffer)

Public Attributes
bool	enabled
float	acceleration
float	max_acceleration
float	retract_acceleration
float	max_retract_acceleration
float	travel_acceleration
float	max_travel_acceleration
float	extrude_factor_override_percentage
bool	klipper { false }
float	minimum_cruise_ratio { 0.5f }
float	requested_accel_to_decel { -1.0f }
float	klipper_junction_flush { 1.0f }
bool	klipper_queue_priming { true }
double	time
std::vector< StopTime >	stop_times
std::string	line_m73_main_mask
std::string	line_m73_stop_mask
State	curr
State	prev
CustomGCodeTime	gcode_time
std::vector< TimeBlock >	blocks
std::vector< G1LinesCacheItem >	g1_times_cache
float	first_layer_time
std::vector< ActualSpeedMove >	actual_speed_moves
float	prepare_time
AdditionalBuffer	m_additional_time_buffer

Detailed Description

Class Documentation

◆ Slic3r::GCodeProcessor::TimeMachine::G1LinesCacheItem

struct Slic3r::GCodeProcessor::TimeMachine::G1LinesCacheItem

Class Members
float	elapsed_time
unsigned int	id
unsigned int	remaining_internal_g1_lines { 0 }

◆ Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove

struct Slic3r::GCodeProcessor::TimeMachine::ActualSpeedMove

Class Members
float	actual_feedrate { 0.0f }
optional< float >	delta_extruder
optional< float >	fan_speed
optional< float >	feedrate
optional< float >	height
optional< float >	mm3_per_mm
unsigned int	move_id { 0 }
optional< Vec3f >	position
optional< float >	temperature
optional< float >	width

◆ Slic3r::GCodeProcessor::TimeMachine::StopTime

struct Slic3r::GCodeProcessor::TimeMachine::StopTime

Class Members
float	elapsed_time
unsigned int	g1_line_id

Member Typedef Documentation

◆ AdditionalBuffer

using Slic3r::GCodeProcessor::TimeMachine::AdditionalBuffer = std::vector<AdditionalBufferBlock>

◆ AdditionalBufferBlock

using Slic3r::GCodeProcessor::TimeMachine::AdditionalBufferBlock = std::pair<EMoveType, float>

Member Function Documentation

◆ calculate_time()

void Slic3r::GCodeProcessor::TimeMachine::calculate_time	(	GCodeProcessorResult &	result,
		PrintEstimatedStatistics::ETimeMode	mode,
		size_t	keep_last_n_blocks = 0,
		float	additional_time = 0.0f,
		EMoveType	target_move_type = EMoveType::Noop,
		bool	is_final = false )

{
    if (!enabled)
        return;
    // Drain buffered delays on the final pass, even with no motion left.
    // A trailing filament change has no later move to receive its time.
    const bool drain_final = is_final && !m_additional_time_buffer.empty();
    if ((klipper ? blocks.empty() : blocks.size() < 2) && !drain_final) {
        // Not enough blocks to attribute the extra time to yet; buffer it so it is
        // applied on a later pass instead of being dropped.
        if (additional_time > 0.0f)
            m_additional_time_buffer.emplace_back(target_move_type, additional_time);
        return;
    }
 
    assert(klipper || keep_last_n_blocks <= blocks.size());
 
    // Merge any previously buffered extra time with this call's extra time. Each
    // entry is applied, in order, to the first block matching its target move type
    // (EMoveType::Noop matches any block).
    AdditionalBuffer additional_buffer = m_additional_time_buffer;
    if (additional_time > 0.0f)
        additional_buffer.emplace_back(target_move_type, additional_time);
    additional_buffer = merge_adjacent_additional_time_blocks(additional_buffer);
 
    size_t n_blocks_process;
    if (klipper) {
        n_blocks_process = plan_klipper(keep_last_n_blocks != 0);
        keep_last_n_blocks = blocks.size() - n_blocks_process;
    } else {
        for (int i = static_cast<int>(blocks.size()) - 1; i > 0; --i)
            planner_reverse_pass_kernel(blocks[i - 1], blocks[i]);
        for (size_t i = 0; i + 1 < blocks.size(); ++i)
            planner_forward_pass_kernel(blocks[i], blocks[i + 1]);
        recalculate_trapezoids(blocks);
        n_blocks_process = blocks.size() - keep_last_n_blocks;
    }
    size_t additional_buffer_idx = 0;
    for (size_t i = 0; i < n_blocks_process; ++i) {
        const TimeBlock& block = blocks[i];
        double motion_time;
        if (klipper && block.trapezoid.cruise_feedrate > 0.0f) {
            // Integrate using the planned speeds. Reconstructing the exit speed
            // from rounded deceleration distance loses precision near a stop.
            const double cruise = block.trapezoid.cruise_feedrate;
            motion_time = block.distance / cruise;
            if (block.acceleration > 0.0f) {
                const double accel_delta = cruise - block.feedrate_profile.entry;
                const double decel_delta = cruise - block.feedrate_profile.exit;
                motion_time += (sqr(accel_delta) + sqr(decel_delta)) / (2.0 * block.acceleration * cruise);
            }
        } else {
            motion_time = block.time();
        }
        double block_time = motion_time;
        if (additional_buffer_idx < additional_buffer.size()) {
            const EMoveType buf_move_type = additional_buffer[additional_buffer_idx].first;
            if (buf_move_type == EMoveType::Noop || buf_move_type == block.move_type) {
                block_time += additional_buffer[additional_buffer_idx].second;
                ++additional_buffer_idx;
            }
        }
 
        time += block_time;
        // Orca: accumulate per-SkipType time spent inside SKIPPABLE regions, folded into this single
        // calculate_time write site. Fires fleet-wide (the shipping time_lapse_gcode template stamps
        // blocks stTimelapse), but writes only skippable_part_time, which has no g-code-emitting
        // reader until the pre-heat injector consumes it, so output is byte-identical.
        if (block.skippable_type != SkipType::stNone)
            result.skippable_part_time[block.skippable_type] += motion_time;
        result.moves[block.move_id].time[static_cast<size_t>(mode)] = block_time;
        gcode_time.cache += block_time;
        //BBS
        if (block.flags.prepare_stage)
            prepare_time += block_time;
 
        if (block.layer_id == 1)
            first_layer_time += block_time;
 
        // detect actual speed moves required to render toolpaths using actual speed
        if (mode == PrintEstimatedStatistics::ETimeMode::Normal) {
            GCodeProcessorResult::MoveVertex& curr_move = result.moves[block.move_id];
            if (curr_move.type != EMoveType::Extrude &&
                curr_move.type != EMoveType::Travel &&
                curr_move.type != EMoveType::Wipe)
              continue;
 
            assert(curr_move.actual_feedrate == 0.0f);
 
            GCodeProcessorResult::MoveVertex& prev_move = result.moves[block.move_id - 1];
            const bool interpolate = (prev_move.type == curr_move.type);
            if (!interpolate &&
                prev_move.type != EMoveType::Extrude &&
                prev_move.type != EMoveType::Travel &&
                prev_move.type != EMoveType::Wipe)
                prev_move.actual_feedrate = block.feedrate_profile.entry;
 
            if (EPSILON < block.trapezoid.accelerate_until && block.trapezoid.accelerate_until < block.distance - EPSILON) {
                const float t = block.trapezoid.accelerate_until / block.distance;
                const Vec3f position = lerp(prev_move.position, curr_move.position, t);
                if ((position - prev_move.position).norm() > EPSILON &&
                    (position - curr_move.position).norm() > EPSILON) {
                    const float delta_extruder = interpolate ? lerp(prev_move.delta_extruder, curr_move.delta_extruder, t) : curr_move.delta_extruder;
                    const float feedrate = curr_move.feedrate; //  ORCA: set feedrate to the gcode feed rate to prevent visualiser from
                                                                // displaying erroneous speed transition when actual speed/actual flow views are NOT selected.
                                                                // interpolate ? lerp(prev_move.feedrate, curr_move.feedrate, t) : curr_move.feedrate;
                    const float width = interpolate ? lerp(prev_move.width, curr_move.width, t) : curr_move.width;
                    const float height = interpolate ? lerp(prev_move.height, curr_move.height, t) : curr_move.height;
                    // ORCA: Fix issue with flow rate changes being visualized incorrectly
                    const float mm3_per_mm = curr_move.mm3_per_mm;
                    const float fan_speed = curr_move.fan_speed;
                    const float temperature = interpolate ? lerp(prev_move.temperature, curr_move.temperature, t) : curr_move.temperature;
                    actual_speed_moves.push_back({
                        block.move_id,
                        position,
                        block.trapezoid.cruise_feedrate,
                        delta_extruder,
                        feedrate,
                        width,
                        height,
                        mm3_per_mm,
                        fan_speed,
                        temperature
                    });
                }
            }
 
            const bool has_deceleration = block.trapezoid.deceleration_distance(block.distance) > EPSILON;
            if (has_deceleration && block.trapezoid.decelerate_after > block.trapezoid.accelerate_until + EPSILON) {
                const float t = block.trapezoid.decelerate_after / block.distance;
                const Vec3f position = lerp(prev_move.position, curr_move.position, t);
                if ((position - prev_move.position).norm() > EPSILON &&
                    (position - curr_move.position).norm() > EPSILON) {
                    const float delta_extruder = interpolate ? lerp(prev_move.delta_extruder, curr_move.delta_extruder, t) : curr_move.delta_extruder;
                    const float feedrate = curr_move.feedrate; //  ORCA: set feedrate to the gcode feed rate to prevent visualiser from
                                                                // displaying erroneous speed transition when actual speed/actual flow views are NOT selected.
                                                                // interpolate ? lerp(prev_move.feedrate, curr_move.feedrate, t) : curr_move.feedrate;
                    const float width = interpolate ? lerp(prev_move.width, curr_move.width, t) : curr_move.width;
                    const float height = interpolate ? lerp(prev_move.height, curr_move.height, t) : curr_move.height;
                    // ORCA: Fix issue with flow rate changes being visualized incorrectly
                    const float mm3_per_mm = curr_move.mm3_per_mm;
                    const float fan_speed = curr_move.fan_speed;
                    const float temperature = interpolate ? lerp(prev_move.temperature, curr_move.temperature, t) : curr_move.temperature;
                    actual_speed_moves.push_back({
                        block.move_id,
                        position,
                        block.trapezoid.cruise_feedrate,
                        delta_extruder,
                        feedrate,
                        width,
                        height,
                        mm3_per_mm,
                        fan_speed,
                        temperature
                    });
                }
            }
 
            const bool is_cruise_only = block.trapezoid.is_cruise_only(block.distance);
            actual_speed_moves.push_back({
                block.move_id,
                std::nullopt,
                (is_cruise_only || !has_deceleration) ? block.trapezoid.cruise_feedrate : block.feedrate_profile.exit,
                std::nullopt,
                std::nullopt,
                std::nullopt,
                std::nullopt,
                std::nullopt,
                std::nullopt,
                std::nullopt
            });
        }
        g1_times_cache.push_back({ block.g1_line_id, block.remaining_internal_g1_lines, float(time) });
        // update times for remaining time to printer stop placeholders
        auto it_stop_time = std::lower_bound(stop_times.begin(), stop_times.end(), block.g1_line_id,
            [](const StopTime& t, unsigned int value) { return t.g1_line_id < value; });
        if (it_stop_time != stop_times.end() && it_stop_time->g1_line_id == block.g1_line_id)
            it_stop_time->elapsed_time = float(time);
    }
 
    // Carry forward any extra time that found no matching block this pass, so it
    // is retried against the blocks of a later pass.
    m_additional_time_buffer.clear();
    if (additional_buffer_idx < additional_buffer.size()) {
        if (is_final) {
            // Orca EOF hardening: no later pass remains to attribute this remainder,
            // so add it to the machine total (and the custom-gcode cache) instead of
            // dropping it. Deliberately NOT attributed to any move vertex, so a stray
            // filament-change delay can never leak into an extrusion role's time.
            // (BambuStudio drops the remainder here.)
            float leftover = 0.0f;
            for (size_t i = additional_buffer_idx; i < additional_buffer.size(); ++i)
                leftover += additional_buffer[i].second;
            BOOST_LOG_TRIVIAL(debug) << "calculate_time(is_final): leftover=" << leftover
                << "s from " << (additional_buffer.size() - additional_buffer_idx) << " items";
            time += double(leftover);
            gcode_time.cache += leftover;
        } else {
            m_additional_time_buffer.insert(m_additional_time_buffer.end(),
                                            additional_buffer.begin() + additional_buffer_idx,
                                            additional_buffer.end());
        }
    }
 
    if (keep_last_n_blocks) {
        blocks.erase(blocks.begin(), blocks.begin() + n_blocks_process);
 
        // Preserve the boundary speed in the Marlin planner. Klipper only flushes
        // moves whose cruise speed is already independent of future moves.
        if (!klipper) {
            TimeBlock& first_block = blocks.front();
            first_block.max_entry_speed = first_block.feedrate_profile.entry;
        }
    } else {
        blocks.clear();
    }
}

Referenced by Slic3r::GCodeProcessor::calculate_time().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge_adjacent_additional_time_blocks()

GCodeProcessor::TimeMachine::AdditionalBuffer Slic3r::GCodeProcessor::TimeMachine::merge_adjacent_additional_time_blocks ( const AdditionalBuffer & buffer )

static

{
    AdditionalBuffer merged;
    if (buffer.empty())
        return merged;
 
    AdditionalBufferBlock current_block = buffer.front();
    for (size_t idx = 1; idx < buffer.size(); ++idx) {
        const AdditionalBufferBlock& next_block = buffer[idx];
        if (current_block.first == next_block.first)
            current_block.second += next_block.second;
        else {
            merged.push_back(current_block);
            current_block = next_block;
        }
    }
    merged.push_back(current_block);
    return merged;
}

Referenced by calculate_time().

Here is the caller graph for this function:

◆ plan_klipper()

size_t Slic3r::GCodeProcessor::TimeMachine::plan_klipper ( bool lazy )

{
    klipper_junction_flush = requested_accel_to_decel >= 0.0f ? 0.250f : 0.150f;
    klipper_queue_priming = false;
    size_t flush_count = blocks.size();
    bool update_flush_count = lazy;
    float next_start_v2 = 0.0f;
    float next_mcr_start_v2 = 0.0f;
    float peak_cruise_v2 = 0.0f;
    size_t pending = 0;
    for (size_t i = blocks.size(); i-- > 0;) {
        TimeBlock& block = blocks[i];
        const float delta_v2 = 2.0f * block.distance * block.acceleration;
        const float reachable_start_v2 = next_start_v2 + delta_v2;
        const float start_v2 = std::min(sqr(block.max_entry_speed), reachable_start_v2);
        const float reachable_mcr_v2 = next_mcr_start_v2 + block.mcr_delta_v2;
        const float mcr_start_v2 = std::min(block.max_mcr_entry_speed_sqr, reachable_mcr_v2);
        float cruise_v2 = -1.0f;
        ++pending;
        if (mcr_start_v2 < reachable_mcr_v2) {
            if (mcr_start_v2 + block.mcr_delta_v2 > next_mcr_start_v2 || pending > 1) {
                // Stop at this block, not past it: the blocks above still have a cruise speed
                // that depends on moves not yet seen, so only [0, i) may be committed.
                if (update_flush_count && peak_cruise_v2 > 0.0f) {
                    flush_count = i;
                    update_flush_count = false;
                }
                peak_cruise_v2 = std::min(sqr(block.feedrate_profile.cruise),
                                          0.5f * (mcr_start_v2 + reachable_mcr_v2));
            }
            cruise_v2 = std::min({0.5f * (start_v2 + reachable_start_v2),
                                  sqr(block.feedrate_profile.cruise), peak_cruise_v2});
            pending = 0;
        }
        // Until the forward pass, these fields hold v^2, not speeds; -1 marks
        // an unassigned cruise speed. A lazy return leaves them in this state.
        block.feedrate_profile.entry = start_v2;
        block.feedrate_profile.exit = next_start_v2;
        block.trapezoid.cruise_feedrate = cruise_v2;
        block.peak_cruise_v2 = peak_cruise_v2;
        next_start_v2 = start_v2;
        next_mcr_start_v2 = mcr_start_v2;
    }
    if (update_flush_count)
        return 0;
    // A run of blocks that cannot accelerate is resolved here, once the peak cruise speed of the
    // accelerating block that precedes it is known. Each one takes a running minimum with its own
    // entry speed, seeded from that peak rather than from the setter's own clamped cruise speed.
    float prev_cruise_v2 = 0.0f;
    for (size_t i = 0; i < flush_count; ++i) {
        TimeBlock& block = blocks[i];
        float cruise_v2 = block.trapezoid.cruise_feedrate;
        if (cruise_v2 < 0.0f) {
            cruise_v2 = std::min(prev_cruise_v2, block.feedrate_profile.entry);
            prev_cruise_v2 = cruise_v2;
        } else
            prev_cruise_v2 = block.peak_cruise_v2;
        const float start_v2 = std::min(block.feedrate_profile.entry, cruise_v2);
        const float end_v2 = std::min(block.feedrate_profile.exit, cruise_v2);
        // A zero acceleration would put an infinity in the ramp distances; the Marlin helpers guard
        // their divides the same way and fall back to a pure cruise.
        const float inv_two_accel = block.acceleration > 0.0f ? 0.5f / block.acceleration : 0.0f;
        block.feedrate_profile.entry = std::sqrt(start_v2);
        block.feedrate_profile.exit = std::sqrt(end_v2);
        block.trapezoid.cruise_feedrate = std::sqrt(cruise_v2);
        block.trapezoid.accelerate_until = (cruise_v2 - start_v2) * inv_two_accel;
        block.trapezoid.decelerate_after = block.distance - (cruise_v2 - end_v2) * inv_two_accel;
    }
    return flush_count;
}

Referenced by calculate_time().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

void Slic3r::GCodeProcessor::TimeMachine::reset ( )

{
    enabled = false;
    acceleration = 0.0f;
    max_acceleration = 0.0f;
    retract_acceleration = 0.0f;
    max_retract_acceleration = 0.0f;
    travel_acceleration = 0.0f;
    max_travel_acceleration = 0.0f;
    extrude_factor_override_percentage = 1.0f;
    klipper = false;
    minimum_cruise_ratio = 0.5f;
    requested_accel_to_decel = -1.0f;
    klipper_junction_flush = 1.0f;
    klipper_queue_priming = true;
    time = 0.0f;
    stop_times = std::vector<StopTime>();
    curr.reset();
    prev.reset();
    gcode_time.reset();
    blocks = std::vector<TimeBlock>();
    g1_times_cache = std::vector<G1LinesCacheItem>();
    first_layer_time = 0.0f;
    prepare_time = 0.0f;
    m_additional_time_buffer.clear();
}