Skip to content

Commit

Permalink
Porting of Pressure Equalizer feature from Prusa Slicer 2.6.x (#2161)
Browse files Browse the repository at this point in the history
* Overhang perimeter handling

Updated code to handle overhang perimeters as an overhang and not as a bridge.

* Preparing to add curled extrusions identification

* Porting curling calculations from Prusa Slier 2.6.1

* Prototype 1 - slowdown extended to detect curled edges and further reduce speed

First prototype of the code submitted.

* Working prototype - 2

Code is now finally working - external perimeters are slowed down as needed when there is likelyhood of curling up.

ToDo:
1. Reslicing the model causes the algorithm not to run - need to find where this fails to trigger the call for this.
2. Slowdown of internal perimeters not working yet.

* Updated to use overhang wall speed instead of bridging speed for this algorithm

* Fixed bug in speed calculation and tweaked parameters for high speed printer

Fixed bug in speed calculation and tweaked parameters for high speed printer

* Attempting to fix "set started" not being set

* Parameter tweak after print tests

* Fixed estimation not running when model is re-sliced.

* Removing debug printf statements and fixed threading flag.

* Fixed threading

* Parameter tweaks following print tests

* Made this as an option in the GUI

* Reintroduced handling of bridges as per original design

* UI line toggling when option makes sense to be visible.

* Fixed bug in field visibility & made it default to off

* Code optimisation

* Initial commit of code from Prusa Slicer 2.6.1

* Ported ExtrusionRole from Prusa Slicer 2.6.1

* fix compile errors

* Update GCode.hpp

* code changes to invoke pressure equalizer

* attempting to trigger pressure equalizer

(Not compiling)

* Update Fill.cpp

* Update Fill.cpp

* Pressure equaliser layer result update

* Further commits

* Merged PR prusa3d/PrusaSlicer#9622

* First complete working version

* Update PressureEqualizer.cpp

* Implemented parameter in GUI

* Toggle fields according to compatibility

* Updated UI toggles between extrusion rate slope and arc fitting.

* Updated tooltip

* Introduced parameter smoothing segment length

This parameter influences the number of division a line will undergo in response to the requirement to adhere to the extrusion rate flow adjustment.

* Internal parameter and tool tip tweaking

* Parameter and tool tip tweaking

* Updated parameters and tooltip following testing.

* Sync PressureEq with latest PrusaSlicer

* Revert "Sync PressureEq with latest PrusaSlicer"

This reverts commit 131fb94.

---------

Co-authored-by: MGunlogson <[email protected]>
Co-authored-by: Vojtech Bubnik <[email protected]>
  • Loading branch information
3 people authored Sep 27, 2023
1 parent 78a8bad commit cf84619
Show file tree
Hide file tree
Showing 14 changed files with 826 additions and 433 deletions.
6 changes: 4 additions & 2 deletions src/libslic3r/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -62,6 +62,8 @@ set(lisbslic3r_sources
ExtrusionEntity.hpp
ExtrusionEntityCollection.cpp
ExtrusionEntityCollection.hpp
ExtrusionRole.cpp
ExtrusionRole.hpp
ExtrusionSimulator.cpp
ExtrusionSimulator.hpp
FileParserError.hpp
Expand Down Expand Up @@ -128,8 +130,8 @@ set(lisbslic3r_sources
GCode/FanMover.hpp
GCode/PostProcessor.cpp
GCode/PostProcessor.hpp
# GCode/PressureEqualizer.cpp
# GCode/PressureEqualizer.hpp
GCode/PressureEqualizer.cpp
GCode/PressureEqualizer.hpp
GCode/PrintExtents.cpp
GCode/PrintExtents.hpp
GCode/RetractWhenCrossingPerimeters.cpp
Expand Down
94 changes: 94 additions & 0 deletions src/libslic3r/ExtrusionRole.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,94 @@
///|/ Copyright (c) Prusa Research 2023 Pavel Mikuš @Godrak, Oleksandra Iushchenko @YuSanka, Vojtěch Bubník @bubnikv
///|/
///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
///|/
#include "ExtrusionRole.hpp"
#include "I18N.hpp"

#include <string>
#include <string_view>
#include <cassert>


namespace Slic3r {

// Convert a rich bitmask based ExtrusionRole to a less expressive ordinal GCodeExtrusionRole.
// GCodeExtrusionRole is to be serialized into G-code and deserialized by G-code viewer,
GCodeExtrusionRole extrusion_role_to_gcode_extrusion_role(ExtrusionRole role)
{
if (role == erNone) return GCodeExtrusionRole::None;
if (role == erOverhangPerimeter) return GCodeExtrusionRole::OverhangPerimeter;
if (role == erExternalPerimeter) return GCodeExtrusionRole::ExternalPerimeter;
if (role == erPerimeter) return GCodeExtrusionRole::Perimeter;
if (role == erInternalInfill) return GCodeExtrusionRole::InternalInfill;
if (role == erSolidInfill) return GCodeExtrusionRole::SolidInfill;
if (role == erTopSolidInfill) return GCodeExtrusionRole::TopSolidInfill;
if (role == erIroning) return GCodeExtrusionRole::Ironing;
if (role == erBridgeInfill) return GCodeExtrusionRole::BridgeInfill;
if (role == erGapFill) return GCodeExtrusionRole::GapFill;
if (role == erSkirt) return GCodeExtrusionRole::Skirt;
if (role == erSupportMaterial) return GCodeExtrusionRole::SupportMaterial;
if (role == erSupportMaterialInterface) return GCodeExtrusionRole::SupportMaterialInterface;
if (role == erWipeTower) return GCodeExtrusionRole::WipeTower;
assert(false);
return GCodeExtrusionRole::None;
}

std::string gcode_extrusion_role_to_string(GCodeExtrusionRole role)
{
switch (role) {
case GCodeExtrusionRole::None : return L("Unknown");
case GCodeExtrusionRole::Perimeter : return L("Perimeter");
case GCodeExtrusionRole::ExternalPerimeter : return L("External perimeter");
case GCodeExtrusionRole::OverhangPerimeter : return L("Overhang perimeter");
case GCodeExtrusionRole::InternalInfill : return L("Internal infill");
case GCodeExtrusionRole::SolidInfill : return L("Solid infill");
case GCodeExtrusionRole::TopSolidInfill : return L("Top solid infill");
case GCodeExtrusionRole::Ironing : return L("Ironing");
case GCodeExtrusionRole::BridgeInfill : return L("Bridge infill");
case GCodeExtrusionRole::GapFill : return L("Gap fill");
case GCodeExtrusionRole::Skirt : return L("Skirt/Brim");
case GCodeExtrusionRole::SupportMaterial : return L("Support material");
case GCodeExtrusionRole::SupportMaterialInterface : return L("Support material interface");
case GCodeExtrusionRole::WipeTower : return L("Wipe tower");
case GCodeExtrusionRole::Custom : return L("Custom");
default : assert(false);
}
return {};
}

GCodeExtrusionRole string_to_gcode_extrusion_role(const std::string_view role)
{
if (role == L("Perimeter"))
return GCodeExtrusionRole::Perimeter;
else if (role == L("External perimeter"))
return GCodeExtrusionRole::ExternalPerimeter;
else if (role == L("Overhang perimeter"))
return GCodeExtrusionRole::OverhangPerimeter;
else if (role == L("Internal infill"))
return GCodeExtrusionRole::InternalInfill;
else if (role == L("Solid infill"))
return GCodeExtrusionRole::SolidInfill;
else if (role == L("Top solid infill"))
return GCodeExtrusionRole::TopSolidInfill;
else if (role == L("Ironing"))
return GCodeExtrusionRole::Ironing;
else if (role == L("Bridge infill"))
return GCodeExtrusionRole::BridgeInfill;
else if (role == L("Gap fill"))
return GCodeExtrusionRole::GapFill;
else if (role == L("Skirt") || role == L("Skirt/Brim")) // "Skirt" is for backward compatibility with 2.3.1 and earlier
return GCodeExtrusionRole::Skirt;
else if (role == L("Support material"))
return GCodeExtrusionRole::SupportMaterial;
else if (role == L("Support material interface"))
return GCodeExtrusionRole::SupportMaterialInterface;
else if (role == L("Wipe tower"))
return GCodeExtrusionRole::WipeTower;
else if (role == L("Custom"))
return GCodeExtrusionRole::Custom;
else
return GCodeExtrusionRole::None;
}

}
83 changes: 83 additions & 0 deletions src/libslic3r/ExtrusionRole.hpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,83 @@
///|/ Copyright (c) 2023 Robert Schiele @schiele
///|/ Copyright (c) Prusa Research 2023 Vojtěch Bubník @bubnikv
///|/
///|/ PrusaSlicer is released under the terms of the AGPLv3 or higher
///|/
#ifndef slic3r_ExtrusionRole_hpp_
#define slic3r_ExtrusionRole_hpp_

#include "enum_bitmask.hpp"
#include "ExtrusionEntity.hpp"

#include <string>
#include <string_view>
#include <cstdint>

namespace Slic3r {

enum class ExtrusionRoleModifier : uint16_t {
// 1) Extrusion types
// Perimeter (external, inner, ...)
Perimeter,
// Infill (top / bottom / solid inner / sparse inner / bridging inner ...)
Infill,
// Variable width extrusion
Thin,
// Support material extrusion
Support,
Skirt,
Wipe,
// 2) Extrusion modifiers
External,
Solid,
Ironing,
Bridge,
// 3) Special types
// Indicator that the extrusion role was mixed from multiple differing extrusion roles,
// for example from Support and SupportInterface.
Mixed,
// Stopper, there should be maximum 16 modifiers defined for uint16_t bit mask.
Count
};
// There should be maximum 16 modifiers defined for uint16_t bit mask.
static_assert(int(ExtrusionRoleModifier::Count) <= 16, "ExtrusionRoleModifier: there must be maximum 16 modifiers defined to fit a 16 bit bitmask");

using ExtrusionRoleModifiers = enum_bitmask<ExtrusionRoleModifier>;
ENABLE_ENUM_BITMASK_OPERATORS(ExtrusionRoleModifier);



// Be careful when editing this list as many parts of the code depend
// on the values of these ordinars, for example
// GCodeViewer::Extrusion_Role_Colors
enum class GCodeExtrusionRole : uint8_t {
None,
Perimeter,
ExternalPerimeter,
OverhangPerimeter,
InternalInfill,
SolidInfill,
TopSolidInfill,
Ironing,
BridgeInfill,
GapFill,
Skirt,
SupportMaterial,
SupportMaterialInterface,
WipeTower,
// Custom (user defined) G-code block, for example start / end G-code.
Custom,
// Stopper to count number of enums.
Count
};

// Convert a rich bitmask based ExtrusionRole to a less expressive ordinal GCodeExtrusionRole.
// GCodeExtrusionRole is to be serialized into G-code and deserialized by G-code viewer,
GCodeExtrusionRole extrusion_role_to_gcode_extrusion_role(ExtrusionRole role);

std::string gcode_extrusion_role_to_string(GCodeExtrusionRole role);
GCodeExtrusionRole string_to_gcode_extrusion_role(const std::string_view role);

}

#endif // slic3r_ExtrusionRole_hpp_
93 changes: 49 additions & 44 deletions src/libslic3r/GCode.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1873,14 +1873,13 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato

if (print.config().spiral_mode.value)
m_spiral_vase = make_unique<SpiralVase>(print.config());
#ifdef HAS_PRESSURE_EQUALIZER
if (print.config().max_volumetric_extrusion_rate_slope_positive.value > 0 ||
print.config().max_volumetric_extrusion_rate_slope_negative.value > 0)
m_pressure_equalizer = make_unique<PressureEqualizer>(&print.config());
m_enable_extrusion_role_markers = (bool)m_pressure_equalizer;
#else /* HAS_PRESSURE_EQUALIZER */
m_enable_extrusion_role_markers = false;
#endif /* HAS_PRESSURE_EQUALIZER */

if (print.config().max_volumetric_extrusion_rate_slope.value > 0){
m_pressure_equalizer = make_unique<PressureEqualizer>(print.config());
m_enable_extrusion_role_markers = (bool)m_pressure_equalizer;
} else
m_enable_extrusion_role_markers = false;


file.write_format("; HEADER_BLOCK_START\n");
// Write information on the generator.
Expand Down Expand Up @@ -2388,10 +2387,6 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
file.write("M1003 S0\n");
}
}
#ifdef HAS_PRESSURE_EQUALIZER
if (m_pressure_equalizer)
file.write(m_pressure_equalizer->process("", true));
#endif /* HAS_PRESSURE_EQUALIZER */
++ finished_objects;
// Flag indicating whether the nozzle temperature changes from 1st to 2nd layer were performed.
// Reset it when starting another object from 1st layer.
Expand Down Expand Up @@ -2459,10 +2454,6 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
file.write("M1003 S0\n");
}
}
#ifdef HAS_PRESSURE_EQUALIZER
if (m_pressure_equalizer)
file.write(m_pressure_equalizer->process("", true));
#endif /* HAS_PRESSURE_EQUALIZER */
if (m_wipe_tower)
// Purge the extruder, pull out the active filament.
file.write(m_wipe_tower->finalize(*this));
Expand Down Expand Up @@ -2595,11 +2586,18 @@ void GCode::process_layers(
{
// The pipeline is variable: The vase mode filter is optional.
size_t layer_to_print_idx = 0;
const auto generator = tbb::make_filter<void, GCode::LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print, &layer_to_print_idx](tbb::flow_control& fc) -> GCode::LayerResult {
if (layer_to_print_idx == layers_to_print.size()) {
fc.stop();
return {};
const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[this, &print, &tool_ordering, &print_object_instances_ordering, &layers_to_print, &layer_to_print_idx](tbb::flow_control& fc) -> LayerResult {
if (layer_to_print_idx >= layers_to_print.size()) {
if ((!m_pressure_equalizer && layer_to_print_idx == layers_to_print.size()) || (m_pressure_equalizer && layer_to_print_idx == (layers_to_print.size() + 1))) {
fc.stop();
return {};
} else {
// Pressure equalizer need insert empty input. Because it returns one layer back.
// Insert NOP (no operation) layer;
++layer_to_print_idx;
return LayerResult::make_nop_layer_result();
}
} else {
const std::pair<coordf_t, std::vector<LayerToPrint>>& layer = layers_to_print[layer_to_print_idx++];
const LayerTools& layer_tools = tool_ordering.tools_for_layer(layer.first);
Expand All @@ -2612,13 +2610,23 @@ void GCode::process_layers(
return this->process_layer(print, layer.second, layer_tools, &layer == &layers_to_print.back(), &print_object_instances_ordering, size_t(-1));
}
});
const auto spiral_mode = tbb::make_filter<GCode::LayerResult, GCode::LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[&spiral_mode = *this->m_spiral_vase.get()](GCode::LayerResult in) -> GCode::LayerResult {

const auto spiral_mode = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[&spiral_mode = *this->m_spiral_vase.get()](LayerResult in) -> LayerResult {
if (in.nop_layer_result)
return in;

spiral_mode.enable(in.spiral_vase_enable);
return { spiral_mode.process_layer(std::move(in.gcode)), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush };
});
const auto cooling = tbb::make_filter<GCode::LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
[&cooling_buffer = *this->m_cooling_buffer.get()](GCode::LayerResult in) -> std::string {
const auto pressure_equalizer = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[pressure_equalizer = this->m_pressure_equalizer.get()](LayerResult in) -> LayerResult {
return pressure_equalizer->process_layer(std::move(in));
});
const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
[&cooling_buffer = *this->m_cooling_buffer.get()](LayerResult in) -> std::string {
if (in.nop_layer_result)
return in.gcode;
return cooling_buffer.process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
});
const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
Expand All @@ -2627,6 +2635,7 @@ void GCode::process_layers(

const auto fan_mover = tbb::make_filter<std::string, std::string>(slic3r_tbb_filtermode::serial_in_order,
[&fan_mover = this->m_fan_mover, &config = this->config(), &writer = this->m_writer](std::string in)->std::string {

CNumericLocalesSetter locales_setter;

if (config.fan_speedup_time.value != 0 || config.fan_kickstart.value > 0) {
Expand All @@ -2645,10 +2654,14 @@ void GCode::process_layers(
});

// The pipeline elements are joined using const references, thus no copying is performed.
if (m_spiral_vase)
tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output);
if (m_spiral_vase && m_pressure_equalizer)
tbb::parallel_pipeline(12, generator & spiral_mode & pressure_equalizer & cooling & fan_mover & output);
else if (m_spiral_vase)
tbb::parallel_pipeline(12, generator & spiral_mode & cooling & fan_mover & output);
else if (m_pressure_equalizer)
tbb::parallel_pipeline(12, generator & pressure_equalizer & cooling & fan_mover & output);
else
tbb::parallel_pipeline(12, generator & cooling & fan_mover & output);
tbb::parallel_pipeline(12, generator & cooling & fan_mover & output);
}

// Process all layers of a single object instance (sequential mode) with a parallel pipeline:
Expand All @@ -2665,8 +2678,8 @@ void GCode::process_layers(
{
// The pipeline is variable: The vase mode filter is optional.
size_t layer_to_print_idx = 0;
const auto generator = tbb::make_filter<void, GCode::LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[this, &print, &tool_ordering, &layers_to_print, &layer_to_print_idx, single_object_idx, prime_extruder](tbb::flow_control& fc) -> GCode::LayerResult {
const auto generator = tbb::make_filter<void, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[this, &print, &tool_ordering, &layers_to_print, &layer_to_print_idx, single_object_idx, prime_extruder](tbb::flow_control& fc) -> LayerResult {
if (layer_to_print_idx == layers_to_print.size()) {
fc.stop();
return {};
Expand All @@ -2679,13 +2692,13 @@ void GCode::process_layers(
return this->process_layer(print, { std::move(layer) }, tool_ordering.tools_for_layer(layer.print_z()), &layer == &layers_to_print.back(), nullptr, single_object_idx, prime_extruder);
}
});
const auto spiral_mode = tbb::make_filter<GCode::LayerResult, GCode::LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[&spiral_mode = *this->m_spiral_vase.get()](GCode::LayerResult in)->GCode::LayerResult {
const auto spiral_mode = tbb::make_filter<LayerResult, LayerResult>(slic3r_tbb_filtermode::serial_in_order,
[&spiral_mode = *this->m_spiral_vase.get()](LayerResult in)->LayerResult {
spiral_mode.enable(in.spiral_vase_enable);
return { spiral_mode.process_layer(std::move(in.gcode)), in.layer_id, in.spiral_vase_enable, in.cooling_buffer_flush };
});
const auto cooling = tbb::make_filter<GCode::LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
[&cooling_buffer = *this->m_cooling_buffer.get()](GCode::LayerResult in)->std::string {
const auto cooling = tbb::make_filter<LayerResult, std::string>(slic3r_tbb_filtermode::serial_in_order,
[&cooling_buffer = *this->m_cooling_buffer.get()](LayerResult in)->std::string {
return cooling_buffer.process_layer(std::move(in.gcode), in.layer_id, in.cooling_buffer_flush);
});
const auto output = tbb::make_filter<std::string, void>(slic3r_tbb_filtermode::serial_in_order,
Expand Down Expand Up @@ -3216,7 +3229,7 @@ inline std::string get_instance_name(const PrintObject *object, const PrintInsta
// In non-sequential mode, process_layer is called per each print_z height with all object and support layers accumulated.
// For multi-material prints, this routine minimizes extruder switches by gathering extruder specific extrusion paths
// and performing the extruder specific extrusions together.
GCode::LayerResult GCode::process_layer(
LayerResult GCode::process_layer(
const Print &print,
// Set of object & print layers of the same PrintObject and with the same print_z.
const std::vector<LayerToPrint> &layers,
Expand Down Expand Up @@ -3255,7 +3268,7 @@ GCode::LayerResult GCode::process_layer(
else if (support_layer != nullptr)
layer_ptr = support_layer;
const Layer& layer = *layer_ptr;
GCode::LayerResult result { {}, layer.id(), false, last_layer };
LayerResult result { {}, layer.id(), false, last_layer };
if (layer_tools.extruders.empty())
// Nothing to extrude.
return result;
Expand Down Expand Up @@ -3878,14 +3891,6 @@ GCode::LayerResult GCode::process_layer(
// Flush the cooling buffer at each object layer or possibly at the last layer, even if it contains just supports (This should not happen).
object_layer || last_layer);

#ifdef HAS_PRESSURE_EQUALIZER
// Apply pressure equalization if enabled;
// printf("G-code before filter:\n%s\n", gcode.c_str());
if (m_pressure_equalizer)
gcode = m_pressure_equalizer->process(gcode.c_str(), false);
// printf("G-code after filter:\n%s\n", out.c_str());
#endif /* HAS_PRESSURE_EQUALIZER */

file.write(gcode);
#endif

Expand Down
Loading

0 comments on commit cf84619

Please sign in to comment.