3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-11 16:57:53 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Refactored ToolOrdering to a class,

Browse source 
layers with print_z closer than EPSILON are merged and printed together.
This commit is contained in:
bubnikv 2017-05-23 15:00:01 +02:00
parent aad9f61bad
commit ca590cb559
3 changed files with 200 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

227
xs/src/libslic3r/GCode/ToolOrdering.cpp
View file

@ -1,15 +1,113 @@
#include "ToolOrdering.hpp"
#include <assert.h>
namespace Slic3r {
namespace ToolOrdering {
// For the use case when each object is printed separately
// (print.config.complete_objects is true).
ToolOrdering::ToolOrdering(const PrintObject &object, unsigned int first_extruder)
{
// Initialize the print layers for just a single object.
{
std::vector<coordf_t> zs;
zs.reserve(zs.size() + object.layers.size() + object.support_layers.size());
for (auto layer : object.layers)
zs.emplace_back(layer->print_z);
for (auto layer : object.support_layers)
zs.emplace_back(layer->print_z);
this->initialize_layers(zs);
}
// Collect extruders reuqired to print the layers.
this->collect_extruders(object);
// Reorder the extruders to minimize tool switches.
this->reorder_extruders(first_extruder);
this->fill_wipe_tower_partitions();
}
// For the use case when all objects are printed at once.
// (print.config.complete_objects is false).
ToolOrdering::ToolOrdering(const Print &print, unsigned int first_extruder)
{
// Initialize the print layers for all objects and all layers.
{
std::vector<coordf_t> zs;
for (auto object : print.objects) {
zs.reserve(zs.size() + object->layers.size() + object->support_layers.size());
for (auto layer : object->layers)
zs.emplace_back(layer->print_z);
for (auto layer : object->support_layers)
zs.emplace_back(layer->print_z);
}
this->initialize_layers(zs);
}
// Collect extruders reuqired to print the layers.
for (auto object : print.objects)
this->collect_extruders(*object);
// Reorder the extruders to minimize tool switches.
this->reorder_extruders(first_extruder);
this->fill_wipe_tower_partitions();
}
unsigned int ToolOrdering::first_extruder() const
{
for (const auto &lt : m_layer_tools)
if (! lt.extruders.empty())
return lt.extruders.front();
return (unsigned int)-1;
}
unsigned int ToolOrdering::last_extruder() const
{
for (auto lt_it = m_layer_tools.rbegin(); lt_it != m_layer_tools.rend(); ++ lt_it)
if (! lt_it->extruders.empty())
return lt_it->extruders.back();
return (unsigned int)-1;
}
ToolOrdering::LayerTools& ToolOrdering::tools_for_layer(coordf_t print_z)
{
auto it_layer_tools = std::lower_bound(m_layer_tools.begin(), m_layer_tools.end(), ToolOrdering::LayerTools(print_z - EPSILON));
assert(it_layer_tools != m_layer_tools.end());
coordf_t dist_min = std::abs(it_layer_tools->print_z - print_z);
for (++ it_layer_tools; it_layer_tools != m_layer_tools.end(); ++it_layer_tools) {
coordf_t d = std::abs(it_layer_tools->print_z - print_z);
if (d >= dist_min)
break;
dist_min = d;
}
-- it_layer_tools;
assert(dist_min < EPSILON);
return *it_layer_tools;
}
void ToolOrdering::initialize_layers(std::vector<coordf_t> &zs)
{
sort_remove_duplicates(zs);
// Merge numerically very close Z values.
for (size_t i = 0; i < zs.size();) {
// Find the last layer with roughly the same print_z.
size_t j = i + 1;
coordf_t zmax = zs[i] + EPSILON;
for (; j < zs.size() && zs[j] <= zmax; ++ j) ;
// Assign an average print_z to the set of layers with nearly equal print_z.
m_layer_tools.emplace_back(LayerTools(0.5 * (zs[i] + zs[j-1])));
i = j;
}
}
// Collect extruders reuqired to print layers.
static void collect_extruders(const PrintObject &object, std::vector<LayerTools> &layers)
void ToolOrdering::collect_extruders(const PrintObject &object)
{
// Collect the support extruders.
for (auto support_layer : object.support_layers) {
auto it_layer = std::find(layers.begin(), layers.end(), LayerTools(support_layer->print_z));
assert(it_layer != layers.end());
LayerTools &layer_tools = this->tools_for_layer(support_layer->print_z);
ExtrusionRole role = support_layer->support_fills.role();
bool has_support = role == erMixed || role == erSupportMaterial;
bool has_interface = role == erMixed || role == erSupportMaterialInterface;
@ -24,16 +122,15 @@ static void collect_extruders(const PrintObject &object, std::vector<LayerTools>
extruder_interface = extruder_support;
}
if (has_support)
it_layer->extruders.push_back(extruder_support);
layer_tools.extruders.push_back(extruder_support);
if (has_interface)
it_layer->extruders.push_back(extruder_interface);
layer_tools.extruders.push_back(extruder_interface);
if (has_support || has_interface)
it_layer->has_support = true;
layer_tools.has_support = true;
}
// Collect the object extruders.
for (auto layer : object.layers) {
auto it_layer = std::find(layers.begin(), layers.end(), LayerTools(layer->print_z));
assert(it_layer != layers.end());
LayerTools &layer_tools = this->tools_for_layer(layer->print_z);
// What extruders are required to print this object layer?
for (size_t region_id = 0; region_id < object.print()->regions.size(); ++ region_id) {
const LayerRegion *layerm = layer->regions[region_id];
@ -41,8 +138,8 @@ static void collect_extruders(const PrintObject &object, std::vector<LayerTools>
continue;
const PrintRegion &region = *object.print()->regions[region_id];
if (! layerm->perimeters.entities.empty()) {
it_layer->extruders.push_back(region.config.perimeter_extruder.value);
it_layer->has_object = true;
layer_tools.extruders.push_back(region.config.perimeter_extruder.value);
layer_tools.has_object = true;
}
bool has_infill = false;
bool has_solid_infill = false;
@ -56,31 +153,31 @@ static void collect_extruders(const PrintObject &object, std::vector<LayerTools>
has_infill = true;
}
if (has_solid_infill)
it_layer->extruders.push_back(region.config.solid_infill_extruder);
layer_tools.extruders.push_back(region.config.solid_infill_extruder);
if (has_infill)
it_layer->extruders.push_back(region.config.infill_extruder);
layer_tools.extruders.push_back(region.config.infill_extruder);
if (has_solid_infill || has_infill)
it_layer->has_object = true;
layer_tools.has_object = true;
}
}
// Sort and remove duplicates
for (LayerTools &lt : layers)
for (LayerTools &lt : m_layer_tools)
sort_remove_duplicates(lt.extruders);
}
// Reorder extruders to minimize layer changes.
static void reorder_extruders(std::vector<LayerTools> &layers, unsigned int last_extruder_id)
void ToolOrdering::reorder_extruders(unsigned int last_extruder_id)
{
if (layers.empty())
if (m_layer_tools.empty())
return;
if (last_extruder_id == (unsigned int)-1) {
// The initial print extruder has not been decided yet.
// Initialize the last_extruder_id with the first non-zero extruder id used for the print.
last_extruder_id = 0;
for (size_t i = 0; i < layers.size() && last_extruder_id == 0; ++ i) {
const LayerTools &lt = layers[i];
for (size_t i = 0; i < m_layer_tools.size() && last_extruder_id == 0; ++ i) {
const LayerTools &lt = m_layer_tools[i];
for (unsigned int extruder_id : lt.extruders)
if (extruder_id > 0) {
last_extruder_id = extruder_id;
@ -94,7 +191,7 @@ static void reorder_extruders(std::vector<LayerTools> &layers, unsigned int last
// 1 based index
++ last_extruder_id;
for (LayerTools &lt : layers) {
for (LayerTools &lt : m_layer_tools) {
if (lt.extruders.empty())
continue;
if (lt.extruders.size() == 1 && lt.extruders.front() == 0)
@ -116,21 +213,21 @@ static void reorder_extruders(std::vector<LayerTools> &layers, unsigned int last
}
// Reindex the extruders, so they are zero based, not 1 based.
for (LayerTools &lt : layers)
for (LayerTools &lt : m_layer_tools)
for (unsigned int &extruder_id : lt.extruders) {
assert(extruder_id > 0);
-- extruder_id;
}
}
static void fill_wipe_tower_partitions(std::vector<LayerTools> &layers)
void ToolOrdering::fill_wipe_tower_partitions()
{
if (layers.empty())
if (m_layer_tools.empty())
return;
// Count the minimum number of tool changes per layer.
size_t last_extruder = size_t(-1);
for (LayerTools &lt : layers) {
for (LayerTools &lt : m_layer_tools) {
lt.wipe_tower_partitions = lt.extruders.size();
if (! lt.extruders.empty()) {
if (last_extruder == size_t(-1) || last_extruder == lt.extruders.front())
@ -141,88 +238,12 @@ static void fill_wipe_tower_partitions(std::vector<LayerTools> &layers)
}
// Propagate the wipe tower partitions down to support the upper partitions by the lower partitions.
for (int i = int(layers.size()) - 2; i >= 0; -- i)
layers[i].wipe_tower_partitions = std::max(layers[i + 1].wipe_tower_partitions, layers[i].wipe_tower_partitions);
for (int i = int(m_layer_tools.size()) - 2; i >= 0; -- i)
m_layer_tools[i].wipe_tower_partitions = std::max(m_layer_tools[i + 1].wipe_tower_partitions, m_layer_tools[i].wipe_tower_partitions);
//FIXME this is a hack to get the ball rolling.
for (LayerTools &lt : layers)
for (LayerTools &lt : m_layer_tools)
lt.has_wipe_tower = lt.has_object;
}
// For the use case when each object is printed separately
// (print.config.complete_objects is true).
std::vector<LayerTools> tool_ordering(const PrintObject &object, unsigned int first_extruder)
{
// Initialize the print layers for just a single object.
std::vector<LayerTools> layers;
{
std::vector<coordf_t> zs;
zs.reserve(zs.size() + object.layers.size() + object.support_layers.size());
for (auto layer : object.layers)
zs.emplace_back(layer->print_z);
for (auto layer : object.support_layers)
zs.emplace_back(layer->print_z);
sort_remove_duplicates(zs);
for (coordf_t z : zs)
layers.emplace_back(LayerTools(z));
}
// Collect extruders reuqired to print the layers.
collect_extruders(object, layers);
// Reorder the extruders to minimize tool switches.
reorder_extruders(layers, first_extruder);
fill_wipe_tower_partitions(layers);
return layers;
}
// For the use case when all objects are printed at once.
// (print.config.complete_objects is false).
std::vector<LayerTools> tool_ordering(const Print &print, unsigned int first_extruder)
{
// Initialize the print layers for all objects and all layers.
std::vector<LayerTools> layers;
{
std::vector<coordf_t> zs;
for (auto object : print.objects) {
zs.reserve(zs.size() + object->layers.size() + object->support_layers.size());
for (auto layer : object->layers)
zs.emplace_back(layer->print_z);
for (auto layer : object->support_layers)
zs.emplace_back(layer->print_z);
}
sort_remove_duplicates(zs);
for (coordf_t z : zs)
layers.emplace_back(LayerTools(z));
}
// Collect extruders reuqired to print the layers.
for (auto object : print.objects)
collect_extruders(*object, layers);
// Reorder the extruders to minimize tool switches.
reorder_extruders(layers, first_extruder);
fill_wipe_tower_partitions(layers);
return layers;
}
unsigned int first_extruder(const std::vector<LayerTools> &layer_tools)
{
for (const auto &lt : layer_tools)
if (! lt.extruders.empty())
return lt.extruders.front();
return (unsigned int)-1;
}
unsigned int last_extruder(const std::vector<LayerTools> &layer_tools)
{
for (auto lt_it = layer_tools.rbegin(); lt_it != layer_tools.rend(); ++ lt_it)
if (! lt_it->extruders.empty())
return lt_it->extruders.back();
return (unsigned int)-1;
}
} // namespace ToolOrdering
} // namespace Slic3r