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

Major scheduling speed improvement via various algorithmic techniques.

Browse Source
This commit is contained in:
surynek 2024-10-23 00:50:34 +02:00 committed by Lukas Matena
parent e75ff22438
commit 46d0d60df9
6 changed files with 363 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/libseqarrange/include/libseqarrange/seq_interface.hpp
View File

@ -78,6 +78,7 @@ struct SolverConfiguration
int max_refines; int max_refines;
int object_group_size; int object_group_size;
int fixed_object_grouping_limit;
int temporal_spread; int temporal_spread;
DecimationPrecision decimation_precision; DecimationPrecision decimation_precision;

7
src/libseqarrange/src/seq_interface.cpp
View File

@ -27,6 +27,7 @@ namespace Sequential
/*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/
const int SEQ_OBJECT_GROUP_SIZE = 4; const int SEQ_OBJECT_GROUP_SIZE = 4;
const int SEQ_FIXED_OBJECT_GROUPING_LIMIT = 64;
const int SEQ_SCHEDULING_TEMPORAL_SPREAD = 16; const int SEQ_SCHEDULING_TEMPORAL_SPREAD = 16;
const int SEQ_BOUNDING_BOX_SIZE_OPTIMIZATION_STEP = 4; const int SEQ_BOUNDING_BOX_SIZE_OPTIMIZATION_STEP = 4;
@ -96,6 +97,7 @@ SolverConfiguration::SolverConfiguration()
, y_plate_bounding_box_size(SEQ_PRUSA_MK3S_Y_SIZE) , y_plate_bounding_box_size(SEQ_PRUSA_MK3S_Y_SIZE)
, max_refines(SEQ_MAX_REFINES) , max_refines(SEQ_MAX_REFINES)
, object_group_size(SEQ_OBJECT_GROUP_SIZE) , object_group_size(SEQ_OBJECT_GROUP_SIZE)
, fixed_object_grouping_limit(SEQ_FIXED_OBJECT_GROUPING_LIMIT)
, temporal_spread(SEQ_SCHEDULING_TEMPORAL_SPREAD) , temporal_spread(SEQ_SCHEDULING_TEMPORAL_SPREAD)
, decimation_precision(SEQ_DECIMATION_PRECISION_LOW) , decimation_precision(SEQ_DECIMATION_PRECISION_LOW)
, optimization_timeout(SEQ_Z3_SOLVER_TIMEOUT) , optimization_timeout(SEQ_Z3_SOLVER_TIMEOUT)
@ -109,6 +111,7 @@ SolverConfiguration::SolverConfiguration(const PrinterGeometry &printer_geometry
, minimum_bounding_box_size(SEQ_MINIMUM_BOUNDING_BOX_SIZE) , minimum_bounding_box_size(SEQ_MINIMUM_BOUNDING_BOX_SIZE)
, max_refines(SEQ_MAX_REFINES) , max_refines(SEQ_MAX_REFINES)
, object_group_size(SEQ_OBJECT_GROUP_SIZE) , object_group_size(SEQ_OBJECT_GROUP_SIZE)
, fixed_object_grouping_limit(SEQ_FIXED_OBJECT_GROUPING_LIMIT)
, temporal_spread(SEQ_SCHEDULING_TEMPORAL_SPREAD) , temporal_spread(SEQ_SCHEDULING_TEMPORAL_SPREAD)
, decimation_precision(SEQ_DECIMATION_PRECISION_LOW) , decimation_precision(SEQ_DECIMATION_PRECISION_LOW)
, optimization_timeout(SEQ_Z3_SOLVER_TIMEOUT) , optimization_timeout(SEQ_Z3_SOLVER_TIMEOUT)
@ -573,7 +576,7 @@ int schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver_
decimated_polygon = objects_to_print[i].pgns_at_height[j].second; decimated_polygon = objects_to_print[i].pgns_at_height[j].second;
decimated_polygon.make_counter_clockwise(); decimated_polygon.make_counter_clockwise();
} }
if (!check_PolygonSize(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon)) if (!check_PolygonSizeFitToPlate(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon))
{ {
#ifdef DEBUG #ifdef DEBUG
{ {
@ -998,7 +1001,7 @@ int schedule_ObjectsForSequentialPrint(const SolverConfiguration
decimated_polygon.make_counter_clockwise(); decimated_polygon.make_counter_clockwise();
} }
if (!check_PolygonSize(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon)) if (!check_PolygonSizeFitToPlate(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon))
{ {
#ifdef DEBUG #ifdef DEBUG
{ {

157
src/libseqarrange/src/seq_preprocess.cpp
View File

@ -714,7 +714,7 @@ void prepare_ExtruderPolygons(const SolverConfiguration &solver
decimated_polygon.make_counter_clockwise(); decimated_polygon.make_counter_clockwise();
} }
if (!check_PolygonSize(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon)) if (!check_PolygonSizeFitToPlate(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon))
{ {
#ifdef DEBUG #ifdef DEBUG
{ {
@ -779,32 +779,40 @@ void prepare_UnreachableZonePolygons(const SolverConfiguration
const std::vector<std::vector<Slic3r::Polygon> > &extruder_box_level_polygons, const std::vector<std::vector<Slic3r::Polygon> > &extruder_box_level_polygons,
std::vector<Slic3r::Polygon> &unreachable_polygons) std::vector<Slic3r::Polygon> &unreachable_polygons)
{ {
std::vector<Slic3r::Polygon> scaled_unreachable_polygons; std::vector<std::vector<Slic3r::Polygon> > scaled_unreachable_polygons;
for (unsigned int i = 0; i < extruder_convex_level_polygons.size(); ++i) for (unsigned int i = 0; i < extruder_convex_level_polygons.size(); ++i)
{ {
std::vector<Slic3r::Polygon> scaled_level_unreachable_polygons;
extend_PolygonConvexUnreachableZone(solver_configuration, extend_PolygonConvexUnreachableZone(solver_configuration,
polygon, polygon,
extruder_convex_level_polygons[i], extruder_convex_level_polygons[i],
scaled_unreachable_polygons); scaled_level_unreachable_polygons);
scaled_unreachable_polygons.push_back(scaled_level_unreachable_polygons);
} }
for (unsigned int i = 0; i < extruder_box_level_polygons.size(); ++i) for (unsigned int i = 0; i < extruder_box_level_polygons.size(); ++i)
{ {
std::vector<Slic3r::Polygon> scaled_level_unreachable_polygons;
extend_PolygonBoxUnreachableZone(solver_configuration, extend_PolygonBoxUnreachableZone(solver_configuration,
polygon, polygon,
extruder_box_level_polygons[i], extruder_box_level_polygons[i],
scaled_unreachable_polygons); scaled_level_unreachable_polygons);
scaled_unreachable_polygons.push_back(scaled_level_unreachable_polygons);
} }
scaled_unreachable_polygons = simplify_UnreachableZonePolygons(scaled_unreachable_polygons);
for (unsigned int i = 0; i < scaled_unreachable_polygons.size(); ++i) for (unsigned int i = 0; i < scaled_unreachable_polygons.size(); ++i)
{ {
Polygon scale_down_polygon; for (unsigned int j = 0; j < scaled_unreachable_polygons[i].size(); ++j)
{
Polygon scale_down_polygon;
scaleDown_PolygonForSequentialSolver(scaled_unreachable_polygons[i], scaleDown_PolygonForSequentialSolver(scaled_unreachable_polygons[i][j],
scale_down_polygon); scale_down_polygon);
scale_down_polygon.make_counter_clockwise(); scale_down_polygon.make_counter_clockwise();
unreachable_polygons.push_back(scale_down_polygon); unreachable_polygons.push_back(scale_down_polygon);
}
} }
} }
@ -816,40 +824,48 @@ void prepare_UnreachableZonePolygons(const SolverConfiguration
const std::vector<std::vector<Slic3r::Polygon> > &extruder_box_level_polygons, const std::vector<std::vector<Slic3r::Polygon> > &extruder_box_level_polygons,
std::vector<Slic3r::Polygon> &unreachable_polygons) std::vector<Slic3r::Polygon> &unreachable_polygons)
{ {
std::vector<Slic3r::Polygon> scaled_unreachable_polygons; std::vector<std::vector<Slic3r::Polygon> > scaled_unreachable_polygons;
assert(extruder_convex_level_polygons.size() == convex_level_polygons.size()); assert(extruder_convex_level_polygons.size() == convex_level_polygons.size());
for (unsigned int i = 0; i < extruder_convex_level_polygons.size(); ++i) for (unsigned int i = 0; i < extruder_convex_level_polygons.size(); ++i)
{ {
extend_PolygonConvexUnreachableZone(solver_configuration, std::vector<Slic3r::Polygon> scaled_level_unreachable_polygons;
convex_level_polygons[i], extend_PolygonConvexUnreachableZone(solver_configuration,
extruder_convex_level_polygons[i], convex_level_polygons[i],
scaled_unreachable_polygons); extruder_convex_level_polygons[i],
scaled_level_unreachable_polygons);
scaled_unreachable_polygons.push_back(scaled_level_unreachable_polygons);
} }
assert(extruder_box_level_polygons.size() == box_level_polygons.size()); assert(extruder_box_level_polygons.size() == box_level_polygons.size());
for (unsigned int i = 0; i < extruder_box_level_polygons.size(); ++i) for (unsigned int i = 0; i < extruder_box_level_polygons.size(); ++i)
{ {
std::vector<Slic3r::Polygon> scaled_level_unreachable_polygons;
extend_PolygonBoxUnreachableZone(solver_configuration, extend_PolygonBoxUnreachableZone(solver_configuration,
box_level_polygons[i], box_level_polygons[i],
extruder_box_level_polygons[i], extruder_box_level_polygons[i],
scaled_unreachable_polygons); scaled_level_unreachable_polygons);
scaled_unreachable_polygons.push_back(scaled_level_unreachable_polygons);
} }
scaled_unreachable_polygons = simplify_UnreachableZonePolygons(scaled_unreachable_polygons);
for (unsigned int i = 0; i < scaled_unreachable_polygons.size(); ++i) for (unsigned int i = 0; i < scaled_unreachable_polygons.size(); ++i)
{ {
Polygon scale_down_polygon; for (unsigned int j = 0; j < scaled_unreachable_polygons[i].size(); ++j)
{
scaleDown_PolygonForSequentialSolver(scaled_unreachable_polygons[i], Polygon scale_down_polygon;
scale_down_polygon);
scale_down_polygon.make_counter_clockwise(); scaleDown_PolygonForSequentialSolver(scaled_unreachable_polygons[i][j],
unreachable_polygons.push_back(scale_down_polygon); scale_down_polygon);
scale_down_polygon.make_counter_clockwise();
unreachable_polygons.push_back(scale_down_polygon);
}
} }
} }
bool check_PolygonSize(const SolverConfiguration &solver_configuration, const Slic3r::Polygon &polygon) bool check_PolygonSizeFitToPlate(const SolverConfiguration &solver_configuration, const Slic3r::Polygon &polygon)
{ {
BoundingBox polygon_box = get_extents(polygon); BoundingBox polygon_box = get_extents(polygon);
@ -869,7 +885,7 @@ bool check_PolygonSize(const SolverConfiguration &solver_configuration, const Sl
} }
bool check_PolygonSize(const SolverConfiguration &solver_configuration, coord_t scale_factor, const Slic3r::Polygon &polygon) bool check_PolygonSizeFitToPlate(const SolverConfiguration &solver_configuration, coord_t scale_factor, const Slic3r::Polygon &polygon)
{ {
BoundingBox polygon_box = get_extents(polygon); BoundingBox polygon_box = get_extents(polygon);
@ -889,6 +905,73 @@ bool check_PolygonSize(const SolverConfiguration &solver_configuration, coord_t
} }
/*----------------------------------------------------------------*/
bool check_PolygonConsumation(const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &consumer_polygons)
{
std::vector<Slic3r::Polygon> polygons_to_clip;
std::vector<Slic3r::Polygon> next_polygons_to_clip;
polygons_to_clip = polygons;
for (unsigned int poly_cons = 0; poly_cons < consumer_polygons.size(); ++poly_cons)
{
for (unsigned int clip_poly = 0; clip_poly < polygons_to_clip.size(); ++clip_poly)
{
Slic3r::Polygons clip_result;
clip_result = diff(polygons_to_clip[clip_poly], consumer_polygons[poly_cons]);
for (const auto& clipped_polygon: clip_result)
{
next_polygons_to_clip.push_back(clipped_polygon);
}
}
polygons_to_clip = next_polygons_to_clip;
}
if (polygons_to_clip.empty())
{
return true;
}
return false;
}
std::vector<std::vector<Slic3r::Polygon> > simplify_UnreachableZonePolygons(const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons)
{
std::vector<std::vector<Slic3r::Polygon> > simplified_unreachable_polygons;
for (unsigned int i = 0; i < unreachable_polygons.size(); ++i)
{
bool consumed = false;
for (unsigned int j = 0; j < unreachable_polygons.size(); ++j)
{
if (i != j)
{
double area_i = calc_PolygonUnreachableZoneArea(unreachable_polygons[i]);
double area_j = calc_PolygonUnreachableZoneArea(unreachable_polygons[j]);
if (area_j > area_i)
{
if (check_PolygonConsumation(unreachable_polygons[i], unreachable_polygons[j]))
{
consumed = true;
break;
}
}
}
}
if (!consumed)
{
simplified_unreachable_polygons.push_back(unreachable_polygons[i]);
}
}
return simplified_unreachable_polygons;
}
void glue_LowObjects(std::vector<SolvableObject> &solvable_objects) void glue_LowObjects(std::vector<SolvableObject> &solvable_objects)
{ {
int low = 0; int low = 0;
@ -900,18 +983,15 @@ void glue_LowObjects(std::vector<SolvableObject> &solvable_objects)
if (2 * polygon_area > unreachable_area) if (2 * polygon_area > unreachable_area)
{ {
printf("Low: %d\n", solvable_objects[i].id);
if (++low >= 2) if (++low >= 2)
{ {
assert(i > 0); assert(i > 0);
printf("---> gluing: %d -> %d\n", solvable_objects[i-1].id, solvable_objects[i].id);
solvable_objects[i-1].lepox_to_next = true; solvable_objects[i-1].lepox_to_next = true;
low = 1; low = 1;
} }
} }
else else
{ {
printf("noLow: %d\n", solvable_objects[i].id);
low = 0; low = 0;
} }
} }
@ -937,6 +1017,27 @@ double calc_PolygonArea(const Slic3r::Polygon &polygon)
} }
double calc_PolygonUnreachableZoneArea(const std::vector<Slic3r::Polygon> &unreachable_polygons)
{
Polygons overlapping_polygons;
for (const auto& unreachable_polygon: unreachable_polygons)
{
overlapping_polygons.push_back(unreachable_polygon);
}
ExPolygons union_polygons = union_ex(overlapping_polygons);
double area = 0;
for (const auto& union_polygon: union_polygons)
{
area += union_polygon.area();
}
return area;
}
double calc_PolygonUnreachableZoneArea(const Slic3r::Polygon &polygon, double calc_PolygonUnreachableZoneArea(const Slic3r::Polygon &polygon,
const std::vector<Slic3r::Polygon> &unreachable_polygons) const std::vector<Slic3r::Polygon> &unreachable_polygons)
{ {

244
src/libseqarrange/src/seq_sequential.cpp
View File

@ -9,6 +9,8 @@
*/ */
/*================================================================*/ /*================================================================*/
#include <libslic3r/Geometry/ConvexHull.hpp>
#include "seq_defs.hpp" #include "seq_defs.hpp"
#include "seq_sequential.hpp" #include "seq_sequential.hpp"
@ -2895,6 +2897,92 @@ void introduce_ConsequentialPolygonExternalFixedPolygon(z3::solver
} }
void introduce_ConsequentialPolygonExternalFixedGroupPolygon(z3::solver &Solver,
z3::context &Context,
const z3::expr &dec_var_X1,
const z3::expr &dec_var_Y1,
const z3::expr &dec_var_T1,
const Slic3r::Polygon &polygon,
const std::vector<Slic3r::Polygon> &unreachable_polygons,
const Rational &dec_value_group_min_T,
const Rational &dec_value_group_max_T,
const Slic3r::Polygon &group_polygon,
const std::vector<Slic3r::Polygon> &group_unreachable_polygons)
{
for (unsigned int poly2 = 0; poly2 < group_unreachable_polygons.size(); ++poly2)
{
for (unsigned int p1 = 0; p1 < polygon.points.size(); ++p1)
{
const Point &point1 = polygon.points[p1];
introduce_ConsequentialPointOutsideFixedPolygon(Solver,
Context,
dec_var_X1 + point1.x(),
dec_var_Y1 + point1.y(),
dec_var_T1,
Rational(0),
Rational(0),
dec_value_group_min_T,
group_unreachable_polygons[poly2]);
}
}
for (unsigned int poly2 = 0; poly2 < group_unreachable_polygons.size(); ++poly2)
{
for (unsigned int p2 = 0; p2 < group_unreachable_polygons[poly2].points.size(); ++p2)
{
const Point &pro_point2 = group_unreachable_polygons[poly2].points[p2];
introduce_ConsequentialFixedPointOutsidePolygon(Solver,
Context,
pro_point2.x(),
pro_point2.y(),
dec_var_T1,
dec_var_X1,
dec_var_Y1,
dec_value_group_min_T,
polygon);
}
}
for (unsigned int poly1 = 0; poly1 < unreachable_polygons.size(); ++poly1)
{
for (unsigned int p2 = 0; p2 < group_polygon.points.size(); ++p2)
{
const Point &point2 = group_polygon.points[p2];
introduce_ConsequentialFixedPointOutsidePolygon(Solver,
Context,
point2.x(),
point2.y(),
dec_value_group_max_T,
dec_var_X1,
dec_var_Y1,
dec_var_T1,
unreachable_polygons[poly1]);
}
}
for (unsigned int poly1 = 0; poly1 < unreachable_polygons.size(); ++poly1)
{
for (unsigned int p1 = 0; p1 < unreachable_polygons[poly1].points.size(); ++p1)
{
const Point &pro_point1 = unreachable_polygons[poly1].points[p1];
introduce_ConsequentialPointOutsideFixedPolygon(Solver,
Context,
dec_var_X1 + pro_point1.x(),
dec_var_Y1 + pro_point1.y(),
dec_value_group_max_T,
Rational(0),
Rational(0),
dec_var_T1,
group_polygon);
}
}
}
/*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/
void introduce_PolygonWeakNonoverlapping(z3::solver &Solver, void introduce_PolygonWeakNonoverlapping(z3::solver &Solver,
@ -3171,7 +3259,8 @@ void introduce_SequentialPolygonWeakNonoverlapping(z3::solver
} }
void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver &Solver, void introduce_ConsequentialPolygonWeakNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const z3::expr_vector &dec_vars_X, const z3::expr_vector &dec_vars_X,
const z3::expr_vector &dec_vars_Y, const z3::expr_vector &dec_vars_Y,
@ -3192,7 +3281,8 @@ void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver
_unreachable_polygons[poly].push_back(unreachable_polygons[poly]); _unreachable_polygons[poly].push_back(unreachable_polygons[poly]);
} }
introduce_ConsequentialPolygonWeakNonoverlapping(Solver, introduce_ConsequentialPolygonWeakNonoverlapping(solver_configuration,
Solver,
Context, Context,
dec_vars_X, dec_vars_X,
dec_vars_Y, dec_vars_Y,
@ -3207,7 +3297,8 @@ void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver
} }
void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver &Solver, void introduce_ConsequentialPolygonWeakNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const z3::expr_vector &dec_vars_X, const z3::expr_vector &dec_vars_X,
const z3::expr_vector &dec_vars_Y, const z3::expr_vector &dec_vars_Y,
@ -3219,7 +3310,7 @@ void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver
const std::vector<int> &undecided, const std::vector<int> &undecided,
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons) const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons)
{ {
for (unsigned int i = 0; i < undecided.size() - 1; ++i) for (unsigned int i = 0; i < undecided.size() - 1; ++i)
{ {
for (unsigned int j = i + 1; j < undecided.size(); ++j) for (unsigned int j = i + 1; j < undecided.size(); ++j)
@ -3244,27 +3335,124 @@ void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver
} }
} }
for (unsigned int i = 0; i < undecided.size(); ++i) if (fixed.size() < (unsigned int)solver_configuration.fixed_object_grouping_limit)
{ {
for (unsigned int j = 0; j < fixed.size(); ++j) for (unsigned int i = 0; i < undecided.size(); ++i)
{
for (unsigned int j = 0; j < fixed.size(); ++j)
{
#ifdef DEBUG
{
printf("PoFP: %d,%d\n", undecided[i], fixed[j]);
}
#endif
introduce_ConsequentialPolygonExternalFixedPolygon(Solver,
Context,
dec_vars_X[undecided[i]],
dec_vars_Y[undecided[i]],
dec_vars_T[undecided[i]],
polygons[undecided[i]],
unreachable_polygons[undecided[i]],
dec_values_X[fixed[j]],
dec_values_Y[fixed[j]],
dec_values_T[fixed[j]],
polygons[fixed[j]],
unreachable_polygons[fixed[j]]);
}
}
}
else
{
for (unsigned int i = 0; i < undecided.size(); ++i)
{
for (unsigned int j = fixed.size() - (unsigned int)solver_configuration.fixed_object_grouping_limit; j < fixed.size(); ++j)
{
#ifdef DEBUG
{
printf("PoFP: %d,%d\n", undecided[i], fixed[j]);
}
#endif
introduce_ConsequentialPolygonExternalFixedPolygon(Solver,
Context,
dec_vars_X[undecided[i]],
dec_vars_Y[undecided[i]],
dec_vars_T[undecided[i]],
polygons[undecided[i]],
unreachable_polygons[undecided[i]],
dec_values_X[fixed[j]],
dec_values_Y[fixed[j]],
dec_values_T[fixed[j]],
polygons[fixed[j]],
unreachable_polygons[fixed[j]]);
}
}
Slic3r::Polygons flat_polygons;
for (unsigned int i = 0; i < fixed.size() - (unsigned int)solver_configuration.fixed_object_grouping_limit; ++i)
{
Polygon fixed_polygon = polygons[fixed[i]];
for (unsigned int p = 0; p < fixed_polygon.points.size(); ++p)
{
fixed_polygon.points[p] += Point(dec_values_X[fixed[i]].as_double(), dec_values_Y[fixed[i]].as_double());
}
flat_polygons.push_back(fixed_polygon);
}
Slic3r::Polygons flat_unreachable_polygons;
for (unsigned int i = 0; i < fixed.size() - (unsigned int)solver_configuration.fixed_object_grouping_limit; ++i)
{
for (unsigned int j = 0; j < unreachable_polygons[fixed[i]].size(); ++j)
{
Polygon fixed_polygon = unreachable_polygons[fixed[i]][j];
for (unsigned int p = 0; p < fixed_polygon.points.size(); ++p)
{
fixed_polygon.points[p] += Point(dec_values_X[fixed[i]].as_double(), dec_values_Y[fixed[i]].as_double());
}
flat_unreachable_polygons.push_back(fixed_polygon);
}
}
Polygon flat_hull = Slic3r::Geometry::convex_hull(flat_polygons);
Polygon flat_unreachable_hull = Slic3r::Geometry::convex_hull(flat_unreachable_polygons);
std::vector<Slic3r::Polygon> flat_unreachable_hulls;
flat_unreachable_hulls.push_back(flat_unreachable_hull);
assert(!fixed.empty());
Rational dec_value_flat_min_T = dec_values_T[fixed[0]];
Rational dec_value_flat_max_T = dec_values_T[fixed[0]];
for (unsigned int i = 1; i < fixed.size() - (unsigned int)solver_configuration.fixed_object_grouping_limit; ++i)
{
if (dec_values_T[fixed[i]] < dec_value_flat_min_T)
{
dec_value_flat_min_T = dec_values_T[fixed[i]];
}
if (dec_values_T[fixed[i]] > dec_value_flat_max_T)
{
dec_value_flat_max_T = dec_values_T[fixed[i]];
}
}
for (unsigned int i = 0; i < undecided.size(); ++i)
{ {
#ifdef DEBUG #ifdef DEBUG
{ {
printf("PoFP: %d,%d\n", undecided[i], fixed[j]); printf("PoGROUP: %d\n", undecided[i]);
} }
#endif #endif
introduce_ConsequentialPolygonExternalFixedPolygon(Solver,
Context, introduce_ConsequentialPolygonExternalFixedGroupPolygon(Solver,
dec_vars_X[undecided[i]], Context,
dec_vars_Y[undecided[i]], dec_vars_X[undecided[i]],
dec_vars_T[undecided[i]], dec_vars_Y[undecided[i]],
polygons[undecided[i]], dec_vars_T[undecided[i]],
unreachable_polygons[undecided[i]], polygons[undecided[i]],
dec_values_X[fixed[j]], unreachable_polygons[undecided[i]],
dec_values_Y[fixed[j]], dec_value_flat_min_T,
dec_values_T[fixed[j]], dec_value_flat_max_T,
polygons[fixed[j]], flat_hull,
unreachable_polygons[fixed[j]]); flat_unreachable_hulls);
} }
} }
} }
@ -6766,7 +6954,8 @@ void build_SequentialWeakPolygonNonoverlapping(z3::solver
} }
void build_ConsequentialWeakPolygonNonoverlapping(z3::solver &Solver, void build_ConsequentialWeakPolygonNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<Slic3r::Polygon> &unreachable_polygons, const std::vector<Slic3r::Polygon> &unreachable_polygons,
@ -6788,7 +6977,8 @@ void build_ConsequentialWeakPolygonNonoverlapping(z3::solver
_unreachable_polygons[poly].push_back(unreachable_polygons[poly]); _unreachable_polygons[poly].push_back(unreachable_polygons[poly]);
} }
build_ConsequentialWeakPolygonNonoverlapping(Solver, build_ConsequentialWeakPolygonNonoverlapping(solver_configuration,
Solver,
Context, Context,
polygons, polygons,
_unreachable_polygons, _unreachable_polygons,
@ -6804,7 +6994,8 @@ void build_ConsequentialWeakPolygonNonoverlapping(z3::solver
} }
void build_ConsequentialWeakPolygonNonoverlapping(z3::solver &Solver, void build_ConsequentialWeakPolygonNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons, const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons,
@ -6842,7 +7033,8 @@ void build_ConsequentialWeakPolygonNonoverlapping(z3::solver
dec_var_names_map[name] = i; dec_var_names_map[name] = i;
} }
introduce_ConsequentialPolygonWeakNonoverlapping(Solver, introduce_ConsequentialPolygonWeakNonoverlapping(solver_configuration,
Solver,
Context, Context,
dec_vars_X, dec_vars_X,
dec_vars_Y, dec_vars_Y,
@ -10085,7 +10277,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
build_start = clock(); build_start = clock();
} }
#endif #endif
build_ConsequentialWeakPolygonNonoverlapping(z_solver, build_ConsequentialWeakPolygonNonoverlapping(solver_configuration,
z_solver,
z_context, z_context,
polygons, polygons,
unreachable_polygons, unreachable_polygons,
@ -10368,7 +10561,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
} }
#endif #endif
build_ConsequentialWeakPolygonNonoverlapping(z_solver, build_ConsequentialWeakPolygonNonoverlapping(solver_configuration,
z_solver,
z_context, z_context,
polygons, polygons,
unreachable_polygons, unreachable_polygons,

12
src/libseqarrange/src/seq_sequential.hpp
View File

@ -994,7 +994,8 @@ void introduce_SequentialPolygonWeakNonoverlapping(z3::solver
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons); const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons);
void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver &Solver, void introduce_ConsequentialPolygonWeakNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const z3::expr_vector &dec_vars_X, const z3::expr_vector &dec_vars_X,
const z3::expr_vector &dec_vars_Y, const z3::expr_vector &dec_vars_Y,
@ -1007,7 +1008,8 @@ void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<Slic3r::Polygon> &unreachable_polygons); const std::vector<Slic3r::Polygon> &unreachable_polygons);
void introduce_ConsequentialPolygonWeakNonoverlapping(z3::solver &Solver, void introduce_ConsequentialPolygonWeakNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const z3::expr_vector &dec_vars_X, const z3::expr_vector &dec_vars_X,
const z3::expr_vector &dec_vars_Y, const z3::expr_vector &dec_vars_Y,
@ -1339,7 +1341,8 @@ void build_SequentialWeakPolygonNonoverlapping(z3::solver
const std::vector<int> &undecided, const std::vector<int> &undecided,
string_map &dec_var_names_map); string_map &dec_var_names_map);
void build_ConsequentialWeakPolygonNonoverlapping(z3::solver &Solver, void build_ConsequentialWeakPolygonNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<Slic3r::Polygon> &unreachable_polygons, const std::vector<Slic3r::Polygon> &unreachable_polygons,
@ -1353,7 +1356,8 @@ void build_ConsequentialWeakPolygonNonoverlapping(z3::solver
const std::vector<int> &undecided, const std::vector<int> &undecided,
string_map &dec_var_names_map); string_map &dec_var_names_map);
void build_ConsequentialWeakPolygonNonoverlapping(z3::solver &Solver, void build_ConsequentialWeakPolygonNonoverlapping(const SolverConfiguration &solver_configuration,
z3::solver &Solver,
z3::context &Context, z3::context &Context,
const std::vector<Slic3r::Polygon> &polygons, const std::vector<Slic3r::Polygon> &polygons,
const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons, const std::vector<std::vector<Slic3r::Polygon> > &unreachable_polygons,

4
src/libseqarrange/src/sequential_prusa.cpp
View File

@ -242,7 +242,6 @@ int solve_SequentialPrint(const CommandParameters &command_parameters)
if (!objects_to_print[i].pgns_at_height[j].second.points.empty()) if (!objects_to_print[i].pgns_at_height[j].second.points.empty())
{ {
Polygon decimated_polygon; Polygon decimated_polygon;
//ground_PolygonByFirstPoint(objects_to_print[i].pgns_at_height[j].second);
if (command_parameters.decimation) if (command_parameters.decimation)
{ {
@ -264,7 +263,7 @@ int solve_SequentialPrint(const CommandParameters &command_parameters)
decimated_polygon = objects_to_print[i].pgns_at_height[j].second; decimated_polygon = objects_to_print[i].pgns_at_height[j].second;
decimated_polygon.make_counter_clockwise(); decimated_polygon.make_counter_clockwise();
} }
if (!check_PolygonSize(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon)) if (!check_PolygonSizeFitToPlate(solver_configuration, SEQ_SLICER_SCALE_FACTOR, decimated_polygon))
{ {
printf("Object too large to fit onto plate [ID:%d RID:%d].\n", original_index_map[i], i); printf("Object too large to fit onto plate [ID:%d RID:%d].\n", original_index_map[i], i);
return -1; return -1;
@ -362,7 +361,6 @@ int solve_SequentialPrint(const CommandParameters &command_parameters)
vector<int> remaining_polygons; vector<int> remaining_polygons;
vector<int> polygon_index_map; vector<int> polygon_index_map;
//vector<int> original_index_map;
vector<int> decided_polygons; vector<int> decided_polygons;
for (unsigned int index = 0; index < polygons.size(); ++index) for (unsigned int index = 0; index < polygons.size(); ++index)