Slic3r::Feature::FuzzySkin Namespace Reference

Classes
class	UniformNoise
struct	MergedFuzzyRegion

Functions
static double	random_value ()
static std::unique_ptr< noise::module::Module >	get_noise_module (const FuzzySkinConfig &cfg)
static double	ripple_phase_shift_rad (const FuzzySkinConfig &cfg)
static double	ripple_anchor_arc_mm (const Points &poly)
static void	fuzzy_polyline_ripple (Points &poly, const FuzzySkinConfig &cfg)
static void	fuzzy_extrusion_line_ripple (Arachne::ExtrusionJunctions &ext_lines, const FuzzySkinConfig &cfg)
void	fuzzy_polyline (Points &poly, bool closed, coordf_t slice_z, const FuzzySkinConfig &cfg)
void	fuzzy_extrusion_line (Arachne::ExtrusionJunctions &ext_lines, coordf_t slice_z, coordf_t layer_height, const FuzzySkinConfig &cfg, bool closed)
void	group_region_by_fuzzify (PerimeterGenerator &g)
bool	should_fuzzify (const FuzzySkinConfig &config, const int layer_id, const size_t loop_idx, const bool is_contour)
static bool	same_fuzzy_effect (const FuzzySkinConfig &a, const FuzzySkinConfig &b)
static std::vector< MergedFuzzyRegion >	collect_merged_fuzzy_regions (const std::vector< std::pair< FuzzySkinConfig, ExPolygons > > &regions, const int layer_id, const size_t loop_idx, const bool is_contour)
static void	restrict_to_supported (std::vector< MergedFuzzyRegion > &merged_regions, const std::optional< ExPolygons > &supported)
Polygon	apply_fuzzy_skin (const Polygon &polygon, const PerimeterGenerator &perimeter_generator, const size_t loop_idx, const bool is_contour)
void	apply_fuzzy_skin (Arachne::ExtrusionLine *extrusion, const PerimeterGenerator &perimeter_generator, const bool is_contour, const bool closed)

---

Class Documentation

Slic3r::Feature::FuzzySkin::MergedFuzzyRegion

struct Slic3r::Feature::FuzzySkin::MergedFuzzyRegion

Collaboration diagram for Slic3r::Feature::FuzzySkin::MergedFuzzyRegion:

Class Members
const FuzzySkinConfig *	config
ExPolygons	expolygons

Function Documentation

apply_fuzzy_skin() [1/2]

void Slic3r::Feature::FuzzySkin::apply_fuzzy_skin	(	Arachne::ExtrusionLine *	extrusion,
		const PerimeterGenerator &	perimeter_generator,
		const bool	is_contour,
		const bool	closed )

