Slic3r::SeamContour::Resolver Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/SeamContour.hpp>

Collaboration diagram for Slic3r::SeamContour::Resolver:

Public Member Functions
	Resolver (Layers layers, Options options={}, std::function< void()> throw_if_canceled={})
Result	resolve (size_t layer, size_t contour, size_t vertex, int direction, double radius=-1.0) const

Private Types
using	Key = std::tuple<size_t, size_t, size_t, int, double>

Private Member Functions
std::vector< size_t >	query (size_t layer, const Vec2d &point, double reach) const
bool	in_material (size_t layer, const Vec2d &point) const
bool	near_boundary (size_t layer, const Vec2d &point, double noise) const
Result	select (size_t layer, size_t contour, const Vec2d &point, int direction, double radius, bool check_reverse) const

Private Attributes
Layers	m_layers
std::vector< AABBTreeIndirect::Tree2d >	m_indices
Options	m_options
std::map< Key, Result >	m_cache

Detailed Description

Member Typedef Documentation

Key

using Slic3r::SeamContour::Resolver::Key = std::tuple<size_t, size_t, size_t, int, double>

private

Constructor & Destructor Documentation

Resolver()

Slic3r::SeamContour::Resolver::Resolver ( Layers layers, Options options = {}, std::function< void()> throw_if_canceled = {} )

explicit

                                                                                        :
    m_layers(std::move(layers)), m_options(options) {
    m_indices.resize(m_layers.size());
    for (size_t i = 0; i < m_layers.size(); ++i) {
        if (throw_if_canceled) throw_if_canceled(); // Index construction on dense objects remains cancellable.
        std::vector<BoxEntry> boxes;
        for (size_t j = 0; j < m_layers[i].size(); ++j) {
            Contour &c = m_layers[i][j];
            c.min = Vec2d::Constant(std::numeric_limits<double>::infinity());
            c.max = -c.min;
            for (const Vec2d &p : c.points) { c.min = c.min.cwiseMin(p); c.max = c.max.cwiseMax(p); }
            if (!c.points.empty()) boxes.push_back({j, AABBTreeIndirect::Tree2d::BoundingBox(c.min, c.max)});
        }
        // Build once per layer; all seeds, reverse matches and material probes reuse the boxes.
        m_indices[i].build(std::move(boxes));
    }
}

References m_indices, m_layers, m_options, Slic3r::SeamContour::Contour::max, Slic3r::SeamContour::Contour::min, and Slic3r::SeamContour::Contour::points.

Member Function Documentation

in_material()

bool Slic3r::SeamContour::Resolver::in_material ( size_t layer, const Vec2d & point ) const

private

                                                             {
    bool inside = false;
    for (size_t index : query(layer, p, 0.0)) {
        const Contour &c = m_layers[layer][index];
        if (!c.reliable) continue; // select() already falls back wherever unknown geometry can affect a probe.
        if ((p.array() < c.min.array()).any() || (p.array() > c.max.array()).any()) continue;
        for (size_t i = 0; i < c.points.size(); ++i) {
            const Vec2d &a = c.points[i], &b = c.points[(i + 1) % c.points.size()];
            if ((a.y() > p.y()) != (b.y() > p.y()) &&
                p.x() < a.x() + (p.y() - a.y()) * (b.x() - a.x()) / (b.y() - a.y()))
                inside = !inside;
        }
    }
    return inside;
}

References m_layers, Slic3r::SeamContour::Contour::max, Slic3r::SeamContour::Contour::min, Slic3r::SeamContour::Contour::points, query(), and Slic3r::SeamContour::Contour::reliable.

Referenced by select().

Here is the call graph for this function:

Here is the caller graph for this function:

near_boundary()

bool Slic3r::SeamContour::Resolver::near_boundary ( size_t layer, const Vec2d & point, double noise ) const

private

                                                                             {
    for (size_t index : query(layer, p, noise)) {
        const Contour &c = m_layers[layer][index];
        if (box_distance(c, p) <= noise && closest(c, p, noise).distance <= noise) return true;
    }
    return false;
}

References m_layers, and query().

Referenced by select().

Here is the call graph for this function:

Here is the caller graph for this function:

query()

std::vector< size_t > Slic3r::SeamContour::Resolver::query ( size_t layer, const Vec2d & point, double reach ) const

private

                                                                                  {
    std::vector<size_t> result;
    const Vec2d margin = Vec2d::Constant(reach);
    AABBTreeIndirect::traverse(m_indices[layer],
        AABBTreeIndirect::intersecting(AABBTreeIndirect::Tree2d::BoundingBox(p - margin, p + margin)),
        [&](const auto &node) { result.push_back(node.idx); return true; });
    // Tree traversal order must not alter tie-breaking in the existing contour predicates.
    std::sort(result.begin(), result.end());
    return result;
}

References Slic3r::AABBTreeIndirect::intersecting(), m_indices, and Slic3r::AABBTreeIndirect::traverse().

Referenced by in_material(), near_boundary(), and select().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve()

Result Slic3r::SeamContour::Resolver::resolve	(	size_t	layer,
		size_t	contour,
		size_t	vertex,
		int	direction,
		double	radius = -1.0 ) const

                                                                                                        {
    Result result;
    if (direction != -1 && direction != 1) return result;
    const Contour &source = m_layers.at(layer).at(contour);
    if (!source.reliable) return {Outcome::None, Method::Local, {}, true};
    if (radius < 0.0) radius = source.width * m_options.radius_width_factor;
    if (!std::isfinite(radius)) return result;
    // Alternative seeds may have different widths; their actual KD search radii cannot share a cache entry.
    const Key key(layer, contour, vertex, direction, radius);
    const auto cached = m_cache.find(key);
    if (cached != m_cache.end()) return cached->second;
    const ptrdiff_t target = ptrdiff_t(layer) + direction;
    if (target >= 0 && size_t(target) < m_layers.size() && source.points.size() >= 3) {
        const Vec2d &p = source.points.at(vertex);
        result = select(layer, contour, p, direction, radius, true);
    }
    m_cache.emplace(key, result);
    return result;
}

References Slic3r::contour(), Slic3r::SeamContour::Local, m_cache, m_layers, m_options, Slic3r::SeamContour::None, Slic3r::SeamContour::Contour::points, Slic3r::SeamContour::Contour::reliable, select(), and Slic3r::SeamContour::Contour::width.

Referenced by Slic3r::SeamPlacer::find_next_seam_in_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

select()

Result Slic3r::SeamContour::Resolver::select ( size_t layer, size_t contour, const Vec2d & point, int direction, double radius, bool check_reverse ) const

private

                                                  {
    const size_t target = size_t(ptrdiff_t(layer) + direction);
    const Contour &source = m_layers[layer][contour];
    const auto &next = m_layers[target];
    const double bounds = source.nozzle * m_options.bounds_nozzle_factor;
    const double noise = source.width * m_options.noise_width_factor;
    const double reach = std::max({radius, bounds, noise});
    const auto candidates = query(target, p, reach);
    // An open path near either end or a material probe makes the geometric restriction uncertain.
    for (size_t i : query(layer, p, reach))
        if (!m_layers[layer][i].reliable) return {Outcome::None, Method::Local, {}, true};
    for (size_t i : candidates)
        if (!next[i].reliable) return {Outcome::None, Method::Local, {}, true};
    std::vector<size_t> fast, nearby;
    for (size_t i : candidates) {
        const Contour &c = next[i];
        if (c.points.size() < 3) continue;
        // A wall can become a hole when an opening closes; local geometry decides that continuation.
        if (box_distance(c, p) <= radius) nearby.push_back(i);
        if (c.hole == source.hole && (c.min - source.min).cwiseAbs().maxCoeff() <= bounds &&
            (c.max - source.max).cwiseAbs().maxCoeff() <= bounds) fast.push_back(i);
    }
    const auto source_normals = normals(source, p);
    const auto compatible_foot = [&](const Contour &c) {
        // Across a type change, use the closest patch itself: another side can mimic a shifted annulus.
        return closest(c, p, -1.0, c.hole == source.hole ? &source_normals : nullptr,
                       m_options.normal_cosine);
    };
    const auto normal_agreement = [&](const Contour &c, const Vec2d &foot) {
        double agreement = -1.0;
        const auto target_normals = normals(c, foot);
        for (const Vec2d &a : source_normals)
            for (const Vec2d &b : target_normals) agreement = std::max(agreement, a.dot(b));
        return agreement;
    };
    if (fast.size() == 1) {
        const size_t index = fast.front();
        const Foot foot = compatible_foot(next[index]);
        // Bounds alone cannot certify a wall: only a near-coincident, consistently oriented patch can.
        if (foot.distance <= noise && normal_agreement(next[index], foot.point) >= m_options.normal_cosine) {
            bool competing = false;
            for (size_t other : nearby) {
                if (other == index || box_distance(next[other], p) > noise) continue;
                const Foot alternative = compatible_foot(next[other]);
                if (alternative.distance <= noise &&
                    normal_agreement(next[other], alternative.point) >= m_options.normal_cosine) {
                    competing = true;
                    break;
                }
            }
            // A competing local wall or failed reverse match must reach the full fallback.
            if (!competing) {
                if (!check_reverse) return {Outcome::Unique, Method::Bounds, {index}};
                const Result back = select(target, index, foot.point, -direction, radius, false);
                // An uncertain certificate must leave the entire legacy candidate set unrestricted.
                if (back.uncertain) return back;
                if (std::find(back.contours.begin(), back.contours.end(), contour) != back.contours.end())
                    return {Outcome::Unique, Method::Bounds, {index}};
            }
        }
    }
    std::vector<Witness> witnessed;
    for (size_t i : nearby) {
        const Foot foot = compatible_foot(next[i]);
        if (foot.distance > radius) continue;
        const double agreement = normal_agreement(next[i], foot.point);
        if (agreement < m_options.normal_cosine) continue;
        bool band = true;
        if (foot.distance > noise) {
            // Three witnesses reject connectors through material (or air) shared by both layers.
            for (double t : std::array<double, 3>{0.25, 0.5, 0.75}) {
                const Vec2d probe = p + t * (foot.point - p);
                if (in_material(layer, probe) == in_material(target, probe) &&
                    !near_boundary(layer, probe, noise) && !near_boundary(target, probe, noise)) {
                    band = false;
                    break;
                }
            }
        }
        if (!band) continue;
        if (check_reverse) {
            const Result back = select(target, i, foot.point, -direction, radius, false);
            if (back.uncertain) return back;
            // Several reverse continuations are valid if they still include the source wall.
            if (std::find(back.contours.begin(), back.contours.end(), contour) == back.contours.end()) continue;
        }
        witnessed.push_back({i, foot.distance, std::acos(std::clamp(agreement, -1.0, 1.0)) *
                                                 180.0 / std::acos(-1.0)});
    }
    Result result;
    const double distance_margin = std::max(1e-6, source.width * m_options.dominance_width_factor);
    const double angle_margin = std::max(1e-6, m_options.dominance_angle_degrees);
    for (const Witness &candidate : witnessed) {
        // A contour is discarded only with a meaningful advantage in every scored criterion.
        const bool dominated = std::any_of(witnessed.begin(), witnessed.end(), [&](const Witness &other) {
            return other.distance + distance_margin <= candidate.distance &&
                   other.angle_degrees + angle_margin <= candidate.angle_degrees;
        });
        if (!dominated) result.contours.push_back(candidate.contour);
    }
    result.outcome = result.contours.empty() ? Outcome::None :
                     result.contours.size() == 1 ? Outcome::Unique : Outcome::Multiple;
    return result;
}

References Slic3r::SeamContour::Bounds, Slic3r::bounds(), Slic3r::contour(), Slic3r::SeamContour::Result::contours, Slic3r::SeamContour::Contour::hole, in_material(), Slic3r::SeamContour::Local, m_layers, m_options, Slic3r::SeamContour::Contour::max, Slic3r::SeamContour::Contour::min, Slic3r::SeamContour::Multiple, near_boundary(), Slic3r::SeamContour::None, Slic3r::SeamContour::Contour::nozzle, Slic3r::SeamContour::Result::outcome, Slic3r::SeamContour::Contour::points, query(), select(), Slic3r::SeamContour::Result::uncertain, Slic3r::SeamContour::Unique, and Slic3r::SeamContour::Contour::width.

Referenced by resolve(), and select().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_cache

std::map<Key, Result> Slic3r::SeamContour::Resolver::m_cache

mutableprivate

Referenced by resolve().

m_indices

std::vector<AABBTreeIndirect::Tree2d> Slic3r::SeamContour::Resolver::m_indices

private

Referenced by Resolver(), and query().

m_layers

Layers Slic3r::SeamContour::Resolver::m_layers

private

Referenced by Resolver(), in_material(), near_boundary(), resolve(), and select().

m_options

Options Slic3r::SeamContour::Resolver::m_options

private

Referenced by Resolver(), resolve(), and select().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/SeamContour.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCode/SeamContour.cpp