mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-05 06:41:10 +00:00
HanifKoh
8a6377f087
* Add Missing Includes Across src/libslic3r Every libslic3r source and header now directly includes the headers declaring what it uses, rather than relying on the precompiled header or transitive includes. Generated with clang-tidy misc-include-cleaner, with libslic3r headers spelled libslic3r/... so they resolve outside the library's private include paths. MultiMaterialSegmentation.hpp, Support/SupportParameters.hpp and Format/STEP.hpp are made self-contained by hand. * Make the libslic3r Headers Compile on Their Own Each now includes, or forward-declares, what it uses instead of relying on what its includers happened to include first. Left out: I18N.hpp, which errors on purpose when included from GUI code, and VoxelizeCSGMesh.hpp and SLA/bicubic.h, which nothing includes and which no longer compile at all. * Add the Includes Missing From the Hand-Fixed libslic3r Headers clang-tidy would not edit these headers while they failed to compile on their own, so the first pass skipped them. With the headers now self-contained, a second pass adds the rest. * Keep Windows Setup Ahead of the Added libslic3r Includes Print.cpp and Thread.cpp open with a _WIN32 block that has to come first; without the precompiled header, Print.cpp otherwise reaches windows.h through OCCT with NONLS defined and boost/regex fails. OpenVDBUtils.cpp and SLA/SupportTreeBuilder.cpp had includes inside #ifndef NOMINMAX, which libslic3r defines on Windows, so those were skipped there. .clang-tidy also ignores the MSVC STL and UCRT internals, Boost.Multiprecision's fwd.hpp and CPython's Windows include directory. * Re-Add libslic3r Includes After the Clipper2 2.0.1 Migration Rebasing onto main took main's version of the files the Clipper2 migration rewrote, so their added includes are restored here, along with includes for main's new code. Clipper2's individual headers are now ignored by clang-tidy: they only build the Z variant through clipper2_z.hpp, which defines USINGZ first, so including clipper.core.h and the like directly broke ClipperZUtils.cpp.
575 lines
27 KiB
C++
575 lines
27 KiB
C++
#include "RegionExpansion.hpp"
|
||
#include "libslic3r/Point.hpp"
|
||
#include "libslic3r/ExPolygon.hpp"
|
||
#include "libslic3r/libslic3r.h"
|
||
#include "libslic3r/Polyline.hpp"
|
||
#include "libslic3r/Polygon.hpp"
|
||
|
||
#include <algorithm>
|
||
#include <cmath>
|
||
#include <cstddef>
|
||
#include <cassert>
|
||
#include <iterator>
|
||
#include <cstdint>
|
||
#include <libslic3r/AABBTreeIndirect.hpp>
|
||
#include <libslic3r/ClipperZUtils.hpp>
|
||
#include <libslic3r/ClipperUtils.hpp>
|
||
#include <libslic3r/Utils.hpp>
|
||
|
||
#include <math.h>
|
||
#include <numeric>
|
||
#include <vector>
|
||
#include <utility>
|
||
|
||
namespace Slic3r {
|
||
namespace Algorithm {
|
||
|
||
// Calculating radius discretization according to the Clipper offsetter code, see ClipperOffset::DoGroupOffset()
|
||
inline double clipper_round_offset_error(double offset, double arc_tolerance)
|
||
{
|
||
static constexpr const double def_arc_tolerance = 0.25;
|
||
const double y =
|
||
arc_tolerance <= 0 ?
|
||
def_arc_tolerance :
|
||
arc_tolerance > offset * def_arc_tolerance ?
|
||
offset * def_arc_tolerance :
|
||
arc_tolerance;
|
||
double steps = std::min(M_PI / std::acos(1. - y / offset), offset * M_PI);
|
||
return offset * (1. - cos(M_PI / steps));
|
||
}
|
||
|
||
RegionExpansionParameters RegionExpansionParameters::build(
|
||
// Scaled expansion value
|
||
float full_expansion,
|
||
// Expand by waves of expansion_step size (expansion_step is scaled).
|
||
float expansion_step,
|
||
// Don't take more than max_nr_steps for small expansion_step.
|
||
size_t max_nr_expansion_steps)
|
||
{
|
||
assert(full_expansion > 0);
|
||
assert(expansion_step > 0);
|
||
assert(max_nr_expansion_steps > 0);
|
||
|
||
RegionExpansionParameters out;
|
||
// Initial expansion of src to make the source regions intersect with boundary regions just a bit.
|
||
// The expansion should not be too tiny, but also small enough, so the following expansion will
|
||
// compensate for tiny_expansion and bring the wave back to the boundary without producing
|
||
// ugly cusps where it touches the boundary.
|
||
out.tiny_expansion = std::min(0.25f * full_expansion, scaled<float>(0.05f));
|
||
size_t nsteps = size_t(ceil((full_expansion - out.tiny_expansion) / expansion_step));
|
||
if (max_nr_expansion_steps > 0)
|
||
nsteps = std::min(nsteps, max_nr_expansion_steps);
|
||
assert(nsteps > 0);
|
||
out.initial_step = (full_expansion - out.tiny_expansion) / nsteps;
|
||
if (nsteps > 1 && 0.25 * out.initial_step < out.tiny_expansion) {
|
||
// Decrease the step size by lowering number of steps.
|
||
nsteps = std::max<size_t>(1, (floor((full_expansion - out.tiny_expansion) / (4. * out.tiny_expansion))));
|
||
out.initial_step = (full_expansion - out.tiny_expansion) / nsteps;
|
||
}
|
||
if (0.25 * out.initial_step < out.tiny_expansion || nsteps == 1) {
|
||
out.tiny_expansion = 0.2f * full_expansion;
|
||
out.initial_step = 0.8f * full_expansion;
|
||
}
|
||
out.other_step = out.initial_step;
|
||
out.num_other_steps = nsteps - 1;
|
||
|
||
// Accuracy of the offsetter for wave propagation.
|
||
out.arc_tolerance = scaled<double>(0.1);
|
||
|
||
// Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
|
||
// clipping during wave propagation. Needs to be in sync with the offsetter accuracy.
|
||
// Clipper positive round offset should rather offset less than more.
|
||
// Still a little bit of additional offset was added.
|
||
out.max_inflation = (out.tiny_expansion + nsteps * out.initial_step) * 1.1;
|
||
// (clipper_round_offset_error(out.tiny_expansion, co.ArcTolerance) + nsteps * clipper_round_offset_error(out.initial_step, co.ArcTolerance) * 1.5; // Account for uncertainty
|
||
|
||
return out;
|
||
}
|
||
|
||
// similar to expolygons_to_zpaths(), but each contour is expanded before converted to zpath.
|
||
// The expanded contours are then opened (the first point is repeated at the end).
|
||
static ClipperZUtils::ZPaths expolygons_to_zpaths_expanded_opened(
|
||
const ExPolygons &src, const float expansion, coord_t &base_idx)
|
||
{
|
||
ClipperZUtils::ZPaths out;
|
||
out.reserve(2 * std::accumulate(src.begin(), src.end(), size_t(0),
|
||
[](const size_t acc, const ExPolygon &expoly) { return acc + expoly.num_contours(); }));
|
||
for (const ExPolygon &expoly : src) {
|
||
for (size_t icontour = 0; icontour < expoly.num_contours(); ++ icontour) {
|
||
// Orient CCW, then grow the contour and shrink the holes. The output contours are CCW.
|
||
Polygon contour = expoly.contour_or_hole(icontour);
|
||
if (! contour.is_counter_clockwise())
|
||
contour.reverse();
|
||
for (const Polygon &expanded : offset(contour, icontour == 0 ? expansion : -expansion, jtSquare))
|
||
out.emplace_back(ClipperZUtils::to_zpath<true>(expanded.points, base_idx));
|
||
}
|
||
++ base_idx;
|
||
}
|
||
return out;
|
||
}
|
||
|
||
// Paths were created by splitting closed polygons into open paths and then by clipping them.
|
||
// Thus some pieces of the clipped polygons may now become split at the ends of the source polygons.
|
||
// Those ends are sorted lexicographically in "splits".
|
||
// Reconnect those split pieces.
|
||
static inline void merge_splits(ClipperZUtils::ZPaths &paths, std::vector<std::pair<ClipperZUtils::ZPoint, int>> &splits)
|
||
{
|
||
for (auto it_path = paths.begin(); it_path != paths.end(); ) {
|
||
ClipperZUtils::ZPath &path = *it_path;
|
||
assert(path.size() >= 2);
|
||
bool merged = false;
|
||
if (path.size() >= 2) {
|
||
const ClipperZUtils::ZPoint &front = path.front();
|
||
const ClipperZUtils::ZPoint &back = path.back();
|
||
// The path before clipping was supposed to cross the clipping boundary or be fully out of it.
|
||
// Thus the clipped contour is supposed to become open, with one exception: The anchor expands into a closed hole.
|
||
if (front.x() != back.x() || front.y() != back.y()) {
|
||
// Look up the ends in "splits", possibly join the contours.
|
||
// "splits" maps into the other piece connected to the same end point.
|
||
auto find_end = [&splits](const ClipperZUtils::ZPoint &pt) -> std::pair<ClipperZUtils::ZPoint, int>* {
|
||
auto it = std::lower_bound(splits.begin(), splits.end(), pt,
|
||
[](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r); });
|
||
return it != splits.end() && it->first == pt ? &(*it) : nullptr;
|
||
};
|
||
auto *end = find_end(front);
|
||
bool end_front = true;
|
||
if (! end) {
|
||
end_front = false;
|
||
end = find_end(back);
|
||
}
|
||
if (end) {
|
||
// This segment ends at a split point of the source closed contour before clipping.
|
||
if (end->second == -1) {
|
||
// Open end was found, not matched yet.
|
||
end->second = int(it_path - paths.begin());
|
||
} else {
|
||
// Open end was found and matched with end->second
|
||
ClipperZUtils::ZPath &other_path = paths[end->second];
|
||
polylines_merge(other_path, other_path.front() == end->first, std::move(path), end_front);
|
||
if (std::next(it_path) == paths.end()) {
|
||
paths.pop_back();
|
||
break;
|
||
}
|
||
path = std::move(paths.back());
|
||
paths.pop_back();
|
||
merged = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (! merged)
|
||
++ it_path;
|
||
}
|
||
}
|
||
|
||
using AABBTreeBBoxes = AABBTreeIndirect::Tree<2, coord_t>;
|
||
|
||
static AABBTreeBBoxes build_aabb_tree_over_expolygons(const ExPolygons &expolygons)
|
||
{
|
||
// Calculate bounding boxes of internal slices.
|
||
std::vector<AABBTreeIndirect::BoundingBoxWrapper> bboxes;
|
||
bboxes.reserve(expolygons.size());
|
||
for (size_t i = 0; i < expolygons.size(); ++ i)
|
||
bboxes.emplace_back(i, get_extents(expolygons[i].contour));
|
||
// Build AABB tree over bounding boxes of boundary expolygons.
|
||
AABBTreeBBoxes out;
|
||
out.build_modify_input(bboxes);
|
||
return out;
|
||
}
|
||
|
||
static int sample_in_expolygons(
|
||
// AABB tree over boundary expolygons
|
||
const AABBTreeBBoxes &aabb_tree,
|
||
const ExPolygons &expolygons,
|
||
const Point &sample)
|
||
{
|
||
int out = -1;
|
||
AABBTreeIndirect::traverse(aabb_tree,
|
||
[&sample](const AABBTreeBBoxes::Node &node) {
|
||
return node.bbox.contains(sample);
|
||
},
|
||
[&expolygons, &sample, &out](const AABBTreeBBoxes::Node &node) {
|
||
assert(node.is_leaf());
|
||
assert(node.is_valid());
|
||
if (expolygons[node.idx].contains(sample)) {
|
||
out = int(node.idx);
|
||
// Stop traversal.
|
||
return false;
|
||
}
|
||
// Continue traversal.
|
||
return true;
|
||
});
|
||
return out;
|
||
}
|
||
|
||
std::vector<WaveSeed> wave_seeds(
|
||
// Source regions that are supposed to touch the boundary.
|
||
const ExPolygons &src,
|
||
// Boundaries of source regions touching the "boundary" regions will be expanded into the "boundary" region.
|
||
const ExPolygons &boundary,
|
||
// Initial expansion of src to make the source regions intersect with boundary regions just a bit.
|
||
float tiny_expansion,
|
||
// Sort output by boundary ID and source ID.
|
||
bool sorted)
|
||
{
|
||
assert(tiny_expansion > 0);
|
||
|
||
if (src.empty() || boundary.empty())
|
||
return {};
|
||
|
||
using Intersection = ClipperZUtils::ClipperZIntersectionVisitor::Intersection;
|
||
using Intersections = ClipperZUtils::ClipperZIntersectionVisitor::Intersections;
|
||
|
||
ClipperZUtils::ZPaths segments;
|
||
Intersections intersections;
|
||
|
||
coord_t idx_boundary_begin = 1;
|
||
coord_t idx_boundary_end = idx_boundary_begin;
|
||
coord_t idx_src_end;
|
||
|
||
{
|
||
ClipperZUtils::ClipperZIntersectionVisitor visitor(intersections);
|
||
// as closed contours
|
||
ClipperZUtils::ZPaths zboundary = ClipperZUtils::expolygons_to_zpaths(boundary, idx_boundary_end);
|
||
// as open contours
|
||
std::vector<std::pair<ClipperZUtils::ZPoint, int>> zsrc_splits;
|
||
idx_src_end = idx_boundary_end;
|
||
ClipperZUtils::ZPaths zsrc = expolygons_to_zpaths_expanded_opened(src, tiny_expansion, idx_src_end);
|
||
zsrc_splits.reserve(zsrc.size());
|
||
for (const ClipperZUtils::ZPath &path : zsrc) {
|
||
assert(path.size() >= 2);
|
||
assert(path.front() == path.back());
|
||
zsrc_splits.emplace_back(path.front(), -1);
|
||
}
|
||
std::sort(zsrc_splits.begin(), zsrc_splits.end(), [](const auto &l, const auto &r){ return ClipperZUtils::zpoint_lower(l.first, r.first); });
|
||
segments = ClipperZUtils::clip_zpaths(ctIntersection, zsrc, true, zboundary, visitor.clipper_callback());
|
||
merge_splits(segments, zsrc_splits);
|
||
}
|
||
|
||
// AABBTree over bounding boxes of boundaries.
|
||
// Only built if necessary, that is if any of the seed contours is closed, thus there is no intersection point
|
||
// with the boundary and all Z coordinates of the closed contour point to the source contour.
|
||
AABBTreeBBoxes aabb_tree;
|
||
|
||
// Sort paths into their respective islands.
|
||
// Each src x boundary will be processed (wave expanded) independently.
|
||
// Multiple pieces of a single src may intersect the same boundary.
|
||
WaveSeeds out;
|
||
out.reserve(segments.size());
|
||
int iseed = 0;
|
||
for (const ClipperZUtils::ZPath &path : segments) {
|
||
assert(path.size() >= 2);
|
||
ClipperZUtils::ZPoint front = path.front();
|
||
ClipperZUtils::ZPoint back = path.back();
|
||
// Both ends of a seed segment are supposed to be inside a single boundary expolygon.
|
||
// Thus as long as the seed contour is not closed, it should be open at a boundary point.
|
||
assert((front == back && front.z() >= idx_boundary_end && front.z() < idx_src_end) ||
|
||
//(front.z() < 0 && back.z() < 0));
|
||
// Hope that at least one end of an open polyline is clipped by the boundary, thus an intersection point is created.
|
||
(front.z() < 0 || back.z() < 0));
|
||
// However, with complex geometry, both endpoints may coincide with existing polygon
|
||
// vertices (z >= 0), which is handled below.
|
||
|
||
if (front != back && front.z() >= 0 && back.z() >= 0) {
|
||
// Very rare case when both endpoints intersect boundary ExPolygons in existing points.
|
||
// So the ZFillFunction callback hasn't been called.
|
||
// Both endpoints coincide with existing polygon vertices, so the
|
||
// ZFillFunction callback was never called. With complex geometry
|
||
// this is common because source and boundary contours share many
|
||
// vertices. Determine src_id / boundary_id from Z coordinates
|
||
// (and fall back to an AABB-tree point-in-polygon test when a
|
||
// boundary ID is not directly available).
|
||
coord_t src_z = -1, boundary_z = -1;
|
||
// Scan all path points for the information we need.
|
||
for (const ClipperZUtils::ZPoint &point : path) {
|
||
if (point.z() >= idx_boundary_end && point.z() < idx_src_end && src_z < 0)
|
||
src_z = point.z();
|
||
else if (point.z() >= idx_boundary_begin && point.z() < idx_boundary_end && boundary_z < 0)
|
||
boundary_z = point.z();
|
||
if (src_z >= 0 && boundary_z >= 0)
|
||
break;
|
||
}
|
||
if (src_z >= 0) {
|
||
uint32_t src_id = uint32_t(src_z - idx_boundary_end);
|
||
if (boundary_z >= 0) {
|
||
out.push_back({ src_id, uint32_t(boundary_z - 1), ClipperZUtils::from_zpath(path) });
|
||
} else {
|
||
// Source ID known but boundary unknown – use AABB tree.
|
||
if (aabb_tree.empty())
|
||
aabb_tree = build_aabb_tree_over_expolygons(boundary);
|
||
int boundary_id = sample_in_expolygons(aabb_tree, boundary, Point(front.x(), front.y()));
|
||
if (boundary_id >= 0)
|
||
out.push_back({ src_id, uint32_t(boundary_id), ClipperZUtils::from_zpath(path) });
|
||
}
|
||
++ iseed;
|
||
continue;
|
||
}
|
||
// Unable to determine source ID – drop the segment.
|
||
continue;
|
||
} else
|
||
if (front == back && (front.z() < idx_boundary_end)) {
|
||
// This should be a very rare exception.
|
||
// See https://github.com/prusa3d/PrusaSlicer/issues/12469.
|
||
// Segement is open, yet its first point seems to be part of boundary polygon.
|
||
// Take the first point with src polygon index.
|
||
for (const ClipperZUtils::ZPoint &point : path) {
|
||
if (point.z() >= idx_boundary_end) {
|
||
front = point;
|
||
back = point;
|
||
}
|
||
}
|
||
}
|
||
|
||
const Intersection *intersection = nullptr;
|
||
auto intersection_point_valid = [idx_boundary_end, idx_src_end](const Intersection &is) {
|
||
return is.first >= 1 && is.first < idx_boundary_end &&
|
||
is.second >= idx_boundary_end && is.second < idx_src_end;
|
||
};
|
||
if (front.z() < 0) {
|
||
const Intersection &is = intersections[- front.z() - 1];
|
||
assert(intersection_point_valid(is));
|
||
if (intersection_point_valid(is))
|
||
intersection = &is;
|
||
}
|
||
if (! intersection && back.z() < 0) {
|
||
const Intersection &is = intersections[- back.z() - 1];
|
||
assert(intersection_point_valid(is));
|
||
if (intersection_point_valid(is))
|
||
intersection = &is;
|
||
}
|
||
if (intersection) {
|
||
// The path intersects the boundary contour at least at one side.
|
||
out.push_back({ uint32_t(intersection->second - idx_boundary_end), uint32_t(intersection->first - 1), ClipperZUtils::from_zpath(path) });
|
||
} else {
|
||
// This should be a closed contour.
|
||
assert(front == back && front.z() >= idx_boundary_end && front.z() < idx_src_end);
|
||
// Find a source boundary expolygon of one sample of this closed path.
|
||
if (aabb_tree.empty())
|
||
aabb_tree = build_aabb_tree_over_expolygons(boundary);
|
||
int boundary_id = sample_in_expolygons(aabb_tree, boundary, Point(front.x(), front.y()));
|
||
// Boundary that contains the sample point was found.
|
||
assert(boundary_id >= 0);
|
||
if (boundary_id >= 0)
|
||
out.push_back({ uint32_t(front.z() - idx_boundary_end), uint32_t(boundary_id), ClipperZUtils::from_zpath(path) });
|
||
}
|
||
++ iseed;
|
||
}
|
||
|
||
if (sorted)
|
||
// Sort the seeds by their intersection boundary and source contour.
|
||
std::sort(out.begin(), out.end(), lower_by_boundary_and_src);
|
||
return out;
|
||
}
|
||
|
||
static Polygons wavefront_initial(const VecOfPoints &polylines, float offset, double arc_tolerance)
|
||
{
|
||
Polygons out;
|
||
out.reserve(polylines.size());
|
||
for (const Points &path : polylines) {
|
||
assert(path.size() >= 2);
|
||
append(out, Slic3r::offset(Polyline(path), offset, jtRound, arc_tolerance, path.front() == path.back() ? etClosedLine : etOpenRound));
|
||
}
|
||
return out;
|
||
}
|
||
|
||
// Input polygons may consist of multiple expolygons, even nested expolygons.
|
||
// After inflation some polygons may thus overlap, however the overlap is being resolved during the successive
|
||
// clipping operation, thus it is not being done here.
|
||
static Polygons wavefront_step(const Polygons &polygons, float offset, double arc_tolerance)
|
||
{
|
||
Polygons out;
|
||
out.reserve(polygons.size());
|
||
for (const Polygon &polygon : polygons)
|
||
// CCW contours grow, CW holes shrink.
|
||
append(out, Slic3r::offset(polygon, offset, jtRound, arc_tolerance));
|
||
return out;
|
||
}
|
||
|
||
static Polygons wavefront_clip(const Polygons &wavefront, const Polygons &clipping)
|
||
{
|
||
return intersection(wavefront, clipping, pftPositive);
|
||
}
|
||
|
||
static Polygons propagate_wave_from_boundary(
|
||
// Seed of the wave: Open polylines very close to the boundary.
|
||
const VecOfPoints &seed,
|
||
// Boundary inside which the waveform will propagate.
|
||
const ExPolygon &boundary,
|
||
// How much to inflate the seed lines to produce the first wave area.
|
||
const float initial_step,
|
||
// How much to inflate the first wave area and the successive wave areas in each step.
|
||
const float other_step,
|
||
// Number of inflate steps after the initial step.
|
||
const size_t num_other_steps,
|
||
// Maximum inflation of seed contours over the boundary. Used to trim boundary to speed up
|
||
// clipping during wave propagation.
|
||
const float max_inflation,
|
||
// Accuracy of the round offsets.
|
||
const double arc_tolerance)
|
||
{
|
||
assert(! seed.empty() && seed.front().size() >= 2);
|
||
Polygons clipping = ClipperUtils::clip_clipper_polygons_with_subject_bbox(boundary, get_extents<true>(seed).inflated(max_inflation));
|
||
Polygons polygons = wavefront_clip(wavefront_initial(seed, initial_step, arc_tolerance), clipping);
|
||
// Now offset the remaining
|
||
for (size_t ioffset = 0; ioffset < num_other_steps; ++ ioffset)
|
||
polygons = wavefront_clip(wavefront_step(polygons, other_step, arc_tolerance), clipping);
|
||
return polygons;
|
||
}
|
||
|
||
// Resulting regions are sorted by boundary id and source id.
|
||
std::vector<RegionExpansion> propagate_waves(const WaveSeeds &seeds, const ExPolygons &boundary, const RegionExpansionParameters ¶ms)
|
||
{
|
||
std::vector<RegionExpansion> out;
|
||
VecOfPoints paths;
|
||
for (auto it_seed = seeds.begin(); it_seed != seeds.end();) {
|
||
auto it = it_seed;
|
||
paths.clear();
|
||
for (; it != seeds.end() && it->boundary == it_seed->boundary && it->src == it_seed->src; ++ it)
|
||
paths.emplace_back(it->path);
|
||
// Propagate the wavefront while clipping it with the trimmed boundary.
|
||
// Collect the expanded polygons, merge them with the source polygons.
|
||
RegionExpansion re;
|
||
for (Polygon &polygon : propagate_wave_from_boundary(paths, boundary[it_seed->boundary], params.initial_step, params.other_step, params.num_other_steps, params.max_inflation, params.arc_tolerance))
|
||
out.push_back({ std::move(polygon), it_seed->src, it_seed->boundary });
|
||
it_seed = it;
|
||
}
|
||
|
||
return out;
|
||
}
|
||
|
||
std::vector<RegionExpansion> propagate_waves(const ExPolygons &src, const ExPolygons &boundary, const RegionExpansionParameters ¶ms)
|
||
{
|
||
return propagate_waves(wave_seeds(src, boundary, params.tiny_expansion, true), boundary, params);
|
||
}
|
||
|
||
std::vector<RegionExpansion> propagate_waves(const ExPolygons &src, const ExPolygons &boundary,
|
||
// Scaled expansion value
|
||
float expansion,
|
||
// Expand by waves of expansion_step size (expansion_step is scaled).
|
||
float expansion_step,
|
||
// Don't take more than max_nr_steps for small expansion_step.
|
||
size_t max_nr_steps)
|
||
{
|
||
return propagate_waves(src, boundary, RegionExpansionParameters::build(expansion, expansion_step, max_nr_steps));
|
||
}
|
||
|
||
// Returns regions per source ExPolygon expanded into boundary.
|
||
std::vector<RegionExpansionEx> propagate_waves_ex(const WaveSeeds &seeds, const ExPolygons &boundary, const RegionExpansionParameters ¶ms)
|
||
{
|
||
std::vector<RegionExpansion> expanded = propagate_waves(seeds, boundary, params);
|
||
assert(std::is_sorted(seeds.begin(), seeds.end(), [](const auto &l, const auto &r){ return l.boundary < r.boundary || (l.boundary == r.boundary && l.src < r.src); }));
|
||
Polygons acc;
|
||
std::vector<RegionExpansionEx> out;
|
||
for (auto it = expanded.begin(); it != expanded.end(); ) {
|
||
auto it2 = it;
|
||
acc.clear();
|
||
for (; it2 != expanded.end() && it2->boundary_id == it->boundary_id && it2->src_id == it->src_id; ++ it2)
|
||
acc.emplace_back(std::move(it2->polygon));
|
||
size_t size = it2 - it;
|
||
if (size == 1)
|
||
out.push_back({ ExPolygon{std::move(acc.front())}, it->src_id, it->boundary_id });
|
||
else {
|
||
ExPolygons expolys = union_ex(acc);
|
||
reserve_more_power_of_2(out, expolys.size());
|
||
for (ExPolygon &ex : expolys)
|
||
out.push_back({ std::move(ex), it->src_id, it->boundary_id });
|
||
}
|
||
it = it2;
|
||
}
|
||
return out;
|
||
}
|
||
|
||
// Returns regions per source ExPolygon expanded into boundary.
|
||
std::vector<RegionExpansionEx> propagate_waves_ex(
|
||
// Source regions that are supposed to touch the boundary.
|
||
// Boundaries of source regions touching the "boundary" regions will be expanded into the "boundary" region.
|
||
const ExPolygons &src,
|
||
const ExPolygons &boundary,
|
||
// Scaled expansion value
|
||
float full_expansion,
|
||
// Expand by waves of expansion_step size (expansion_step is scaled).
|
||
float expansion_step,
|
||
// Don't take more than max_nr_steps for small expansion_step.
|
||
size_t max_nr_expansion_steps)
|
||
{
|
||
auto params = RegionExpansionParameters::build(full_expansion, expansion_step, max_nr_expansion_steps);
|
||
return propagate_waves_ex(wave_seeds(src, boundary, params.tiny_expansion, true), boundary, params);
|
||
}
|
||
|
||
std::vector<Polygons> expand_expolygons(const ExPolygons &src, const ExPolygons &boundary,
|
||
// Scaled expansion value
|
||
float expansion,
|
||
// Expand by waves of expansion_step size (expansion_step is scaled).
|
||
float expansion_step,
|
||
// Don't take more than max_nr_steps for small expansion_step.
|
||
size_t max_nr_steps)
|
||
{
|
||
std::vector<Polygons> out(src.size(), Polygons{});
|
||
for (RegionExpansion &r : propagate_waves(src, boundary, expansion, expansion_step, max_nr_steps))
|
||
out[r.src_id].emplace_back(std::move(r.polygon));
|
||
return out;
|
||
}
|
||
|
||
std::vector<ExPolygon> merge_expansions_into_expolygons(ExPolygons &&src, std::vector<RegionExpansion> &&expanded)
|
||
{
|
||
// expanded regions will be merged into source regions, thus they will be re-sorted by source id.
|
||
std::sort(expanded.begin(), expanded.end(), [](const auto &l, const auto &r) { return l.src_id < r.src_id; });
|
||
uint32_t last = 0;
|
||
Polygons acc;
|
||
ExPolygons out;
|
||
out.reserve(src.size());
|
||
for (auto it = expanded.begin(); it != expanded.end();) {
|
||
for (; last < it->src_id; ++ last)
|
||
out.emplace_back(std::move(src[last]));
|
||
acc.clear();
|
||
assert(it->src_id == last);
|
||
for (; it != expanded.end() && it->src_id == last; ++ it)
|
||
acc.emplace_back(std::move(it->polygon));
|
||
//FIXME offset & merging could be more efficient, for example one does not need to copy the source expolygon
|
||
ExPolygon &src_ex = src[last ++];
|
||
assert(! src_ex.contour.empty());
|
||
#if 0
|
||
{
|
||
static int iRun = 0;
|
||
BoundingBox bbox = get_extents(acc);
|
||
bbox.merge(get_extents(src_ex));
|
||
SVG svg(debug_out_path("expand_merge_expolygons-failed-union=%d.svg", iRun ++).c_str(), bbox);
|
||
svg.draw(acc);
|
||
svg.draw_outline(acc, "black", scale_(0.05));
|
||
svg.draw(src_ex, "red");
|
||
svg.Close();
|
||
}
|
||
#endif
|
||
Point sample = src_ex.contour.front();
|
||
append(acc, to_polygons(std::move(src_ex)));
|
||
ExPolygons merged = union_safety_offset_ex(acc);
|
||
// Expanding one expolygon by waves should not change connectivity of the source expolygon:
|
||
// Single expolygon should be produced possibly with increased number of holes.
|
||
if (merged.size() > 1) {
|
||
// assert(merged.size() == 1);
|
||
// There is something wrong with the initial waves. Most likely the bridge was not valid at all
|
||
// or the boundary region was very close to some bridge edge, but not really touching.
|
||
// Pick only a single merged expolygon, which contains one sample point of the source expolygon.
|
||
auto aabb_tree = build_aabb_tree_over_expolygons(merged);
|
||
int id = sample_in_expolygons(aabb_tree, merged, sample);
|
||
assert(id != -1);
|
||
if (id != -1)
|
||
out.emplace_back(std::move(merged[id]));
|
||
} else if (merged.size() == 1)
|
||
out.emplace_back(std::move(merged.front()));
|
||
}
|
||
for (; last < uint32_t(src.size()); ++ last)
|
||
out.emplace_back(std::move(src[last]));
|
||
return out;
|
||
}
|
||
|
||
std::vector<ExPolygon> expand_merge_expolygons(ExPolygons &&src, const ExPolygons &boundary, const RegionExpansionParameters ¶ms)
|
||
{
|
||
// expanded regions are sorted by boundary id and source id
|
||
std::vector<RegionExpansion> expanded = propagate_waves(src, boundary, params);
|
||
return merge_expansions_into_expolygons(std::move(src), std::move(expanded));
|
||
}
|
||
|
||
} // Algorithm
|
||
} // Slic3r
|