Slic3r::PreciseSeam::detail Namespace Reference

Classes
struct	ClippedEdgeInterval
struct	FragmentBindingFailure

Functions
static std::optional< double >	parameter_on_edge (const Point &point, const Point &a, const Point &b)
static std::optional< ClippedEdgeInterval >	interval_on_edge (const Point &first, const Point &last, size_t edge, const Polygon &perimeter)
static bool	append_exact_fragment (const Polyline &fragment, const Polygon &perimeter, std::vector< ClippedEdgeInterval > &intervals)
bool	append_projected_fragment (const Polyline &fragment, const Polygon &perimeter, std::vector< ClippedEdgeInterval > &intervals, FragmentBindingFailure &failure)
bool	bind_fragment (const Polyline &fragment, const Polygon &perimeter, std::vector< ClippedEdgeInterval > &intervals, FragmentBindingFailure &failure)
static bool	snap_cuts_to_adjacent_vertices (Polyline &fragment, const Polygon &perimeter)
static std::string	fragment_location (const ExtractionContext &context, size_t fragment_index)
bool	append_fragment (const Polyline &fragment, const Polygon &perimeter, std::vector< ClippedEdgeInterval > &intervals, const ExtractionContext &context, size_t fragment_index)

---

Class Documentation

Slic3r::PreciseSeam::detail::ClippedEdgeInterval

struct Slic3r::PreciseSeam::detail::ClippedEdgeInterval

Collaboration diagram for Slic3r::PreciseSeam::detail::ClippedEdgeInterval:

Class Members
double	begin
size_t	edge
double	end
Point	first
Point	last

Slic3r::PreciseSeam::detail::FragmentBindingFailure

struct Slic3r::PreciseSeam::detail::FragmentBindingFailure

Class Members
size_t	pair_index = 0
const char *	reason = "empty fragment"

Function Documentation

append_exact_fragment()

bool Slic3r::PreciseSeam::detail::append_exact_fragment ( const Polyline & fragment, const Polygon & perimeter, std::vector< ClippedEdgeInterval > & intervals )

static

{
    const size_t size = fragment.size();
    const size_t count = perimeter.size();
    assert(size >= 3); // bind_fragment() sends only fragments with interior points here.
    // A longer sequence cannot be one exact pass over this contour.
    if (size > count + 2)
        return false;
    for (size_t anchor = 0; anchor < count; ++anchor) {
        if (fragment.points[1] != perimeter.points[anchor])
            continue;
        // Clipping may return either direction, independent of contour winding.
        for (bool forward : {true, false}) {
            const auto next = [count, forward](size_t index) {
                return forward ? (index + 1) % count : (index + count - 1) % count;
            };
            size_t last = anchor;
            bool matches = true;
            for (size_t i = 2; i + 1 < size; ++i) {
                last = next(last);
                if (fragment.points[i] != perimeter.points[last]) {
                    matches = false;
                    break;
                }
            }
            if (!matches)
                continue;
            const size_t first_edge = forward ? (anchor + count - 1) % count : anchor;
            const size_t last_edge = forward ? last : (last + count - 1) % count;
            const auto first = interval_on_edge(fragment.points.front(), fragment.points[1], first_edge, perimeter);
            const auto end = interval_on_edge(fragment.points[size - 2], fragment.points.back(), last_edge, perimeter);
            if (!first || !end)
                continue;
            // Commit only a complete match, so rejected anchors leave no intervals.
            intervals.push_back(*first);
            size_t vertex = anchor;
            for (size_t i = 2; i + 1 < size; ++i) {
                const size_t adjacent = next(vertex);
                const size_t edge = forward ? vertex : adjacent;
                intervals.push_back({edge, 0., 1., perimeter.points[edge], perimeter.points[(edge + 1) % count]});
                vertex = adjacent;
            }
            intervals.push_back(*end);
            return true;
        }
    }
    return false;
}

References count, interval_on_edge(), Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Referenced by bind_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

append_fragment()

bool Slic3r::PreciseSeam::detail::append_fragment	(	const Polyline &	fragment,
		const Polygon &	perimeter,
		std::vector< ClippedEdgeInterval > &	intervals,
		const ExtractionContext &	context,
		size_t	fragment_index )

