GitHub-Proxy/Slic3r
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/slic3r/Slic3r.git synced 2025-08-14 09:05:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix some tests, add a dense infill test

Browse Source
This commit is contained in:
supermerill 2020-10-26 21:31:23 +01:00
parent 484cdd12af
commit 77a15a2d7f
11 changed files with 150 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/libslic3r/ExtrusionEntity.cpp
View File

@ -391,6 +391,13 @@ void ExtrusionPrinter::use(const ExtrusionEntityCollection &collection) {
}
void ExtrusionLength::default_use(const ExtrusionEntity& entity) { dist += entity.length(); };
void ExtrusionLength::use(const ExtrusionEntityCollection& collection) {
for (int i = 0; i < collection.entities.size(); i++) {
collection.entities[i]->visit(*this);
}
}
//class ExtrusionTreeVisitor : ExtrusionVisitor {
//public:
// //virtual void use(ExtrusionEntity &entity) { assert(false); };

27
src/libslic3r/ExtrusionEntity.hpp
View File

@ -552,19 +552,32 @@ class ExtrusionPrinter : public ExtrusionVisitorConst {
bool trunc;
public:
ExtrusionPrinter(double mult = 0.0001, bool trunc = false) : mult(mult), trunc(trunc) { }
virtual void use(const ExtrusionPath &path) override;
virtual void use(const ExtrusionPath3D &path3D) override;
virtual void use(const ExtrusionMultiPath &multipath) override;
virtual void use(const ExtrusionMultiPath3D &multipath) override;
virtual void use(const ExtrusionLoop &loop) override;
virtual void use(const ExtrusionEntityCollection &collection) override;
virtual void use(const ExtrusionPath& path) override;
virtual void use(const ExtrusionPath3D& path3D) override;
virtual void use(const ExtrusionMultiPath& multipath) override;
virtual void use(const ExtrusionMultiPath3D& multipath) override;
virtual void use(const ExtrusionLoop& loop) override;
virtual void use(const ExtrusionEntityCollection& collection) override;
std::string str() { return ss.str(); }
std::string print(const ExtrusionEntity &entity) && {
std::string print(const ExtrusionEntity& entity)&& {
entity.visit(*this);
return ss.str();
}
};
class ExtrusionLength : public ExtrusionVisitorConst {
double dist;
public:
ExtrusionLength() : dist(0){ }
virtual void default_use(const ExtrusionEntity& path) override;
virtual void use(const ExtrusionEntityCollection& collection) override;
double get() { return dist; }
double length(const ExtrusionEntity& entity)&& {
entity.visit(*this);
return get();
}
};
}
#endif

3
src/libslic3r/Print.cpp
View File

@ -1724,7 +1724,8 @@ void Print::process()
m_skirt.clear();
m_skirt_convex_hull.clear();
m_first_layer_convex_hull.points.clear(); for (PrintObject *obj : m_objects) {
m_first_layer_convex_hull.points.clear();
for (PrintObject *obj : m_objects) {
obj->m_skirt.clear();
}
if (this->has_skirt()) {

4
src/libslic3r/Print.hpp
View File

@ -556,6 +556,10 @@ private:
friend class PrintObject;
};
//for testing purpose
ExPolygons dense_fill_fit_to_size(const ExPolygon &polygon_to_cover, const ExPolygons& allowedPoints,
const ExPolygon& growing_area, const coord_t offset, float coverage);
} /* slic3r_Print_hpp_ */
#endif

2
src/libslic3r/PrintConfig.cpp
View File

