GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-07-31 11:41:57 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rewrite gcode.t to c++

Browse Source
This commit is contained in:
Martin Šach 2023-12-15 11:05:45 +01:00 committed by SachCZ
parent 852faddc5b
commit 6e871a874a
5 changed files with 344 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
t/gcode.t
View File

@ -1,243 +0,0 @@
use Test::More tests => 22;
use strict;
use warnings;
BEGIN {
use FindBin;
use lib "$FindBin::Bin/../lib";
use local::lib "$FindBin::Bin/../local-lib";
}
use List::Util qw(first);
use Slic3r;
use Slic3r::Geometry qw(scale convex_hull);
use Slic3r::Test;
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('wipe', [1]);
$config->set('retract_layer_change', [0]);
my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
my $have_wipe = 0;
my @retract_speeds = ();
my $extruded_on_this_layer = 0;
my $wiping_on_new_layer = 0;
Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
my ($self, $cmd, $args, $info) = @_;
if ($info->{travel} && $info->{dist_Z}) {
# changing layer
$extruded_on_this_layer = 0;
} elsif ($info->{extruding} && $info->{dist_XY}) {
$extruded_on_this_layer = 1;
} elsif ($info->{retracting} && $info->{dist_XY} > 0) {
$have_wipe = 1;
$wiping_on_new_layer = 1 if !$extruded_on_this_layer;
my $move_time = $info->{dist_XY} / ($args->{F} // $self->F);
push @retract_speeds, abs($info->{dist_E}) / $move_time;
}
});
ok $have_wipe, "wipe";
ok !defined (first { abs($_ - $config->retract_speed->[0]*60) < 5 } @retract_speeds), 'wipe moves don\'t retract faster than configured speed';
ok !$wiping_on_new_layer, 'no wiping after layer change';
}
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('z_offset', 5);
$config->set('start_gcode', '');
my $test = sub {
my ($comment) = @_;
my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
my $moves_below_z_offset = 0;
Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
my ($self, $cmd, $args, $info) = @_;
if ($info->{travel} && exists $args->{Z}) {
$moves_below_z_offset++ if $args->{Z} < $config->z_offset;
}
});
is $moves_below_z_offset, 0, "no Z moves below Z offset ($comment)";
};
$test->("no lift");
$config->set('retract_lift', [3]);
$test->("lift < z_offset");
$config->set('retract_lift', [6]);
$test->("lift > z_offset");
}
{
# This tests the following behavior:
# - complete objects does not crash
# - no hard-coded "E" are generated
# - Z moves are correctly generated for both objects
# - no travel moves go outside skirt
# - temperatures are set correctly
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_comments', 1);
$config->set('complete_objects', 1);
$config->set('extrusion_axis', 'A');
$config->set('start_gcode', ''); # prevent any default extra Z move
$config->set('layer_height', 0.4);
$config->set('first_layer_height', 0.4);
$config->set('temperature', [200]);
$config->set('first_layer_temperature', [210]);
my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2);
ok my $gcode = Slic3r::Test::gcode($print), "complete_objects";
my @z_moves = ();
my @travel_moves = (); # array of scaled points
my @extrusions = (); # array of scaled points
my @temps = ();
Slic3r::GCode::Reader->new->parse($gcode, sub {
my ($self, $cmd, $args, $info) = @_;
fail 'unexpected E argument' if defined $args->{E};
if (defined $args->{Z}) {
push @z_moves, $args->{Z};
}
if ($info->{dist_XY}) {
if ($info->{extruding} || $args->{A}) {
push @extrusions, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y});
} else {
push @travel_moves, Slic3r::Point->new_scale($info->{new_X}, $info->{new_Y})
if @extrusions; # skip initial travel move to first skirt point
}
} elsif ($cmd eq 'M104' || $cmd eq 'M109') {
push @temps, $args->{S} if !@temps || $args->{S} != $temps[-1];
}
});
my $layer_count = 20/0.4; # cube is 20mm tall
is scalar(@z_moves), 2*$layer_count, 'complete_objects generates the correct number of Z moves';
is_deeply [ @z_moves[0..($layer_count-1)] ], [ @z_moves[$layer_count..$#z_moves] ], 'complete_objects generates the correct Z moves';
my $convex_hull = convex_hull(\@extrusions);
ok !(defined first { !$convex_hull->contains_point($_) } @travel_moves), 'all travel moves happen within skirt';
is_deeply \@temps, [210, 200, 210, 200, 0], 'expected temperature changes';
}
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('retract_length', [1000000]);
$config->set('use_relative_e_distances', 1);
$config->set('layer_gcode', "G92 E0\n");
my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
Slic3r::Test::gcode($print);
ok $print->print->total_used_filament > 0, 'final retraction is not considered in total used filament';
}
{
my $test = sub {
my ($print, $comment) = @_;
my @percent = ();
my $got_100 = 0;
my $extruding_after_100 = 0;
Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
my ($self, $cmd, $args, $info) = @_;
if ($cmd eq 'M73') {
push @percent, $args->{P};
$got_100 = 1 if $args->{P} eq '100';
}
if ($info->{extruding} && $got_100) {
$extruding_after_100 = 1;
}
});
# the extruder heater is turned off when M73 P100 is reached
ok !(defined first { $_ > 100 } @percent), "M73 is never given more than 100% ($comment)";
ok !$extruding_after_100, "no extrusions after M73 P100 ($comment)";
};
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_flavor', 'sailfish');
$config->set('raft_layers', 3);
my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
$test->($print, 'single object');
}
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_flavor', 'sailfish');
my $print = Slic3r::Test::init_print('20mm_cube', config => $config, duplicate => 2);
$test->($print, 'two copies of single object');
}
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_flavor', 'sailfish');
my $print = Slic3r::Test::init_print(['20mm_cube','20mm_cube'], config => $config);
$test->($print, 'two objects');
}
{
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_flavor', 'sailfish');
my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale_xyz => [1,1, 1/(20/$config->layer_height) ]);
$test->($print, 'one layer object');
}
}
#{
# [input_filename] placeholder was removed in 0cbbe96.
# my $config = Slic3r::Config::new_from_defaults;
# $config->set('start_gcode', 'START:[input_filename]');
# my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
# my $gcode = Slic3r::Test::gcode($print);
# like $gcode, qr/START:20mm_cube/, '[input_filename] is also available in custom G-code';
#}
# The current Spiral Vase slicing code removes the holes and all but the largest contours from each slice,
# therefore the following test is no more valid.
#{
# my $config = Slic3r::Config::new_from_defaults;
# $config->set('spiral_vase', 1);
# my $print = Slic3r::Test::init_print('cube_with_hole', config => $config);
#
# my $spiral = 0;
# Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
# my ($self, $cmd, $args, $info) = @_;
#
# if ($cmd eq 'G1' && exists $args->{E} && exists $args->{Z}) {
# $spiral = 1;
# }
# });
#
# ok !$spiral, 'spiral vase is correctly disabled on layers with multiple loops';
#}
{
# Tests that the Repetier flavor produces M201 Xnnn Ynnn for resetting
# acceleration, also that M204 Snnn syntax is not generated.
my $config = Slic3r::Config::new_from_defaults;
$config->set('gcode_flavor', 'repetier');
$config->set('default_acceleration', 1337);
my $print = Slic3r::Test::init_print('cube_with_hole', config => $config);
my $has_accel = 0;
my $has_m204 = 0;
Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
my ($self, $cmd, $args, $info) = @_;
if ($cmd eq 'M201' && exists $args->{X} && exists $args->{Y}) {
if ($args->{X} == 1337 && $args->{Y} == 1337) {
$has_accel = 1;
}
}
if ($cmd eq 'M204' && exists $args->{S}) {
$has_m204 = 1;
}
});
ok $has_accel, 'M201 is generated for repetier firmware.';
ok !$has_m204, 'M204 is not generated for repetier firmware';
}
__END__

31
tests/fff_print/test_data.cpp
View File

@ -236,7 +236,7 @@ static bool verbose_gcode()
return s == "1" || s == "on" || s == "yes";
}
void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments)
void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count)
{
DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
config.apply(config_in);
@ -247,10 +247,19 @@ void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r
for (const TriangleMesh &t : meshes) {
ModelObject *object = model.add_object();
object->name += "object.stl";
object->add_volume(std::move(t));
object->add_volume(t);
object->add_instance();
}
arrange_objects(model, arr2::to_arrange_bed(get_bed_shape(config)), arr2::ArrangeSettings{}.set_distance_from_objects(min_object_distance(config)));
double distance = min_object_distance(config);
arr2::ArrangeSettings arrange_settings{};
arrange_settings.set_distance_from_objects(distance);
arr2::ArrangeBed bed{arr2::to_arrange_bed(get_bed_shape(config))};
if (duplicate_count > 1) {
duplicate(model, duplicate_count, bed, arrange_settings);
}
arrange_objects(model, bed, arrange_settings);
model.center_instances_around_point({100, 100});
for (ModelObject *mo : model.objects) {
mo->ensure_on_bed();
@ -262,36 +271,36 @@ void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r
print.set_status_silent();
}
void init_print(std::initializer_list<TestMesh> test_meshes, Slic3r::Print &print, Slic3r::Model &model, const Slic3r::DynamicPrintConfig &config_in, bool comments)
void init_print(std::initializer_list<TestMesh> test_meshes, Slic3r::Print &print, Slic3r::Model &model, const Slic3r::DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count)
{
std::vector<TriangleMesh> triangle_meshes;
triangle_meshes.reserve(test_meshes.size());
for (const TestMesh test_mesh : test_meshes)
triangle_meshes.emplace_back(mesh(test_mesh));
init_print(std::move(triangle_meshes), print, model, config_in, comments);
init_print(std::move(triangle_meshes), print, model, config_in, comments, duplicate_count);
}
void init_print(std::initializer_list<TriangleMesh> input_meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments)
void init_print(std::initializer_list<TriangleMesh> input_meshes, Slic3r::Print &print, Slic3r::Model &model, const DynamicPrintConfig &config_in, bool comments, unsigned duplicate_count)
{
std::vector<TriangleMesh> triangle_meshes;
triangle_meshes.reserve(input_meshes.size());
for (const TriangleMesh &input_mesh : input_meshes)
triangle_meshes.emplace_back(input_mesh);
init_print(std::move(triangle_meshes), print, model, config_in, comments);
init_print(std::move(triangle_meshes), print, model, config_in, comments, duplicate_count);
}
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments)
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments, unsigned duplicate_count)
{
Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict(config_items);
init_print(meshes, print, model, config, comments);
init_print(meshes, print, model, config, comments, duplicate_count);
}
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments)
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model &model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments, unsigned duplicate_count)
{
Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict(config_items);
init_print(meshes, print, model, config, comments);
init_print(meshes, print, model, config, comments, duplicate_count);
}
void init_and_process_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, const DynamicPrintConfig &config, bool comments)

10
tests/fff_print/test_data.hpp
View File

@ -63,11 +63,11 @@ template <typename T>
bool _equiv(const T& a, const T& b, double epsilon) { return abs(a - b) < epsilon; }
Slic3r::Model model(const std::string& model_name, TriangleMesh&& _mesh);
void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r::Model& model, const DynamicPrintConfig &config_in, bool comments = false);
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false);
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false);
void init_print(std::vector<TriangleMesh> &&meshes, Slic3r::Print &print, Slic3r::Model& model, const DynamicPrintConfig &config_in, bool comments = false, unsigned duplicate_count = 1);
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false, unsigned duplicate_count = 1);
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, const Slic3r::DynamicPrintConfig &config_in = Slic3r::DynamicPrintConfig::full_print_config(), bool comments = false, unsigned duplicate = 1);
void init_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false, unsigned duplicate = 1);
void init_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, Slic3r::Model& model, std::initializer_list<Slic3r::ConfigBase::SetDeserializeItem> config_items, bool comments = false, unsigned duplicate = 1);
void init_and_process_print(std::initializer_list<TestMesh> meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false);
void init_and_process_print(std::initializer_list<TriangleMesh> meshes, Slic3r::Print &print, const DynamicPrintConfig& config, bool comments = false);

302
tests/fff_print/test_gcode.cpp
View File

@ -1,10 +1,22 @@
/**
* Mostly ported from t/gcode.t
*/
#include <catch2/catch.hpp>
#include <memory>
#include <regex>
#include <fstream>
#include "libslic3r/GCode.hpp"
#include "libslic3r/Geometry/ConvexHull.hpp"
#include "libslic3r/ModelArrange.hpp"
#include "test_data.hpp"
using namespace Slic3r;
using namespace Test;
constexpr bool debug_files = false;
SCENARIO("Origin manipulation", "[GCode]") {
Slic3r::GCodeGenerator gcodegen;
@ -20,3 +32,293 @@ SCENARIO("Origin manipulation", "[GCode]") {
}
}
}
TEST_CASE("Wiping speeds", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict({
{ "wipe", "1" },
{ "retract_layer_change", "0" },
});
bool have_wipe = false;
std::vector<double> retract_speeds;
bool extruded_on_this_layer = false;
bool wiping_on_new_layer = false;
GCodeReader parser;
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
if (line.travel() && line.dist_Z(self) != 0) {
extruded_on_this_layer = false;
} else if (line.extruding(self) && line.dist_XY(self) > 0) {
extruded_on_this_layer = true;
} else if (line.retracting(self) && line.dist_XY(self) > 0) {
have_wipe = true;
wiping_on_new_layer = !extruded_on_this_layer;
const double f = line.has_f() ? line.f() : self.f();
double move_time = line.dist_XY(self) / f;
retract_speeds.emplace_back(std::abs(line.dist_E(self)) / move_time);
}
});
CHECK(have_wipe);
double expected_retract_speed = config.option<ConfigOptionFloats>("retract_speed")->get_at(0) * 60;
for (const double retract_speed : retract_speeds) {
INFO("Wipe moves don\'t retract faster than configured speed");
CHECK(retract_speed < expected_retract_speed);
}
INFO("No wiping after layer change")
CHECK(!wiping_on_new_layer);
}
bool has_moves_below_z_offset(const DynamicPrintConfig& config) {
GCodeReader parser;
std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
unsigned moves_below_z_offset{};
double configured_offset = config.opt_float("z_offset");
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
if (line.travel() && line.has_z() && line.z() < configured_offset) {
moves_below_z_offset++;
}
});
return moves_below_z_offset > 0;
}
TEST_CASE("Z moves with offset", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict({
{ "z_offset", 5 },
{ "start_gcode", "" },
});
INFO("No lift");
CHECK(!has_moves_below_z_offset(config));
config.set_deserialize_strict({{ "retract_lift", "3" }});
INFO("Lift < z offset");
CHECK(!has_moves_below_z_offset(config));
config.set_deserialize_strict({{ "retract_lift", "6" }});
INFO("Lift > z offset");
CHECK(!has_moves_below_z_offset(config));
}
std::optional<double> parse_axis(const std::string& line, const std::string& axis) {
std::smatch matches;
if (std::regex_search(line, matches, std::regex{axis + "(\\d+)"})) {
std::string matchedValue = matches[1].str();
return std::stod(matchedValue);
}
return std::nullopt;
}
/**
* This tests the following behavior:
* - complete objects does not crash
* - no hard-coded "E" are generated
* - Z moves are correctly generated for both objects
* - no travel moves go outside skirt
* - temperatures are set correctly
*/
TEST_CASE("Extrusion, travels, temeperatures", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict({
{ "gcode_comments", 1 },
{ "complete_objects", 1 },
{ "extrusion_axis", 'A' },
{ "start_gcode", "" }, // prevent any default extra Z move
{ "layer_height", 0.4 },
{ "first_layer_height", 0.4 },
{ "temperature", "200" },
{ "first_layer_temperature", "210" }
});
std::vector<double> z_moves;
Points travel_moves;
Points extrusions;
std::vector<double> temps;
GCodeReader parser;
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2);
std::string gcode = Test::gcode(print);
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
INFO("Unexpected E argument");
CHECK(!line.has_e());
if (line.has_z()) {
z_moves.emplace_back(line.z());
}
if (line.has_x() || line.has_y()) {
if (line.extruding(self) || line.has_unknown_axis()) {
extrusions.emplace_back(scaled(line.x()), scaled(line.y()));
} else if (!extrusions.empty()){ // skip initial travel move to first skirt point
travel_moves.emplace_back(scaled(line.x()), scaled(line.y()));
}
} else if (line.cmd_is("M104") || line.cmd_is("M109")) {
const std::optional<double> parsed_temperature = parse_axis(line.raw(), "S");
if (!parsed_temperature) {
FAIL("Failed to parse temperature!");
}
if (temps.empty() || temps.back() != parsed_temperature) {
temps.emplace_back(*parsed_temperature);
}
}
});
const unsigned layer_count = 20 / 0.4;
INFO("Complete_objects generates the correct number of Z moves.");
CHECK(z_moves.size() == layer_count * 2);
auto first_moves = tcb::span{z_moves}.subspan(0, layer_count);
auto second_moves = tcb::span{z_moves}.subspan(layer_count);
CHECK( std::vector(first_moves.begin(), first_moves.end()) == std::vector(second_moves.begin(), second_moves.end()));
const Polygon convex_hull{Geometry::convex_hull(extrusions)};
INFO("All travel moves happen within skirt.");
for (const Point& travel_move : travel_moves) {
CHECK(convex_hull.contains(travel_move));
}
INFO("Expected temperature changes");
CHECK(temps == std::vector<double>{210, 200, 210, 200, 0});
}
TEST_CASE("Used filament", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict({
{ "retract_length", "1000000" },
{ "use_relative_e_distances", 1 },
{ "layer_gcode", "G92 E0\n" },
});
GCodeReader parser;
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config);
Test::gcode(print);
INFO("Final retraction is not considered in total used filament");
CHECK(print.print_statistics().total_used_filament > 0);
}
void check_m73s(Print& print){
std::vector<double> percent{};
bool got_100 = false;
bool extruding_after_100 = 0;
GCodeReader parser;
std::string gcode = Slic3r::Test::gcode(print);
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
if (line.cmd_is("M73")) {
std::optional<double> p = parse_axis(line.raw(), "P");
if (!p) {
FAIL("Failed to parse percent");
}
percent.emplace_back(*p);
got_100 = p == Approx(100);
}
if (line.extruding(self) && got_100) {
extruding_after_100 = true;
}
});
INFO("M73 is never given more than 100%");
for (const double value : percent) {
CHECK(value <= 100);
}
INFO("No extrusions after M73 P100.");
CHECK(!extruding_after_100);
}
TEST_CASE("M73s have correct percent values", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
SECTION("Single object") {
config.set_deserialize_strict({
{" gcode_flavor", "sailfish" },
{" raft_layers", 3 },
});
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config);
check_m73s(print);
}
SECTION("Two copies of single object") {
config.set_deserialize_strict({
{" gcode_flavor", "sailfish" },
});
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2);
check_m73s(print);
if constexpr (debug_files) {
std::ofstream gcode_file{"M73_2_copies.gcode"};
gcode_file << Test::gcode(print);
}
}
SECTION("Two objects") {
config.set_deserialize_strict({
{" gcode_flavor", "sailfish" },
});
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20, TestMesh::cube_20x20x20}, print, model, config);
check_m73s(print);
}
SECTION("One layer object") {
config.set_deserialize_strict({
{" gcode_flavor", "sailfish" },
});
Print print;
Model model;
TriangleMesh test_mesh{mesh(TestMesh::cube_20x20x20)};
const double layer_height = config.opt_float("layer_height");
test_mesh.scale(Vec3f{1, 1, layer_height/20});
Test::init_print({test_mesh}, print, model, config);
check_m73s(print);
if constexpr (debug_files) {
std::ofstream gcode_file{"M73_one_layer.gcode"};
gcode_file << Test::gcode(print);
}
}
}
TEST_CASE("M201 for acceleation reset", "[GCode]") {
DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
config.set_deserialize_strict({
{ "gcode_flavor", "repetier" },
{ "default_acceleration", 1337 },
});
GCodeReader parser;
std::string gcode = Slic3r::Test::slice({TestMesh::cube_with_hole}, config);
bool has_accel = false;
bool has_m204 = false;
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
if (line.cmd_is("M201") && line.has_x() && line.has_y()) {
if (line.x() == 1337 && line.y() == 1337) {
has_accel = true;
}
}
if (line.cmd_is("M204") && line.raw().find('S') != std::string::npos) {
has_m204 = true;
}
});
INFO("M201 is generated for repetier firmware.");
CHECK(has_accel);
INFO("M204 is not generated for repetier firmware");
CHECK(!has_m204);
}

28
tests/fff_print/test_retraction.cpp
View File

@ -13,9 +13,7 @@
using namespace Slic3r;
using namespace Test;
void check_gcode(std::initializer_list<TestMesh> meshes, const DynamicPrintConfig& config) {
std::string gcode = Slic3r::Test::slice(meshes, config);
void check_gcode(std::initializer_list<TestMesh> meshes, const DynamicPrintConfig& config, const unsigned duplicate) {
constexpr std::size_t tools_count = 4;
std::size_t tool = 0;
std::array<unsigned, tools_count> toolchange_count{0}; // Track first usages so that we don't expect retract_length_toolchange when extruders are used for the first time
@ -26,6 +24,10 @@ void check_gcode(std::initializer_list<TestMesh> meshes, const DynamicPrintConfi
bool changed_tool = false;
bool wait_for_toolchange = false;
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, duplicate);
std::string gcode = Test::gcode(print);
GCodeReader parser;
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
@ -114,24 +116,24 @@ void check_gcode(std::initializer_list<TestMesh> meshes, const DynamicPrintConfi
});
}
void test_slicing(std::initializer_list<TestMesh> meshes, DynamicPrintConfig& config) {
void test_slicing(std::initializer_list<TestMesh> meshes, DynamicPrintConfig& config, const unsigned duplicate = 1) {
SECTION("Retraction") {
check_gcode(meshes, config);
check_gcode(meshes, config, duplicate);
}
SECTION("Restart extra length") {
config.set_deserialize_strict({{ "retract_restart_extra", "1" }});
check_gcode(meshes, config);
check_gcode(meshes, config, duplicate);
}
SECTION("Negative restart extra length") {
config.set_deserialize_strict({{ "retract_restart_extra", "-1" }});
check_gcode(meshes, config);
check_gcode(meshes, config, duplicate);
}
SECTION("Retract_lift") {
config.set_deserialize_strict({{ "retract_lift", "1,2" }});
check_gcode(meshes, config);
check_gcode(meshes, config, duplicate);
}
}
@ -149,10 +151,10 @@ TEST_CASE("Slicing with retraction and lifing", "[retraction]") {
});
SECTION("Standard run") {
//test_slicing({TestMesh::cube_20x20x20}, config);
test_slicing({TestMesh::cube_20x20x20}, config);
}
SECTION("With duplicate cube") {
//test_slicing({TestMesh::cube_20x20x20, TestMesh::cube_20x20x20}, config);
test_slicing({TestMesh::cube_20x20x20}, config, 2);
}
SECTION("Dual extruder with multiple skirt layers") {
config.set_deserialize_strict({
@ -258,8 +260,12 @@ TEST_CASE("Firmware retraction when length is 0", "[retraction]") {
}
std::vector<double> get_lift_layers(const DynamicPrintConfig& config) {
Print print;
Model model;
Test::init_print({TestMesh::cube_20x20x20}, print, model, config, false, 2);
std::string gcode = Test::gcode(print);
std::vector<double> result;
const std::string gcode = Slic3r::Test::slice({TestMesh::cube_20x20x20}, config);
GCodeReader parser;
parser.parse_buffer(gcode, [&] (Slic3r::GCodeReader &self, const Slic3r::GCodeReader::GCodeLine &line) {
if (line.cmd_is("G1") && line.dist_Z(self) < 0) {