{
    const auto  slice_z = perimeter_generator.slice_z;
    const auto  layer_height = perimeter_generator.layer_height;
    const auto& regions = perimeter_generator.regions_by_fuzzify;
    const auto& supported = perimeter_generator.fuzzy_supported_area;
    if (regions.size() == 1 && !supported) { // optimization
        const auto& config  = regions.begin()->first;
        const bool  fuzzify = should_fuzzify(config, perimeter_generator.layer_id, extrusion->inset_idx, is_contour);
        if (fuzzify)
            fuzzy_extrusion_line(extrusion->junctions, slice_z, perimeter_generator.layer_height, config, closed);
    } else {
        // Merge regions that produce identical fuzzy effects (differ only in type).
        // When the style (e.g. External) and a painted region (All) both fuzzify this loop
        // with the same noise parameters, merging avoids splitting the perimeter at the
        // painted boundary — eliminating discontinuity artifacts.
        auto merged_regions = collect_merged_fuzzy_regions(regions, perimeter_generator.layer_id, extrusion->inset_idx, is_contour);
        if (!merged_regions.empty()) {
 
            // Fast path: single merged region — apply directly without splitting
            if (merged_regions.size() == 1 && merged_regions.front().expolygons.empty() && !supported) {
                fuzzy_extrusion_line(extrusion->junctions, slice_z, perimeter_generator.layer_height, *merged_regions.front().config, closed);
                return;
            }
 
            // Open path means this is a thin wall that collapsed into a single thick line, in this case the path will go exactly
            // between the middle two sides of the object. And since the paint segmentation never goes beyond the middle line because
            // it uses voronoi diagram, we need to expand the segmentation a little bit to make sure it covers the path.
            if (!closed) {
                for (auto& r : merged_regions) {
                    r.expolygons = offset_ex(r.expolygons, perimeter_generator.ext_perimeter_flow.scaled_width() / 10);
                }
            }
 
#ifdef DEBUG_FUZZY
            {
                int i = 0;
                for (const auto& r : merged_regions) {
                    BoundingBox bbox = get_extents(perimeter_generator.slices->surfaces);
                    bbox.offset(scale_(1.));
                    ::Slic3r::SVG svg(debug_out_path("fuzzy_traverse_loops_%d_%d_%d_region_%d.svg", perimeter_generator.layer_id,
                                                     is_contour ? 0 : 1, extrusion->inset_idx, i)
                                          .c_str(),
                                      bbox);
 
                    // Convert extrusion line to polygon for visualization
                    Polygon extrusion_polygon;
                    extrusion_polygon.points.reserve(extrusion->junctions.size());
                    for (const auto& junction : extrusion->junctions) {
                        extrusion_polygon.points.push_back(junction.p);
                    }
 
                    svg.draw_outline(perimeter_generator.slices->surfaces);
                    svg.draw_outline(extrusion_polygon, "green");
                    svg.draw(r.expolygons, "red", 0.5);
                    svg.draw_outline(r.expolygons, "red");
                    svg.Close();
                    i++;
                }
            }
#endif
 
            // Make each region's ExPolygons exclusive so overlapping regions don't double-fuzz
            // the same perimeter section. Later regions in the list take priority over earlier ones
            // in overlapping areas.
            for (size_t i = 0; i < merged_regions.size(); ++i)
                for (size_t j = i + 1; j < merged_regions.size(); ++j)
                    if (!merged_regions[i].expolygons.empty() && !merged_regions[j].expolygons.empty())
                        merged_regions[i].expolygons = diff_ex(merged_regions[i].expolygons, merged_regions[j].expolygons);
 
            restrict_to_supported(merged_regions, supported);
 
            // Split the loops into lines with different config, and fuzzy them separately
            for (const auto& r : merged_regions) {
                const auto splitted = Algorithm::split_line(*extrusion, r.expolygons, false);
                if (splitted.empty()) {
                    // No intersection, skip
                    continue;
                }
 
                // Fuzzy splitted extrusion
                if (std::all_of(splitted.begin(), splitted.end(), [](const Algorithm::SplitLineJunction& j) { return j.clipped; })) {
                    // The entire polygon is fuzzified
                    fuzzy_extrusion_line(extrusion->junctions, slice_z, perimeter_generator.layer_height, *r.config, closed);
                    continue;
                } else {
                    const auto                              current_ext = extrusion->junctions;
                    std::vector<Arachne::ExtrusionJunction> segment;
                    segment.reserve(current_ext.size());
                    extrusion->junctions.clear();
 
                    const auto fuzzy_current_segment = [&segment, &extrusion, &r, slice_z, layer_height]() {
                        // Orca: non fuzzy points to isolate fuzzy region
                        const auto front = segment.front();
                        const auto back  = segment.back();
 
                        fuzzy_extrusion_line(segment, slice_z, layer_height, *r.config, false);
                        // Orca: only add non fuzzy point if it's not in the extrusion closing point.
                        if (!extrusion->junctions.empty() && extrusion->junctions.front().p != front.p) {
                            extrusion->junctions.push_back(front);
                        }
                        extrusion->junctions.insert(extrusion->junctions.end(), segment.begin(), segment.end());
                        // Orca: only add non fuzzy point if it's not in the extrusion closing point.
                        if (!extrusion->junctions.empty() && extrusion->junctions.back().p != front.p) {
                            extrusion->junctions.push_back(back);
                        }
                        segment.clear();
                    };
 
                    const auto to_ex_junction = [&current_ext](const Algorithm::SplitLineJunction& j) -> Arachne::ExtrusionJunction {
                        Arachne::ExtrusionJunction res = current_ext[j.get_src_index()];
                        if (!j.is_src()) {
                            res.p = j.p;
                        }
                        return res;
                    };
 
                    for (const auto& p : splitted) {
                        if (p.clipped) {
                            segment.push_back(to_ex_junction(p));
                        } else {
                            if (segment.empty()) {
                                extrusion->junctions.push_back(to_ex_junction(p));
                            } else {
                                segment.push_back(to_ex_junction(p));
                                fuzzy_current_segment();
                            }
                        }
                    }
                    if (!segment.empty()) {
                        fuzzy_current_segment();
                    }
 
                    //Orca: ensure the loop is closed after fuzzy
                    if (closed && !extrusion->junctions.empty() && extrusion->junctions.front().p != extrusion->junctions.back().p) {
                        extrusion->junctions.back().p = extrusion->junctions.front().p;
                        extrusion->junctions.back().w = extrusion->junctions.front().w;
                    }
                }
            }
        }
    }
}

References Slic3r::SVG::Close(), collect_merged_fuzzy_regions(), Slic3r::debug_out_path(), Slic3r::diff_ex(), Slic3r::SVG::draw(), Slic3r::SVG::draw_outline(), Slic3r::PerimeterGenerator::ext_perimeter_flow, fuzzy_extrusion_line(), Slic3r::PerimeterGenerator::fuzzy_supported_area, Slic3r::get_extents(), Slic3r::Algorithm::SplitLineJunction::get_src_index(), Slic3r::Arachne::ExtrusionLine::inset_idx, Slic3r::Algorithm::SplitLineJunction::is_src(), Slic3r::Arachne::ExtrusionLine::junctions, Slic3r::layer_height(), Slic3r::PerimeterGenerator::layer_height, Slic3r::PerimeterGenerator::layer_id, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::offset_ex(), Slic3r::Algorithm::SplitLineJunction::p, Slic3r::Arachne::ExtrusionJunction::p, Slic3r::MultiPoint::points, Slic3r::PerimeterGenerator::regions_by_fuzzify, restrict_to_supported(), scale_, Slic3r::Flow::scaled_width(), should_fuzzify(), Slic3r::PerimeterGenerator::slice_z, Slic3r::PerimeterGenerator::slices, Slic3r::Algorithm::split_line(), and Slic3r::SurfaceCollection::surfaces.

Here is the call graph for this function:

apply_fuzzy_skin() [2/2]

Polygon Slic3r::Feature::FuzzySkin::apply_fuzzy_skin	(	const Polygon &	polygon,
		const PerimeterGenerator &	perimeter_generator,
		const size_t	loop_idx,
		const bool	is_contour )