{
    FragmentBindingFailure failure;
    if (bind_fragment(fragment, perimeter, intervals, failure))
        return true;
    // Rare-case fallback: repair the end cuts and retry once. A recovery is logged but is not a failure
    // (no failure count, no user warning).
    const char *outcome = nullptr;
    Polyline cleaned = fragment;
    if (snap_cuts_to_adjacent_vertices(cleaned, perimeter)) {
        FragmentBindingFailure retry_failure;
        // Only a contact shorter than the snapping distance may remain: nothing to bind, nothing lost.
        if (cleaned.size() < 2)
            outcome = "contact";
        else if (bind_fragment(cleaned, perimeter, intervals, retry_failure))
            outcome = "bound";
    }
    // A failed fragment shorter than the snapping radius is a contact: insertion would collapse it to one
    // point anyway, so accept it instead of reporting a failure.
    if (outcome == nullptr && fragment.length() < double(TOLERANCE_LINEAR))
        outcome = "contact";
    if (outcome != nullptr) {
        // Same log budget as failures, counted separately; SeamPlacer::init() reports the total.
        if (context.warnings == nullptr ||
            context.warnings->recovered_fragments.fetch_add(1, std::memory_order_relaxed) < failed_fragment_log_limit)
            BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamFragmentRecovered] Rare case resolved after a binding failure"
                << " outcome=" << outcome << fragment_location(context, fragment_index)
                << " original_pair=" << failure.pair_index << " original_reason=" << failure.reason
                << " fragment_points=" << fragment.size() << " cleaned_points=" << cleaned.size()
                << " perimeter_points=" << perimeter.size();
        return true;
    }
    // Reserve a log slot atomically before formatting; callers without shared state log every failure.
    if (context.warnings &&
        context.warnings->failed_fragments.fetch_add(1, std::memory_order_relaxed) >= failed_fragment_log_limit)
        return false;
    // Keep a small marker for investigating a saved project, not a full geometry dump.
    BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamIntersectionFailed] Unable to process intersection"
        << fragment_location(context, fragment_index) << " pair=" << failure.pair_index
        << " reason=" << failure.reason << " fragment_points=" << fragment.size()
        << " perimeter_points=" << perimeter.size();
    return false;
}

References bind_fragment(), Slic3r::PreciseSeam::failed_fragment_log_limit, Slic3r::PreciseSeam::PreciseSeamWarnings::failed_fragments, fragment_location(), Slic3r::MultiPoint::length(), Slic3r::PreciseSeam::detail::FragmentBindingFailure::pair_index, Slic3r::PreciseSeam::detail::FragmentBindingFailure::reason, Slic3r::PreciseSeam::PreciseSeamWarnings::recovered_fragments, Slic3r::MultiPoint::size(), snap_cuts_to_adjacent_vertices(), Slic3r::PreciseSeam::TOLERANCE_LINEAR, and Slic3r::PreciseSeam::ExtractionContext::warnings.

Referenced by Slic3r::PreciseSeam::extract_perimeter_segments().

Here is the call graph for this function:

Here is the caller graph for this function:

append_projected_fragment()

bool Slic3r::PreciseSeam::detail::append_projected_fragment	(	const Polyline &	fragment,
		const Polygon &	perimeter,
		std::vector< ClippedEdgeInterval > &	intervals,
		FragmentBindingFailure &	failure )

