GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-09-26 15:23:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

SPE-1964: Fixed export of M73 lines

Browse Source 
Added post processing of G0

Added post processing of G2/G3

Added post processing of G28

Modified ExportLines::update()

M73 line exported after current line has been processed (to get the proper time)
This commit is contained in:
enricoturri1966 2023-10-18 10:47:11 +02:00
parent 82e70b744a
commit a8155eb8db
2 changed files with 75 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
src/libslic3r/GCode/GCodeProcessor.cpp
View File

@ -344,7 +344,7 @@ void GCodeProcessor::TimeMachine::calculate_time(size_t keep_last_n_blocks, floa
} }
} }
layers_time[block.layer_id - 1] += block_time; layers_time[block.layer_id - 1] += block_time;
g1_times_cache.push_back({ block.g1_line_id, time }); g1_times_cache.push_back({ block.g1_line_id, block.remaining_internal_g1_lines, time });
// update times for remaining time to printer stop placeholders // 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, 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; }); [](const StopTime& t, unsigned int value) { return t.g1_line_id < value; });
@ -2557,7 +2557,8 @@ void GCodeProcessor::process_G1(const GCodeReader::GCodeLine& line)
process_G1(g1_axes, g1_feedrate); process_G1(g1_axes, g1_feedrate);
} }
void GCodeProcessor::process_G1(const std::array<std::optional<double>, 4>& axes, std::optional<double> feedrate, G1DiscretizationOrigin origin) void GCodeProcessor::process_G1(const std::array<std::optional<double>, 4>& axes, const std::optional<double>& feedrate,
G1DiscretizationOrigin origin, const std::optional<unsigned int>& remaining_internal_g1_lines)
{ {
const float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[m_extruder_id] : m_result.filament_diameters.back(); const float filament_diameter = (static_cast<size_t>(m_extruder_id) < m_result.filament_diameters.size()) ? m_result.filament_diameters[m_extruder_id] : m_result.filament_diameters.back();
const float filament_radius = 0.5f * filament_diameter; const float filament_radius = 0.5f * filament_diameter;
@ -2713,6 +2714,7 @@ void GCodeProcessor::process_G1(const std::array<std::optional<double>, 4>& axes
block.role = m_extrusion_role; block.role = m_extrusion_role;
block.distance = distance; block.distance = distance;
block.g1_line_id = m_g1_line_id; block.g1_line_id = m_g1_line_id;
block.remaining_internal_g1_lines = remaining_internal_g1_lines.has_value() ? *remaining_internal_g1_lines : 0;
block.layer_id = std::max<unsigned int>(1, m_layer_id); block.layer_id = std::max<unsigned int>(1, m_layer_id);
// calculates block cruise feedrate // calculates block cruise feedrate
@ -3031,16 +3033,17 @@ void GCodeProcessor::process_G2_G3(const GCodeReader::GCodeLine& line, bool cloc
return ret; return ret;
}; };
auto internal_only_g1_line = [this](const AxisCoords& target, bool has_z, const std::optional<float>& feedrate, const std::optional<float>& extrusion) { auto internal_only_g1_line = [this](const AxisCoords& target, bool has_z, const std::optional<float>& feedrate,
std::array<std::optional<double>, 4> g1_axes = { target[X], target[Y], std::nullopt, std::nullopt }; const std::optional<float>& extrusion, const std::optional<unsigned int>& remaining_internal_g1_lines = std::nullopt) {
std::optional<double> g1_feedrate = std::nullopt; std::array<std::optional<double>, 4> g1_axes = { target[X], target[Y], std::nullopt, std::nullopt };
if (has_z) std::optional<double> g1_feedrate = std::nullopt;
g1_axes[Z] = target[Z]; if (has_z)
if (feedrate.has_value()) g1_axes[Z] = target[Z];
g1_feedrate = (double)*feedrate; if (extrusion.has_value())
if (extrusion.has_value()) g1_axes[E] = target[E];
g1_axes[E] = target[E]; if (feedrate.has_value())
process_G1(g1_axes, g1_feedrate, G1DiscretizationOrigin::G2G3); g1_feedrate = (double)*feedrate;
process_G1(g1_axes, g1_feedrate, G1DiscretizationOrigin::G2G3, remaining_internal_g1_lines);
}; };
// calculate arc segments // calculate arc segments
@ -3103,7 +3106,8 @@ void GCodeProcessor::process_G2_G3(const GCodeReader::GCodeLine& line, bool cloc
arc_target[E] += extruder_per_segment; arc_target[E] += extruder_per_segment;
m_start_position = m_end_position; // this is required because we are skipping the call to process_gcode_line() m_start_position = m_end_position; // this is required because we are skipping the call to process_gcode_line()
internal_only_g1_line(adjust_target(arc_target, prev_target), z_per_segment != 0.0, (i == 1) ? feedrate : std::nullopt, extrusion); internal_only_g1_line(adjust_target(arc_target, prev_target), z_per_segment != 0.0, (i == 1) ? feedrate : std::nullopt,
extrusion, segments - i);
prev_target = arc_target; prev_target = arc_target;
} }
@ -3839,7 +3843,7 @@ void GCodeProcessor::post_process()
// used to update m_result.moves[].gcode_id // used to update m_result.moves[].gcode_id
std::vector<std::pair<size_t, size_t>> m_gcode_lines_map; std::vector<std::pair<size_t, size_t>> m_gcode_lines_map;
size_t m_curr_g1_id{ 0 }; size_t m_times_cache_id{ 0 };
size_t m_out_file_pos{ 0 }; size_t m_out_file_pos{ 0 };
bgcode::binarize::Binarizer& m_binarizer; bgcode::binarize::Binarizer& m_binarizer;
@ -3852,21 +3856,44 @@ void GCodeProcessor::post_process()
: m_binarizer(binarizer), m_write_type(type), m_machine(machine) {} : m_binarizer(binarizer), m_write_type(type), m_machine(machine) {}
#endif // NDEBUG #endif // NDEBUG
void update(size_t lines_counter, size_t g1_lines_counter) { // return: number of internal G1 lines (from G2/G3 splitting) processed
unsigned int update(const std::string& line, size_t lines_counter, size_t g1_lines_counter) {
unsigned int ret = 0;
m_gcode_lines_map.push_back({ lines_counter, 0 }); m_gcode_lines_map.push_back({ lines_counter, 0 });
if (g1_lines_counter == 0) if (GCodeReader::GCodeLine::cmd_is(line, "G0") ||
return; GCodeReader::GCodeLine::cmd_is(line, "G1") ||
GCodeReader::GCodeLine::cmd_is(line, "G2") ||
GCodeReader::GCodeLine::cmd_is(line, "G3") ||
GCodeReader::GCodeLine::cmd_is(line, "G28"))
++g1_lines_counter;
else
return ret;
auto init_it = m_machine.g1_times_cache.begin() + m_curr_g1_id; auto init_it = m_machine.g1_times_cache.begin() + m_times_cache_id;
auto it = init_it; auto it = init_it;
while (it != m_machine.g1_times_cache.end() && it->id < g1_lines_counter + 1) { while (it != m_machine.g1_times_cache.end() && it->id < g1_lines_counter) {
++it; ++it;
++m_curr_g1_id; ++m_times_cache_id;
} }
if ((it != m_machine.g1_times_cache.end() && it != init_it) || m_curr_g1_id == 0) if (it->id > g1_lines_counter)
return ret;
// search for internal G1 lines
if (GCodeReader::GCodeLine::cmd_is(line, "G2") || GCodeReader::GCodeLine::cmd_is(line, "G3")) {
while (it != m_machine.g1_times_cache.end() && it->remaining_internal_g1_lines > 0) {
++it;
++m_times_cache_id;
++g1_lines_counter;
++ret;
}
}
if (it != m_machine.g1_times_cache.end() && it->id == g1_lines_counter)
m_time = it->elapsed_time; m_time = it->elapsed_time;
return ret;
} }
// add the given gcode line to the cache // add the given gcode line to the cache
@ -4203,7 +4230,7 @@ void GCodeProcessor::post_process()
} }
}; };
// add lines XXX to exported gcode // add lines M104 to exported gcode
auto process_line_T = [this, &export_lines](const std::string& gcode_line, const size_t g1_lines_counter, const ExportLines::Backtrace& backtrace) { auto process_line_T = [this, &export_lines](const std::string& gcode_line, const size_t g1_lines_counter, const ExportLines::Backtrace& backtrace) {
const std::string cmd = GCodeReader::GCodeLine::extract_cmd(gcode_line); const std::string cmd = GCodeReader::GCodeLine::extract_cmd(gcode_line);
if (cmd.size() >= 2) { if (cmd.size() >= 2) {
@ -4281,9 +4308,8 @@ void GCodeProcessor::post_process()
gcode_line.insert(gcode_line.end(), it, it_end); gcode_line.insert(gcode_line.end(), it, it_end);
if (eol) { if (eol) {
++line_id; ++line_id;
export_lines.update(line_id, g1_lines_counter);
gcode_line += "\n"; gcode_line += "\n";
const unsigned int internal_g1_lines_counter = export_lines.update(gcode_line, line_id, g1_lines_counter);
// replace placeholder lines // replace placeholder lines
bool processed = process_placeholders(gcode_line); bool processed = process_placeholders(gcode_line);
if (processed) if (processed)
@ -4291,11 +4317,24 @@ void GCodeProcessor::post_process()
if (!processed) if (!processed)
processed = process_used_filament(gcode_line); processed = process_used_filament(gcode_line);
if (!processed && !is_temporary_decoration(gcode_line)) { if (!processed && !is_temporary_decoration(gcode_line)) {
if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G1")) if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G0") || GCodeReader::GCodeLine::cmd_is(gcode_line, "G1")) {
export_lines.append_line(gcode_line);
// add lines M73 where needed // add lines M73 where needed
process_line_G1(g1_lines_counter++); process_line_G1(g1_lines_counter++);
gcode_line.clear();
}
else if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G2") || GCodeReader::GCodeLine::cmd_is(gcode_line, "G3")) {
export_lines.append_line(gcode_line);
// add lines M73 where needed
process_line_G1(g1_lines_counter + internal_g1_lines_counter);
g1_lines_counter += (1 + internal_g1_lines_counter);
gcode_line.clear();
}
else if (GCodeReader::GCodeLine::cmd_is(gcode_line, "G28")) {
++g1_lines_counter;
}
else if (m_result.backtrace_enabled && GCodeReader::GCodeLine::cmd_starts_with(gcode_line, "T")) { else if (m_result.backtrace_enabled && GCodeReader::GCodeLine::cmd_starts_with(gcode_line, "T")) {
// add lines XXX where needed // add lines M104 where needed
process_line_T(gcode_line, g1_lines_counter, backtrace_T); process_line_T(gcode_line, g1_lines_counter, backtrace_T);
max_backtrace_time = std::max(max_backtrace_time, backtrace_T.time); max_backtrace_time = std::max(max_backtrace_time, backtrace_T.time);
} }

5
src/libslic3r/GCode/GCodeProcessor.hpp
View File

@ -277,6 +277,7 @@ namespace Slic3r {
EMoveType move_type{ EMoveType::Noop }; EMoveType move_type{ EMoveType::Noop };
GCodeExtrusionRole role{ GCodeExtrusionRole::None }; GCodeExtrusionRole role{ GCodeExtrusionRole::None };
unsigned int g1_line_id{ 0 }; unsigned int g1_line_id{ 0 };
unsigned int remaining_internal_g1_lines;
unsigned int layer_id{ 0 }; unsigned int layer_id{ 0 };
float distance{ 0.0f }; // mm float distance{ 0.0f }; // mm
float acceleration{ 0.0f }; // mm/s^2 float acceleration{ 0.0f }; // mm/s^2
@ -317,6 +318,7 @@ namespace Slic3r {
struct G1LinesCacheItem struct G1LinesCacheItem
{ {
unsigned int id; unsigned int id;
unsigned int remaining_internal_g1_lines;
float elapsed_time; float elapsed_time;
}; };
@ -710,7 +712,8 @@ namespace Slic3r {
G2G3, G2G3,
}; };
void process_G1(const std::array<std::optional<double>, 4>& axes = { std::nullopt, std::nullopt, std::nullopt, std::nullopt }, void process_G1(const std::array<std::optional<double>, 4>& axes = { std::nullopt, std::nullopt, std::nullopt, std::nullopt },
std::optional<double> feedrate = std::nullopt, G1DiscretizationOrigin origin = G1DiscretizationOrigin::G1); const std::optional<double>& feedrate = std::nullopt, G1DiscretizationOrigin origin = G1DiscretizationOrigin::G1,
const std::optional<unsigned int>& remaining_internal_g1_lines = std::nullopt);
// Arc Move // Arc Move
void process_G2_G3(const GCodeReader::GCodeLine& line, bool clockwise); void process_G2_G3(const GCodeReader::GCodeLine& line, bool clockwise);