{
    Polygon fuzzified;
 
    const auto  slice_z = perimeter_generator.slice_z;
    const auto& regions = perimeter_generator.regions_by_fuzzify;
    const auto& supported = perimeter_generator.fuzzy_supported_area;
    if (regions.size() == 1 && !supported) { // optimization
        const auto& config  = regions.begin()->first;
        const bool  fuzzify = should_fuzzify(config, perimeter_generator.layer_id, loop_idx, is_contour);
        if (!fuzzify) {
            return polygon;
        }
 
        fuzzified = polygon;
        fuzzy_polyline(fuzzified.points, true, slice_z, config);
        return fuzzified;
    }
 
    // Merge regions that produce identical fuzzy effects (differ only in type).
    // When the style (e.g. External) and a painted region (All) both fuzzify this loop
    // with the same noise parameters, merging their ExPolygons avoids splitting the
    // perimeter at the painted boundary — eliminating discontinuity artifacts.
    auto merged_regions = collect_merged_fuzzy_regions(regions, perimeter_generator.layer_id, loop_idx, is_contour);
    if (merged_regions.empty()) {
        return polygon;
    }
 
    // Fast path: single merged region — apply directly without splitting
    if (merged_regions.size() == 1) {
        const auto& mr = merged_regions.front();
        if (mr.expolygons.empty() && !supported) {
            fuzzified = polygon;
            fuzzy_polyline(fuzzified.points, true, slice_z, *mr.config);
            return fuzzified;
        }
        // Fall through to split_line with a single region below
    }
 
#ifdef DEBUG_FUZZY
    {
        int i = 0;
        for (const auto& r : merged_regions) {
            BoundingBox bbox = get_extents(perimeter_generator.slices->surfaces);
            bbox.offset(scale_(1.));
            ::Slic3r::SVG svg(debug_out_path("fuzzy_traverse_loops_%d_%d_%d_region_%d.svg", perimeter_generator.layer_id,
                                             is_contour ? 0 : 1, loop_idx, i)
                                  .c_str(),
                              bbox);
            svg.draw_outline(perimeter_generator.slices->surfaces);
            svg.draw_outline(polygon, "green");
            svg.draw(r.expolygons, "red", 0.5);
            svg.draw_outline(r.expolygons, "red");
            svg.Close();
            i++;
        }
    }
#endif
 
    // Make each region's ExPolygons exclusive so overlapping regions don't double-fuzz
    // the same perimeter section. Later regions in the list take priority over earlier ones
    // in overlapping areas (matching modifier precedence order).
    for (size_t i = 0; i < merged_regions.size(); ++i)
        for (size_t j = i + 1; j < merged_regions.size(); ++j)
            if (!merged_regions[i].expolygons.empty() && !merged_regions[j].expolygons.empty())
                merged_regions[i].expolygons = diff_ex(merged_regions[i].expolygons, merged_regions[j].expolygons);
 
    restrict_to_supported(merged_regions, supported);
 
    // Split the loops into lines with different config, and fuzzy them separately
    fuzzified = polygon;
    for (const auto& r : merged_regions) {
        auto splitted = Algorithm::split_line(fuzzified, r.expolygons, true);
        if (splitted.empty()) {
            // No intersection, skip
            continue;
        }
 
        // Fuzzy splitted polygon
        if (std::all_of(splitted.begin(), splitted.end(), [](const Algorithm::SplitLineJunction& j) { return j.clipped; })) {
            // The entire polygon is fuzzified
            fuzzy_polyline(fuzzified.points, true, slice_z, *r.config);
        } else {
            // Start from a non-clipped junction so wrapped clipped segments do
            // not need an artificial reconnection across the seam.
            const auto first_non_clipped = std::find_if(splitted.begin(), splitted.end(), [](const Algorithm::SplitLineJunction& j) {
                return !j.clipped;
            });
            if (first_non_clipped != splitted.begin()) {
                std::rotate(splitted.begin(), first_non_clipped, splitted.end());
            }
            Points segment;
            segment.reserve(splitted.size());
            fuzzified.points.clear();
 
            const auto fuzzy_current_segment = [&segment, &fuzzified, &r, slice_z]() {
                fuzzified.points.push_back(segment.front());
                const auto back = segment.back();
                fuzzy_polyline(segment, false, slice_z, *r.config);
                fuzzified.points.insert(fuzzified.points.end(), segment.begin(), segment.end());
                fuzzified.points.push_back(back);
                segment.clear();
            };
 
            for (const auto& p : splitted) {
                if (p.clipped) {
                    segment.push_back(p.p);
                } else {
                    if (segment.empty()) {
                        fuzzified.points.push_back(p.p);
                    } else {
                        segment.push_back(p.p);
                        fuzzy_current_segment();
                    }
                }
            }
            if (!segment.empty()) {
                // Close the loop
                segment.push_back(splitted.front().p);
                fuzzy_current_segment();
            }
        }
    }
 
    return fuzzified;
}

References Slic3r::SVG::Close(), collect_merged_fuzzy_regions(), Slic3r::debug_out_path(), Slic3r::diff_ex(), Slic3r::SVG::draw(), Slic3r::SVG::draw_outline(), fuzzy_polyline(), Slic3r::PerimeterGenerator::fuzzy_supported_area, Slic3r::get_extents(), Slic3r::PerimeterGenerator::layer_id, Slic3r::BoundingBoxBase< PointType, APointsType >::offset(), Slic3r::MultiPoint::points, Slic3r::PerimeterGenerator::regions_by_fuzzify, restrict_to_supported(), scale_, should_fuzzify(), Slic3r::PerimeterGenerator::slice_z, Slic3r::PerimeterGenerator::slices, Slic3r::Algorithm::split_line(), and Slic3r::SurfaceCollection::surfaces.

Referenced by Slic3r::traverse_extrusions(), and Slic3r::traverse_loops().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_merged_fuzzy_regions()

std::vector< MergedFuzzyRegion > Slic3r::Feature::FuzzySkin::collect_merged_fuzzy_regions ( const std::vector< std::pair< FuzzySkinConfig, ExPolygons > > & regions, const int layer_id, const size_t loop_idx, const bool is_contour )

static

{
    // Merge regions that produce identical fuzzy effects (differ only in type).
    // When the style (e.g. External) and a painted region (All) both fuzzify this loop
    // with the same noise parameters, merging their ExPolygons avoids splitting the
    // perimeter at the painted boundary — eliminating discontinuity artifacts.
    std::vector<MergedFuzzyRegion> merged_regions;
    merged_regions.reserve(regions.size());
    for (const auto& region : regions) {
        if (!should_fuzzify(region.first, layer_id, loop_idx, is_contour)) {
            continue;
        }
 
        bool merged = false;
        for (auto& merged_region : merged_regions) {
            if (same_fuzzy_effect(*merged_region.config, region.first)) {
                if (merged_region.expolygons.empty()) {
                    // Already full coverage, nothing to add.
                } else if (region.second.empty()) {
                    merged_region.expolygons.clear();
                } else {
                    append(merged_region.expolygons, region.second);
                }
                merged = true;
                break;
            }
        }
 
        if (!merged) {
            merged_regions.push_back({&region.first, region.second});
        }
    }
 
    for (auto& merged_region : merged_regions) {
        if (!merged_region.expolygons.empty()) {
            merged_region.expolygons = union_ex(merged_region.expolygons);
        }
    }
 
    return merged_regions;
}

References Slic3r::append(), same_fuzzy_effect(), should_fuzzify(), and Slic3r::union_ex().

Referenced by apply_fuzzy_skin(), and apply_fuzzy_skin().

Here is the call graph for this function:

Here is the caller graph for this function:

fuzzy_extrusion_line()

void Slic3r::Feature::FuzzySkin::fuzzy_extrusion_line	(	Arachne::ExtrusionJunctions &	ext_lines,
		coordf_t	slice_z,
		coordf_t	layer_height,
		const FuzzySkinConfig &	cfg,
		bool	closed )

{
 
    if (cfg.noise_type == NoiseType::Ripple) {
        if (ext_lines.size() < 3)
            return;
        fuzzy_extrusion_line_ripple(ext_lines, cfg);
        return;
    }
 
    std::unique_ptr<noise::module::Module> noise = get_noise_module(cfg);
 
    const double min_dist_between_points = cfg.point_distance * 3. / 4.; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
    const double range_random_point_dist = cfg.point_distance / 2.;
    // ExtrusionJunction::w is a scaled coord_t, so this floor must be scaled too.
    // Flow::rounded_rectangle_extrusion_spacing() requires width > height * (1 - 0.25 * PI); keep 5% above it.
    const double min_extrusion_width = scaled<double>(layer_height * (1. - 0.25 * M_PI) * 1.05);
    double dist_left_over = random_value() * (min_dist_between_points / 2.); // the distance to be traversed on the line before making the first new point
 
    auto* p0 = &ext_lines.front();
    Arachne::ExtrusionJunctions out;
    out.reserve(ext_lines.size());
    for (auto& p1 : ext_lines) {
        // Orca: only skip the first point for closed path, open path should not skip any point
        if (closed) {
            if (p0->p == p1.p) { // Connect endpoints.
                out.emplace_back(p1.p, p1.w, p1.perimeter_index);
                continue;
            }
        }
 
        // 'a' is the (next) new point between p0 and p1
        Vec2d  p0p1 = (p1.p - p0->p).cast<double>();
        double p0p1_size = p0p1.norm();
        double p0pa_dist = dist_left_over;
        for (; p0pa_dist < p0p1_size; p0pa_dist += min_dist_between_points + random_value() * range_random_point_dist) {
            Point pa = p0->p + (p0p1 * (p0pa_dist / p0p1_size)).cast<coord_t>();
            double r = noise->GetValue(unscale_(pa.x()), unscale_(pa.y()), slice_z) * cfg.thickness;
            switch (cfg.mode) { //the curly code for testing
                case FuzzySkinMode::Displacement :
                    out.emplace_back(pa + (perp(p0p1).cast<double>().normalized() * r).cast<coord_t>(), p1.w, p1.perimeter_index);
                    break;
                case FuzzySkinMode::Extrusion :
                    out.emplace_back(pa, std::max(p1.w + r + min_extrusion_width,  min_extrusion_width), p1.perimeter_index); 
                    break;
                case FuzzySkinMode::Combined :
                    double rad = std::max(p1.w + r + min_extrusion_width,  min_extrusion_width);
                    out.emplace_back(pa + (perp(p0p1).cast<double>().normalized() * ((rad  - p1.w) / 2)).cast<coord_t>(), rad, p1.perimeter_index); //0.05 - minimum width of extruded line
                    break;
            }
        }
        dist_left_over = p0pa_dist - p0p1_size;
        p0 = &p1;
    }
 
    while (out.size() < 3) {
        size_t point_idx = ext_lines.size() - 2;
        out.emplace_back(ext_lines[point_idx].p, ext_lines[point_idx].w, ext_lines[point_idx].perimeter_index);
        if (point_idx == 0)
            break;
        --point_idx;
    }
 
    if (ext_lines.back().p == ext_lines.front().p) { // Connect endpoints.
        out.front().p = out.back().p;
        out.front().w = out.back().w;
    }
 
    if (out.size() >= 3)
        ext_lines = std::move(out);
}

References Slic3r::cast(), Slic3r::Combined, Slic3r::Displacement, Slic3r::Extrusion, fuzzy_extrusion_line_ripple(), get_noise_module(), Slic3r::layer_height(), M_PI, Slic3r::FuzzySkinConfig::mode, Slic3r::FuzzySkinConfig::noise_type, Slic3r::perp(), Slic3r::FuzzySkinConfig::point_distance, random_value(), Slic3r::Ripple, Slic3r::scaled(), Slic3r::FuzzySkinConfig::thickness, and unscale_.

Referenced by apply_fuzzy_skin().

Here is the call graph for this function:

Here is the caller graph for this function:

fuzzy_extrusion_line_ripple()

void Slic3r::Feature::FuzzySkin::fuzzy_extrusion_line_ripple ( Arachne::ExtrusionJunctions & ext_lines, const FuzzySkinConfig & cfg )

static

{
    const double amplitude    = unscale_(cfg.thickness);
    const double N            = static_cast<double>(cfg.ripples_per_layer);
    const double fill_step_mm = unscale_(cfg.point_distance);
 
    if (N <= 0.0 || fill_step_mm < 1e-6)
        return;
 
    // Build a Points vector for perimeter/anchor calculations.
    Points poly;
    poly.reserve(ext_lines.size());
    for (const auto& j : ext_lines)
        poly.push_back(j.p);
 
    // Compute total length in mm.
    const size_t np           = poly.size();
    double       perimeter_mm = 0.0;
    for (size_t i = 0; i + 1 < np; ++i)
        perimeter_mm += unscale_((poly[i + 1] - poly[i]).cast<double>().norm());
 
    if (perimeter_mm < 1e-6)
        return;
 
    const double anchor_arc_mm   = ripple_anchor_arc_mm(poly);
    const double phase_shift_rad = ripple_phase_shift_rad(cfg);
    const double phase_at_anchor = M_PI * 2.0 + phase_shift_rad;
 
    auto arc_phase = [&](double arc_mm) -> double { return N * (2.0 * M_PI) * (arc_mm - anchor_arc_mm) / perimeter_mm + phase_at_anchor; };
 
    Arachne::ExtrusionJunctions out;
    out.reserve(static_cast<size_t>(perimeter_mm / fill_step_mm) + np * 2);
 
    double accum_mm = 0.0;
    for (size_t i = 0; i + 1 < np; ++i) {
        const Arachne::ExtrusionJunction& j0      = ext_lines[i];
        const Arachne::ExtrusionJunction& j1      = ext_lines[i + 1];
        const Vec2d                       seg     = (j1.p - j0.p).cast<double>();
        const double                      seg_len = seg.norm();
        if (seg_len < EPSILON)
            continue;
 
        const double seg_len_mm = unscale_(seg_len);
        const Vec2d  seg_unit   = seg / seg_len;
        const Vec2d  seg_perp   = perp(seg_unit);
        const double seg_end_mm = accum_mm + seg_len_mm;
        const double first_s    = std::ceil(accum_mm / fill_step_mm) * fill_step_mm;
 
        for (double s = first_s; s < seg_end_mm; s += fill_step_mm) {
            const double t    = (s - accum_mm) / seg_len_mm;
            const double disp = std::sin(arc_phase(s)) * amplitude;
            const Point  pt   = j0.p + (seg * t).cast<coord_t>();
            out.emplace_back(pt + (seg_perp * scale_(disp)).cast<coord_t>(), j1.w, j1.perimeter_index);
        }
 
        accum_mm = seg_end_mm;
    }
 
    while (out.size() < 3) {
        size_t point_idx = ext_lines.size() - 2;
        out.emplace_back(ext_lines[point_idx].p, ext_lines[point_idx].w, ext_lines[point_idx].perimeter_index);
        if (point_idx == 0)
            break;
        --point_idx;
    }
 
    if (out.size() >= 3)
        ext_lines = std::move(out);
}

References Slic3r::cast(), EPSILON, M_PI, Slic3r::Arachne::ExtrusionJunction::p, Slic3r::Arachne::ExtrusionJunction::perimeter_index, Slic3r::perp(), Slic3r::FuzzySkinConfig::point_distance, ripple_anchor_arc_mm(), ripple_phase_shift_rad(), Slic3r::FuzzySkinConfig::ripples_per_layer, scale_, Slic3r::FuzzySkinConfig::thickness, unscale_, and Slic3r::Arachne::ExtrusionJunction::w.

Referenced by fuzzy_extrusion_line().

Here is the call graph for this function:

Here is the caller graph for this function:

fuzzy_polyline()

void Slic3r::Feature::FuzzySkin::fuzzy_polyline	(	Points &	poly,
		bool	closed,
		coordf_t	slice_z,
		const FuzzySkinConfig &	cfg )

{
    if (cfg.noise_type == NoiseType::Ripple) {
        if (poly.size() < 3)
            return;
        fuzzy_polyline_ripple(poly, cfg);
        return;
    }
 
    std::unique_ptr<noise::module::Module> noise = get_noise_module(cfg);
 
    const double min_dist_between_points = cfg.point_distance * 3. / 4.; // hardcoded: the point distance may vary between 3/4 and 5/4 the supplied value
    const double range_random_point_dist = cfg.point_distance / 2.;
    double dist_left_over = random_value() * (min_dist_between_points / 2.); // the distance to be traversed on the line before making the first new point
    Point* p0 = &poly.back();
    Points out;
    out.reserve(poly.size());
    for (Point &p1 : poly)
    {
        if (!closed) {
            // Skip the first point for open path
            closed = true;
            p0 = &p1;
            continue;
        }
        // 'a' is the (next) new point between p0 and p1
        Vec2d  p0p1      = (p1 - *p0).cast<double>();
        double p0p1_size = p0p1.norm();
        double p0pa_dist = dist_left_over;
        for (; p0pa_dist < p0p1_size;
            p0pa_dist += min_dist_between_points + random_value() * range_random_point_dist)
        {
            Point pa = *p0 + (p0p1 * (p0pa_dist / p0p1_size)).cast<coord_t>();
            double r = noise->GetValue(unscale_(pa.x()), unscale_(pa.y()), slice_z) * cfg.thickness;
            out.emplace_back(pa + (perp(p0p1).cast<double>().normalized() * r).cast<coord_t>());
        }
        dist_left_over = p0pa_dist - p0p1_size;
        p0 = &p1;
    }
    while (out.size() < 3) {
        size_t point_idx = poly.size() - 2;
        out.emplace_back(poly[point_idx]);
        if (point_idx == 0)
            break;
        -- point_idx;
    }
    if (out.size() >= 3)
        poly = std::move(out);
}

References Slic3r::cast(), fuzzy_polyline_ripple(), get_noise_module(), Slic3r::FuzzySkinConfig::noise_type, Slic3r::perp(), Slic3r::FuzzySkinConfig::point_distance, random_value(), Slic3r::Ripple, Slic3r::FuzzySkinConfig::thickness, and unscale_.

Referenced by apply_fuzzy_skin().

Here is the call graph for this function:

Here is the caller graph for this function:

fuzzy_polyline_ripple()

void Slic3r::Feature::FuzzySkin::fuzzy_polyline_ripple ( Points & poly, const FuzzySkinConfig & cfg )

static

{
    const double amplitude    = unscale_(cfg.thickness);
    const double N            = static_cast<double>(cfg.ripples_per_layer);
    const double fill_step_mm = unscale_(cfg.point_distance);
 
    if (N <= 0.0 || fill_step_mm < 1e-6)
        return;
 
    // Compute total perimeter length in mm.
    const size_t np           = poly.size();
    double       perimeter_mm = 0.0;
    for (size_t i = 0; i < np; ++i)
        perimeter_mm += unscale_((poly[(i + 1) % np] - poly[i]).cast<double>().norm());
 
    if (perimeter_mm < 1e-6)
        return;
 
    const double anchor_arc_mm   = ripple_anchor_arc_mm(poly);
    const double phase_shift_rad = ripple_phase_shift_rad(cfg);
 
    // Phase function: φ(s) = N·2π·(s - anchor_arc) / perimeter + π/2 + phase_shift
    // Adding π/2 ensures sin(φ) = 1 at the anchor when phase_shift = 0 (a peak).
    const double phase_at_anchor = M_PI * 2.0 + phase_shift_rad;
    auto arc_phase = [&](double arc_mm) -> double { return N * (2.0 * M_PI) * (arc_mm - anchor_arc_mm) / perimeter_mm + phase_at_anchor; };
 
    Points out;
    out.reserve(static_cast<size_t>(perimeter_mm / fill_step_mm) + np * 2);
 
    double accum_mm = 0.0;
    for (size_t i = 0; i < np; ++i) {
        const Point& p0      = poly[i];
        const Point& p1      = poly[(i + 1) % np];
        const Vec2d  seg     = (p1 - p0).cast<double>();
        const double seg_len = seg.norm();
        if (seg_len < EPSILON)
            continue;
 
        const double seg_len_mm = unscale_(seg_len);
        const Vec2d  seg_unit   = seg / seg_len;
        const Vec2d  seg_perp   = perp(seg_unit);
        const double seg_end_mm = accum_mm + seg_len_mm;
        const double first_s    = std::ceil(accum_mm / fill_step_mm) * fill_step_mm;
 
        for (double s = first_s; s < seg_end_mm; s += fill_step_mm) {
            const double t    = (s - accum_mm) / seg_len_mm;
            const double disp = std::sin(arc_phase(s)) * amplitude;
            const Point  pt   = p0 + (seg * t).cast<coord_t>();
            out.emplace_back(pt + (seg_perp * scale_(disp)).cast<coord_t>());
        }
 
        accum_mm = seg_end_mm;
    }
 
    while (out.size() < 3)
        out.emplace_back(poly[poly.size() - 2]);
 
    if (out.size() >= 3)
        poly = std::move(out);
}

References Slic3r::cast(), EPSILON, M_PI, Slic3r::perp(), Slic3r::FuzzySkinConfig::point_distance, ripple_anchor_arc_mm(), ripple_phase_shift_rad(), Slic3r::FuzzySkinConfig::ripples_per_layer, scale_, Slic3r::FuzzySkinConfig::thickness, and unscale_.

Referenced by fuzzy_polyline().

Here is the call graph for this function:

Here is the caller graph for this function:

get_noise_module()

std::unique_ptr< noise::module::Module > Slic3r::Feature::FuzzySkin::get_noise_module ( const FuzzySkinConfig & cfg )

static

                                                                                     {
    if (cfg.noise_type == NoiseType::Perlin) {
        auto perlin_noise = noise::module::Perlin();
        perlin_noise.SetFrequency(1 / cfg.noise_scale);
        perlin_noise.SetOctaveCount(cfg.noise_octaves);
        perlin_noise.SetPersistence(cfg.noise_persistence);
        return std::make_unique<noise::module::Perlin>(perlin_noise);
    } else if (cfg.noise_type == NoiseType::Billow) {
        auto billow_noise = noise::module::Billow();
        billow_noise.SetFrequency(1 / cfg.noise_scale);
        billow_noise.SetOctaveCount(cfg.noise_octaves);
        billow_noise.SetPersistence(cfg.noise_persistence);
        return std::make_unique<noise::module::Billow>(billow_noise);
    } else if (cfg.noise_type == NoiseType::RidgedMulti) {
        auto ridged_multi_noise = noise::module::RidgedMulti();
        ridged_multi_noise.SetFrequency(1 / cfg.noise_scale);
        ridged_multi_noise.SetOctaveCount(cfg.noise_octaves);
        return std::make_unique<noise::module::RidgedMulti>(ridged_multi_noise);
    } else if (cfg.noise_type == NoiseType::Voronoi) {
        auto voronoi_noise = noise::module::Voronoi();
        voronoi_noise.SetFrequency(1 / cfg.noise_scale);
        voronoi_noise.SetDisplacement(1.0);
        return std::make_unique<noise::module::Voronoi>(voronoi_noise);
    } else {
        return std::make_unique<UniformNoise>();
    }
}

References Slic3r::Billow, Slic3r::FuzzySkinConfig::noise_octaves, Slic3r::FuzzySkinConfig::noise_persistence, Slic3r::FuzzySkinConfig::noise_scale, Slic3r::FuzzySkinConfig::noise_type, Slic3r::Perlin, Slic3r::RidgedMulti, and Slic3r::Voronoi.

Referenced by fuzzy_extrusion_line(), and fuzzy_polyline().

Here is the caller graph for this function:

group_region_by_fuzzify()

void Slic3r::Feature::FuzzySkin::group_region_by_fuzzify

(

PerimeterGenerator &

g

)