{
    const size_t original_size = intervals.size();
    bool forward = true;
    const size_t count = perimeter.size();
    for (size_t i = 1; i < fragment.size(); ++i) {
        if (fragment.points[i - 1] == fragment.points[i])
            continue;
        failure.pair_index = i - 1;
        std::optional<ClippedEdgeInterval> matched;
        const auto is_forward = [&](const ClippedEdgeInterval &candidate) {
            const Vec2d movement = fragment.points[i].cast<double>() - fragment.points[i - 1].cast<double>();
            const Vec2d edge = perimeter.points[(candidate.edge + 1) % count].cast<double>() -
                               perimeter.points[candidate.edge].cast<double>();
            return movement.dot(edge) > 0.;
        };
        if (intervals.size() == original_size) {
            failure.reason = "initial edge not found";
            for (size_t edge = 0; edge < count; ++edge) {
                matched = interval_on_edge(fragment.points[i - 1], fragment.points[i], edge, perimeter);
                if (matched) {
                    // The first suitable edge defines orientation; overlapping visits are unsupported.
                    forward = is_forward(*matched);
                    break;
                }
            }
        } else {
            failure.reason = "non-continuous binding";
            const ClippedEdgeInterval &previous = intervals.back();
            const double end = forward ? previous.end : previous.begin;
            matched = interval_on_edge(fragment.points[i - 1], fragment.points[i], previous.edge, perimeter);
            if (matched && is_forward(*matched) != forward)
                matched.reset();
            // The shared point is the previous pair's last point on the same edge, so continuity holds by
            // construction. Reuse its parameter rather than comparing a recomputed one: the two projections
            // may be compiled differently (e.g. FMA contraction) and differ by an ulp on some platforms.
            if (matched)
                (forward ? matched->begin : matched->end) = end;
            // Crossing to the neighbor is allowed only at their actual shared vertex.
            const size_t vertex = forward ? (previous.edge + 1) % count : previous.edge;
            if (!matched && end == (forward ? 1. : 0.) && fragment.points[i - 1] == perimeter.points[vertex]) {
                const size_t edge = forward ? vertex : (previous.edge + count - 1) % count;
                matched = interval_on_edge(fragment.points[i - 1], fragment.points[i], edge, perimeter);
                if (matched && is_forward(*matched) != forward)
                    matched.reset();
                // The shared point is exactly the neighbor's start (forward) or end (backward) vertex,
                // so parameter_on_edge() returns exactly 0 or 1 for it.
                assert(!matched || (forward ? matched->begin == 0. : matched->end == 1.));
            }
        }
        if (!matched) {
            // Never leave a partial fragment or discard earlier successful fragments.
            intervals.resize(original_size);
            return false;
        }
        intervals.push_back(*matched);
    }
    return intervals.size() > original_size;
}

References Slic3r::PreciseSeam::detail::ClippedEdgeInterval::begin, Slic3r::cast(), count, Slic3r::PreciseSeam::detail::ClippedEdgeInterval::edge, Slic3r::PreciseSeam::detail::ClippedEdgeInterval::end, interval_on_edge(), Slic3r::PreciseSeam::detail::FragmentBindingFailure::pair_index, Slic3r::MultiPoint::points, Slic3r::PreciseSeam::detail::FragmentBindingFailure::reason, and Slic3r::MultiPoint::size().

Referenced by bind_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

bind_fragment()

bool Slic3r::PreciseSeam::detail::bind_fragment	(	const Polyline &	fragment,
		const Polygon &	perimeter,
		std::vector< ClippedEdgeInterval > &	intervals,
		FragmentBindingFailure &	failure )

{
    if (fragment.size() > 2 && append_exact_fragment(fragment, perimeter, intervals))
        return true;
    return append_projected_fragment(fragment, perimeter, intervals, failure);
}

References append_exact_fragment(), append_projected_fragment(), and Slic3r::MultiPoint::size().

Referenced by append_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

fragment_location()

std::string Slic3r::PreciseSeam::detail::fragment_location ( const ExtractionContext & context, size_t fragment_index )

static

{
    const Layer *layer = context.layer;
    const ModelObject *object = layer && layer->object() ? layer->object()->model_object() : nullptr;
    return " object=" + std::to_string(object ? object->id().id : 0) +
           " modifier=" + std::to_string(context.modifier ? context.modifier->id().id : 0) +
           " layer=" + (layer ? std::to_string(layer->id()) : std::string("unknown")) +
           " z=" + (layer ? std::to_string(layer->slice_z) : std::string("unknown")) +
           " fragment=" + std::to_string(fragment_index);
}

References Slic3r::Layer::id(), Slic3r::ObjectBase::id(), Slic3r::ObjectID::id, Slic3r::PreciseSeam::ExtractionContext::layer, Slic3r::PrintObjectBase::model_object(), Slic3r::PreciseSeam::ExtractionContext::modifier, Slic3r::Layer::object(), and Slic3r::Layer::slice_z.

Referenced by append_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

interval_on_edge()

std::optional< ClippedEdgeInterval > Slic3r::PreciseSeam::detail::interval_on_edge ( const Point & first, const Point & last, size_t edge, const Polygon & perimeter )

static

{
    const Point &a = perimeter.points[edge];
    const Point &b = perimeter.points[(edge + 1) % perimeter.size()];
    const auto t0 = parameter_on_edge(first, a, b);
    // Reject this edge before projecting the second point when the first is outside.
    if (!t0)
        return std::nullopt;
    const auto t1 = parameter_on_edge(last, a, b);
    if (!t1 || *t0 == *t1)
        return std::nullopt;
    ClippedEdgeInterval interval{edge, *t0, *t1, first, last};
    if (interval.begin > interval.end) {
        std::swap(interval.begin, interval.end);
        std::swap(interval.first, interval.last);
    }
    // Canonical endpoints make adjacent original edges join at their shared vertex.
    if (interval.begin == 0.) interval.first = a;
    if (interval.end == 1.) interval.last = b;
    return interval;
}

References Slic3r::PreciseSeam::detail::ClippedEdgeInterval::begin, Slic3r::PreciseSeam::detail::ClippedEdgeInterval::end, Slic3r::PreciseSeam::detail::ClippedEdgeInterval::first, Slic3r::PreciseSeam::detail::ClippedEdgeInterval::last, parameter_on_edge(), Slic3r::MultiPoint::points, and Slic3r::MultiPoint::size().

Referenced by append_exact_fragment(), and append_projected_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

parameter_on_edge()

std::optional< double > Slic3r::PreciseSeam::detail::parameter_on_edge ( const Point & point, const Point & a, const Point & b )

static

{
    // Original vertices need no floating-point projection.
    if (point == a) return 0.;
    if (point == b) return 1.;
    const Vec2d direction = b.cast<double>() - a.cast<double>();
    const Vec2d offset = point.cast<double>() - a.cast<double>();
    const double squared_length = direction.squaredNorm();
    if (squared_length == 0.)
        return std::nullopt;
    const double parameter = std::clamp(offset.dot(direction) / squared_length, 0., 1.);
    if ((offset - parameter * direction).squaredNorm() > MACHINE_PRECISION_SQUARED)
        return std::nullopt;
    return parameter;
}

References Slic3r::PreciseSeam::MACHINE_PRECISION_SQUARED, and Slic3r::offset().

Referenced by interval_on_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

snap_cuts_to_adjacent_vertices()

bool Slic3r::PreciseSeam::detail::snap_cuts_to_adjacent_vertices ( Polyline & fragment, const Polygon & perimeter )

static

{
    const size_t count = perimeter.size();
    // Strict comparison matches the vertex snapping in insert_point_into_perimeter.
    const auto close = [](const Point &a, const Point &b) {
        return (a - b).cast<double>().squaredNorm() < double(TOLERANCE_SQUARED);
    };
    const auto snap_target = [&](const Point &cut, const Point &neighbour) -> std::optional<Point> {
        if (cut == neighbour)
            return std::nullopt;
        bool neighbour_is_vertex = false;
        bool ambiguous = false;
        std::optional<Point> target;
        // Scan the whole perimeter before deciding: a cut that is a real vertex must be detected anywhere,
        // and an ambiguity must not pre-empt the neighbour rule below.
        for (size_t j = 0; j < count; ++j) {
            if (perimeter[j] == cut)
                return std::nullopt; // A real vertex, not a rounded cut.
            if (perimeter[j] != neighbour)
                continue;
            neighbour_is_vertex = true;
            for (const Point &candidate : {perimeter[(j + count - 1) % count], perimeter[(j + 1) % count]}) {
                if (!close(cut, candidate))
                    continue;
                if (target && *target != candidate)
                    ambiguous = true;
                target = candidate;
            }
        }
        // A cut between two arbitrary points of one edge is not this rounding case.
        if (!neighbour_is_vertex)
            return std::nullopt;
        // The neighbour itself takes precedence, even when both of its chain vertices are close too
        // (edges shorter than the radius on both sides): the cut is then just a rounded copy of it.
        if (close(cut, neighbour))
            return neighbour;
        // Two different edge-start candidates: keep the failure rather than guess.
        if (ambiguous)
            return std::nullopt;
        return target;
    };
    bool changed = false;
    if (fragment.size() >= 2)
        if (const auto target = snap_target(fragment.points.front(), fragment.points[1])) {
            if (*target == fragment.points[1])
                fragment.points.erase(fragment.points.begin());
            else
                fragment.points.front() = *target;
            changed = true;
        }
    if (fragment.size() >= 2)
        if (const auto target = snap_target(fragment.points.back(), fragment.points[fragment.size() - 2])) {
            if (*target == fragment.points[fragment.size() - 2])
                fragment.points.pop_back();
            else
                fragment.points.back() = *target;
            changed = true;
        }
    return changed;
}

References count, Slic3r::MultiPoint::points, Slic3r::MultiPoint::size(), and Slic3r::PreciseSeam::TOLERANCE_SQUARED.

Referenced by append_fragment().

Here is the call graph for this function:

Here is the caller graph for this function: