mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-13 19:01:21 +00:00
Ian Bassi
e821665e4b
* Add orca-translations Claude skill and PO tool
Add a .claude skill that guides translation passes over the localization/i18n gettext catalogs. It covers the workflow: run gettext, settle new glossary terms, translate in batches, verify, and report.
Includes translation-rules.md, which condenses the placeholder, line-break and glossary rules plus the guidance on review notes.
Also adds scripts/po_tool.py (standard library only). It lists pending entries with glossary hints, validates and applies translations, adding '# AI Translated' and '# Needs human review' comments, and rewrites only the entries it changes. It can also check catalogs, look up existing translations, suggest glossary candidates and update the wiki glossary TSV.
* Let po_tool apply translations by entry id
pending now gives each entry a short id, so a translation file can name
entries by id instead of repeating the English msgid. apply accepts either.
A "review": "" item clears an earlier review note when overwriting an
entry, and check gives each msgfmt run its own temporary output file so
parallel checks do not collide.
* Fill all empty translations
Regenerate the template with run_gettext --full and translate every empty
entry in the 22 catalogs (7,089 entries) with the orca-translations skill,
following the localization glossary, including the new belt printer,
IDEX/IQEX and plugin terms. Every new entry is marked "# AI Translated";
122 also carry "# Needs human review" with what to check.
* Show entry ids in po_tool lookup and search translations
lookup now prints each entry's id, so an entry found there can be
rewritten with apply --overwrite without repeating the English, and
--msgstr searches the translations instead of the msgids, which finds
every entry that still uses a term being changed.
SKILL.md describes how to change an established term: check the
catalog's usage first, update the glossary cell, then rewrite only the
entries where the term has that meaning.
* Fix mistranslated terms and align catalogs with the glossary
Correct labels that the glossary had copied, and the entries that used
them:
- ca: Raft was rendered as the Brim term; it is now "Rai". Exhaust fan,
Monotonic line, Unretract, Slice, Lateral Honeycomb and PA Tower
labels fixed.
- cs: Lightning infill is "Blesk", not "Osvětlení" (illumination).
- sv: Retraction is "Retraktion", not "Reduktion"; Unretract,
Lagerhöjd, Delkylningsfläkt, Utsugsfläkt, Aligned Rectilinear and the
Preset label fixed.
- de: Brim is "Rand" and Skirt is "Umrandung", as most entries already
had them.
- lt: brim entries used the Skirt word "apvadas"; they now use "kraštas".
- es: Sparse infill is "relleno de baja densidad", the catalog majority.
- eu: nozzle wipe is "garbiketa", not purge.
- th: the project plate is "เพลต", distinct from the bed.
- uk: Quarter Cubic, Latin "PA" in PA Tower, and Belt purge tower.
- pl: Cross Hatch, Tri-hexagon, Volumetric speed and Raft labels.
- zh_TW: Brim stays "Brim", as the existing labels have it.
- tr: "Prime Tower" read "Prime Minister Tower".
- ko: the plugin "Capabilities" label read "performance".
- Build Volume labels fixed in tr, de, cs and eu.
All 242 rewritten entries are marked "# AI Translated".
* Make more UI text translatable and fix pluralization and context
Audit the sources for text that translators could not translate
correctly and fix it.
Mark text that reached users in English only: IDEX/IQEX role names,
plugin permission prompts and errors, 3MF/preset loading errors, G-code
placeholder parser errors, calibration and device messages, notification
texts, file dialog filters, and the config validation messages.
Replace sentences built from translated fragments, such as the prime
tower warnings, "left"/"right" nozzle names, and "Filament " + number,
with single msgids that have placeholders, so translators can reorder
and inflect them.
Use plural forms for texts with a count ("%1% mixed filaments",
"%d objects", "%1% triangles") instead of "(s)" and mismatched verbs.
Fix the swapped singular/plural pair in "The following presets inherit
this preset".
Add translation contexts where one English word has several meanings
(Subscribed/Local, Standard, Pause, View, Step, Model, Camera, Flow,
Filter, Others, Prepare, the Design tools). Show "Size" instead of
"Build Volume" in the Cut tool, which displays the object size.
Fix code that compared translated text with English (the Edit G-code
dialog group, the plugin registration failure check), and add the
bundled web pages' missing string-table entries. Use the single
character for degrees Celsius, say "G-code", and describe the head
filament map without internal jargon.
Install the libslic3r translate callback before the presets load, so
their load errors are translated, and list the 28 source files that had
marked strings but were never extracted into localization/i18n/list.txt.
* Suggest earlier translations and list fuzzy entries in po_tool pending
pending now attaches the closest earlier translation of a similar
English text (from obsolete or translated entries), so a reworded or
split string keeps its wording, and it lists fuzzy entries by default,
since users never see them. A fuzzy entry also carries its stale
translation as previous_translation.
* Fix wording of the non-boolean operands error
The logical operation error said "operators" where it means the
operands the operation was applied to.
* Translate the newly translatable strings in all languages
Regenerate the template after the translatability changes and fill every
new or changed entry in the 22 catalogs (about 12,800 entries): the
strings that became translatable, the plural forms, the entries split by
context, and the previously fuzzy singular entries that became plurals.
Every new entry is marked "# AI Translated", and about 360 also carry a
"# Needs human review" note saying what to check. Terms follow the
localization glossary. Earlier translations of reworded strings were
reused where the meaning was unchanged. Existing entries were not
changed, and obsolete entries are kept.
* Document the source translatability audit in the orca-translations skill
Add a reference describing how strings reach translators, what to look
for (untranslated text, spliced sentences, missing plurals, ambiguous
words), what not to translate, where a context cannot be carried, and
what to do after the edits, plus a scanner that lists untranslated
user-facing string literals.
* Document how to write translatable strings in AGENTS.md
Tell developers to keep each message complete in one msgid: use
placeholders instead of concatenating translated fragments, plural forms
for counts, and contexts for ambiguous words, and to list new source
files in localization/i18n/list.txt. Add a matching code review item.
* Translate the strings added since the rebase
Regenerate the template against the current main and translate the 26
new entries per language: the Fix Model commands and messages, and the
texture displacement image adjustment panel. Each new entry is marked
"# AI Translated"; existing entries are unchanged.
* tidy
1812 lines
96 KiB
C++
1812 lines
96 KiB
C++
#include <algorithm>
|
|
#include <boost/log/trivial.hpp>
|
|
#include <limits>
|
|
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <cassert>
|
|
#include <cstdlib>
|
|
#include <memory>
|
|
#include <math.h>
|
|
#include <cmath>
|
|
#include <iterator>
|
|
#include <tbb/parallel_for.h>
|
|
#include <vector>
|
|
#include <utility>
|
|
|
|
#include "BoundingBox.hpp"
|
|
#include "ClipperUtils.hpp"
|
|
#include "ElephantFootCompensation.hpp"
|
|
#include "ExPolygon.hpp"
|
|
#include "Exception.hpp"
|
|
#include "Flow.hpp"
|
|
#include "I18N.hpp"
|
|
#include "Layer.hpp"
|
|
#include "Model.hpp"
|
|
#include "MultiMaterialSegmentation.hpp"
|
|
#include "ObjectID.hpp"
|
|
#include "Point.hpp"
|
|
#include "Polygon.hpp"
|
|
#include "Print.hpp"
|
|
#include "BeltTransform.hpp"
|
|
#include "BeltSliceStrategy.hpp"
|
|
#include "Geometry.hpp"
|
|
//BBS
|
|
#include "PrintConfig.hpp"
|
|
#include "PrintBase.hpp"
|
|
#include "ShortestPath.hpp"
|
|
#include "libslic3r.h"
|
|
#include "TriangleMeshSlicer.hpp"
|
|
#include "TriangleMesh.hpp"
|
|
#include "Slicing.hpp"
|
|
#include "Surface.hpp"
|
|
#include "Utils.hpp"
|
|
#include "libslic3r/Feature/Interlocking/InterlockingGenerator.hpp"
|
|
#include "Config.hpp"
|
|
#include "SurfaceCollection.hpp"
|
|
|
|
//! macro used to mark string used at localization, return same string
|
|
#define L(s) Slic3r::I18N::translate(s)
|
|
|
|
namespace Slic3r {
|
|
|
|
bool PrintObject::clip_multipart_objects = true;
|
|
bool PrintObject::infill_only_where_needed = false;
|
|
|
|
static coordf_t compute_slice_z(PrintObject* print_object, size_t i_layer, coordf_t lo, coordf_t hi)
|
|
{
|
|
bool zaa_active = false;
|
|
coordf_t z_offset = 0.0;
|
|
|
|
size_t num_regions = print_object->num_printing_regions();
|
|
for (size_t rid = 0; rid < num_regions; ++rid) {
|
|
const auto& rcfg = print_object->printing_region(rid).config();
|
|
if (rcfg.zaa_enabled) {
|
|
if (!zaa_active || rcfg.zaa_min_z < z_offset)
|
|
z_offset = rcfg.zaa_min_z;
|
|
zaa_active = true;
|
|
}
|
|
}
|
|
|
|
if (!zaa_active || i_layer == 0) {
|
|
return 0.5 * (lo + hi);
|
|
}
|
|
|
|
coordf_t slice_z = lo + z_offset;
|
|
if ((slice_z < lo && !is_approx(slice_z, lo)) || (slice_z > hi && !is_approx(slice_z, hi))) {
|
|
throw RuntimeError("Bad min Z value");
|
|
}
|
|
return slice_z;
|
|
}
|
|
|
|
LayerPtrs new_layers(
|
|
PrintObject *print_object,
|
|
// Object layers (pairs of bottom/top Z coordinate), without the raft.
|
|
const std::vector<coordf_t> &object_layers)
|
|
{
|
|
LayerPtrs out;
|
|
out.reserve(object_layers.size());
|
|
auto id = int(print_object->slicing_parameters().raft_layers());
|
|
coordf_t zmin = print_object->slicing_parameters().object_print_z_min;
|
|
Layer *prev = nullptr;
|
|
for (size_t i_layer = 0; i_layer < object_layers.size(); i_layer += 2) {
|
|
coordf_t lo = object_layers[i_layer];
|
|
coordf_t hi = object_layers[i_layer + 1];
|
|
coordf_t slice_z = compute_slice_z(print_object, i_layer, lo, hi);
|
|
|
|
Layer *layer = new Layer(id ++, print_object, hi - lo, hi + zmin, slice_z);
|
|
out.emplace_back(layer);
|
|
if (prev != nullptr) {
|
|
prev->upper_layer = layer;
|
|
layer->lower_layer = prev;
|
|
}
|
|
prev = layer;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Slice single triangle mesh.
|
|
static std::vector<ExPolygons> slice_volume(
|
|
const ModelVolume &volume,
|
|
const std::vector<float> &zs,
|
|
const MeshSlicingParamsEx ¶ms,
|
|
const std::function<void()> &throw_on_cancel_callback)
|
|
{
|
|
std::vector<ExPolygons> layers;
|
|
if (! zs.empty()) {
|
|
indexed_triangle_set its = volume.mesh().its;
|
|
if (its.indices.size() > 0) {
|
|
MeshSlicingParamsEx params2 { params };
|
|
params2.trafo = params2.trafo * volume.get_matrix();
|
|
if (params2.trafo.rotation().determinant() < 0.)
|
|
its_flip_triangles(its);
|
|
layers = slice_mesh_ex(its, zs, params2, throw_on_cancel_callback);
|
|
throw_on_cancel_callback();
|
|
}
|
|
}
|
|
return layers;
|
|
}
|
|
|
|
// Slice single triangle mesh.
|
|
// Filter the zs not inside the ranges. The ranges are closed at the bottom and open at the top, they are sorted lexicographically and non overlapping.
|
|
static std::vector<ExPolygons> slice_volume(
|
|
const ModelVolume &volume,
|
|
const std::vector<float> &z,
|
|
const std::vector<t_layer_height_range> &ranges,
|
|
const MeshSlicingParamsEx ¶ms,
|
|
const std::function<void()> &throw_on_cancel_callback)
|
|
{
|
|
std::vector<ExPolygons> out;
|
|
if (! z.empty() && ! ranges.empty()) {
|
|
if (ranges.size() == 1 && z.front() >= ranges.front().first && z.back() < ranges.front().second) {
|
|
// All layers fit into a single range.
|
|
out = slice_volume(volume, z, params, throw_on_cancel_callback);
|
|
} else {
|
|
std::vector<float> z_filtered;
|
|
std::vector<std::pair<size_t, size_t>> n_filtered;
|
|
z_filtered.reserve(z.size());
|
|
n_filtered.reserve(2 * ranges.size());
|
|
size_t i = 0;
|
|
for (const t_layer_height_range &range : ranges) {
|
|
for (; i < z.size() && z[i] < range.first; ++ i) ;
|
|
size_t first = i;
|
|
for (; i < z.size() && z[i] < range.second; ++ i)
|
|
z_filtered.emplace_back(z[i]);
|
|
if (i > first)
|
|
n_filtered.emplace_back(std::make_pair(first, i));
|
|
}
|
|
if (! n_filtered.empty()) {
|
|
std::vector<ExPolygons> layers = slice_volume(volume, z_filtered, params, throw_on_cancel_callback);
|
|
out.assign(z.size(), ExPolygons());
|
|
i = 0;
|
|
for (const std::pair<size_t, size_t> &span : n_filtered)
|
|
for (size_t j = span.first; j < span.second; ++ j)
|
|
out[j] = std::move(layers[i ++]);
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
static inline bool model_volume_needs_slicing(const ModelVolume &mv)
|
|
{
|
|
ModelVolumeType type = mv.type();
|
|
return type == ModelVolumeType::MODEL_PART || type == ModelVolumeType::NEGATIVE_VOLUME || type == ModelVolumeType::PARAMETER_MODIFIER;
|
|
}
|
|
|
|
// Slice printable volumes, negative volumes and modifier volumes, sorted by ModelVolume::id().
|
|
// Apply closing radius.
|
|
// Apply positive XY compensation to ModelVolumeType::MODEL_PART and ModelVolumeType::PARAMETER_MODIFIER, not to ModelVolumeType::NEGATIVE_VOLUME.
|
|
// Apply contour simplification.
|
|
static std::vector<VolumeSlices> slice_volumes_inner(
|
|
const PrintConfig &print_config,
|
|
const PrintObjectConfig &print_object_config,
|
|
const Transform3d &object_trafo,
|
|
ModelVolumePtrs model_volumes,
|
|
const std::vector<PrintObjectRegions::LayerRangeRegions> &layer_ranges,
|
|
const std::vector<float> &zs,
|
|
const std::function<void()> &throw_on_cancel_callback,
|
|
double *out_belt_min_z = nullptr)
|
|
{
|
|
model_volumes_sort_by_id(model_volumes);
|
|
|
|
std::vector<VolumeSlices> out;
|
|
out.reserve(model_volumes.size());
|
|
|
|
std::vector<t_layer_height_range> slicing_ranges;
|
|
if (layer_ranges.size() > 1)
|
|
slicing_ranges.reserve(layer_ranges.size());
|
|
|
|
MeshSlicingParamsEx params_base;
|
|
params_base.closing_radius = print_object_config.slice_closing_radius.value;
|
|
params_base.extra_offset = 0;
|
|
params_base.trafo = object_trafo;
|
|
// Pre-slice mesh transforms: axis remap (standalone — works without belt
|
|
// mode), belt rotation, and the per-object Z-shift. Owned by BeltSliceStrategy
|
|
// so this belt/remap-specific logic stays out of the generic slicing pipeline.
|
|
BeltSliceStrategy::apply_preslice_transforms(params_base.trafo, print_config, model_volumes, out_belt_min_z);
|
|
//BBS: 0.0025mm is safe enough to simplify the data to speed slicing up for high-resolution model.
|
|
//Also has on influence on arc fitting which has default resolution 0.0125mm.
|
|
params_base.resolution = print_config.resolution <= 0.001 ? 0.0f : 0.0025;
|
|
switch (print_object_config.slicing_mode.value) {
|
|
case SlicingMode::Regular: params_base.mode = MeshSlicingParams::SlicingMode::Regular; break;
|
|
case SlicingMode::EvenOdd: params_base.mode = MeshSlicingParams::SlicingMode::EvenOdd; break;
|
|
case SlicingMode::CloseHoles: params_base.mode = MeshSlicingParams::SlicingMode::Positive; break;
|
|
}
|
|
|
|
params_base.mode_below = params_base.mode;
|
|
|
|
// BBS
|
|
const size_t num_extruders = print_config.filament_diameter.size();
|
|
const bool is_mm_painted = num_extruders > 1 && std::any_of(model_volumes.cbegin(), model_volumes.cend(), [](const ModelVolume *mv) { return mv->is_mm_painted(); });
|
|
// BBS: don't do size compensation when slice volume.
|
|
// Will handle contour and hole size compensation seperately later.
|
|
//const auto extra_offset = is_mm_painted ? 0.f : std::max(0.f, float(print_object_config.xy_contour_compensation.value));
|
|
const auto extra_offset = 0.f;
|
|
|
|
for (const ModelVolume *model_volume : model_volumes)
|
|
if (model_volume_needs_slicing(*model_volume)) {
|
|
MeshSlicingParamsEx params { params_base };
|
|
if (! model_volume->is_negative_volume())
|
|
params.extra_offset = extra_offset;
|
|
if (layer_ranges.size() == 1) {
|
|
if (const PrintObjectRegions::LayerRangeRegions &layer_range = layer_ranges.front(); layer_range.has_volume(model_volume->id())) {
|
|
if (model_volume->is_model_part() && print_config.spiral_mode) {
|
|
auto it = std::find_if(layer_range.volume_regions.begin(), layer_range.volume_regions.end(),
|
|
[model_volume](const auto &slice){ return model_volume == slice.model_volume; });
|
|
params.mode = MeshSlicingParams::SlicingMode::PositiveLargestContour;
|
|
// Slice the bottom layers with SlicingMode::Regular.
|
|
// This needs to be in sync with LayerRegion::make_perimeters() spiral_mode!
|
|
const PrintRegionConfig ®ion_config = it->region->config();
|
|
params.slicing_mode_normal_below_layer = size_t(region_config.bottom_shell_layers.value);
|
|
for (; params.slicing_mode_normal_below_layer < zs.size() && zs[params.slicing_mode_normal_below_layer] < region_config.bottom_shell_thickness - EPSILON;
|
|
++ params.slicing_mode_normal_below_layer);
|
|
}
|
|
out.push_back({
|
|
model_volume->id(),
|
|
slice_volume(*model_volume, zs, params, throw_on_cancel_callback)
|
|
});
|
|
}
|
|
} else {
|
|
assert(! print_config.spiral_mode);
|
|
slicing_ranges.clear();
|
|
for (const PrintObjectRegions::LayerRangeRegions &layer_range : layer_ranges)
|
|
if (layer_range.has_volume(model_volume->id()))
|
|
slicing_ranges.emplace_back(layer_range.layer_height_range);
|
|
if (! slicing_ranges.empty())
|
|
out.push_back({
|
|
model_volume->id(),
|
|
slice_volume(*model_volume, zs, slicing_ranges, params, throw_on_cancel_callback)
|
|
});
|
|
}
|
|
if (! out.empty() && out.back().slices.empty())
|
|
out.pop_back();
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
static inline VolumeSlices& volume_slices_find_by_id(std::vector<VolumeSlices> &volume_slices, const ObjectID id)
|
|
{
|
|
auto it = lower_bound_by_predicate(volume_slices.begin(), volume_slices.end(), [id](const VolumeSlices &vs) { return vs.volume_id < id; });
|
|
assert(it != volume_slices.end() && it->volume_id == id);
|
|
return *it;
|
|
}
|
|
|
|
static inline bool overlap_in_xy(const PrintObjectRegions::BoundingBox &l, const PrintObjectRegions::BoundingBox &r)
|
|
{
|
|
return ! (l.max().x() < r.min().x() || l.min().x() > r.max().x() ||
|
|
l.max().y() < r.min().y() || l.min().y() > r.max().y());
|
|
}
|
|
|
|
static std::vector<PrintObjectRegions::LayerRangeRegions>::const_iterator layer_range_first(const std::vector<PrintObjectRegions::LayerRangeRegions> &layer_ranges, double z)
|
|
{
|
|
auto it = lower_bound_by_predicate(layer_ranges.begin(), layer_ranges.end(),
|
|
[z](const PrintObjectRegions::LayerRangeRegions &lr) {
|
|
return lr.layer_height_range.second < z && abs(lr.layer_height_range.second - z) > EPSILON;
|
|
});
|
|
assert(it != layer_ranges.end() && it->layer_height_range.first <= z && z <= it->layer_height_range.second);
|
|
if (z == it->layer_height_range.second)
|
|
if (auto it_next = it; ++ it_next != layer_ranges.end() && it_next->layer_height_range.first == z)
|
|
it = it_next;
|
|
assert(it != layer_ranges.end() && it->layer_height_range.first <= z && z <= it->layer_height_range.second);
|
|
return it;
|
|
}
|
|
|
|
static std::vector<PrintObjectRegions::LayerRangeRegions>::const_iterator layer_range_next(
|
|
const std::vector<PrintObjectRegions::LayerRangeRegions> &layer_ranges,
|
|
std::vector<PrintObjectRegions::LayerRangeRegions>::const_iterator it,
|
|
double z)
|
|
{
|
|
for (; it->layer_height_range.second <= z + EPSILON; ++ it)
|
|
assert(it != layer_ranges.end());
|
|
assert(it != layer_ranges.end() && it->layer_height_range.first <= z && z < it->layer_height_range.second);
|
|
return it;
|
|
}
|
|
|
|
static std::vector<std::vector<ExPolygons>> slices_to_regions(
|
|
const PrintConfig &print_config,
|
|
const PrintObject &print_object,
|
|
ModelVolumePtrs model_volumes,
|
|
const PrintObjectRegions &print_object_regions,
|
|
const std::vector<float> &zs,
|
|
std::vector<VolumeSlices> &&volume_slices,
|
|
// If clipping is disabled, then ExPolygons produced by different volumes will never be merged, thus they will be allowed to overlap.
|
|
// It is up to the model designer to handle these overlaps.
|
|
const bool clip_multipart_objects,
|
|
const std::function<void()> &throw_on_cancel_callback)
|
|
{
|
|
model_volumes_sort_by_id(model_volumes);
|
|
|
|
std::vector<std::vector<ExPolygons>> slices_by_region(print_object_regions.all_regions.size(), std::vector<ExPolygons>(zs.size(), ExPolygons()));
|
|
|
|
// First shuffle slices into regions if there is no overlap with another region possible, collect zs of the complex cases.
|
|
std::vector<std::pair<size_t, float>> zs_complex;
|
|
{
|
|
size_t z_idx = 0;
|
|
for (const PrintObjectRegions::LayerRangeRegions &layer_range : print_object_regions.layer_ranges) {
|
|
for (; z_idx < zs.size() && zs[z_idx] < layer_range.layer_height_range.first; ++ z_idx) ;
|
|
if (layer_range.volume_regions.empty()) {
|
|
} else if (layer_range.volume_regions.size() == 1) {
|
|
const ModelVolume *model_volume = layer_range.volume_regions.front().model_volume;
|
|
assert(model_volume != nullptr);
|
|
if (model_volume->is_model_part()) {
|
|
VolumeSlices &slices_src = volume_slices_find_by_id(volume_slices, model_volume->id());
|
|
auto &slices_dst = slices_by_region[layer_range.volume_regions.front().region->print_object_region_id()];
|
|
for (; z_idx < zs.size() && zs[z_idx] < layer_range.layer_height_range.second; ++ z_idx)
|
|
slices_dst[z_idx] = std::move(slices_src.slices[z_idx]);
|
|
}
|
|
} else {
|
|
zs_complex.reserve(zs.size());
|
|
// region.bbox is computed in pre-belt-transform slicer space (see PrintApply.cpp::trafo_for_bbox).
|
|
// When belt transforms are active, layer Z values are in post-rotation/shear/scale/remap space,
|
|
// so the Z components of region.bbox aren't comparable to z. Skipping the Z filter here
|
|
// pushes those layers into the parallel_for path below, which handles multi-volume
|
|
// clipping per layer without relying on the bbox Z range.
|
|
const bool bbox_z_in_layer_frame = !(print_config.belt_printer.value &&
|
|
BeltTransformPipeline::has_rotation(print_config));
|
|
// Belt-transform addendum: with bbox-Z untrusted, the simple path's
|
|
// "first model_part wins" logic drops subsequent volumes' slices unless
|
|
// they XY-overlap with the first. Assemblies whose volumes are stacked
|
|
// or side-by-side in pre-transform Z (different bbox.z ranges) thus lose
|
|
// the volumes that originally sat outside the first volume's Z range —
|
|
// showing up as truncation at the top or bottom of the assembly. Force
|
|
// every layer in a multi-volume range through the parallel_for path,
|
|
// which correctly merges all volumes per layer.
|
|
int num_model_parts = 0;
|
|
for (const PrintObjectRegions::VolumeRegion &vr : layer_range.volume_regions)
|
|
if (vr.model_volume->is_model_part())
|
|
++num_model_parts;
|
|
const bool force_complex_for_belt = !bbox_z_in_layer_frame && num_model_parts > 1;
|
|
for (; z_idx < zs.size() && zs[z_idx] < layer_range.layer_height_range.second; ++ z_idx) {
|
|
float z = zs[z_idx];
|
|
if (force_complex_for_belt) {
|
|
zs_complex.push_back({ z_idx, z });
|
|
continue;
|
|
}
|
|
int idx_first_printable_region = -1;
|
|
bool complex = false;
|
|
std::vector<int> printable_region_ids;
|
|
for (int idx_region = 0; idx_region < int(layer_range.volume_regions.size()); ++ idx_region) {
|
|
const PrintObjectRegions::VolumeRegion ®ion = layer_range.volume_regions[idx_region];
|
|
if (!bbox_z_in_layer_frame || (region.bbox->min().z() <= z && region.bbox->max().z() >= z)) {
|
|
if (region.model_volume->is_model_part())
|
|
printable_region_ids.push_back(idx_region);
|
|
|
|
if (idx_first_printable_region == -1 && region.model_volume->is_model_part()) {
|
|
idx_first_printable_region = idx_region;
|
|
}
|
|
else if (idx_first_printable_region != -1) {
|
|
// Test for overlap with some other region.
|
|
for (int idx_region2 = idx_first_printable_region; idx_region2 < idx_region; ++ idx_region2) {
|
|
const PrintObjectRegions::VolumeRegion ®ion2 = layer_range.volume_regions[idx_region2];
|
|
const bool region2_in_z = !bbox_z_in_layer_frame
|
|
|| (region2.bbox->min().z() <= z && region2.bbox->max().z() >= z);
|
|
if (region2_in_z && overlap_in_xy(*region.bbox, *region2.bbox)) {
|
|
complex = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (complex)
|
|
zs_complex.push_back({ z_idx, z });
|
|
else if (idx_first_printable_region >= 0) {
|
|
for (int printable_region_id : printable_region_ids) {
|
|
const PrintObjectRegions::VolumeRegion ®ion = layer_range.volume_regions[printable_region_id];
|
|
append(slices_by_region[region.region->print_object_region_id()][z_idx], std::move(volume_slices_find_by_id(volume_slices, region.model_volume->id()).slices[z_idx]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
throw_on_cancel_callback();
|
|
}
|
|
}
|
|
|
|
// Second perform region clipping and assignment in parallel.
|
|
if (! zs_complex.empty()) {
|
|
std::vector<std::vector<VolumeSlices*>> layer_ranges_regions_to_slices(print_object_regions.layer_ranges.size(), std::vector<VolumeSlices*>());
|
|
for (const PrintObjectRegions::LayerRangeRegions &layer_range : print_object_regions.layer_ranges) {
|
|
std::vector<VolumeSlices*> &layer_range_regions_to_slices = layer_ranges_regions_to_slices[&layer_range - print_object_regions.layer_ranges.data()];
|
|
layer_range_regions_to_slices.reserve(layer_range.volume_regions.size());
|
|
for (const PrintObjectRegions::VolumeRegion ®ion : layer_range.volume_regions)
|
|
layer_range_regions_to_slices.push_back(&volume_slices_find_by_id(volume_slices, region.model_volume->id()));
|
|
}
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, zs_complex.size()),
|
|
[&slices_by_region, &print_object_regions, &zs_complex, &layer_ranges_regions_to_slices, clip_multipart_objects, &throw_on_cancel_callback]
|
|
(const tbb::blocked_range<size_t> &range) {
|
|
float z = zs_complex[range.begin()].second;
|
|
auto it_layer_range = layer_range_first(print_object_regions.layer_ranges, z);
|
|
// Per volume_regions slices at this Z height.
|
|
struct RegionSlice {
|
|
ExPolygons expolygons;
|
|
// Identifier of this region in PrintObjectRegions::all_regions
|
|
int region_id;
|
|
ObjectID volume_id;
|
|
bool operator<(const RegionSlice &rhs) const {
|
|
bool this_empty = this->region_id < 0 || this->expolygons.empty();
|
|
bool rhs_empty = rhs.region_id < 0 || rhs.expolygons.empty();
|
|
// Sort the empty items to the end of the list.
|
|
// Sort by region_id & volume_id lexicographically.
|
|
return ! this_empty && (rhs_empty || (this->region_id < rhs.region_id || (this->region_id == rhs.region_id && volume_id < rhs.volume_id)));
|
|
}
|
|
};
|
|
|
|
// BBS
|
|
auto trim_overlap = [](ExPolygons& expolys_a, ExPolygons& expolys_b) {
|
|
ExPolygons trimming_a;
|
|
ExPolygons trimming_b;
|
|
|
|
for (ExPolygon& expoly_a : expolys_a) {
|
|
BoundingBox bbox_a = get_extents(expoly_a);
|
|
ExPolygons expolys_new;
|
|
for (ExPolygon& expoly_b : expolys_b) {
|
|
BoundingBox bbox_b = get_extents(expoly_b);
|
|
if (!bbox_a.overlap(bbox_b))
|
|
continue;
|
|
|
|
ExPolygons temp = intersection_ex(expoly_b, expoly_a, ApplySafetyOffset::Yes);
|
|
if (temp.empty())
|
|
continue;
|
|
|
|
if (expoly_a.contour.length() > expoly_b.contour.length())
|
|
trimming_a.insert(trimming_a.end(), temp.begin(), temp.end());
|
|
else
|
|
trimming_b.insert(trimming_b.end(), temp.begin(), temp.end());
|
|
}
|
|
}
|
|
|
|
expolys_a = diff_ex(expolys_a, trimming_a);
|
|
expolys_b = diff_ex(expolys_b, trimming_b);
|
|
};
|
|
|
|
std::vector<RegionSlice> temp_slices;
|
|
for (size_t zs_complex_idx = range.begin(); zs_complex_idx < range.end(); ++ zs_complex_idx) {
|
|
auto [z_idx, z] = zs_complex[zs_complex_idx];
|
|
it_layer_range = layer_range_next(print_object_regions.layer_ranges, it_layer_range, z);
|
|
const PrintObjectRegions::LayerRangeRegions &layer_range = *it_layer_range;
|
|
{
|
|
std::vector<VolumeSlices*> &layer_range_regions_to_slices = layer_ranges_regions_to_slices[it_layer_range - print_object_regions.layer_ranges.begin()];
|
|
// Per volume_regions slices at thiz Z height.
|
|
temp_slices.clear();
|
|
temp_slices.reserve(layer_range.volume_regions.size());
|
|
for (VolumeSlices* &slices : layer_range_regions_to_slices) {
|
|
const PrintObjectRegions::VolumeRegion &volume_region = layer_range.volume_regions[&slices - layer_range_regions_to_slices.data()];
|
|
temp_slices.push_back({ std::move(slices->slices[z_idx]), volume_region.region ? volume_region.region->print_object_region_id() : -1, volume_region.model_volume->id() });
|
|
}
|
|
}
|
|
for (int idx_region = 0; idx_region < int(layer_range.volume_regions.size()); ++ idx_region)
|
|
if (! temp_slices[idx_region].expolygons.empty()) {
|
|
const PrintObjectRegions::VolumeRegion ®ion = layer_range.volume_regions[idx_region];
|
|
if (region.model_volume->is_modifier()) {
|
|
assert(region.parent > -1);
|
|
bool next_region_same_modifier = idx_region + 1 < int(temp_slices.size()) && layer_range.volume_regions[idx_region + 1].model_volume == region.model_volume;
|
|
RegionSlice &parent_slice = temp_slices[region.parent];
|
|
RegionSlice &this_slice = temp_slices[idx_region];
|
|
ExPolygons source = std::move(this_slice.expolygons);
|
|
if (parent_slice.expolygons.empty()) {
|
|
this_slice .expolygons.clear();
|
|
} else {
|
|
this_slice .expolygons = intersection_ex(parent_slice.expolygons, source);
|
|
parent_slice.expolygons = diff_ex (parent_slice.expolygons, source);
|
|
}
|
|
if (next_region_same_modifier)
|
|
// To be used in the following iteration.
|
|
temp_slices[idx_region + 1].expolygons = std::move(source);
|
|
} else if ((region.model_volume->is_model_part() && clip_multipart_objects) || region.model_volume->is_negative_volume()) {
|
|
// Clip every non-zero region preceding it.
|
|
for (int idx_region2 = 0; idx_region2 < idx_region; ++ idx_region2)
|
|
if (! temp_slices[idx_region2].expolygons.empty()) {
|
|
// Skip trim_overlap for now, because it slow down the performace so much for some special cases
|
|
#if 1
|
|
if (const PrintObjectRegions::VolumeRegion& region2 = layer_range.volume_regions[idx_region2];
|
|
!region2.model_volume->is_negative_volume() && overlap_in_xy(*region.bbox, *region2.bbox))
|
|
temp_slices[idx_region2].expolygons = diff_ex(temp_slices[idx_region2].expolygons, temp_slices[idx_region].expolygons);
|
|
#else
|
|
const PrintObjectRegions::VolumeRegion& region2 = layer_range.volume_regions[idx_region2];
|
|
if (!region2.model_volume->is_negative_volume() && overlap_in_xy(*region.bbox, *region2.bbox))
|
|
//BBS: handle negative_volume seperately, always minus the negative volume and don't need to trim overlap
|
|
if (!region.model_volume->is_negative_volume())
|
|
trim_overlap(temp_slices[idx_region2].expolygons, temp_slices[idx_region].expolygons);
|
|
else
|
|
temp_slices[idx_region2].expolygons = diff_ex(temp_slices[idx_region2].expolygons, temp_slices[idx_region].expolygons);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
// Sort by region_id, push empty slices to the end.
|
|
std::sort(temp_slices.begin(), temp_slices.end());
|
|
// Remove the empty slices.
|
|
temp_slices.erase(std::find_if(temp_slices.begin(), temp_slices.end(), [](const auto &slice) { return slice.region_id == -1 || slice.expolygons.empty(); }), temp_slices.end());
|
|
// Merge slices and store them to the output.
|
|
for (int i = 0; i < int(temp_slices.size());) {
|
|
// Find a range of temp_slices with the same region_id.
|
|
int j = i;
|
|
bool merged = false;
|
|
ExPolygons &expolygons = temp_slices[i].expolygons;
|
|
for (++ j; j < int(temp_slices.size()) && temp_slices[i].region_id == temp_slices[j].region_id; ++ j)
|
|
if (ExPolygons &expolygons2 = temp_slices[j].expolygons; ! expolygons2.empty()) {
|
|
if (expolygons.empty()) {
|
|
expolygons = std::move(expolygons2);
|
|
} else {
|
|
append(expolygons, std::move(expolygons2));
|
|
merged = true;
|
|
}
|
|
}
|
|
// Don't unite the regions if ! clip_multipart_objects. In that case it is user's responsibility
|
|
// to handle region overlaps. Indeed, one may intentionally let the regions overlap to produce crossing perimeters
|
|
// for example.
|
|
if (merged && clip_multipart_objects)
|
|
expolygons = closing_ex(expolygons, float(scale_(EPSILON)));
|
|
slices_by_region[temp_slices[i].region_id][z_idx] = std::move(expolygons);
|
|
i = j;
|
|
}
|
|
throw_on_cancel_callback();
|
|
}
|
|
});
|
|
}
|
|
|
|
return slices_by_region;
|
|
}
|
|
|
|
//BBS: justify whether a volume is connected to another one
|
|
bool doesVolumeIntersect(VolumeSlices& vs1, VolumeSlices& vs2)
|
|
{
|
|
if (vs1.volume_id == vs2.volume_id) return true;
|
|
// two volumes in the same object should have same number of layers, otherwise the slicing is incorrect.
|
|
if (vs1.slices.size() != vs2.slices.size()) return false;
|
|
|
|
auto& vs1s = vs1.slices;
|
|
auto& vs2s = vs2.slices;
|
|
bool is_intersect = false;
|
|
|
|
tbb::parallel_for(tbb::blocked_range<int>(0, vs1s.size()),
|
|
[&vs1s, &vs2s, &is_intersect](const tbb::blocked_range<int>& range) {
|
|
for (auto i = range.begin(); i != range.end(); ++i) {
|
|
if (vs1s[i].empty()) continue;
|
|
|
|
if (overlaps(vs1s[i], vs2s[i])) {
|
|
is_intersect = true;
|
|
break;
|
|
}
|
|
if (i + 1 != vs2s.size() && overlaps(vs1s[i], vs2s[i + 1])) {
|
|
is_intersect = true;
|
|
break;
|
|
}
|
|
if (i - 1 >= 0 && overlaps(vs1s[i], vs2s[i - 1])) {
|
|
is_intersect = true;
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
return is_intersect;
|
|
}
|
|
|
|
//BBS: grouping the volumes of an object according to their connection relationship
|
|
bool groupingVolumes(std::vector<VolumeSlices> objSliceByVolume, std::vector<groupedVolumeSlices>& groups, double resolution, int firstLayerReplacedBy)
|
|
{
|
|
std::vector<int> groupIndex(objSliceByVolume.size(), -1);
|
|
double offsetValue = 0.05 / SCALING_FACTOR;
|
|
|
|
std::vector<std::vector<int>> osvIndex;
|
|
for (int i = 0; i != objSliceByVolume.size(); ++i) {
|
|
for (int j = 0; j != objSliceByVolume[i].slices.size(); ++j) {
|
|
osvIndex.push_back({ i,j });
|
|
}
|
|
}
|
|
|
|
tbb::parallel_for(tbb::blocked_range<int>(0, osvIndex.size()),
|
|
[&osvIndex, &objSliceByVolume, &resolution](const tbb::blocked_range<int>& range) {
|
|
for (auto k = range.begin(); k != range.end(); ++k) {
|
|
for (ExPolygon& poly_ex : objSliceByVolume[osvIndex[k][0]].slices[osvIndex[k][1]])
|
|
poly_ex.douglas_peucker(resolution);
|
|
}
|
|
});
|
|
|
|
tbb::parallel_for(tbb::blocked_range<int>(0, osvIndex.size()),
|
|
[&osvIndex, &objSliceByVolume,&offsetValue](const tbb::blocked_range<int>& range) {
|
|
for (auto k = range.begin(); k != range.end(); ++k) {
|
|
objSliceByVolume[osvIndex[k][0]].slices[osvIndex[k][1]] = offset_ex(objSliceByVolume[osvIndex[k][0]].slices[osvIndex[k][1]], offsetValue);
|
|
}
|
|
});
|
|
|
|
for (int i = 0; i != objSliceByVolume.size(); ++i) {
|
|
if (groupIndex[i] < 0) {
|
|
groupIndex[i] = i;
|
|
}
|
|
for (int j = i + 1; j != objSliceByVolume.size(); ++j) {
|
|
if (doesVolumeIntersect(objSliceByVolume[i], objSliceByVolume[j])) {
|
|
if (groupIndex[j] < 0) groupIndex[j] = groupIndex[i];
|
|
if (groupIndex[j] != groupIndex[i]) {
|
|
int retain = std::min(groupIndex[i], groupIndex[j]);
|
|
int cover = std::max(groupIndex[i], groupIndex[j]);
|
|
for (int k = 0; k != objSliceByVolume.size(); ++k) {
|
|
if (groupIndex[k] == cover) groupIndex[k] = retain;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
std::vector<int> groupVector{};
|
|
for (int gi : groupIndex) {
|
|
bool exist = false;
|
|
for (int gv : groupVector) {
|
|
if (gv == gi) {
|
|
exist = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!exist) groupVector.push_back(gi);
|
|
}
|
|
|
|
// group volumes and their slices according to the grouping Vector
|
|
groups.clear();
|
|
|
|
for (int gv : groupVector) {
|
|
groupedVolumeSlices gvs;
|
|
gvs.groupId = gv;
|
|
for (int i = 0; i != objSliceByVolume.size(); ++i) {
|
|
if (groupIndex[i] == gv) {
|
|
gvs.volume_ids.push_back(objSliceByVolume[i].volume_id);
|
|
append(gvs.slices, objSliceByVolume[i].slices[firstLayerReplacedBy]);
|
|
}
|
|
}
|
|
|
|
// the slices of a group should be unioned
|
|
gvs.slices = offset_ex(union_ex(gvs.slices), -offsetValue);
|
|
for (ExPolygon& poly_ex : gvs.slices)
|
|
poly_ex.douglas_peucker(resolution);
|
|
|
|
groups.push_back(gvs);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//BBS: filter the members of "objSliceByVolume" such that only "model_part" are included
|
|
std::vector<VolumeSlices> findPartVolumes(const std::vector<VolumeSlices>& objSliceByVolume, ModelVolumePtrs model_volumes) {
|
|
std::vector<VolumeSlices> outPut;
|
|
for (const auto& vs : objSliceByVolume) {
|
|
for (const auto& mv : model_volumes) {
|
|
if (vs.volume_id == mv->id() && mv->is_model_part()) outPut.push_back(vs);
|
|
}
|
|
}
|
|
return outPut;
|
|
}
|
|
|
|
void applyNegtiveVolumes(ModelVolumePtrs model_volumes, const std::vector<VolumeSlices>& objSliceByVolume, std::vector<groupedVolumeSlices>& groups, double resolution) {
|
|
ExPolygons negTotal;
|
|
for (const auto& vs : objSliceByVolume) {
|
|
for (const auto& mv : model_volumes) {
|
|
if (vs.volume_id == mv->id() && mv->is_negative_volume()) {
|
|
if (vs.slices.size() > 0) {
|
|
append(negTotal, vs.slices.front());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto& g : groups) {
|
|
g.slices = diff_ex(g.slices, negTotal);
|
|
for (ExPolygon& poly_ex : g.slices)
|
|
poly_ex.douglas_peucker(resolution);
|
|
}
|
|
}
|
|
|
|
void reGroupingLayerPolygons(std::vector<groupedVolumeSlices>& gvss, ExPolygons &eps, double resolution)
|
|
{
|
|
std::vector<int> epsIndex;
|
|
epsIndex.resize(eps.size(), -1);
|
|
|
|
auto gvssc = gvss;
|
|
auto epsc = eps;
|
|
|
|
for (ExPolygon& poly_ex : epsc)
|
|
poly_ex.douglas_peucker(resolution);
|
|
|
|
for (int i = 0; i != gvssc.size(); ++i) {
|
|
for (ExPolygon& poly_ex : gvssc[i].slices)
|
|
poly_ex.douglas_peucker(resolution);
|
|
}
|
|
|
|
tbb::parallel_for(tbb::blocked_range<int>(0, epsc.size()),
|
|
[&epsc, &gvssc, &epsIndex](const tbb::blocked_range<int>& range) {
|
|
for (auto ie = range.begin(); ie != range.end(); ++ie) {
|
|
if (epsc[ie].area() <= 0)
|
|
continue;
|
|
|
|
double minArea = epsc[ie].area();
|
|
for (int iv = 0; iv != gvssc.size(); iv++) {
|
|
auto clipedExPolys = diff_ex(epsc[ie], gvssc[iv].slices);
|
|
double area = 0;
|
|
for (const auto& ce : clipedExPolys) {
|
|
area += ce.area();
|
|
}
|
|
if (area < minArea) {
|
|
minArea = area;
|
|
epsIndex[ie] = iv;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
for (int iv = 0; iv != gvss.size(); iv++)
|
|
gvss[iv].slices.clear();
|
|
|
|
for (int ie = 0; ie != eps.size(); ie++) {
|
|
if (epsIndex[ie] >= 0)
|
|
gvss[epsIndex[ie]].slices.push_back(eps[ie]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
std::string fix_slicing_errors(PrintObject* object, LayerPtrs &layers, const std::function<void()> &throw_if_canceled, int &firstLayerReplacedBy)
|
|
{
|
|
std::string error_msg;//BBS
|
|
|
|
if (layers.size() == 0) return error_msg;
|
|
|
|
// Collect layers with slicing errors.
|
|
// These layers will be fixed in parallel.
|
|
std::vector<size_t> buggy_layers;
|
|
buggy_layers.reserve(layers.size());
|
|
// BBS: get largest external perimenter width of all layers
|
|
auto get_ext_peri_width = [](Layer* layer) {return layer->m_regions.empty() ? 0 : layer->m_regions[0]->flow(frExternalPerimeter).scaled_width(); };
|
|
auto it = std::max_element(layers.begin(), layers.end(), [get_ext_peri_width](auto& a, auto& b) {return get_ext_peri_width(a) < get_ext_peri_width(b); });
|
|
coord_t thresh = get_ext_peri_width(*it) * 0.5;// half of external perimeter width // 0.5 * scale_(this->config().line_width);
|
|
for (size_t idx_layer = 0; idx_layer < layers.size(); ++idx_layer) {
|
|
// BBS: detect empty layers (layers with very small regions) and mark them as problematic, then these layers will copy the nearest good layer
|
|
auto layer = layers[idx_layer];
|
|
ExPolygons lslices;
|
|
for (size_t region_id = 0; region_id < layer->m_regions.size(); ++region_id) {
|
|
LayerRegion* layerm = layer->m_regions[region_id];
|
|
for (auto& surface : layerm->slices.surfaces) {
|
|
auto expoly = offset_ex(surface.expolygon, -thresh);
|
|
lslices.insert(lslices.begin(), expoly.begin(), expoly.end());
|
|
}
|
|
}
|
|
if (lslices.empty()) {
|
|
layer->slicing_errors = true;
|
|
}
|
|
|
|
if (layers[idx_layer]->slicing_errors) {
|
|
buggy_layers.push_back(idx_layer);
|
|
}
|
|
else
|
|
break; // only detect empty layers near bed
|
|
}
|
|
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing objects - fixing slicing errors in parallel - begin";
|
|
std::atomic<bool> is_replaced = false;
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, buggy_layers.size()),
|
|
[&layers, &throw_if_canceled, &buggy_layers, &is_replaced](const tbb::blocked_range<size_t>& range) {
|
|
for (size_t buggy_layer_idx = range.begin(); buggy_layer_idx < range.end(); ++ buggy_layer_idx) {
|
|
throw_if_canceled();
|
|
size_t idx_layer = buggy_layers[buggy_layer_idx];
|
|
// BBS: only replace empty layers lower than 1mm
|
|
const coordf_t thresh_empty_layer_height = 1;
|
|
Layer* layer = layers[idx_layer];
|
|
if (layer->print_z>= thresh_empty_layer_height)
|
|
continue;
|
|
assert(layer->slicing_errors);
|
|
// Try to repair the layer surfaces by merging all contours and all holes from neighbor layers.
|
|
// BOOST_LOG_TRIVIAL(trace) << "Attempting to repair layer" << idx_layer;
|
|
for (size_t region_id = 0; region_id < layer->region_count(); ++ region_id) {
|
|
LayerRegion *layerm = layer->get_region(region_id);
|
|
// Find the first valid layer below / above the current layer.
|
|
const Surfaces *upper_surfaces = nullptr;
|
|
const Surfaces *lower_surfaces = nullptr;
|
|
//BBS: only repair empty layers lowers than 1mm
|
|
for (size_t j = idx_layer + 1; j < layers.size(); ++j) {
|
|
if (!layers[j]->slicing_errors) {
|
|
upper_surfaces = &layers[j]->regions()[region_id]->slices.surfaces;
|
|
break;
|
|
}
|
|
if (layers[j]->print_z >= thresh_empty_layer_height) break;
|
|
}
|
|
for (int j = int(idx_layer) - 1; j >= 0; --j) {
|
|
if (layers[j]->print_z >= thresh_empty_layer_height) continue;
|
|
if (!layers[j]->slicing_errors) {
|
|
lower_surfaces = &layers[j]->regions()[region_id]->slices.surfaces;
|
|
break;
|
|
}
|
|
}
|
|
// Collect outer contours and holes from the valid layers above & below.
|
|
ExPolygons expolys;
|
|
expolys.reserve(
|
|
((upper_surfaces == nullptr) ? 0 : upper_surfaces->size()) +
|
|
((lower_surfaces == nullptr) ? 0 : lower_surfaces->size()));
|
|
if (upper_surfaces)
|
|
for (const auto &surface : *upper_surfaces) {
|
|
expolys.emplace_back(surface.expolygon);
|
|
}
|
|
if (lower_surfaces)
|
|
for (const auto &surface : *lower_surfaces) {
|
|
expolys.emplace_back(surface.expolygon);
|
|
}
|
|
if (!expolys.empty()) {
|
|
//BBS
|
|
is_replaced = true;
|
|
layerm->slices.set(union_ex(expolys), stInternal);
|
|
}
|
|
}
|
|
// Update layer slices after repairing the single regions.
|
|
layer->make_slices();
|
|
}
|
|
});
|
|
throw_if_canceled();
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing objects - fixing slicing errors in parallel - end";
|
|
|
|
if(is_replaced)
|
|
error_msg = L("Empty layers around bottom are replaced by nearest normal layers.");
|
|
|
|
// remove empty layers from bottom
|
|
while (! layers.empty() && (layers.front()->lslices.empty() || layers.front()->empty())) {
|
|
delete layers.front();
|
|
layers.erase(layers.begin());
|
|
layers.front()->lower_layer = nullptr;
|
|
for (size_t i = 0; i < layers.size(); ++ i)
|
|
layers[i]->set_id(layers[i]->id() - 1);
|
|
}
|
|
|
|
//BBS
|
|
if(error_msg.empty() && !buggy_layers.empty())
|
|
error_msg = L("The model has too many empty layers.");
|
|
|
|
// BBS: first layer slices are sorted by volume group, if the first layer is empty and replaced by the 2nd layer
|
|
// the later will be stored in "object->firstLayerObjGroupsMod()"
|
|
if (!buggy_layers.empty() && buggy_layers.front() == 0 && layers.size() > 1)
|
|
firstLayerReplacedBy = 1;
|
|
|
|
return error_msg;
|
|
}
|
|
*/
|
|
|
|
void groupingVolumesForBrim(PrintObject* object, LayerPtrs& layers, int firstLayerReplacedBy)
|
|
{
|
|
const auto scaled_resolution = scaled<double>(object->print()->config().resolution.value);
|
|
auto partsObjSliceByVolume = findPartVolumes(object->firstLayerObjSliceMod(), object->model_object()->volumes);
|
|
groupingVolumes(partsObjSliceByVolume, object->firstLayerObjGroupsMod(), scaled_resolution, firstLayerReplacedBy);
|
|
applyNegtiveVolumes(object->model_object()->volumes, object->firstLayerObjSliceMod(), object->firstLayerObjGroupsMod(), scaled_resolution);
|
|
|
|
// BBS: the actual first layer slices stored in layers are re-sorted by volume group and will be used to generate brim
|
|
reGroupingLayerPolygons(object->firstLayerObjGroupsMod(), layers.front()->lslices, scaled_resolution);
|
|
}
|
|
|
|
// Called by make_perimeters()
|
|
// 1) Decides Z positions of the layers,
|
|
// 2) Initializes layers and their regions
|
|
// 3) Slices the object meshes
|
|
// 4) Slices the modifier meshes and reclassifies the slices of the object meshes by the slices of the modifier meshes
|
|
// 5) Applies size compensation (offsets the slices in XY plane)
|
|
// 6) Replaces bad slices by the slices reconstructed from the upper/lower layer
|
|
// Resulting expolygons of layer regions are marked as Internal.
|
|
void PrintObject::slice()
|
|
{
|
|
if (! this->set_started(posSlice))
|
|
return;
|
|
//BBS: add flag to reload scene for shell rendering
|
|
m_print->set_status(5, L("Slicing mesh"), PrintBase::SlicingStatus::RELOAD_SCENE);
|
|
std::vector<coordf_t> layer_height_profile;
|
|
this->update_layer_height_profile(*this->model_object(), m_slicing_params, layer_height_profile);
|
|
m_print->throw_if_canceled();
|
|
m_typed_slices = false;
|
|
// The belt state below is only written while belt mode is on (and the min-Z
|
|
// lift only when there is a rotation or remap). Start every slice from zero,
|
|
// or a project switched from a belt printer to a normal one, or whose tilt
|
|
// axis was set to None, keeps the previous offsets: the adaptive infill octree
|
|
// and the organic support layers (PrintObject.cpp) would still be shifted by
|
|
// them.
|
|
m_belt_min_z = 0.;
|
|
m_belt_global_z_offset = 0.;
|
|
this->clear_layers();
|
|
m_layers = new_layers(this, generate_object_layers(m_slicing_params, layer_height_profile, m_config.precise_z_height.value));
|
|
this->slice_volumes();
|
|
m_print->throw_if_canceled();
|
|
|
|
// Belt floor Z-shift: where is the belt surface in final slicer space?
|
|
//
|
|
// The belt surface is the model's Z=0 plane. After the belt rotation and the
|
|
// Z-shift it is the plane Z_belt = shear_factor * from_axis + z_shift_val in
|
|
// slicer space, with z_shift_val = max(0, -m_belt_min_z), the lift that starts
|
|
// the slicing frame at the belt below the footprint.
|
|
if (std::abs(m_slicing_params.belt_floor_shear_factor) > EPSILON) {
|
|
double z_shift_val = (m_belt_min_z < 0.) ? -m_belt_min_z : 0.;
|
|
// The belt surface is at Z=0 in centered slicer space and bb.min.z() is
|
|
// already folded into m_belt_min_z.
|
|
m_slicing_params.belt_floor_z_shift = z_shift_val;
|
|
}
|
|
|
|
int firstLayerReplacedBy = 0;
|
|
|
|
#if 0
|
|
// Fix the model.
|
|
//FIXME is this the right place to do? It is done repeateadly at the UI and now here at the backend.
|
|
std::string warning = fix_slicing_errors(this, m_layers, [this](){ m_print->throw_if_canceled(); }, firstLayerReplacedBy);
|
|
m_print->throw_if_canceled();
|
|
//BBS: send warning message to slicing callback
|
|
// This warning is inaccurate, because the empty layers may have been replaced, or the model has supports.
|
|
//if (!warning.empty()) {
|
|
// BOOST_LOG_TRIVIAL(info) << warning;
|
|
// this->active_step_add_warning(PrintStateBase::WarningLevel::CRITICAL, warning, PrintStateBase::SlicingReplaceInitEmptyLayers);
|
|
//}
|
|
#endif
|
|
|
|
// Detect and process holes that should be converted to polyholes
|
|
this->_transform_hole_to_polyholes();
|
|
|
|
// BBS: the actual first layer slices stored in layers are re-sorted by volume group and will be used to generate brim
|
|
groupingVolumesForBrim(this, m_layers, firstLayerReplacedBy);
|
|
|
|
// Update bounding boxes, back up raw slices of complex models.
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, m_layers.size()),
|
|
[this](const tbb::blocked_range<size_t>& range) {
|
|
for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++ layer_idx) {
|
|
m_print->throw_if_canceled();
|
|
Layer &layer = *m_layers[layer_idx];
|
|
layer.lslices_bboxes.clear();
|
|
layer.lslices_bboxes.reserve(layer.lslices.size());
|
|
for (const ExPolygon &expoly : layer.lslices)
|
|
layer.lslices_bboxes.emplace_back(get_extents(expoly));
|
|
layer.backup_untyped_slices();
|
|
}
|
|
});
|
|
if (m_layers.empty())
|
|
throw Slic3r::SlicingError(L("No layers were detected. You might want to repair the model or check its size or thickness and retry.\n"));
|
|
|
|
// Belt printer: offset all layer Z values so objects at different positions
|
|
// along the belt print at different heights on the tilted belt. This is a
|
|
// post-slicing adjustment: the sliced geometry is the same, only the output Z
|
|
// coordinates change.
|
|
{
|
|
const auto &pcfg = this->print()->config();
|
|
BOOST_LOG_TRIVIAL(trace) << "Belt global check: belt_printer=" << pcfg.belt_printer.value
|
|
<< " belt_slice_rotation=" << int(pcfg.belt_slice_rotation.value)
|
|
<< " object=" << this->model_object()->name;
|
|
if (pcfg.belt_printer.value) {
|
|
|
|
Point inst_shift = this->instances().empty() ? Point(0, 0)
|
|
: this->instances().front().shift - this->center_offset();
|
|
BOOST_LOG_TRIVIAL(trace) << "Belt global: object " << this->model_object()->name
|
|
<< " instances=" << this->instances().size()
|
|
<< " shift=(" << unscale<double>(inst_shift.x()) << ", " << unscale<double>(inst_shift.y()) << ")";
|
|
|
|
// Per-object Z-shift compensation, applied regardless of global mode.
|
|
//
|
|
// BeltSliceStrategy::apply_preslice_transforms lifts the mesh by max(0, -m_belt_min_z)
|
|
// so the slicer can slice with slicer_z >= 0. BeltBackTransform inverts
|
|
// build_forward_transform() which DOES NOT include this per-object
|
|
// Z-shift (it's not known until vertex scan time). Result: G-code
|
|
// coords emerge offset by the un-undone Z-shift — the inverse rotation
|
|
// couples slicer_z back into both machine_y and machine_z. Compensating
|
|
// layer.print_z by belt_z_shift here makes the back-transform produce
|
|
// correct machine-frame coordinates whether or not a global mode is active.
|
|
// The compensation must mirror the Z-shift actually applied, which
|
|
// is max(0, -m_belt_min_z): when the transformed mesh starts ABOVE
|
|
// slicer Z=0 (m_belt_min_z > 0 — possible for counter-rotated or
|
|
// asymmetric geometry whose centered-frame minimum lands positive)
|
|
// no lift was applied, and an unclamped m_belt_min_z here would
|
|
// leak straight into the layer Z values, floating the whole object
|
|
// off the belt by exactly that amount.
|
|
double belt_z_shift = std::min(m_belt_min_z, 0.); // the belt surface is Z=0 in centered slicer space
|
|
double global_z_offset = belt_z_shift;
|
|
|
|
// Centering correction: trafo_centered pretranslates by
|
|
// -m_center_offset.{x,y}. Under the belt forward transform, the
|
|
// Y component of that pretranslate couples into slicer-Z (shear:
|
|
// tan*c.y, rotation: sin*c.y). BeltBackTransform inverts the
|
|
// rotation/shear but doesn't undo centering, so this Z component
|
|
// leaks into machine output as a position offset whenever
|
|
// m_center_offset != 0. When a user moves a volume within an
|
|
// assembly such that the combined bbox center shifts, this shows
|
|
// up as a small Z translation in the print. Compensate by adding
|
|
// the Z component of the centering through the forward transform.
|
|
{
|
|
Transform3d T_fwd = BeltTransformPipeline::build_forward_transform(pcfg);
|
|
Vec3d c_off(unscale<double>(m_center_offset.x()),
|
|
unscale<double>(m_center_offset.y()),
|
|
0.);
|
|
double centering_z_corr = (T_fwd.linear() * c_off).z();
|
|
global_z_offset += centering_z_corr;
|
|
}
|
|
|
|
{
|
|
// Global pre-slice mode: compute full correction c = (T.linear() - I) * d
|
|
// where T is the belt forward transform and d is the bed position, so
|
|
// objects at different bed positions print at different machine Z values
|
|
// along the inclined belt.
|
|
Transform3d T = BeltTransformPipeline::build_forward_transform(pcfg);
|
|
Vec3d d(unscale<double>(inst_shift.x()), unscale<double>(inst_shift.y()), 0.);
|
|
Vec3d c = T.linear() * d - d;
|
|
global_z_offset += c.z();
|
|
|
|
BOOST_LOG_TRIVIAL(trace) << "Belt preslice_global: correction=("
|
|
<< c.x() << ", " << c.y() << ", " << c.z() << ")"
|
|
<< " belt_z_shift=" << belt_z_shift << " (m_belt_min_z=" << m_belt_min_z << ")";
|
|
}
|
|
|
|
BOOST_LOG_TRIVIAL(trace) << "Belt global: z_offset=" << global_z_offset
|
|
<< " (" << this->print()->objects().size() << " objects on the plate)";
|
|
m_belt_global_z_offset = global_z_offset;
|
|
if (std::abs(global_z_offset) > EPSILON) {
|
|
for (Layer *layer : m_layers)
|
|
layer->print_z += global_z_offset;
|
|
// Keep belt floor clipping in sync with the shifted print_z
|
|
// values — the support generator sees globally-offset object
|
|
// layer print_z, so belt_floor_z_shift must match.
|
|
m_slicing_params.belt_floor_z_shift += global_z_offset;
|
|
}
|
|
if (!m_layers.empty()) {
|
|
BOOST_LOG_TRIVIAL(trace) << "Belt global: first_layer_z=" << m_layers.front()->print_z
|
|
<< " last_layer_z=" << m_layers.back()->print_z
|
|
<< " num_layers=" << m_layers.size()
|
|
<< " center_offset=(" << unscale<double>(m_center_offset.x())
|
|
<< ", " << unscale<double>(m_center_offset.y()) << ")";
|
|
}
|
|
|
|
// Cache the final patched belt_floor_z_shift so a later support-only
|
|
// invalidation can rebuild m_slicing_params without losing this exact
|
|
// (vertex-scan-derived) value. update_slicing_parameters() will
|
|
// restore it after create_from_config() seeds the bbox approximation.
|
|
m_belt_floor_z_shift_cached = m_slicing_params.belt_floor_z_shift;
|
|
m_belt_floor_z_shift_cache_valid = true;
|
|
}
|
|
}
|
|
|
|
// BBS
|
|
this->set_done(posSlice);
|
|
}
|
|
|
|
template<typename ThrowOnCancel>
|
|
static inline void apply_mm_segmentation(PrintObject &print_object, ThrowOnCancel throw_on_cancel)
|
|
{
|
|
// Returns MM segmentation based on painting in MM segmentation gizmo
|
|
std::vector<std::vector<ExPolygons>> segmentation = multi_material_segmentation_by_painting(print_object, throw_on_cancel);
|
|
assert(segmentation.size() == print_object.layer_count());
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, segmentation.size(), std::max(segmentation.size() / 128, size_t(1))),
|
|
[&print_object, &segmentation, throw_on_cancel](const tbb::blocked_range<size_t> &range) {
|
|
const auto &layer_ranges = print_object.shared_regions()->layer_ranges;
|
|
double z = print_object.get_layer(int(range.begin()))->slice_z;
|
|
auto it_layer_range = layer_range_first(layer_ranges, z);
|
|
// BBS
|
|
const size_t num_extruders = print_object.print()->config().filament_diameter.size();
|
|
|
|
struct ByExtruder {
|
|
ExPolygons expolygons;
|
|
BoundingBox bbox;
|
|
};
|
|
|
|
struct ByRegion {
|
|
ExPolygons expolygons;
|
|
bool needs_merge { false };
|
|
};
|
|
|
|
std::vector<ByExtruder> by_extruder;
|
|
std::vector<ByRegion> by_region;
|
|
for (size_t layer_id = range.begin(); layer_id < range.end(); ++layer_id) {
|
|
throw_on_cancel();
|
|
Layer &layer = *print_object.get_layer(int(layer_id));
|
|
it_layer_range = layer_range_next(layer_ranges, it_layer_range, layer.slice_z);
|
|
const PrintObjectRegions::LayerRangeRegions &layer_range = *it_layer_range;
|
|
// Gather per extruder expolygons.
|
|
by_extruder.assign(num_extruders, ByExtruder());
|
|
by_region.assign(layer.region_count(), ByRegion());
|
|
bool layer_split = false;
|
|
for (size_t extruder_id = 0; extruder_id < num_extruders; ++ extruder_id) {
|
|
ByExtruder ®ion = by_extruder[extruder_id];
|
|
append(region.expolygons, std::move(segmentation[layer_id][extruder_id]));
|
|
if (! region.expolygons.empty()) {
|
|
region.bbox = get_extents(region.expolygons);
|
|
layer_split = true;
|
|
}
|
|
}
|
|
|
|
if (!layer_split)
|
|
continue;
|
|
|
|
// Split LayerRegions by by_extruder regions.
|
|
// layer_range.painted_regions are sorted by extruder ID and parent PrintObject region ID.
|
|
auto it_painted_region_begin = layer_range.painted_regions.cbegin();
|
|
for (int parent_layer_region_idx = 0; parent_layer_region_idx < layer.region_count(); ++parent_layer_region_idx) {
|
|
if (it_painted_region_begin == layer_range.painted_regions.cend())
|
|
continue;
|
|
|
|
const LayerRegion &parent_layer_region = *layer.get_region(parent_layer_region_idx);
|
|
const PrintRegion &parent_print_region = parent_layer_region.region();
|
|
assert(parent_print_region.print_object_region_id() == parent_layer_region_idx);
|
|
if (parent_layer_region.slices.empty())
|
|
continue;
|
|
|
|
// Find the first PaintedRegion, which overrides the parent PrintRegion.
|
|
auto it_first_painted_region = std::find_if(it_painted_region_begin, layer_range.painted_regions.cend(), [&layer_range, &parent_print_region](const auto &painted_region) {
|
|
return layer_range.volume_regions[painted_region.parent].region->print_object_region_id() == parent_print_region.print_object_region_id();
|
|
});
|
|
|
|
if (it_first_painted_region == layer_range.painted_regions.cend())
|
|
continue; // This LayerRegion isn't overrides by any PaintedRegion.
|
|
|
|
assert(&parent_print_region == layer_range.volume_regions[it_first_painted_region->parent].region);
|
|
|
|
// Update the beginning PaintedRegion iterator for the next iteration.
|
|
it_painted_region_begin = it_first_painted_region;
|
|
|
|
const BoundingBox parent_layer_region_bbox = get_extents(parent_layer_region.slices.surfaces);
|
|
bool self_trimmed = false;
|
|
int self_extruder_id = -1; // 1-based extruder ID
|
|
for (int extruder_id = 1; extruder_id <= int(by_extruder.size()); ++extruder_id) {
|
|
const ByExtruder &segmented = by_extruder[extruder_id - 1];
|
|
if (!segmented.bbox.defined || !parent_layer_region_bbox.overlap(segmented.bbox))
|
|
continue;
|
|
|
|
// Find the first target region iterator.
|
|
auto it_target_region = std::find_if(it_painted_region_begin, layer_range.painted_regions.cend(), [extruder_id](const auto &painted_region) {
|
|
return int(painted_region.extruder_id) >= extruder_id;
|
|
});
|
|
|
|
assert(it_target_region != layer_range.painted_regions.end());
|
|
assert(layer_range.volume_regions[it_target_region->parent].region == &parent_print_region && int(it_target_region->extruder_id) == extruder_id);
|
|
|
|
// Update the beginning PaintedRegion iterator for the next iteration.
|
|
it_painted_region_begin = it_target_region;
|
|
|
|
// FIXME: Don't trim by self, it is not reliable.
|
|
if (it_target_region->region == &parent_print_region) {
|
|
self_extruder_id = extruder_id;
|
|
continue;
|
|
}
|
|
|
|
// Steal from this region.
|
|
int target_region_id = it_target_region->region->print_object_region_id();
|
|
ExPolygons stolen = intersection_ex(parent_layer_region.slices.surfaces, segmented.expolygons);
|
|
if (!stolen.empty()) {
|
|
ByRegion &dst = by_region[target_region_id];
|
|
if (dst.expolygons.empty()) {
|
|
dst.expolygons = std::move(stolen);
|
|
} else {
|
|
append(dst.expolygons, std::move(stolen));
|
|
dst.needs_merge = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!self_trimmed) {
|
|
// Trim slices of this LayerRegion with all the MM regions.
|
|
Polygons mine = to_polygons(parent_layer_region.slices.surfaces);
|
|
for (auto &segmented : by_extruder) {
|
|
if (&segmented - by_extruder.data() + 1 != self_extruder_id && segmented.bbox.defined && parent_layer_region_bbox.overlap(segmented.bbox)) {
|
|
mine = diff(mine, segmented.expolygons);
|
|
if (mine.empty())
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Filter out unprintable polygons produced by subtraction multi-material painted regions from layerm.region().
|
|
// ExPolygon returned from multi-material segmentation does not precisely match ExPolygons in layerm.region()
|
|
// (because of preprocessing of the input regions in multi-material segmentation). Therefore, subtraction from
|
|
// layerm.region() could produce a huge number of small unprintable regions for the model's base extruder.
|
|
// This could, on some models, produce bulges with the model's base color (#7109).
|
|
if (!mine.empty()) {
|
|
mine = opening(union_ex(mine), scaled<float>(5. * EPSILON), scaled<float>(5. * EPSILON));
|
|
}
|
|
|
|
if (!mine.empty()) {
|
|
ByRegion &dst = by_region[parent_print_region.print_object_region_id()];
|
|
if (dst.expolygons.empty()) {
|
|
dst.expolygons = union_ex(mine);
|
|
} else {
|
|
append(dst.expolygons, union_ex(mine));
|
|
dst.needs_merge = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Re-create Surfaces of LayerRegions.
|
|
for (int region_id = 0; region_id < layer.region_count(); ++region_id) {
|
|
ByRegion &src = by_region[region_id];
|
|
if (src.needs_merge) {
|
|
// Multiple regions were merged into one.
|
|
src.expolygons = closing_ex(src.expolygons, scaled<float>(10. * EPSILON));
|
|
}
|
|
|
|
layer.get_region(region_id)->slices.set(std::move(src.expolygons), stInternal);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
template<typename ThrowOnCancel>
|
|
void apply_fuzzy_skin_segmentation(PrintObject &print_object, ThrowOnCancel throw_on_cancel)
|
|
{
|
|
// Returns fuzzy skin segmentation based on painting in the fuzzy skin painting gizmo.
|
|
std::vector<std::vector<ExPolygons>> segmentation = fuzzy_skin_segmentation_by_painting(print_object, throw_on_cancel);
|
|
assert(segmentation.size() == print_object.layer_count());
|
|
|
|
struct ByRegion
|
|
{
|
|
ExPolygons expolygons;
|
|
bool needs_merge { false };
|
|
};
|
|
|
|
tbb::parallel_for(tbb::blocked_range<size_t>(0, segmentation.size(), std::max(segmentation.size() / 128, size_t(1))), [&print_object, &segmentation, throw_on_cancel](const tbb::blocked_range<size_t> &range) {
|
|
const auto &layer_ranges = print_object.shared_regions()->layer_ranges;
|
|
auto it_layer_range = layer_range_first(layer_ranges, print_object.get_layer(int(range.begin()))->slice_z);
|
|
|
|
for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
|
|
throw_on_cancel();
|
|
|
|
Layer &layer = *print_object.get_layer(int(layer_idx));
|
|
it_layer_range = layer_range_next(layer_ranges, it_layer_range, layer.slice_z);
|
|
const PrintObjectRegions::LayerRangeRegions &layer_range = *it_layer_range;
|
|
|
|
assert(segmentation[layer_idx].size() == 1);
|
|
const ExPolygons &fuzzy_skin_segmentation = segmentation[layer_idx][0];
|
|
const BoundingBox fuzzy_skin_segmentation_bbox = get_extents(fuzzy_skin_segmentation);
|
|
if (fuzzy_skin_segmentation.empty())
|
|
continue;
|
|
|
|
// Split LayerRegions by painted fuzzy skin regions.
|
|
// layer_range.fuzzy_skin_painted_regions are sorted by parent PrintObject region ID.
|
|
std::vector<ByRegion> by_region(layer.region_count());
|
|
auto it_fuzzy_skin_region_begin = layer_range.fuzzy_skin_painted_regions.cbegin();
|
|
for (int parent_layer_region_idx = 0; parent_layer_region_idx < layer.region_count(); ++parent_layer_region_idx) {
|
|
if (it_fuzzy_skin_region_begin == layer_range.fuzzy_skin_painted_regions.cend())
|
|
continue;
|
|
|
|
const LayerRegion &parent_layer_region = *layer.get_region(parent_layer_region_idx);
|
|
const PrintRegion &parent_print_region = parent_layer_region.region();
|
|
assert(parent_print_region.print_object_region_id() == parent_layer_region_idx);
|
|
if (parent_layer_region.slices.empty())
|
|
continue;
|
|
|
|
// Find the first FuzzySkinPaintedRegion, which overrides the parent PrintRegion.
|
|
auto it_fuzzy_skin_region = std::find_if(it_fuzzy_skin_region_begin, layer_range.fuzzy_skin_painted_regions.cend(), [&layer_range, &parent_print_region](const auto &fuzzy_skin_region) {
|
|
return fuzzy_skin_region.parent_print_object_region_id(layer_range) == parent_print_region.print_object_region_id();
|
|
});
|
|
|
|
if (it_fuzzy_skin_region == layer_range.fuzzy_skin_painted_regions.cend())
|
|
continue; // This LayerRegion isn't overrides by any FuzzySkinPaintedRegion.
|
|
|
|
assert(it_fuzzy_skin_region->parent_print_object_region(layer_range) == &parent_print_region);
|
|
|
|
// Update the beginning FuzzySkinPaintedRegion iterator for the next iteration.
|
|
it_fuzzy_skin_region_begin = std::next(it_fuzzy_skin_region);
|
|
|
|
const BoundingBox parent_layer_region_bbox = get_extents(parent_layer_region.slices.surfaces);
|
|
Polygons layer_region_remaining_polygons = to_polygons(parent_layer_region.slices.surfaces);
|
|
// Don't trim by self, it is not reliable.
|
|
if (parent_layer_region_bbox.overlap(fuzzy_skin_segmentation_bbox) && it_fuzzy_skin_region->region != &parent_print_region) {
|
|
// Steal from this region.
|
|
const int target_region_id = it_fuzzy_skin_region->region->print_object_region_id();
|
|
ExPolygons stolen = intersection_ex(parent_layer_region.slices.surfaces, fuzzy_skin_segmentation);
|
|
if (!stolen.empty()) {
|
|
ByRegion &dst = by_region[target_region_id];
|
|
if (dst.expolygons.empty()) {
|
|
dst.expolygons = std::move(stolen);
|
|
} else {
|
|
append(dst.expolygons, std::move(stolen));
|
|
dst.needs_merge = true;
|
|
}
|
|
}
|
|
|
|
// Trim slices of this LayerRegion by the fuzzy skin region.
|
|
layer_region_remaining_polygons = diff(layer_region_remaining_polygons, fuzzy_skin_segmentation);
|
|
|
|
// Filter out unprintable polygons. Detailed explanation is inside apply_mm_segmentation.
|
|
if (!layer_region_remaining_polygons.empty()) {
|
|
layer_region_remaining_polygons = opening(union_ex(layer_region_remaining_polygons), scaled<float>(5. * EPSILON), scaled<float>(5. * EPSILON));
|
|
}
|
|
}
|
|
|
|
if (!layer_region_remaining_polygons.empty()) {
|
|
ByRegion &dst = by_region[parent_print_region.print_object_region_id()];
|
|
if (dst.expolygons.empty()) {
|
|
dst.expolygons = union_ex(layer_region_remaining_polygons);
|
|
} else {
|
|
append(dst.expolygons, union_ex(layer_region_remaining_polygons));
|
|
dst.needs_merge = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Re-create Surfaces of LayerRegions.
|
|
for (int region_id = 0; region_id < layer.region_count(); ++region_id) {
|
|
ByRegion &src = by_region[region_id];
|
|
if (src.needs_merge) {
|
|
// Multiple regions were merged into one.
|
|
src.expolygons = closing_ex(src.expolygons, scaled<float>(10. * EPSILON));
|
|
}
|
|
|
|
layer.get_region(region_id)->slices.set(std::move(src.expolygons), stInternal);
|
|
}
|
|
}
|
|
}); // end of parallel_for
|
|
}
|
|
|
|
|
|
// 1) Decides Z positions of the layers,
|
|
// 2) Initializes layers and their regions
|
|
// 3) Slices the object meshes
|
|
// 4) Slices the modifier meshes and reclassifies the slices of the object meshes by the slices of the modifier meshes
|
|
// 5) Applies size compensation (offsets the slices in XY plane)
|
|
// 6) Replaces bad slices by the slices reconstructed from the upper/lower layer
|
|
// Resulting expolygons of layer regions are marked as Internal.
|
|
//
|
|
// this should be idempotent
|
|
void PrintObject::slice_volumes()
|
|
{
|
|
BOOST_LOG_TRIVIAL(info) << "Slicing volumes..." << log_memory_info();
|
|
const Print *print = this->print();
|
|
const auto throw_on_cancel_callback = std::function<void()>([print](){ print->throw_if_canceled(); });
|
|
|
|
// Clear old LayerRegions, allocate for new PrintRegions.
|
|
for (Layer* layer : m_layers) {
|
|
//BBS: should delete all LayerRegionPtr to avoid memory leak
|
|
while (!layer->m_regions.empty()) {
|
|
if (layer->m_regions.back())
|
|
delete layer->m_regions.back();
|
|
layer->m_regions.pop_back();
|
|
}
|
|
layer->m_regions.reserve(m_shared_regions->all_regions.size());
|
|
for (const std::unique_ptr<PrintRegion> &pr : m_shared_regions->all_regions)
|
|
layer->m_regions.emplace_back(new LayerRegion(layer, pr.get()));
|
|
}
|
|
|
|
std::vector<float> slice_zs = zs_from_layers(m_layers);
|
|
std::vector<VolumeSlices> objSliceByVolume;
|
|
if (!slice_zs.empty()) {
|
|
objSliceByVolume = slice_volumes_inner(
|
|
print->config(), this->config(), this->trafo_centered(),
|
|
this->model_object()->volumes, m_shared_regions->layer_ranges, slice_zs, throw_on_cancel_callback,
|
|
&m_belt_min_z);
|
|
}
|
|
|
|
//BBS: "model_part" volumes are grouded according to their connections
|
|
//const auto scaled_resolution = scaled<double>(print->config().resolution.value);
|
|
//firstLayerObjSliceByVolume = findPartVolumes(objSliceByVolume, this->model_object()->volumes);
|
|
//groupingVolumes(objSliceByVolumeParts, firstLayerObjSliceByGroups, scaled_resolution);
|
|
//applyNegtiveVolumes(this->model_object()->volumes, objSliceByVolume, firstLayerObjSliceByGroups, scaled_resolution);
|
|
firstLayerObjSliceByVolume = objSliceByVolume;
|
|
|
|
std::vector<std::vector<ExPolygons>> region_slices =
|
|
slices_to_regions(print->config(), *this, this->model_object()->volumes, *m_shared_regions, slice_zs,
|
|
std::move(objSliceByVolume), PrintObject::clip_multipart_objects, throw_on_cancel_callback);
|
|
|
|
for (size_t region_id = 0; region_id < region_slices.size(); ++ region_id) {
|
|
std::vector<ExPolygons> &by_layer = region_slices[region_id];
|
|
for (size_t layer_id = 0; layer_id < by_layer.size(); ++ layer_id)
|
|
m_layers[layer_id]->regions()[region_id]->slices.append(std::move(by_layer[layer_id]), stInternal);
|
|
}
|
|
region_slices.clear();
|
|
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing volumes - removing top empty layers";
|
|
while (! m_layers.empty()) {
|
|
const Layer *layer = m_layers.back();
|
|
if (! layer->empty())
|
|
break;
|
|
delete layer;
|
|
m_layers.pop_back();
|
|
}
|
|
if (! m_layers.empty())
|
|
m_layers.back()->upper_layer = nullptr;
|
|
m_print->throw_if_canceled();
|
|
|
|
this->apply_conical_overhang();
|
|
|
|
// Is any ModelVolume multi-material painted?
|
|
if (const auto& volumes = this->model_object()->volumes;
|
|
m_print->config().filament_diameter.size() > 1 && // BBS
|
|
std::find_if(volumes.begin(), volumes.end(), [](const ModelVolume* v) { return !v->mmu_segmentation_facets.empty(); }) != volumes.end()) {
|
|
|
|
// If XY Size compensation is also enabled, notify the user that XY Size compensation
|
|
// would not be used because the object is multi-material painted.
|
|
if (m_config.xy_hole_compensation.value != 0.f || m_config.xy_contour_compensation.value != 0.f) {
|
|
this->active_step_add_warning(
|
|
PrintStateBase::WarningLevel::CRITICAL,
|
|
L("An object's XY size compensation will not be used because it is also color-painted.\nXY Size "
|
|
"compensation cannot be combined with color-painting."));
|
|
BOOST_LOG_TRIVIAL(info) << "xy compensation will not work for object " << this->model_object()->name << " for multi filament.";
|
|
}
|
|
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing volumes - MMU segmentation";
|
|
apply_mm_segmentation(*this, [print]() { print->throw_if_canceled(); });
|
|
}
|
|
|
|
// Is any ModelVolume fuzzy skin painted?
|
|
if (this->model_object()->is_fuzzy_skin_painted()) {
|
|
// If XY Size compensation is also enabled, notify the user that XY Size compensation
|
|
// would not be used because the object has custom fuzzy skin painted.
|
|
if (m_config.xy_hole_compensation.value != 0.f || m_config.xy_contour_compensation.value != 0.f) {
|
|
this->active_step_add_warning(
|
|
PrintStateBase::WarningLevel::CRITICAL,
|
|
_u8L("An object has enabled XY Size compensation which will not be used because it is also fuzzy skin painted.\nXY Size "
|
|
"compensation cannot be combined with fuzzy skin painting.") +
|
|
"\n" + (_u8L("Object name")) + ": " + this->model_object()->name);
|
|
}
|
|
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing volumes - Fuzzy skin segmentation";
|
|
apply_fuzzy_skin_segmentation(*this, [print]() { print->throw_if_canceled(); });
|
|
}
|
|
|
|
InterlockingGenerator::generate_interlocking_structure(this, [print]() { print->throw_if_canceled(); });
|
|
m_print->throw_if_canceled();
|
|
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing volumes - make_slices in parallel - begin";
|
|
{
|
|
// Compensation value, scaled. Only applying the negative scaling here, as the positive scaling has already been applied during slicing.
|
|
const size_t num_extruders = print->config().filament_diameter.size();
|
|
const auto xy_hole_scaled = (num_extruders > 1 && this->is_mm_painted()) ? scaled<float>(0.f) : scaled<float>(m_config.xy_hole_compensation.value);
|
|
const auto xy_contour_scaled = (num_extruders > 1 && this->is_mm_painted()) ? scaled<float>(0.f) : scaled<float>(m_config.xy_contour_compensation.value);
|
|
const float elephant_foot_compensation_scaled = (m_config.raft_layers == 0) ?
|
|
// Only enable Elephant foot compensation if printing directly on the print bed.
|
|
float(scale_(m_config.elefant_foot_compensation.value)) :
|
|
0.f;
|
|
// Uncompensated slices for the layers in case the Elephant foot compensation is applied.
|
|
std::vector<ExPolygons> lslices_elfoot_uncompensated;
|
|
lslices_elfoot_uncompensated.resize(elephant_foot_compensation_scaled > 0 ? std::min(m_config.elefant_foot_compensation_layers.value, (int)m_layers.size()) : 0);
|
|
//BBS: this part has been changed a lot to support seperated contour and hole size compensation
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, m_layers.size()),
|
|
[this, xy_hole_scaled, xy_contour_scaled, elephant_foot_compensation_scaled, &lslices_elfoot_uncompensated](const tbb::blocked_range<size_t>& range) {
|
|
for (size_t layer_id = range.begin(); layer_id < range.end(); ++ layer_id) {
|
|
m_print->throw_if_canceled();
|
|
Layer *layer = m_layers[layer_id];
|
|
// Apply size compensation and perform clipping of multi-part objects.
|
|
float elfoot = elephant_foot_compensation_scaled > 0 && layer_id < m_config.elefant_foot_compensation_layers.value ?
|
|
elephant_foot_compensation_scaled - (elephant_foot_compensation_scaled / m_config.elefant_foot_compensation_layers.value) * layer_id :
|
|
0.f;
|
|
if (layer->m_regions.size() == 1) {
|
|
// Optimized version for a single region layer.
|
|
// Single region, growing or shrinking.
|
|
LayerRegion *layerm = layer->m_regions.front();
|
|
if (elfoot > 0) {
|
|
// Apply the elephant foot compensation and store the original layer slices without the Elephant foot compensation applied.
|
|
ExPolygons expolygons_to_compensate = to_expolygons(std::move(layerm->slices.surfaces));
|
|
if (xy_contour_scaled > 0 || xy_hole_scaled > 0) {
|
|
expolygons_to_compensate = _shrink_contour_holes(std::max(0.f, xy_contour_scaled),
|
|
std::max(0.f, xy_hole_scaled),
|
|
expolygons_to_compensate);
|
|
}
|
|
if (xy_contour_scaled < 0 || xy_hole_scaled < 0) {
|
|
expolygons_to_compensate = _shrink_contour_holes(std::min(0.f, xy_contour_scaled),
|
|
std::min(0.f, xy_hole_scaled),
|
|
expolygons_to_compensate);
|
|
}
|
|
lslices_elfoot_uncompensated[layer_id] = expolygons_to_compensate;
|
|
layerm->slices.set(
|
|
union_ex(
|
|
Slic3r::elephant_foot_compensation(expolygons_to_compensate,
|
|
layerm->flow(frExternalPerimeter), unscale<double>(elfoot))),
|
|
stInternal);
|
|
} else {
|
|
// Apply the XY contour and hole size compensation.
|
|
if (xy_contour_scaled != 0.0f || xy_hole_scaled != 0.0f) {
|
|
ExPolygons expolygons = to_expolygons(std::move(layerm->slices.surfaces));
|
|
if (xy_contour_scaled > 0 || xy_hole_scaled > 0) {
|
|
expolygons = _shrink_contour_holes(std::max(0.f, xy_contour_scaled),
|
|
std::max(0.f, xy_hole_scaled),
|
|
expolygons);
|
|
}
|
|
if (xy_contour_scaled < 0 || xy_hole_scaled < 0) {
|
|
expolygons = _shrink_contour_holes(std::min(0.f, xy_contour_scaled),
|
|
std::min(0.f, xy_hole_scaled),
|
|
expolygons);
|
|
}
|
|
layerm->slices.set(std::move(expolygons), stInternal);
|
|
}
|
|
}
|
|
} else {
|
|
float max_growth = std::max(xy_hole_scaled, xy_contour_scaled);
|
|
float min_growth = std::min(xy_hole_scaled, xy_contour_scaled);
|
|
ExPolygons merged_poly_for_holes_growing;
|
|
if (max_growth > 0) {
|
|
//BBS: merge polygons because region can cut "holes".
|
|
//Then, cut them to give them again later to their region
|
|
merged_poly_for_holes_growing = layer->merged(float(SCALED_EPSILON));
|
|
merged_poly_for_holes_growing = _shrink_contour_holes(std::max(0.f, xy_contour_scaled),
|
|
std::max(0.f, xy_hole_scaled),
|
|
union_ex(merged_poly_for_holes_growing));
|
|
|
|
// BBS: clipping regions, priority is given to the first regions.
|
|
Polygons processed;
|
|
for (size_t region_id = 0; region_id < layer->regions().size(); ++region_id) {
|
|
ExPolygons slices = to_expolygons(std::move(layer->m_regions[region_id]->slices.surfaces));
|
|
if (max_growth > 0.f) {
|
|
slices = intersection_ex(offset_ex(slices, max_growth), merged_poly_for_holes_growing);
|
|
}
|
|
|
|
//BBS: Trim by the slices of already processed regions.
|
|
if (region_id > 0)
|
|
slices = diff_ex(to_polygons(std::move(slices)), processed);
|
|
if (region_id + 1 < layer->regions().size())
|
|
// Collect the already processed regions to trim the to be processed regions.
|
|
polygons_append(processed, slices);
|
|
layer->m_regions[region_id]->slices.set(std::move(slices), stInternal);
|
|
}
|
|
}
|
|
if (min_growth < 0.f || elfoot > 0.f) {
|
|
// Apply the negative XY compensation. (the ones that is <0)
|
|
ExPolygons trimming;
|
|
const float eps = float(scale_(m_config.slice_closing_radius.value) * 1.5);
|
|
if (elfoot > 0.f) {
|
|
ExPolygons expolygons_to_compensate = offset_ex(layer->merged(eps), -eps);
|
|
lslices_elfoot_uncompensated[layer_id] = expolygons_to_compensate;
|
|
trimming = Slic3r::elephant_foot_compensation(expolygons_to_compensate,
|
|
layer->m_regions.front()->flow(frExternalPerimeter), unscale<double>(elfoot));
|
|
} else {
|
|
trimming = layer->merged(float(SCALED_EPSILON));
|
|
}
|
|
if (min_growth < 0.0f)
|
|
trimming = _shrink_contour_holes(std::min(0.f, xy_contour_scaled),
|
|
std::min(0.f, xy_hole_scaled),
|
|
trimming);
|
|
//BBS: trim surfaces
|
|
for (size_t region_id = 0; region_id < layer->regions().size(); ++region_id) {
|
|
// BBS: split trimming result by region
|
|
ExPolygons contour_exp = to_expolygons(std::move(layer->regions()[region_id]->slices.surfaces));
|
|
|
|
layer->regions()[region_id]->slices.set(intersection_ex(contour_exp, to_polygons(trimming)), stInternal);
|
|
}
|
|
}
|
|
}
|
|
// Merge all regions' slices to get islands, chain them by a shortest path.
|
|
layer->make_slices();
|
|
}
|
|
});
|
|
if (elephant_foot_compensation_scaled > 0.f && ! m_layers.empty()) {
|
|
// The Elephant foot has been compensated, therefore the elefant_foot_compensation_layers layer's lslices are shrank with the Elephant foot compensation value.
|
|
// Store the uncompensated value there.
|
|
assert(m_layers.front()->id() == 0);
|
|
//BBS: sort the lslices_elfoot_uncompensated according to shortest path before saving
|
|
//Otherwise the travel of the layer layer would be mess.
|
|
for (int i = 0; i < lslices_elfoot_uncompensated.size(); i++) {
|
|
ExPolygons &expolygons_uncompensated = lslices_elfoot_uncompensated[i];
|
|
Points ordering_points;
|
|
ordering_points.reserve(expolygons_uncompensated.size());
|
|
for (const ExPolygon &ex : expolygons_uncompensated)
|
|
ordering_points.push_back(ex.contour.first_point());
|
|
std::vector<Points::size_type> order = chain_points(ordering_points);
|
|
ExPolygons lslices_sorted;
|
|
lslices_sorted.reserve(expolygons_uncompensated.size());
|
|
for (size_t i : order)
|
|
lslices_sorted.emplace_back(std::move(expolygons_uncompensated[i]));
|
|
m_layers[i]->lslices = std::move(lslices_sorted);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_print->throw_if_canceled();
|
|
BOOST_LOG_TRIVIAL(debug) << "Slicing volumes - make_slices in parallel - end";
|
|
}
|
|
|
|
void PrintObject::apply_conical_overhang() {
|
|
BOOST_LOG_TRIVIAL(info) << "Make overhang printable...";
|
|
|
|
if (m_layers.empty()) {
|
|
return;
|
|
}
|
|
|
|
const double conical_overhang_angle = this->config().make_overhang_printable_angle;
|
|
if (conical_overhang_angle == 90.0) {
|
|
return;
|
|
}
|
|
const double angle_radians = conical_overhang_angle * M_PI / 180.;
|
|
const double max_hole_area = this->config().make_overhang_printable_hole_size; // in MM^2
|
|
const double tan_angle = tan(angle_radians); // the XY-component of the angle
|
|
BOOST_LOG_TRIVIAL(info) << "angle " << angle_radians << " maxHoleArea " << max_hole_area << " tan_angle "
|
|
<< tan_angle;
|
|
const coordf_t layer_thickness = m_config.layer_height.value;
|
|
const coordf_t max_dist_from_lower_layer = tan_angle * layer_thickness; // max dist which can be bridged, in MM
|
|
BOOST_LOG_TRIVIAL(info) << "layer_thickness " << layer_thickness << " max_dist_from_lower_layer "
|
|
<< max_dist_from_lower_layer;
|
|
|
|
// Pre-scale config
|
|
const coordf_t scaled_max_dist_from_lower_layer = -float(scale_(max_dist_from_lower_layer));
|
|
const coordf_t scaled_max_hole_area = float(scale_(scale_(max_hole_area)));
|
|
|
|
|
|
for (auto i = m_layers.rbegin() + 1; i != m_layers.rend(); ++i) {
|
|
m_print->throw_if_canceled();
|
|
Layer *layer = *i;
|
|
Layer *upper_layer = layer->upper_layer;
|
|
|
|
if (upper_layer->empty()) {
|
|
continue;
|
|
}
|
|
|
|
// Skip if entire layer has this disabled
|
|
if (std::all_of(layer->m_regions.begin(), layer->m_regions.end(),
|
|
[](const LayerRegion *r) { return r->slices.empty() || !r->region().config().make_overhang_printable; })) {
|
|
continue;
|
|
}
|
|
|
|
//layer->export_region_slices_to_svg_debug("layer_before_conical_overhang");
|
|
//upper_layer->export_region_slices_to_svg_debug("upper_layer_before_conical_overhang");
|
|
|
|
|
|
// Merge the upper layer because we want to offset the entire layer uniformly, otherwise
|
|
// the model could break at the region boundary.
|
|
auto upper_poly = upper_layer->merged(float(SCALED_EPSILON));
|
|
upper_poly = union_ex(upper_poly);
|
|
|
|
// Merge layer for the same reason
|
|
auto current_poly = layer->merged(float(SCALED_EPSILON));
|
|
current_poly = union_ex(current_poly);
|
|
|
|
// Avoid closing up of recessed holes in the base of a model.
|
|
// Detects when a hole is completely covered by the layer above and removes the hole from the layer above before
|
|
// adding it in.
|
|
// This should have no effect any time a hole in a layer interacts with any polygon in the layer above
|
|
if (scaled_max_hole_area > 0.0) {
|
|
|
|
// Now go through all the holes in the current layer and check if they intersect anything in the layer above
|
|
// If not, then they're the top of a hole and should be cut from the layer above before the union
|
|
for (auto layer_polygon : current_poly) {
|
|
for (auto hole : layer_polygon.holes) {
|
|
if (std::abs(hole.area()) < scaled_max_hole_area) {
|
|
ExPolygon hole_poly(hole);
|
|
auto hole_with_above = intersection_ex(upper_poly, hole_poly);
|
|
if (!hole_with_above.empty()) {
|
|
// The hole had some intersection with the above layer, check if it's a complete overlap
|
|
auto hole_difference = xor_ex(hole_with_above, hole_poly);
|
|
if (hole_difference.empty()) {
|
|
// The layer above completely cover it, remove it from the layer above
|
|
upper_poly = diff_ex(upper_poly, hole_poly);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now offset the upper layer to be added into current layer
|
|
upper_poly = offset_ex(upper_poly, scaled_max_dist_from_lower_layer);
|
|
|
|
for (size_t region_id = 0; region_id < this->num_printing_regions(); ++region_id) {
|
|
// export_to_svg(debug_out_path("Surface-obj-%d-layer-%d-region-%d.svg", id().id, layer->id(), region_id).c_str(),
|
|
// layer->m_regions[region_id]->slices.surfaces);
|
|
|
|
// Disable on given region
|
|
if (!upper_layer->m_regions[region_id]->region().config().make_overhang_printable) {
|
|
continue;
|
|
}
|
|
|
|
// Calculate the scaled upper poly that belongs to current region
|
|
auto p = union_ex(intersection_ex(upper_layer->m_regions[region_id]->slices.surfaces, upper_poly));
|
|
|
|
// Remove all islands that have already been fully covered by current layer
|
|
p.erase(std::remove_if(p.begin(), p.end(), [¤t_poly](const ExPolygon& ex) {
|
|
return diff_ex(ex, current_poly).empty();
|
|
}), p.end());
|
|
|
|
// And now union it with current region
|
|
ExPolygons layer_polygons = to_expolygons(layer->m_regions[region_id]->slices.surfaces);
|
|
layer->m_regions[region_id]->slices.set(union_ex(layer_polygons, p), stInternal);
|
|
|
|
// Then remove it from all other regions, to avoid overlapping regions
|
|
for (size_t other_region = 0; other_region < this->num_printing_regions(); ++other_region) {
|
|
if (other_region == region_id) {
|
|
continue;
|
|
}
|
|
ExPolygons s = to_expolygons(layer->m_regions[other_region]->slices.surfaces);
|
|
layer->m_regions[other_region]->slices.set(diff_ex(s, p, ApplySafetyOffset::Yes), stInternal);
|
|
}
|
|
}
|
|
//layer->export_region_slices_to_svg_debug("layer_after_conical_overhang");
|
|
}
|
|
}
|
|
|
|
//BBS: this function is used to offset contour and holes of expolygons seperately by different value
|
|
ExPolygons PrintObject::_shrink_contour_holes(double contour_delta, double hole_delta, const ExPolygons& polys) const
|
|
{
|
|
ExPolygons new_ex_polys;
|
|
for (const ExPolygon& ex_poly : polys) {
|
|
Polygons contours;
|
|
Polygons holes;
|
|
//BBS: modify hole
|
|
for (const Polygon& hole : ex_poly.holes) {
|
|
if (hole_delta != 0) {
|
|
for (Polygon& newHole : offset(hole, -hole_delta)) {
|
|
newHole.make_counter_clockwise();
|
|
holes.emplace_back(std::move(newHole));
|
|
}
|
|
} else {
|
|
holes.push_back(hole);
|
|
holes.back().make_counter_clockwise();
|
|
}
|
|
}
|
|
//BBS: modify contour
|
|
if (contour_delta != 0) {
|
|
Polygons new_contours = offset(ex_poly.contour, contour_delta);
|
|
if (new_contours.size() == 0)
|
|
continue;
|
|
contours.insert(contours.end(), std::make_move_iterator(new_contours.begin()), std::make_move_iterator(new_contours.end()));
|
|
} else {
|
|
contours.push_back(ex_poly.contour);
|
|
}
|
|
ExPolygons temp = diff_ex(union_(contours), union_(holes));
|
|
new_ex_polys.insert(new_ex_polys.end(), std::make_move_iterator(temp.begin()), std::make_move_iterator(temp.end()));
|
|
}
|
|
return union_ex(new_ex_polys);
|
|
}
|
|
|
|
Transform3d PrintObject::trafo_sliced() const
|
|
{
|
|
Transform3d trafo = this->trafo_centered();
|
|
BeltSliceStrategy::apply_preslice_transforms(trafo, this->print()->config(), this->model_object()->volumes);
|
|
return trafo;
|
|
}
|
|
|
|
std::vector<Polygons> PrintObject::slice_support_volumes(const ModelVolumeType model_volume_type) const
|
|
{
|
|
auto it_volume = this->model_object()->volumes.begin();
|
|
auto it_volume_end = this->model_object()->volumes.end();
|
|
for (; it_volume != it_volume_end && (*it_volume)->type() != model_volume_type; ++ it_volume) ;
|
|
std::vector<Polygons> slices;
|
|
if (it_volume != it_volume_end) {
|
|
// Found at least a single support volume of model_volume_type.
|
|
std::vector<float> zs = zs_from_layers(this->layers());
|
|
std::vector<char> merge_layers;
|
|
bool merge = false;
|
|
const Print *print = this->print();
|
|
auto throw_on_cancel_callback = std::function<void()>([print](){ print->throw_if_canceled(); });
|
|
MeshSlicingParamsEx params;
|
|
params.trafo = this->trafo_sliced();
|
|
for (; it_volume != it_volume_end; ++ it_volume)
|
|
if ((*it_volume)->type() == model_volume_type) {
|
|
std::vector<ExPolygons> slices2 = slice_volume(*(*it_volume), zs, params, throw_on_cancel_callback);
|
|
if (slices.empty()) {
|
|
slices.reserve(slices2.size());
|
|
for (ExPolygons &src : slices2)
|
|
slices.emplace_back(to_polygons(std::move(src)));
|
|
} else if (!slices2.empty()) {
|
|
if (merge_layers.empty())
|
|
merge_layers.assign(zs.size(), false);
|
|
for (size_t i = 0; i < zs.size(); ++ i) {
|
|
if (slices[i].empty())
|
|
slices[i] = to_polygons(std::move(slices2[i]));
|
|
else if (! slices2[i].empty()) {
|
|
append(slices[i], to_polygons(std::move(slices2[i])));
|
|
merge_layers[i] = true;
|
|
merge = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (merge) {
|
|
std::vector<Polygons*> to_merge;
|
|
to_merge.reserve(zs.size());
|
|
for (size_t i = 0; i < zs.size(); ++ i)
|
|
if (merge_layers[i])
|
|
to_merge.emplace_back(&slices[i]);
|
|
tbb::parallel_for(
|
|
tbb::blocked_range<size_t>(0, to_merge.size()),
|
|
[&to_merge](const tbb::blocked_range<size_t> &range) {
|
|
for (size_t i = range.begin(); i < range.end(); ++ i)
|
|
*to_merge[i] = union_(*to_merge[i]);
|
|
});
|
|
}
|
|
}
|
|
return slices;
|
|
}
|
|
|
|
std::vector<ExPolygons> PrintObject::slice_single_volume_regions(const ModelVolume* volume) const
|
|
{
|
|
if (volume == nullptr)
|
|
return {};
|
|
// Match the existing slicing heights and the frame the layers were sliced in (belt
|
|
// pre-slice transforms included) without flattening holes.
|
|
const std::vector<float> zs = zs_from_layers(this->layers());
|
|
MeshSlicingParamsEx params;
|
|
params.trafo = this->trafo_sliced();
|
|
const Print *print = this->print();
|
|
return slice_volume(*volume, zs, params, [print]() { print->throw_if_canceled(); });
|
|
}
|
|
|
|
} // namespace Slic3r
|