{
    g.regions_by_fuzzify.clear();
    g.has_fuzzy_skin = false;
    g.has_fuzzy_hole = false;
 
    struct ConfigSurfaces {
        FuzzySkinConfig config;
        SurfacesPtr     surfaces;
    };
 
    std::vector<ConfigSurfaces> regions;
    regions.reserve(g.compatible_regions->size());
    for (auto region : *g.compatible_regions) {
        const auto&           region_config = region->region().config();
        const FuzzySkinConfig cfg{region_config.fuzzy_skin,
                                  scaled<coord_t>(region_config.fuzzy_skin_thickness.value),
                                  scaled<coord_t>(region_config.fuzzy_skin_point_distance.value),
                                  region_config.fuzzy_skin_first_layer,
                                  region_config.fuzzy_skin_noise_type,
                                  region_config.fuzzy_skin_scale,
                                  region_config.fuzzy_skin_octaves,
                                  region_config.fuzzy_skin_persistence,
                                  region_config.fuzzy_skin_mode,
                                  region_config.fuzzy_skin_ripples_per_layer,
                                  region_config.fuzzy_skin_ripple_offset,
                                  region_config.fuzzy_skin_layers_between_ripple_offset,
                                  g.layer_id};
 
        auto it = std::find_if(regions.begin(), regions.end(), [&cfg](const ConfigSurfaces& item) {
            return item.config == cfg;
        });
        if (it == regions.end()) {
            regions.push_back({cfg, {}});
            it = regions.end() - 1;
        }
 
        auto& surfaces = it->surfaces;
        for (const auto& surface : region->slices.surfaces) {
            surfaces.push_back(&surface);
        }
 
        if (should_fuzzify(cfg, g.layer_id, 0, true)) {
            g.has_fuzzy_skin = true;
        }
        if (should_fuzzify(cfg, g.layer_id, 0, false)) {
            g.has_fuzzy_hole = true;
        }
    }
 
    g.fuzzy_supported_area.reset();
    if ((g.has_fuzzy_skin || g.has_fuzzy_hole) && g.lower_slices != nullptr) {
        coord_t max_thickness = 0;
        for (const auto& region : regions)
            if (should_fuzzify(region.config, g.layer_id, 0, true) || should_fuzzify(region.config, g.layer_id, 0, false))
                max_thickness = std::max(max_thickness, region.config.thickness);
        // Walls farther than a line width plus the noise amplitude from the layer below are bridging; keep them smooth.
        g.fuzzy_supported_area = offset_ex(*g.lower_slices, float(g.ext_perimeter_flow.scaled_width() + max_thickness));
    }
 
    if (regions.size() == 1) { // optimization
        g.regions_by_fuzzify.push_back({regions.front().config, {}});
        return;
    }
 
    g.regions_by_fuzzify.reserve(regions.size());
    for (const auto& region : regions) {
        g.regions_by_fuzzify.push_back({region.config, offset_ex(region.surfaces, ClipperSafetyOffset)});
    }
}

References Slic3r::ClipperSafetyOffset, Slic3r::PerimeterGenerator::compatible_regions, Slic3r::PerimeterGenerator::ext_perimeter_flow, Slic3r::PerimeterGenerator::fuzzy_supported_area, Slic3r::PerimeterGenerator::has_fuzzy_hole, Slic3r::PerimeterGenerator::has_fuzzy_skin, Slic3r::PerimeterGenerator::layer_id, Slic3r::PerimeterGenerator::lower_slices, Slic3r::offset_ex(), Slic3r::PerimeterGenerator::regions_by_fuzzify, Slic3r::scaled(), Slic3r::Flow::scaled_width(), and should_fuzzify().

Referenced by Slic3r::PerimeterGenerator::process_arachne(), and Slic3r::PerimeterGenerator::process_classic().

Here is the call graph for this function:

Here is the caller graph for this function:

random_value()

double Slic3r::Feature::FuzzySkin::random_value ( )

static

                             {
    thread_local std::random_device rd;
    // Hash thread ID for random number seed if no hardware rng seed is available
    thread_local std::mt19937 gen(rd.entropy() > 0 ? rd() : std::hash<std::thread::id>()(std::this_thread::get_id()));
    thread_local std::uniform_real_distribution<double> dist(0.0, 1.0);
    return dist(gen);
}

References Slic3r::Geometry::dist().

Referenced by fuzzy_extrusion_line(), fuzzy_polyline(), and Slic3r::Feature::FuzzySkin::UniformNoise::GetValue().

Here is the call graph for this function:

Here is the caller graph for this function:

restrict_to_supported()

void Slic3r::Feature::FuzzySkin::restrict_to_supported ( std::vector< MergedFuzzyRegion > & merged_regions, const std::optional< ExPolygons > & supported )

static

{
    if (!supported)
        return;
    for (auto& merged_region : merged_regions)
        merged_region.expolygons = merged_region.expolygons.empty() ? *supported : intersection_ex(merged_region.expolygons, *supported);
}

References Slic3r::intersection_ex().

Referenced by apply_fuzzy_skin(), and apply_fuzzy_skin().

Here is the call graph for this function:

Here is the caller graph for this function:

ripple_anchor_arc_mm()

double Slic3r::Feature::FuzzySkin::ripple_anchor_arc_mm ( const Points & poly )

static

