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

Adding consistency tests for automated testing, found bug in progress bar - trying to fix it (almost done).

Browse Source
This commit is contained in:
surynek 2024-11-28 17:31:01 +01:00 committed by Lukas Matena
parent c65315ce5a
commit 3c40a68f16
4 changed files with 138 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -380,7 +380,8 @@ void schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver
#endif #endif
int progress_objects_done = 0; int progress_objects_done = 0;
int progress_objects_total = objects_to_print.size(); int progress_object_phases_done = 0;
int progress_object_phases_total = objects_to_print.size() * SEQ_PROGRESS_PHASES_PER_OBJECT;
do do
{ {
@ -396,7 +397,8 @@ void schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver
#endif #endif
bool optimized; bool optimized;
printf("Object phases A1: %d, %d\n", progress_object_phases_done, solvable_objects.size());
optimized = optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(solver_configuration, optimized = optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(solver_configuration,
poly_positions_X, poly_positions_X,
poly_positions_Y, poly_positions_Y,
@ -404,9 +406,10 @@ void schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver
solvable_objects, solvable_objects,
decided_polygons, decided_polygons,
remaining_polygons, remaining_polygons,
progress_objects_done, progress_object_phases_done,
progress_objects_total, progress_object_phases_total,
progress_callback); progress_callback);
printf("Object phases A2: %d,%d,%d\n", progress_object_phases_done, decided_polygons.size(), remaining_polygons.size());
#ifdef DEBUG #ifdef DEBUG
{ {
@ -454,7 +457,16 @@ void schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver
scheduled_plate.scheduled_objects.push_back(ScheduledObject(original_index->second, X, Y)); scheduled_plate.scheduled_objects.push_back(ScheduledObject(original_index->second, X, Y));
} }
progress_objects_done += decided_polygons.size(); printf("Object phases B: %d\n", progress_object_phases_done);
/*
if (!decided_polygons.empty())
{
progress_objects_done += decided_polygons.size();
progress_object_phases_done = (progress_object_phases_done % SEQ_PROGRESS_PHASES_PER_OBJECT)
+ progress_objects_done * SEQ_PROGRESS_PHASES_PER_OBJECT;
}
printf("Object phases B1: %d\n", progress_object_phases_done);
*/
} }
else else
{ {
@ -771,7 +783,8 @@ int schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver_
#endif #endif
int progress_objects_done = 0; int progress_objects_done = 0;
int progress_objects_total = objects_to_print.size(); int progress_object_phases_done = 0;
int progress_object_phases_total = objects_to_print.size() * SEQ_PROGRESS_PHASES_PER_OBJECT;
do do
{ {
@ -795,8 +808,8 @@ int schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver_
solvable_objects, solvable_objects,
decided_polygons, decided_polygons,
remaining_polygons, remaining_polygons,
progress_objects_done, progress_object_phases_done,
progress_objects_total, progress_object_phases_total,
progress_callback); progress_callback);
#ifdef DEBUG #ifdef DEBUG
@ -845,7 +858,11 @@ int schedule_ObjectsForSequentialPrint(const SolverConfiguration &solver_
scheduled_plate.scheduled_objects.push_back(ScheduledObject(original_index->second, X, Y)); scheduled_plate.scheduled_objects.push_back(ScheduledObject(original_index->second, X, Y));
} }
progress_objects_done += decided_polygons.size(); if (!decided_polygons.empty())
{
progress_objects_done += decided_polygons.size();
progress_object_phases_done = progress_objects_done * SEQ_PROGRESS_PHASES_PER_OBJECT;
}
} }
else else
{ {

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

@ -8860,7 +8860,8 @@ bool optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z3::solver
const ProgressRange &progress_range, const ProgressRange &progress_range,
std::function<void(int)> progress_callback) std::function<void(int)> progress_callback)
{ {
z3::set_param("timeout", solver_configuration.optimization_timeout.c_str()); z3::set_param("timeout", solver_configuration.optimization_timeout.c_str());
printf("Progress range: %d -- %d\n", progress_range.progress_min, progress_range.progress_max);
coord_t last_solvable_bounding_box_size = -1; coord_t last_solvable_bounding_box_size = -1;
@ -8874,7 +8875,7 @@ bool optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z3::solver
coord_t half_y_min = 0; coord_t half_y_min = 0;
coord_t half_y_max = box_half_y_max; coord_t half_y_max = box_half_y_max;
int progress_total_estimation = MAX(1,std::log2(half_x_max - half_x_min)); int progress_total_estimation = MAX(1, std::log2(half_x_max - half_x_min));
int progress = 0; int progress = 0;
while ((half_x_max - half_x_min) > 1 && (half_y_max - half_y_min) > 1) while ((half_x_max - half_x_min) > 1 && (half_y_max - half_y_min) > 1)
@ -9106,7 +9107,7 @@ bool optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z3::solver
printf("Printing solver status:\n"); printf("Printing solver status:\n");
cout << Solver << "\n"; cout << Solver << "\n";
*/ */
progress_callback(progress_range.progress_min + (progress_range.progress_max - progress_range.progress_min) * progress / progress_total_estimation); progress_callback(progress_range.progress_min + (progress_range.progress_max - progress_range.progress_min) * progress / progress_total_estimation);
if (refined_sat) if (refined_sat)
{ {
@ -9212,7 +9213,7 @@ bool optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z3::solver
} }
#endif #endif
++progress; progress = MIN(progress + 1, progress_total_estimation);
progress_callback(progress_range.progress_min + (progress_range.progress_max - progress_range.progress_min) * progress / progress_total_estimation); progress_callback(progress_range.progress_min + (progress_range.progress_max - progress_range.progress_min) * progress / progress_total_estimation);
} }
progress_callback(progress_range.progress_max); progress_callback(progress_range.progress_max);
@ -10262,8 +10263,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
const std::vector<int> &undecided_polygons, const std::vector<int> &undecided_polygons,
std::vector<int> &decided_polygons, std::vector<int> &decided_polygons,
std::vector<int> &remaining_polygons, std::vector<int> &remaining_polygons,
int progress_objects_done, int &progress_object_phases_done,
int progress_total_objects, int progress_total_object_phases,
std::function<void(int)> progress_callback) std::function<void(int)> progress_callback)
{ {
std::vector<int> undecided; std::vector<int> undecided;
@ -10419,7 +10420,7 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
} }
#endif #endif
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_object_phases_done)) / progress_total_object_phases);
optimized = optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z_solver, optimized = optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z_solver,
z_context, z_context,
@ -10438,8 +10439,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
polygons, polygons,
unreachable_polygons, unreachable_polygons,
presence_assumptions, presence_assumptions,
ProgressRange((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects, ProgressRange((SEQ_PROGRESS_RANGE * (decided_polygons.size() * SEQ_PROGRESS_PHASES_PER_OBJECT + progress_object_phases_done)) / progress_total_object_phases,
(SEQ_PROGRESS_RANGE * (decided_polygons.size() + (progress_objects_done + 1))) / progress_total_objects), (SEQ_PROGRESS_RANGE * (decided_polygons.size() * SEQ_PROGRESS_PHASES_PER_OBJECT + (progress_object_phases_done + 1))) / progress_total_object_phases),
progress_callback); progress_callback);
if (optimized) if (optimized)
@ -10467,11 +10468,10 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
} }
else else
{ {
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() * SEQ_PROGRESS_PHASES_PER_OBJECT + progress_object_phases_done)) / progress_total_object_phases);
return true; return true;
} }
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() * SEQ_PROGRESS_PHASES_PER_OBJECT + progress_object_phases_done)) / progress_total_object_phases);
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects);
break; break;
} }
else else
@ -10481,13 +10481,14 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
printf("Remaining polygon: %d\n", curr_polygon + object_group_size - 1); printf("Remaining polygon: %d\n", curr_polygon + object_group_size - 1);
} }
#endif #endif
++progress_object_phases_done;
remaining_local.push_back(undecided_polygons[curr_polygon + object_group_size - 1]); remaining_local.push_back(undecided_polygons[curr_polygon + object_group_size - 1]);
} }
missing.push_back(undecided.back()); missing.push_back(undecided.back());
undecided.pop_back(); undecided.pop_back();
--object_group_size; --object_group_size;
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() * SEQ_PROGRESS_PHASES_PER_OBJECT + progress_object_phases_done)) / progress_total_object_phases);
} }
std::reverse(remaining_local.begin(), remaining_local.end()); std::reverse(remaining_local.begin(), remaining_local.end());
@ -10534,8 +10535,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
const std::vector<SolvableObject> &solvable_objects, const std::vector<SolvableObject> &solvable_objects,
std::vector<int> &decided_polygons, std::vector<int> &decided_polygons,
std::vector<int> &remaining_polygons, std::vector<int> &remaining_polygons,
int progress_objects_done, int &progress_object_phases_done,
int progress_total_objects, int progress_total_object_phases,
std::function<void(int)> progress_callback) std::function<void(int)> progress_callback)
{ {
std::vector<int> undecided; std::vector<int> undecided;
@ -10703,8 +10704,9 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
} }
#endif #endif
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); printf("Top call 1\n");
progress_callback((SEQ_PROGRESS_RANGE * progress_object_phases_done) / progress_total_object_phases);
optimized = optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z_solver, optimized = optimize_ConsequentialWeakPolygonNonoverlappingBinaryCentered(z_solver,
z_context, z_context,
solver_configuration, solver_configuration,
@ -10722,12 +10724,14 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
polygons, polygons,
unreachable_polygons, unreachable_polygons,
presence_assumptions, presence_assumptions,
ProgressRange((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects, ProgressRange((SEQ_PROGRESS_RANGE * progress_object_phases_done) / progress_total_object_phases,
(SEQ_PROGRESS_RANGE * (decided_polygons.size() + (progress_objects_done + 1))) / progress_total_objects), (SEQ_PROGRESS_RANGE * (progress_object_phases_done + SEQ_PROGRESS_PHASES_PER_OBJECT / 2)) / progress_total_object_phases),
progress_callback); progress_callback);
printf("Optimo: %d\n", optimized);
if (optimized) if (optimized)
{ {
printf("alpha 1\n");
/* /*
printf("Printing solver status:\n"); printf("Printing solver status:\n");
cout << z_solver << "\n"; cout << z_solver << "\n";
@ -10742,6 +10746,9 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
dec_values_Y[undecided[i]] = local_values_Y[undecided[i]]; dec_values_Y[undecided[i]] = local_values_Y[undecided[i]];
dec_values_T[undecided[i]] = local_values_T[undecided[i]]; dec_values_T[undecided[i]] = local_values_T[undecided[i]];
decided_polygons.push_back(undecided[i]); decided_polygons.push_back(undecided[i]);
int progress_phase_starter = progress_object_phases_done % SEQ_PROGRESS_PHASES_PER_OBJECT;
progress_object_phases_done += progress_phase_starter > 0 ? SEQ_PROGRESS_PHASES_PER_OBJECT - progress_phase_starter : SEQ_PROGRESS_PHASES_PER_OBJECT;
} }
augment_TemporalSpread(solver_configuration, dec_values_T, decided_polygons); augment_TemporalSpread(solver_configuration, dec_values_T, decided_polygons);
@ -10751,27 +10758,32 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
} }
else else
{ {
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); printf("Top call 2\n");
progress_callback((SEQ_PROGRESS_RANGE * progress_object_phases_done) / progress_total_object_phases);
return true; return true;
} }
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); printf("Top call 3\n");
progress_callback((SEQ_PROGRESS_RANGE * progress_object_phases_done) / progress_total_object_phases);
break; break;
} }
else else
{ {
printf("alpha 2\n");
#ifdef DEBUG #ifdef DEBUG
{ {
printf("Remaining polygon: %d\n", curr_polygon + object_group_size - 1); printf("Remaining polygon: %d\n", curr_polygon + object_group_size - 1);
} }
#endif #endif
printf("Phase increasing\n");
remaining_local.push_back(undecided.back()); remaining_local.push_back(undecided.back());
} }
missing.push_back(undecided.back()); missing.push_back(undecided.back());
undecided.pop_back(); undecided.pop_back();
--object_group_size; --object_group_size;
progress_callback((SEQ_PROGRESS_RANGE * (decided_polygons.size() + progress_objects_done)) / progress_total_objects); printf("Top call 4\n");
progress_callback((SEQ_PROGRESS_RANGE * progress_object_phases_done) / progress_total_object_phases);
} }
std::reverse(remaining_local.begin(), remaining_local.end()); std::reverse(remaining_local.begin(), remaining_local.end());
@ -10800,12 +10812,15 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
remaining_polygons.push_back(curr_polygon); remaining_polygons.push_back(curr_polygon);
} }
} }
progress_object_phases_done += SEQ_PROGRESS_PHASES_PER_OBJECT / 2;
printf("Complete exit\n");
return true; return true;
} }
} }
assert(remaining_polygons.empty()); assert(remaining_polygons.empty());
} }
assert(remaining_polygons.empty()); assert(remaining_polygons.empty());
printf("Complete exit 2\n");
return true; return true;
} }

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

@ -55,9 +55,10 @@ namespace Sequential
#define SEQ_Z3_SOLVER_TIMEOUT "8000" #define SEQ_Z3_SOLVER_TIMEOUT "8000"
const coord_t SEQ_SVG_SCALE_FACTOR = 50000; const coord_t SEQ_SVG_SCALE_FACTOR = 50000;
const int SEQ_GROUND_PRESENCE_TIME = 32; const int SEQ_GROUND_PRESENCE_TIME = 32;
const int SEQ_PROGRESS_RANGE = 100; const int SEQ_PROGRESS_RANGE = 100;
const int SEQ_PROGRESS_PHASES_PER_OBJECT = 2;
const int64_t SEQ_RATIONAL_PRECISION = 1000000; const int64_t SEQ_RATIONAL_PRECISION = 1000000;
const double SEQ_DECIMATION_TOLERANCE = 400000.0; const double SEQ_DECIMATION_TOLERANCE = 400000.0;
@ -1598,8 +1599,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
const std::vector<int> &undecided_polygons, const std::vector<int> &undecided_polygons,
std::vector<int> &decided_polygons, std::vector<int> &decided_polygons,
std::vector<int> &remaining_polygons, std::vector<int> &remaining_polygons,
int progress_objects_done, int &progress_object_phases_done,
int progress_total_objects, int progress_total_object_phases,
std::function<void(int)> progress_callback = [](int progress){}); std::function<void(int)> progress_callback = [](int progress){});
bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const SolverConfiguration &solver_configuration, bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const SolverConfiguration &solver_configuration,
@ -1609,8 +1610,8 @@ bool optimize_SubglobalConsequentialPolygonNonoverlappingBinaryCentered(const So
const std::vector<SolvableObject> &solvable_objects, const std::vector<SolvableObject> &solvable_objects,
std::vector<int> &decided_polygons, std::vector<int> &decided_polygons,
std::vector<int> &remaining_polygons, std::vector<int> &remaining_polygons,
int progress_objects_done, int &progress_object_phases_done,
int progress_total_objects, int progress_total_object_phases,
std::function<void(int)> progress_callback = [](int progress){}); std::function<void(int)> progress_callback = [](int progress){});
/*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/

84
src/libseqarrange/test/seq_test_interface.cpp
View File

@ -114,7 +114,7 @@ void save_import_data(const std::string &filename,
/*----------------------------------------------------------------*/ /*----------------------------------------------------------------*/
/*
TEST_CASE("Interface test 1", "[Sequential Arrangement Interface]") TEST_CASE("Interface test 1", "[Sequential Arrangement Interface]")
{ {
clock_t start, finish; clock_t start, finish;
@ -128,33 +128,43 @@ TEST_CASE("Interface test 1", "[Sequential Arrangement Interface]")
printf("Loading objects ...\n"); printf("Loading objects ...\n");
std::vector<ObjectToPrint> objects_to_print = load_exported_data("arrange_data_export.txt"); std::vector<ObjectToPrint> objects_to_print = load_exported_data("arrange_data_export.txt");
REQUIRE(objects_to_print.size() > 0);
printf("Loading objects ... finished\n");
std::vector<ScheduledPlate> scheduled_plates; std::vector<ScheduledPlate> scheduled_plates;
printf("Scheduling objects for sequential print ...\n"); printf("Scheduling objects for sequential print ...\n");
int result = schedule_ObjectsForSequentialPrint(solver_configuration, int result = schedule_ObjectsForSequentialPrint(solver_configuration,
objects_to_print, objects_to_print,
scheduled_plates); scheduled_plates);
REQUIRE(result == 0);
if (result == 0) if (result == 0)
{ {
printf("Object scheduling for sequential print SUCCESSFUL !\n"); printf("Object scheduling for sequential print SUCCESSFUL !\n");
printf("Number of plates: %ld\n", scheduled_plates.size()); printf("Number of plates: %ld\n", scheduled_plates.size());
REQUIRE(scheduled_plates.size() > 0);
for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate) for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate)
{ {
printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size()); printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size());
REQUIRE(scheduled_plates[plate].scheduled_objects.size() > 0);
for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects) for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects)
{ {
cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl; cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl;
REQUIRE(scheduled_object.x >= 0);
REQUIRE(scheduled_object.x <= solver_configuration.x_plate_bounding_box_size * SEQ_SLICER_SCALE_FACTOR);
REQUIRE(scheduled_object.y >= 0);
REQUIRE(scheduled_object.y <= solver_configuration.y_plate_bounding_box_size * SEQ_SLICER_SCALE_FACTOR);
} }
} }
} }
else else
{ {
printf("Something went WRONG during sequential scheduling (code: %d)\n", result); printf("Something went WRONG during sequential scheduling (code: %d)\n", result);
} }
finish = clock(); finish = clock();
@ -192,19 +202,26 @@ TEST_CASE("Interface test 2", "[Sequential Arrangement Interface]")
box_unreachable_zones, box_unreachable_zones,
scheduled_plates); scheduled_plates);
REQUIRE(result == 0);
if (result == 0) if (result == 0)
{ {
printf("Object scheduling for sequential print SUCCESSFUL !\n"); printf("Object scheduling for sequential print SUCCESSFUL !\n");
printf("Number of plates: %ld\n", scheduled_plates.size()); printf("Number of plates: %ld\n", scheduled_plates.size());
REQUIRE(scheduled_plates.size() > 0);
for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate) for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate)
{ {
printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size()); printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size());
REQUIRE(scheduled_plates[plate].scheduled_objects.size() > 0);
for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects) for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects)
{ {
cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl; cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl;
REQUIRE(scheduled_object.x >= 0);
REQUIRE(scheduled_object.x <= solver_configuration.x_plate_bounding_box_size * SEQ_SLICER_SCALE_FACTOR);
REQUIRE(scheduled_object.y >= 0);
REQUIRE(scheduled_object.y <= solver_configuration.y_plate_bounding_box_size * SEQ_SLICER_SCALE_FACTOR);
} }
} }
} }
@ -229,7 +246,10 @@ TEST_CASE("Interface test 3", "[Sequential Arrangement Interface]")
start = clock(); start = clock();
PrinterGeometry printer_geometry; PrinterGeometry printer_geometry;
if (load_printer_geometry("printer_geometry.mk4.txt", printer_geometry) != 0) int result = load_printer_geometry("printer_geometry.mk4.txt", printer_geometry);
REQUIRE(result == 0);
if (result != 0)
{ {
printf("Printer geometry load error.\n"); printf("Printer geometry load error.\n");
return; return;
@ -237,6 +257,8 @@ TEST_CASE("Interface test 3", "[Sequential Arrangement Interface]")
printf("x_size: %d\n", printer_geometry.x_size); printf("x_size: %d\n", printer_geometry.x_size);
printf("y_size: %d\n", printer_geometry.y_size); printf("y_size: %d\n", printer_geometry.y_size);
REQUIRE(printer_geometry.x_size > 0);
REQUIRE(printer_geometry.y_size > 0);
for (const auto& convex_height: printer_geometry.convex_heights) for (const auto& convex_height: printer_geometry.convex_heights)
{ {
@ -247,8 +269,8 @@ TEST_CASE("Interface test 3", "[Sequential Arrangement Interface]")
{ {
cout << "box_height:" << box_height << endl; cout << "box_height:" << box_height << endl;
} }
printf("extruder slices:\n"); printf("extruder slices:\n");
REQUIRE(printer_geometry.extruder_slices.size() > 0);
for (std::map<coord_t, std::vector<Polygon> >::const_iterator extruder_slice = printer_geometry.extruder_slices.begin(); extruder_slice != printer_geometry.extruder_slices.end(); ++extruder_slice) for (std::map<coord_t, std::vector<Polygon> >::const_iterator extruder_slice = printer_geometry.extruder_slices.begin(); extruder_slice != printer_geometry.extruder_slices.end(); ++extruder_slice)
{ {
@ -290,7 +312,8 @@ TEST_CASE("Interface test 4", "[Sequential Arrangement Interface]")
printf("Loading printer geometry ...\n"); printf("Loading printer geometry ...\n");
int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry); int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry);
REQUIRE(result == 0);
if (result != 0) if (result != 0)
{ {
printf("Cannot load printer geometry (code: %d).\n", result); printf("Cannot load printer geometry (code: %d).\n", result);
@ -304,19 +327,25 @@ TEST_CASE("Interface test 4", "[Sequential Arrangement Interface]")
scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration, scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration,
printer_geometry, printer_geometry,
objects_to_print); objects_to_print);
printf("Object scheduling for sequential print SUCCESSFUL !\n"); printf("Object scheduling for sequential print SUCCESSFUL !\n");
printf("Number of plates: %ld\n", scheduled_plates.size()); printf("Number of plates: %ld\n", scheduled_plates.size());
REQUIRE(scheduled_plates.size() > 0);
for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate) for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate)
{ {
printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size()); printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size());
REQUIRE(scheduled_plates[plate].scheduled_objects.size() > 0);
for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects) for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects)
{ {
cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl; cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl;
REQUIRE(scheduled_object.x >= 0);
REQUIRE(scheduled_object.x <= printer_geometry.x_size);
REQUIRE(scheduled_object.y >= 0);
REQUIRE(scheduled_object.y <= printer_geometry.y_size);
} }
} }
@ -348,6 +377,7 @@ TEST_CASE("Interface test 5", "[Sequential Arrangement Interface]")
printf("Loading printer geometry ...\n"); printf("Loading printer geometry ...\n");
int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry); int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry);
REQUIRE(result == 0);
if (result != 0) if (result != 0)
{ {
printf("Cannot load printer geometry (code: %d).\n", result); printf("Cannot load printer geometry (code: %d).\n", result);
@ -362,19 +392,27 @@ TEST_CASE("Interface test 5", "[Sequential Arrangement Interface]")
scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration, scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration,
printer_geometry, printer_geometry,
objects_to_print, objects_to_print,
[](int progress) { printf("Progress: %d\n", progress); }); [](int progress) { printf("Progress: %d\n", progress);
REQUIRE(progress >= 0);
REQUIRE(progress <= 100); });
printf("Object scheduling for sequential print SUCCESSFUL !\n"); printf("Object scheduling for sequential print SUCCESSFUL !\n");
printf("Number of plates: %ld\n", scheduled_plates.size()); printf("Number of plates: %ld\n", scheduled_plates.size());
REQUIRE(scheduled_plates.size() > 0);
for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate) for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate)
{ {
printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size()); printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size());
REQUIRE(scheduled_plates[plate].scheduled_objects.size() > 0);
for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects) for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects)
{ {
cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl; cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl;
REQUIRE(scheduled_object.x >= 0);
REQUIRE(scheduled_object.x <= printer_geometry.x_size);
REQUIRE(scheduled_object.y >= 0);
REQUIRE(scheduled_object.y <= printer_geometry.y_size);
} }
} }
@ -388,9 +426,9 @@ TEST_CASE("Interface test 5", "[Sequential Arrangement Interface]")
bool printable = check_ScheduledObjectsForSequentialPrintability(solver_configuration, bool printable = check_ScheduledObjectsForSequentialPrintability(solver_configuration,
printer_geometry, printer_geometry,
objects_to_print, objects_to_print,
scheduled_plates); scheduled_plates);
printf(" Scheduled/arranged objects are sequentially printable: %s\n", (printable ? "YES" : "NO")); printf(" Scheduled/arranged objects are sequentially printable: %s\n", (printable ? "YES" : "NO"));
REQUIRE(printable);
printf("Checking sequential printability ... finished\n"); printf("Checking sequential printability ... finished\n");
@ -399,7 +437,7 @@ TEST_CASE("Interface test 5", "[Sequential Arrangement Interface]")
printf("Testing interface 5 ... finished\n"); printf("Testing interface 5 ... finished\n");
} }
*/
TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]") TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]")
{ {
@ -415,6 +453,7 @@ TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]")
printf("Loading objects ...\n"); printf("Loading objects ...\n");
std::vector<ObjectToPrint> objects_to_print = load_exported_data("arrange_data_export.txt"); std::vector<ObjectToPrint> objects_to_print = load_exported_data("arrange_data_export.txt");
REQUIRE(objects_to_print.size() > 0);
printf("Loading objects ... finished\n"); printf("Loading objects ... finished\n");
for (auto& object_to_print: objects_to_print) for (auto& object_to_print: objects_to_print)
@ -426,7 +465,7 @@ TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]")
printf("Loading printer geometry ...\n"); printf("Loading printer geometry ...\n");
int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry); int result = load_printer_geometry("../printers/printer_geometry.mk4.compatibility.txt", printer_geometry);
REQUIRE(result == 0);
if (result != 0) if (result != 0)
{ {
printf("Cannot load printer geometry (code: %d).\n", result); printf("Cannot load printer geometry (code: %d).\n", result);
@ -441,19 +480,27 @@ TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]")
scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration, scheduled_plates = schedule_ObjectsForSequentialPrint(solver_configuration,
printer_geometry, printer_geometry,
objects_to_print, objects_to_print,
[](int progress) { printf("Progress: %d\n", progress); }); [](int progress) { printf("Progress: %d\n", progress);
REQUIRE(progress >= 0);
REQUIRE(progress <= 100); });
printf("Object scheduling for sequential print SUCCESSFUL !\n"); printf("Object scheduling for sequential print SUCCESSFUL !\n");
printf("Number of plates: %ld\n", scheduled_plates.size()); printf("Number of plates: %ld\n", scheduled_plates.size());
REQUIRE(scheduled_plates.size() > 0);
for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate) for (unsigned int plate = 0; plate < scheduled_plates.size(); ++plate)
{ {
printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size()); printf(" Number of objects on plate: %ld\n", scheduled_plates[plate].scheduled_objects.size());
REQUIRE(scheduled_plates[plate].scheduled_objects.size() > 0);
for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects) for (const auto& scheduled_object: scheduled_plates[plate].scheduled_objects)
{ {
cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl; cout << " ID: " << scheduled_object.id << " X: " << scheduled_object.x << " Y: " << scheduled_object.y << endl;
REQUIRE(scheduled_object.x >= 0);
REQUIRE(scheduled_object.x <= printer_geometry.x_size);
REQUIRE(scheduled_object.y >= 0);
REQUIRE(scheduled_object.y <= printer_geometry.y_size);
} }
} }
@ -470,6 +517,7 @@ TEST_CASE("Interface test 6", "[Sequential Arrangement Interface]")
scheduled_plates); scheduled_plates);
printf(" Scheduled/arranged objects are sequentially printable: %s\n", (printable ? "YES" : "NO")); printf(" Scheduled/arranged objects are sequentially printable: %s\n", (printable ? "YES" : "NO"));
REQUIRE(printable);
printf("Checking sequential printability ... finished\n"); printf("Checking sequential printability ... finished\n");