@ -4865,7 +4865,7 @@ double PrintConfig::min_object_distance() const
return PrintConfig::min_object_distance(static_cast<const ConfigBase*>(this));
}
double PrintConfig::min_object_distance(const ConfigBase *config, double ref_height)
double PrintConfig::min_object_distance(const ConfigBase *config, double ref_height /* = 0*/)
{
if (printer_technology(*config) == ptSLA) return 6.;

25
tests/libslic3r/test_clipper_utils.cpp
View File

@ -10,6 +10,29 @@
using namespace Slic3r;
SCENARIO("test clipper limits", "[ClipperUtils]") {
GIVEN("100mm square") {
WHEN("offset") {
Slic3r::Polygon square{ Point::new_scale(200, 100), Point::new_scale(200, 200), Point::new_scale(100, 200), Point::new_scale(100, 100) };
THEN("offset 100") {
REQUIRE(offset(square, scale_(100)).size() == 1);
}
THEN("offset 1000") {
REQUIRE(offset(square, scale_(1000)).size() == 1);
}
THEN("offset 10000") {
REQUIRE(offset(square, scale_(10000)).size() == 1);
}
THEN("offset 100000") {
REQUIRE(offset(square, scale_(100000)).size() == 1);
}
THEN("offset 1000000") {
REQUIRE(offset(square, scale_(1000000)).size() == 1);
}
}
}
}
SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
// CCW oriented contour
Slic3r::Polygon square{ { 200, 100 }, {200, 200}, {100, 200}, {100, 100} };
@ -246,7 +269,7 @@ TEST_CASE("Traversing Clipper PolyTree", "[ClipperUtils]") {
// Create a polygon representing unit box
Polygon unitbox;
const coord_t UNIT = coord_t(1. / SCALING_FACTOR);
unitbox.points = Points{Point{0, 0}, Point{UNIT, 0}, Point{UNIT, UNIT}, Point{0, UNIT}};
unitbox.points = Points{Point{0, 0}, Point{UNIT, coord_t(0)}, Point{UNIT, UNIT}, Point{coord_t(0), UNIT}};
Polygon box_frame = unitbox;
box_frame.scale(20, 10);

1
tests/superslicerlibslic3r/CMakeLists.txt
View File

@ -16,6 +16,7 @@ add_executable(${_TEST_NAME}_tests
test_data.hpp
test_data.cpp
# test_clipper_utils.cpp
test_dense_infill.cpp
)

8
tests/superslicerlibslic3r/test_complete_objects.cpp
View File

@ -1,7 +1,7 @@
//#define CATCH_CONFIG_DISABLE
//#include <catch2/catch.hpp>
#include <catch_main.hpp>
#define CATCH_CONFIG_DISABLE
#include <catch2/catch.hpp>
//#include <catch_main.hpp>
#include <string>
#include "test_data.hpp"
@ -38,7 +38,7 @@ std::unique_ptr<Print> init_print_with_dist(DynamicPrintConfig &config, float di
if (distance <= 0) {
print->apply(model, config);
arrange_objects(*print, model, InfiniteBed{}, ArrangeParams{ scaled(min_object_distance(config)) });// print->config().min_object_distance(&print->config(), 999999));
arrange_objects(print.get(), model, InfiniteBed{}, ArrangeParams{ scaled(/*min_object_distance(config)) });/*/ print->config().min_object_distance(&print->config(), 999999)) });
model.center_instances_around_point(Slic3r::Vec2d(100, 100));
}

4
tests/superslicerlibslic3r/test_data.cpp
View File

@ -288,7 +288,7 @@ void init_print(Print& print, std::initializer_list<TestMesh> meshes, Slic3r::Mo
}
print.apply(model, config); // apply config for the arrange_objects
arrange_objects(&print, model, InfiniteBed{}, ArrangeParams{ scaled(min_object_distance(config)) });
arrange_objects(&print, model, InfiniteBed{}, ArrangeParams{ scaled(print.config().min_object_distance()) });
model.center_instances_around_point(Slic3r::Vec2d(100,100));
for (auto* mo : model.objects) {
print.auto_assign_extruders(mo);
@ -324,7 +324,7 @@ void init_print(Print& print, std::vector<TriangleMesh> meshes, Slic3r::Model& m
}
print.apply(model, config); // apply config for the arrange_objects
arrange_objects(&print, model, InfiniteBed{}, ArrangeParams{ scaled(min_object_distance(config)) });
arrange_objects(&print, model, InfiniteBed{}, ArrangeParams{ scaled(print.config().min_object_distance()) });
model.center_instances_around_point(Slic3r::Vec2d(100,100));
print.apply(model, config);
for (ModelObject* mo : model.objects) {

75
tests/superslicerlibslic3r/test_dense_infill.cpp Normal file
View File

@ -0,0 +1,75 @@
//#define CATCH_CONFIG_DISABLE
//#include <catch2/catch.hpp>
#include <catch_main.hpp>
//#include <catch2/catch.hpp>
#include <string>
#include "test_data.hpp"
#include <libslic3r/libslic3r.h>
//#include <libslic3r/ModelArrange.hpp>
//#include <libslic3r/SVG.hpp>
//#include <libslic3r/SVG.hpp>
//#include <libslic3r/Print.hpp>
using namespace Slic3r::Test;
using namespace Slic3r;
using namespace std::literals;
Slic3r::Polygon get_polygon_scale(std::vector<std::vector<float>> points) {
Slic3r::Polygon poly;
for (std::vector<float>& point : points) {
poly.points.push_back(Point::new_scale(point[0], point[1]));
}
return poly;
}
SCENARIO("test auto generation") {
GIVEN("triangle with top to fill") {
//DynamicPrintConfig& config = Slic3r::DynamicPrintConfig::full_print_config();
//config.set_key_value("fill_density", new ConfigOptionPercent(0));
//config.set_deserialize("nozzle_diameter", "0.4");
//config.set_deserialize("layer_height", "0.3");
//config.set_deserialize("infill_dense_algo", "50");
//config.set_deserialize("extruder_clearance_radius", "10");
WHEN("little surface") {
ExPolygon polygon_to_cover;
polygon_to_cover.contour = get_polygon_scale({ {0,0}, {10,0}, {10,10}, {0,10} });
ExPolygon growing_area;
growing_area.contour = get_polygon_scale({ {0,0}, {40,0}, {0,40} });
ExPolygons allowedPoints;
allowedPoints.emplace_back();
//diff_ex(offset_ex(growing_area, scale_(1)), offset_ex(layerm->fill_no_overlap_expolygons, double(-layerm->flow(frInfill).scaled_width())));
allowedPoints.back().contour = get_polygon_scale({ {0,0}, {40,0}, {0,40} });
coord_t offset = scale_(2);
float coverage = 1.f;
ExPolygons solution = dense_fill_fit_to_size(polygon_to_cover, allowedPoints, growing_area, offset, coverage);
THEN("little support") {
double area_result = 0;
for (ExPolygon& p : solution)
area_result += unscaled(unscaled(p.area()));
double area_full = unscaled(unscaled(growing_area.area()));
//for (ExPolygon& p : allowedPoints)
// area_full += unscaled(unscaled(p.area());
for (ExPolygon& po : solution)
for (Point& p : po.contour.points)
std::cout << ", " << unscaled(p.x()) << ":" << unscaled(p.y());
std::cout << "\n";
std::cout << "area_result= " << area_result << "\n";
std::cout << "area_full = " << area_full << "\n";
REQUIRE(area_full > 1.5 * area_result);
}
}
//THEN("(too near)") {
// result = init_print_with_dist(config, 40)->validate();
// REQUIRE(result.first == PrintBase::PrintValidationError::pveWrongPosition);
//}
//THEN("(ok far)") {
// result = init_print_with_dist(config, 40.8)->validate();
// REQUIRE(result.second == "");
// REQUIRE(result.first == PrintBase::PrintValidationError::pveNone);
//}
}
}

16
tests/superslicerlibslic3r/test_print.cpp
View File

@ -165,26 +165,30 @@ SCENARIO("Print: Brim generation") {
}
}
WHEN("Brim without first layer compensation") {
config.set_key_value("brim_width", new ConfigOptionFloat(2));
config.set_key_value("brim_width", new ConfigOptionFloat(1));
config.set_key_value("brim_offset", new ConfigOptionFloat(0));
Print print{};
Slic3r::Test::init_print(print, { m }, model, &config);
print.process();
THEN("First Brim Extrusion has a length of ~88") {
REQUIRE(unscaled(print.brim().entities.front()->length()) > 22*4);
REQUIRE(unscaled(print.brim().entities.front()->length()) < 22*4+1);
REQUIRE(print.brim().entities.size() > 0);
double dist = unscaled(ExtrusionLength{}.length(*print.brim().entities.front()));
REQUIRE(dist > 22*4);
REQUIRE(dist < 22*4+1);
}
}
WHEN("Brim with 1mm first layer compensation") {
config.set_key_value("brim_width", new ConfigOptionFloat(2));
config.set_key_value("brim_width", new ConfigOptionFloat(1));
config.set_key_value("brim_offset", new ConfigOptionFloat(0));
config.set_key_value("first_layer_size_compensation", new ConfigOptionFloat(-1));
Print print{};
Slic3r::Test::init_print(print, { m }, model, &config);
print.process();
THEN("First Brim Extrusion has a length of ~80") {
REQUIRE(unscaled(print.brim().entities.front()->length()) > 20 * 4);
REQUIRE(unscaled(print.brim().entities.front()->length()) < 20 * 4 + 1);
REQUIRE(print.brim().entities.size() > 0);
double dist = unscaled(ExtrusionLength{}.length(*print.brim().entities.front()));
REQUIRE(dist > 20 * 4);
REQUIRE(dist < 20 * 4 + 1);
}
}
WHEN("Brim is set to 6mm, extrusion width 0.5mm") {