{
    const size_t np = poly.size();
 
    // Find anchor world position: leftmost Y=0 crossing.
    Vec2d anchor_world(std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
    bool  found_crossing = false;
    for (size_t i = 0; i < np; ++i) {
        const double ya = unscale_(poly[i].y());
        const double yb = unscale_(poly[(i + 1) % np].y());
        if ((ya <= 0.0 && yb >= 0.0) || (ya >= 0.0 && yb <= 0.0)) {
            const double t       = (std::abs(yb - ya) < 1e-9) ? 0.0 : ya / (ya - yb);
            const double x_cross = unscale_(poly[i].x()) +
                                   std::max(0.0, std::min(1.0, t)) * (unscale_(poly[(i + 1) % np].x()) - unscale_(poly[i].x()));
            if (!found_crossing || x_cross < anchor_world.x()) {
                anchor_world   = Vec2d(x_cross, 0.0);
                found_crossing = true;
            }
        }
    }
    if (!found_crossing) {
        double best_abs_y = std::numeric_limits<double>::max();
        for (const Point& p : poly) {
            const double ay = std::abs(unscale_(p.y()));
            if (ay < best_abs_y) {
                best_abs_y   = ay;
                anchor_world = Vec2d(unscale_(p.x()), unscale_(p.y()));
            }
        }
    }
 
    // Find the arc-length of the closest point on the polyline to anchor_world.
    double anchor_arc_mm = 0.0;
    double best_dist_sq  = std::numeric_limits<double>::max();
    double accum_mm      = 0.0;
    for (size_t i = 0; i < np; ++i) {
        const Vec2d  pa_mm(unscale_(poly[i].x()), unscale_(poly[i].y()));
        const Vec2d  pb_mm(unscale_(poly[(i + 1) % np].x()), unscale_(poly[(i + 1) % np].y()));
        const Vec2d  seg     = pb_mm - pa_mm;
        const double seg_len = seg.norm();
        if (seg_len > 1e-9) {
            const double t       = std::max(0.0, std::min(1.0, (anchor_world - pa_mm).dot(seg) / (seg_len * seg_len)));
            const double dist_sq = (pa_mm + seg * t - anchor_world).squaredNorm();
            if (dist_sq < best_dist_sq) {
                best_dist_sq  = dist_sq;
                anchor_arc_mm = accum_mm + t * seg_len;
            }
        }
        accum_mm += seg_len;
    }
    return anchor_arc_mm;
}

References Slic3r::dot(), and unscale_.

Referenced by fuzzy_extrusion_line_ripple(), and fuzzy_polyline_ripple().

Here is the call graph for this function:

Here is the caller graph for this function:

ripple_phase_shift_rad()

double Slic3r::Feature::FuzzySkin::ripple_phase_shift_rad ( const FuzzySkinConfig & cfg )

static

{
    if (cfg.ripple_offset == 0.0 || cfg.layers_between_ripple_offset <= 0)
        return 0.0;
 
    const int    effective_layer = std::max(cfg.layer_id, 0);
    const int    period_index    = effective_layer / std::max(cfg.layers_between_ripple_offset, 1);
    const double raw_shift       = period_index * (cfg.ripple_offset/100) * (2.0 * M_PI);
    return fmod(raw_shift, 2.0 * M_PI);
}

References Slic3r::FuzzySkinConfig::layer_id, Slic3r::FuzzySkinConfig::layers_between_ripple_offset, M_PI, and Slic3r::FuzzySkinConfig::ripple_offset.

Referenced by fuzzy_extrusion_line_ripple(), and fuzzy_polyline_ripple().

Here is the caller graph for this function:

same_fuzzy_effect()

bool Slic3r::Feature::FuzzySkin::same_fuzzy_effect ( const FuzzySkinConfig & a, const FuzzySkinConfig & b )

static

{
    return a.thickness                    == b.thickness
        && a.point_distance               == b.point_distance
        && a.noise_type                   == b.noise_type
        && a.noise_scale                  == b.noise_scale
        && a.noise_octaves                == b.noise_octaves
        && a.noise_persistence            == b.noise_persistence
        && a.mode                         == b.mode
        && a.ripples_per_layer            == b.ripples_per_layer
        && a.ripple_offset                == b.ripple_offset
        && a.layers_between_ripple_offset == b.layers_between_ripple_offset;
}

References Slic3r::FuzzySkinConfig::layers_between_ripple_offset, Slic3r::FuzzySkinConfig::mode, Slic3r::FuzzySkinConfig::noise_octaves, Slic3r::FuzzySkinConfig::noise_persistence, Slic3r::FuzzySkinConfig::noise_scale, Slic3r::FuzzySkinConfig::noise_type, Slic3r::FuzzySkinConfig::point_distance, Slic3r::FuzzySkinConfig::ripple_offset, Slic3r::FuzzySkinConfig::ripples_per_layer, and Slic3r::FuzzySkinConfig::thickness.

Referenced by collect_merged_fuzzy_regions().

Here is the caller graph for this function:

should_fuzzify()

bool Slic3r::Feature::FuzzySkin::should_fuzzify	(	const FuzzySkinConfig &	config,
		const int	layer_id,
		const size_t	loop_idx,
		const bool	is_contour )

{
    const auto fuzziy_type = config.type;
 
    if (fuzziy_type == FuzzySkinType::None|| fuzziy_type == FuzzySkinType::Disabled_fuzzy) {
        return false;
    }
    if (!config.fuzzy_first_layer && layer_id <= 0) {
        // Do not fuzzy first layer unless told to
        return false;
    }
 
    const bool fuzzify_contours = (loop_idx == 0 && fuzziy_type != FuzzySkinType::Hole) || fuzziy_type == FuzzySkinType::AllWalls;
    const bool fuzzify_holes    = (fuzziy_type == FuzzySkinType::Hole || fuzziy_type == FuzzySkinType::All || fuzziy_type == FuzzySkinType::AllWalls)
                                  && (loop_idx == 0 || fuzziy_type == FuzzySkinType::AllWalls);
 
    return is_contour ? fuzzify_contours : fuzzify_holes;
}

References Slic3r::All, Slic3r::AllWalls, Slic3r::Disabled_fuzzy, Slic3r::FuzzySkinConfig::fuzzy_first_layer, Slic3r::Hole, Slic3r::None, and Slic3r::FuzzySkinConfig::type.

Referenced by apply_fuzzy_skin(), apply_fuzzy_skin(), collect_merged_fuzzy_regions(), and group_region_by_fuzzify().

Here is the caller graph for this function: