#include <src/libslic3r/GCode/SeamPlacer.hpp>

Collaboration diagram for Slic3r::SeamPlacer:

Public Member Functions
void	init (const Print &print, std::function< void(void)> throw_if_canceled_func)

void	place_seam (const Layer *layer, ExtrusionLoop &loop, bool external_first, const Point &last_pos) const

Public Attributes
std::unordered_map< const PrintObject *, PrintObjectSeamData >	m_seam_per_object

Static Public Attributes
static constexpr size_t	raycasting_visibility_samples_count = 30000

static constexpr size_t	fast_decimation_triangle_count_target = 16000

static constexpr size_t	sqr_rays_per_sample_point = 5

static constexpr float	sharp_angle_snapping_threshold = 55.0f * float(PI) / 180.0f

static constexpr float	overhang_angle_threshold = 50.0f * float(PI) / 180.0f

static constexpr float	angle_importance_aligned = 0.6f

static constexpr float	angle_importance_nearest = 1.0f

static constexpr float	enforcer_oversampling_distance = 0.2f

static constexpr float	seam_align_score_tolerance = 0.3f

static constexpr float	seam_align_tolerable_dist_factor = 4.0f

static constexpr size_t	seam_align_minimum_string_seams = 6

static constexpr size_t	seam_align_mm_per_segment = 4.0f

Private Member Functions
void	gather_seam_candidates (const PrintObject *po, const SeamPlacerImpl::GlobalModelInfo &global_model_info)

void	calculate_candidates_visibility (const PrintObject *po, const SeamPlacerImpl::GlobalModelInfo &global_model_info)

void	calculate_overhangs_and_layer_embedding (const PrintObject *po)

void	align_seam_points (const PrintObject *po, const SeamPlacerImpl::SeamComparator &comparator)

std::vector< std::pair< size_t, size_t > >	find_seam_string (const PrintObject *po, std::pair< size_t, size_t > start_seam, const SeamPlacerImpl::SeamComparator &comparator) const

std::optional< std::pair< size_t, size_t > >	find_next_seam_in_layer (const std::vector< PrintObjectSeamData::LayerSeams > &layers, const Vec3f &projected_position, const size_t layer_idx, const float max_distance, const SeamPlacerImpl::SeamComparator &comparator) const

Detailed Description

Member Function Documentation

◆ align_seam_points()

void Slic3r::SeamPlacer::align_seam_points	(	const PrintObject *	po,
		const SeamPlacerImpl::SeamComparator &	comparator
	)

private

                                                                                                        {
    using namespace SeamPlacerImpl;
 
    // Prepares Debug files for writing.
#ifdef DEBUG_FILES
    Slic3r::CNumericLocalesSetter locales_setter;
    auto clusters_f = debug_out_path("seam_clusters.obj");
    FILE *clusters = boost::nowide::fopen(clusters_f.c_str(), "w");
    if (clusters == nullptr) {
        BOOST_LOG_TRIVIAL(error)
        << "stl_write_obj: Couldn't open " << clusters_f << " for writing";
        return;
    }
    auto aligned_f = debug_out_path("aligned_clusters.obj");
    FILE *aligns = boost::nowide::fopen(aligned_f.c_str(), "w");
    if (aligns == nullptr) {
        BOOST_LOG_TRIVIAL(error)
        << "stl_write_obj: Couldn't open " << clusters_f << " for writing";
        return;
    }
#endif
 
    //gather vector of all seams on the print_object - pair of layer_index and seam__index within that layer
    const std::vector<PrintObjectSeamData::LayerSeams> &layers = m_seam_per_object[po].layers;
    std::vector<std::pair<size_t, size_t>> seams;
    for (size_t layer_idx = 0; layer_idx < layers.size(); ++layer_idx) {
        const std::vector<SeamCandidate> &layer_perimeter_points = layers[layer_idx].points;
        size_t current_point_index = 0;
        while (current_point_index < layer_perimeter_points.size()) {
            seams.emplace_back(layer_idx, layer_perimeter_points[current_point_index].perimeter.seam_index);
            current_point_index = layer_perimeter_points[current_point_index].perimeter.end_index;
        }
    }
 
    //sort them before alignment. Alignment is sensitive to initializaion, this gives it better chance to choose something nice
    std::stable_sort(seams.begin(), seams.end(),
            [&comparator, &layers](const std::pair<size_t, size_t> &left,
                    const std::pair<size_t, size_t> &right) {
                return comparator.is_first_better(layers[left.first].points[left.second],
                        layers[right.first].points[right.second]);
            }
    );
 
    //align the seam points - start with the best, and check if they are aligned, if yes, skip, else start alignment
    // Keeping the vectors outside, so with a bit of luck they will not get reallocated after couple of for loop iterations.
    std::vector<std::pair<size_t, size_t>> seam_string;
    std::vector<std::pair<size_t, size_t>> alternative_seam_string;
    std::vector<Vec2f> observations;
    std::vector<float> observation_points;
    std::vector<float> weights;
 
    int global_index = 0;
    while (global_index < int(seams.size())) {
        size_t layer_idx = seams[global_index].first;
        size_t seam_index = seams[global_index].second;
        global_index++;
        const std::vector<SeamCandidate> &layer_perimeter_points = layers[layer_idx].points;
        if (layer_perimeter_points[seam_index].perimeter.finalized) {
            // This perimeter is already aligned, skip seam
            continue;
        } else {
            seam_string = this->find_seam_string(po, { layer_idx, seam_index }, comparator);
            size_t step_size = 1 + seam_string.size() / 20;
            for (size_t alternative_start = 0; alternative_start < seam_string.size(); alternative_start += step_size) {
                size_t start_layer_idx = seam_string[alternative_start].first;
                size_t seam_idx =
                        layers[start_layer_idx].points[seam_string[alternative_start].second].perimeter.seam_index;
                alternative_seam_string = this->find_seam_string(po,
                        std::pair<size_t, size_t>(start_layer_idx, seam_idx), comparator);
                if (alternative_seam_string.size() > seam_string.size()) {
                    seam_string = std::move(alternative_seam_string);
                }
            }
            if (seam_string.size() < seam_align_minimum_string_seams) {
                //string NOT long enough to be worth aligning, skip
                continue;
            }
 
            // String is long enough, all string seams and potential string seams gathered, now do the alignment
            //sort by layer index
            std::sort(seam_string.begin(), seam_string.end(),
                    [](const std::pair<size_t, size_t> &left, const std::pair<size_t, size_t> &right) {
                        return left.first < right.first;
                    });
 
            //repeat the alignment for the current seam, since it could be skipped due to alternative path being aligned.
            global_index--;
 
            // gather all positions of seams and their weights
            observations.resize(seam_string.size());
            observation_points.resize(seam_string.size());
            weights.resize(seam_string.size());
 
            auto angle_3d = [](const Vec3f& a, const Vec3f& b){
                return std::abs(acosf(a.normalized().dot(b.normalized())));
            };
 
            auto angle_weight = [](float angle){
                return 1.0f / (0.1f + compute_angle_penalty(angle));
            };
 
            //gather points positions and weights
            float total_length = 0.0f;
            Vec3f last_point_pos = layers[seam_string[0].first].points[seam_string[0].second].position;
            for (size_t index = 0; index < seam_string.size(); ++index) {
                const SeamCandidate &current = layers[seam_string[index].first].points[seam_string[index].second];
                float layer_angle = 0.0f;
                if (index > 0 && index < seam_string.size() - 1) {
                    layer_angle = angle_3d(
                                    current.position
                                            - layers[seam_string[index - 1].first].points[seam_string[index - 1].second].position,
                                    layers[seam_string[index + 1].first].points[seam_string[index + 1].second].position
                                            - current.position
                                            );
                }
                observations[index] = current.position.head<2>();
                observation_points[index] = current.position.z();
                weights[index] = angle_weight(current.local_ccw_angle);
                float curling_influence = layer_angle > 2.0 * std::abs(current.local_ccw_angle) ? -0.8f : 1.0f;
                if (current.type == EnforcedBlockedSeamPoint::Enforced) {
                    curling_influence = 1.0f;
                    weights[index] += 3.0f;
                }
                total_length += curling_influence * (last_point_pos - current.position).norm();
                last_point_pos = current.position;
            }
 
            if (comparator.setup == spRear) {
                total_length *= 0.3f;
            }
 
            // Curve Fitting
            size_t number_of_segments = std::max(size_t(1),
                    size_t(std::max(0.0f,total_length) / SeamPlacer::seam_align_mm_per_segment));
            auto curve = Geometry::fit_cubic_bspline(observations, observation_points, weights, number_of_segments);
 
            // Do alignment - compute fitted point for each point in the string from its Z coord, and store the position into
            // Perimeter structure of the point; also set flag aligned to true
            for (size_t index = 0; index < seam_string.size(); ++index) {
                const auto &pair = seam_string[index];
                float t = std::min(1.0f, std::pow(std::abs(layers[pair.first].points[pair.second].local_ccw_angle)
                        / SeamPlacer::sharp_angle_snapping_threshold, 3.0f));
                if (layers[pair.first].points[pair.second].type == EnforcedBlockedSeamPoint::Enforced){
                    t = std::max(0.4f, t);
                }
 
                Vec3f current_pos = layers[pair.first].points[pair.second].position;
                Vec2f fitted_pos = curve.get_fitted_value(current_pos.z());
 
                //interpolate between current and fitted position, prefer current pos for large weights.
                Vec3f final_position = t * current_pos + (1.0f - t) * to_3d(fitted_pos, current_pos.z());
 
                Perimeter &perimeter = layers[pair.first].points[pair.second].perimeter;
                perimeter.seam_index = pair.second;
                perimeter.final_seam_position = final_position;
                perimeter.finalized = true;
            }
 
#ifdef DEBUG_FILES
            auto randf = []() {
                return float(rand()) / float(RAND_MAX);
            };
            Vec3f color { randf(), randf(), randf() };
            for (size_t i = 0; i < seam_string.size(); ++i) {
                auto orig_seam = layers[seam_string[i].first].points[seam_string[i].second];
                fprintf(clusters, "v %f %f %f %f %f %f \n", orig_seam.position[0],
                        orig_seam.position[1],
                        orig_seam.position[2], color[0], color[1],
                        color[2]);
            }
 
            color = Vec3f { randf(), randf(), randf() };
            for (size_t i = 0; i < seam_string.size(); ++i) {
                const Perimeter &perimeter = layers[seam_string[i].first].points[seam_string[i].second].perimeter;
                fprintf(aligns, "v %f %f %f %f %f %f \n", perimeter.final_seam_position[0],
                        perimeter.final_seam_position[1],
                        perimeter.final_seam_position[2], color[0], color[1],
                        color[2]);
            }
#endif
        }
    }
 
#ifdef DEBUG_FILES
    fclose(clusters);
    fclose(aligns);
#endif
 
}

References Slic3r::angle(), Slic3r::debug_out_path(), error, Slic3r::Perimeter, Slic3r::SeamPlacerImpl::SeamComparator::setup, Slic3r::spRear, Slic3r::to_3d(), and Slic3r::total_length().

Here is the call graph for this function:

◆ calculate_candidates_visibility()

void Slic3r::SeamPlacer::calculate_candidates_visibility	(	const PrintObject *	po,
		const SeamPlacerImpl::GlobalModelInfo &	global_model_info
	)

private

                                                                {
    using namespace SeamPlacerImpl;
 
    std::vector<PrintObjectSeamData::LayerSeams> &layers = m_seam_per_object[po].layers;
    tbb::parallel_for(tbb::blocked_range<size_t>(0, layers.size()),
            [&layers, &global_model_info](tbb::blocked_range<size_t> r) {
                for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) {
                    for (auto &perimeter_point : layers[layer_idx].points) {
                        perimeter_point.visibility = global_model_info.calculate_point_visibility(
                                perimeter_point.position);
                    }
                }
            });
}

◆ calculate_overhangs_and_layer_embedding()

void Slic3r::SeamPlacer::calculate_overhangs_and_layer_embedding ( const PrintObject * po )

private

                                                                              {
    using namespace SeamPlacerImpl;
    using PerimeterDistancer = AABBTreeLines::LinesDistancer<Linef>;
 
    std::vector<PrintObjectSeamData::LayerSeams> &layers = m_seam_per_object[po].layers;
    tbb::parallel_for(tbb::blocked_range<size_t>(0, layers.size()),
            [po, &layers](tbb::blocked_range<size_t> r) {
                std::unique_ptr<PerimeterDistancer> prev_layer_distancer;
                if (r.begin() > 0) { // previous layer exists
                    prev_layer_distancer = std::make_unique<PerimeterDistancer>(to_unscaled_linesf(po->layers()[r.begin() - 1]->lslices));
                }
 
                for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) {
                    size_t regions_with_perimeter = 0;
                    for (const LayerRegion *region : po->layers()[layer_idx]->regions()) {
                        if (region->perimeters().size() > 0) {
                            regions_with_perimeter++;
                        }
                    };
                    bool should_compute_layer_embedding = regions_with_perimeter > 1;
                    std::unique_ptr<PerimeterDistancer> current_layer_distancer        = std::make_unique<PerimeterDistancer>(
                        to_unscaled_linesf(po->layers()[layer_idx]->lslices));
 
                    for (SeamCandidate &perimeter_point : layers[layer_idx].points) {
                        Vec2f point = Vec2f { perimeter_point.position.head<2>() };
                        if (prev_layer_distancer.get() != nullptr) {
                            perimeter_point.overhang = prev_layer_distancer->distance_from_lines<true>(point.cast<double>())
                                    + 0.6f * perimeter_point.perimeter.flow_width
                                    - tan(SeamPlacer::overhang_angle_threshold)
                                            * po->layers()[layer_idx]->height;
                            perimeter_point.overhang =
                                    perimeter_point.overhang < 0.0f ? 0.0f : perimeter_point.overhang;
                        }
 
                        if (should_compute_layer_embedding) { // search for embedded perimeter points (points hidden inside the print ,e.g. multimaterial join, best position for seam)
                            perimeter_point.embedded_distance = current_layer_distancer->distance_from_lines<true>(point.cast<double>())
                                    + 0.6f * perimeter_point.perimeter.flow_width;
                        }
                    }
 
                    prev_layer_distancer.swap(current_layer_distancer);
                }
            }
            );
        }

References Slic3r::PrintObject::layers(), tan(), and Slic3r::to_unscaled_linesf().

Here is the call graph for this function:

◆ find_next_seam_in_layer()

std::optional< std::pair< size_t, size_t > > Slic3r::SeamPlacer::find_next_seam_in_layer	(	const std::vector< PrintObjectSeamData::LayerSeams > &	layers,
		const Vec3f &	projected_position,
		const size_t	layer_idx,
		const float	max_distance,
		const SeamPlacerImpl::SeamComparator &	comparator
	)		const

private

                                                              {
    using namespace SeamPlacerImpl;
    std::vector<size_t> nearby_points_indices = find_nearby_points(*layers[layer_idx].points_tree, projected_position,
            max_distance);
 
    if (nearby_points_indices.empty()) {
        return {};
    }
 
    size_t best_nearby_point_index = nearby_points_indices[0];
    size_t nearest_point_index = nearby_points_indices[0];
 
    // Now find best nearby point, nearest point, and corresponding indices
    for (const size_t &nearby_point_index : nearby_points_indices) {
        const SeamCandidate &point = layers[layer_idx].points[nearby_point_index];
        if (point.perimeter.finalized) {
            continue; // skip over finalized perimeters, try to find some that is not finalized
        }
        if (comparator.is_first_better(point, layers[layer_idx].points[best_nearby_point_index],
                projected_position.head<2>())
                || layers[layer_idx].points[best_nearby_point_index].perimeter.finalized) {
            best_nearby_point_index = nearby_point_index;
        }
        if ((point.position - projected_position).squaredNorm()
                < (layers[layer_idx].points[nearest_point_index].position - projected_position).squaredNorm()
                || layers[layer_idx].points[nearest_point_index].perimeter.finalized) {
            nearest_point_index = nearby_point_index;
        }
    }
 
    const SeamCandidate &best_nearby_point = layers[layer_idx].points[best_nearby_point_index];
    const SeamCandidate &nearest_point = layers[layer_idx].points[nearest_point_index];
 
    if (nearest_point.perimeter.finalized) {
        //all points are from already finalized perimeter, skip
        return {};
    }
 
    //from the nearest_point, deduce index of seam in the next layer
    const SeamCandidate &next_layer_seam = layers[layer_idx].points[nearest_point.perimeter.seam_index];
 
    // First try to pick central enforcer if any present
    if (next_layer_seam.central_enforcer
            && (next_layer_seam.position - projected_position).squaredNorm()
                    < sqr(3 * max_distance)) {
        return {std::pair<size_t, size_t> {layer_idx, nearest_point.perimeter.seam_index}};
    }
 
    // First try to align the nearest, then try the best nearby
    if (comparator.is_first_not_much_worse(nearest_point, next_layer_seam)) {
        return {std::pair<size_t, size_t> {layer_idx, nearest_point_index}};
    }
    // If nearest point is not good enough, try it with the best nearby point.
    if (comparator.is_first_not_much_worse(best_nearby_point, next_layer_seam)) {
        return {std::pair<size_t, size_t> {layer_idx, best_nearby_point_index}};
    }
 
    return {};
}

References Slic3r::find_nearby_points(), Slic3r::SeamPlacerImpl::SeamComparator::is_first_better(), Slic3r::SeamPlacerImpl::SeamComparator::is_first_not_much_worse(), Slic3r::nearest_point(), Slic3r::nearest_point_index(), and Slic3r::sqr().

Here is the call graph for this function:

◆ find_seam_string()

std::vector< std::pair< size_t, size_t > > Slic3r::SeamPlacer::find_seam_string	(	const PrintObject *	po,
		std::pair< size_t, size_t >	start_seam,
		const SeamPlacerImpl::SeamComparator &	comparator
	)		const

private

                                                                                                  {
    const std::vector<PrintObjectSeamData::LayerSeams> &layers = m_seam_per_object.find(po)->second.layers;
    int layer_idx = start_seam.first;
 
    //initialize searching for seam string - cluster of nearby seams on previous and next layers
    int next_layer = layer_idx + 1;
    int step = 1;
    std::pair<size_t, size_t> prev_point_index = start_seam;
    std::vector<std::pair<size_t, size_t>> seam_string { start_seam };
 
    auto reverse_lookup_direction = [&]() {
        step = -1;
        prev_point_index = start_seam;
        next_layer = layer_idx - 1;
    };
 
    while (next_layer >= 0) {
        if (next_layer >= int(layers.size())) {
            reverse_lookup_direction();
            if (next_layer < 0) {
                break;
            }
        }
        float max_distance = SeamPlacer::seam_align_tolerable_dist_factor *
                layers[start_seam.first].points[start_seam.second].perimeter.flow_width;
        Vec3f prev_position = layers[prev_point_index.first].points[prev_point_index.second].position;
        Vec3f projected_position = prev_position;
        projected_position.z() = float(po->get_layer(next_layer)->slice_z);
 
        std::optional<std::pair<size_t, size_t>> maybe_next_seam = find_next_seam_in_layer(layers, projected_position,
                next_layer,
                max_distance, comparator);
 
        if (maybe_next_seam.has_value()) {
            // For old macOS (pre 10.14), std::optional does not have .value() method, so the code is using operator*() instead.
            seam_string.push_back(maybe_next_seam.operator*());
            prev_point_index = seam_string.back();
            //String added, prev_point_index updated
        } else {
            if (step == 1) {
                reverse_lookup_direction();
                if (next_layer < 0) {
                    break;
                }
            } else {
                break;
            }
        }
        next_layer += step;
    }
    return seam_string;
}

References Slic3r::PrintObject::get_layer(), and Slic3r::Layer::slice_z.

Here is the call graph for this function:

◆ gather_seam_candidates()

void Slic3r::SeamPlacer::gather_seam_candidates	(	const PrintObject *	po,
		const SeamPlacerImpl::GlobalModelInfo &	global_model_info
	)

private

                                                                                                                     {
    using namespace SeamPlacerImpl;
    PrintObjectSeamData &seam_data = m_seam_per_object.emplace(po, PrintObjectSeamData { }).first->second;
    seam_data.layers.resize(po->layer_count());
 
    tbb::parallel_for(tbb::blocked_range<size_t>(0, po->layers().size()),
            [po, &global_model_info, &seam_data]
            (tbb::blocked_range<size_t> r) {
                for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) {
                    PrintObjectSeamData::LayerSeams &layer_seams = seam_data.layers[layer_idx];
                    const Layer *layer = po->get_layer(layer_idx);
                    auto unscaled_z = layer->slice_z;
                    std::vector<const LayerRegion*> regions;
                    //NOTE corresponding region ptr may be null, if the layer has zero perimeters
                    Polygons polygons = extract_perimeter_polygons(layer, regions);
                    for (size_t poly_index = 0; poly_index < polygons.size(); ++poly_index) {
                        process_perimeter_polygon(polygons[poly_index], unscaled_z,
                                regions[poly_index], global_model_info, layer_seams);
                    }
                    auto functor = SeamCandidateCoordinateFunctor { layer_seams.points };
                    seam_data.layers[layer_idx].points_tree =
                            std::make_unique<PrintObjectSeamData::SeamCandidatesTree>(functor,
                                    layer_seams.points.size());
                }
            }
    );
}

References Slic3r::PrintObject::layer_count(), Slic3r::PrintObjectSeamData::layers, and Slic3r::PrintObject::layers().

Here is the call graph for this function:

◆ init()

void Slic3r::SeamPlacer::init	(	const Print &	print,
		std::function< void(void)>	throw_if_canceled_func
	)

                                                                                        {
    using namespace SeamPlacerImpl;
    m_seam_per_object.clear();
 
    for (const PrintObject *po : print.objects()) {
        throw_if_canceled_func();
        SeamPosition configured_seam_preference = po->config().seam_position.value;
        SeamComparator comparator { configured_seam_preference };
 
        {
            GlobalModelInfo global_model_info { };
            gather_enforcers_blockers(global_model_info, po);
            throw_if_canceled_func();
            if (configured_seam_preference == spAligned || configured_seam_preference == spNearest) {
                compute_global_occlusion(global_model_info, po, throw_if_canceled_func);
            }
            throw_if_canceled_func();
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: gather_seam_candidates: start";
            gather_seam_candidates(po, global_model_info);
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: gather_seam_candidates: end";
            throw_if_canceled_func();
            if (configured_seam_preference == spAligned || configured_seam_preference == spNearest) {
                BOOST_LOG_TRIVIAL(debug)
                << "SeamPlacer: calculate_candidates_visibility : start";
                calculate_candidates_visibility(po, global_model_info);
                BOOST_LOG_TRIVIAL(debug)
                << "SeamPlacer: calculate_candidates_visibility : end";
            }
        } // destruction of global_model_info (large structure, no longer needed)
        throw_if_canceled_func();
        BOOST_LOG_TRIVIAL(debug)
        << "SeamPlacer: calculate_overhangs and layer embdedding : start";
        calculate_overhangs_and_layer_embedding(po);
        BOOST_LOG_TRIVIAL(debug)
        << "SeamPlacer: calculate_overhangs and layer embdedding: end";
        throw_if_canceled_func();
        if (configured_seam_preference != spNearest) { // For spNearest, the seam is picked in the place_seam method with actual nozzle position information
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: pick_seam_point : start";
            //pick seam point
            std::vector<PrintObjectSeamData::LayerSeams> &layers = m_seam_per_object[po].layers;
            tbb::parallel_for(tbb::blocked_range<size_t>(0, layers.size()),
                    [&layers, configured_seam_preference, comparator](tbb::blocked_range<size_t> r) {
                        for (size_t layer_idx = r.begin(); layer_idx < r.end(); ++layer_idx) {
                            std::vector<SeamCandidate> &layer_perimeter_points = layers[layer_idx].points;
                            for (size_t current = 0; current < layer_perimeter_points.size();
                                    current = layer_perimeter_points[current].perimeter.end_index)
                                if (configured_seam_preference == spRandom)
                                    pick_random_seam_point(layer_perimeter_points, current);
                                else
                                    pick_seam_point(layer_perimeter_points, current, comparator);
                        }
                    });
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: pick_seam_point : end";
        }
        throw_if_canceled_func();
        if (configured_seam_preference == spAligned || configured_seam_preference == spRear) {
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: align_seam_points : start";
            align_seam_points(po, comparator);
            BOOST_LOG_TRIVIAL(debug)
            << "SeamPlacer: align_seam_points : end";
        }
 
#ifdef DEBUG_FILES
        debug_export_points(m_seam_per_object[po].layers, po->bounding_box(), comparator);
#endif
    }
}

References Slic3r::PrintObject::bounding_box(), Slic3r::PrintObject::config(), Slic3r::Print::objects(), Slic3r::spAligned, Slic3r::spNearest, and Slic3r::spRear.

Referenced by Slic3r::GCode::_do_export().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ place_seam()

void Slic3r::SeamPlacer::place_seam	(	const Layer *	layer,
		ExtrusionLoop &	loop,
		bool	external_first,
		const Point &	last_pos
	)		const

                                     {
    using namespace SeamPlacerImpl;
    const PrintObject *po = layer->object();
    // Must not be called with supprot layer.
    assert(dynamic_cast<const SupportLayer*>(layer) == nullptr);
    // Object layer IDs are incremented by the number of raft layers.
    assert(layer->id() >= po->slicing_parameters().raft_layers());
    const size_t layer_index = layer->id() - po->slicing_parameters().raft_layers();
    const double unscaled_z = layer->slice_z;
 
    auto get_next_loop_point = [loop](ExtrusionLoop::ClosestPathPoint current) {
        current.segment_idx += 1;
        if (current.segment_idx >= loop.paths[current.path_idx].polyline.points.size()) {
            current.path_idx = next_idx_modulo(current.path_idx, loop.paths.size());
            current.segment_idx = 0;
        }
        current.foot_pt = loop.paths[current.path_idx].polyline.points[current.segment_idx];
        return current;
    };
 
    const PrintObjectSeamData::LayerSeams &layer_perimeters =
            m_seam_per_object.find(layer->object())->second.layers[layer_index];
 
    // Find the closest perimeter in the SeamPlacer to this loop.
    // Repeat search until two consecutive points of the loop are found, that result in the same closest_perimeter
    // This is beacuse with arachne, T-Junctions may exist and sometimes the wrong perimeter was chosen
    size_t closest_perimeter_point_index = 0;
    { // local space for the closest_perimeter_point_index
        Perimeter *closest_perimeter = nullptr;
        ExtrusionLoop::ClosestPathPoint closest_point{0,0,loop.paths[0].polyline.points[0]};
        size_t points_count = std::accumulate(loop.paths.begin(), loop.paths.end(), 0, [](size_t acc,const ExtrusionPath& p) {
           return acc + p.polyline.points.size();
        });
        for (size_t i = 0; i < points_count; ++i) {
            Vec2f unscaled_p = unscaled<float>(closest_point.foot_pt);
            closest_perimeter_point_index = find_closest_point(*layer_perimeters.points_tree.get(),
                    to_3d(unscaled_p, float(unscaled_z)));
            if (closest_perimeter != &layer_perimeters.points[closest_perimeter_point_index].perimeter) {
                closest_perimeter = &layer_perimeters.points[closest_perimeter_point_index].perimeter;
                closest_point = get_next_loop_point(closest_point);
            } else {
                break;
            }
        }
    }
 
    Vec3f seam_position;
    size_t seam_index;
    if (const Perimeter &perimeter = layer_perimeters.points[closest_perimeter_point_index].perimeter;
    perimeter.finalized) {
        seam_position = perimeter.final_seam_position;
        seam_index = perimeter.seam_index;
    } else {
        seam_index =
                po->config().seam_position == spNearest ?
                        pick_nearest_seam_point_index(layer_perimeters.points, perimeter.start_index,
                                unscaled<float>(last_pos)) :
                        perimeter.seam_index;
        seam_position = layer_perimeters.points[seam_index].position;
    }
 
    Point seam_point = Point::new_scale(seam_position.x(), seam_position.y());
 
    if (loop.role() == ExtrusionRole::Perimeter) { //Hopefully inner perimeter
        const SeamCandidate &perimeter_point = layer_perimeters.points[seam_index];
        ExtrusionLoop::ClosestPathPoint projected_point = loop.get_closest_path_and_point(seam_point, false);
        // determine depth of the seam point.
        float depth = (float) unscale(Point(seam_point - projected_point.foot_pt)).norm();
        float beta_angle = cos(perimeter_point.local_ccw_angle / 2.0f);
        size_t index_of_prev =
                seam_index == perimeter_point.perimeter.start_index ?
                                                                      perimeter_point.perimeter.end_index - 1 :
                                                                      seam_index - 1;
        size_t index_of_next =
                seam_index == perimeter_point.perimeter.end_index - 1 ?
                                                                        perimeter_point.perimeter.start_index :
                                                                        seam_index + 1;
 
        if ((seam_position - perimeter_point.position).squaredNorm() < depth && // seam is on perimeter point
                perimeter_point.local_ccw_angle < -EPSILON // In concave angles
                        ) { // In this case, we are at internal perimeter, where the external perimeter has seam in concave angle. We want to align
                // the internal seam into the concave corner, and not on the perpendicular projection on the closest edge (which is what the split_at function does)
            Vec2f dir_to_middle =
                    ((perimeter_point.position - layer_perimeters.points[index_of_prev].position).head<2>().normalized()
                            + (perimeter_point.position - layer_perimeters.points[index_of_next].position).head<2>().normalized())
                            * 0.5;
            depth = 1.4142 * depth / beta_angle;
            // There are some nice geometric identities in determination of the correct depth of new seam point.
            //overshoot the target depth, in concave angles it will correctly snap to the corner; TODO: find out why such big overshoot is needed.
            Vec2f final_pos = perimeter_point.position.head<2>() + depth * dir_to_middle;
            projected_point = loop.get_closest_path_and_point(Point::new_scale(final_pos.x(), final_pos.y()), false);
        } else { // not concave angle, in that case the nearest point is the good candidate
            // but for staggering, we also need to recompute depth of the inner perimter, because in convex corners, the distance is larger than layer width
            // we want the perpendicular depth, not distance to nearest point
            depth = depth * beta_angle / 1.4142;
        }
 
        seam_point = projected_point.foot_pt;
 
        //lastly, for internal perimeters, do the staggering if requested
        if (po->config().staggered_inner_seams && loop.length() > 0.0) {
            //fix depth, it is sometimes strongly underestimated
            depth = std::max(loop.paths[projected_point.path_idx].width, depth);
 
            while (depth > 0.0f) {
                auto next_point = get_next_loop_point(projected_point);
                Vec2f a = unscale(projected_point.foot_pt).cast<float>();
                Vec2f b = unscale(next_point.foot_pt).cast<float>();
                float dist = (a - b).norm();
                if (dist > depth) {
                    Vec2f final_pos = a + (b - a) * depth / dist;
                    next_point.foot_pt = Point::new_scale(final_pos.x(), final_pos.y());
                }
                depth -= dist;
                projected_point = next_point;
            }
            seam_point = projected_point.foot_pt;
        }
    }
 
    // Because the G-code export has 1um resolution, don't generate segments shorter than 1.5 microns,
    // thus empty path segments will not be produced by G-code export.
    if (!loop.split_at_vertex(seam_point, scaled<double>(0.0015))) {
        // The point is not in the original loop.
        // Insert it.
        loop.split_at(seam_point, true);
    }
 
}

References Slic3r::PrintObject::config(), cos(), EPSILON, Slic3r::find_closest_point(), Slic3r::ExtrusionLoop::ClosestPathPoint::foot_pt, Slic3r::Layer::id(), Slic3r::next_idx_modulo(), Slic3r::Layer::object(), Slic3r::ExtrusionLoop::ClosestPathPoint::path_idx, Slic3r::Perimeter, Slic3r::PrintObjectSeamData::LayerSeams::points, Slic3r::PrintObjectSeamData::LayerSeams::points_tree, Slic3r::SlicingParameters::raft_layers(), Slic3r::Layer::slice_z, Slic3r::PrintObject::slicing_parameters(), Slic3r::spNearest, Slic3r::to_3d(), and Slic3r::unscale().

Referenced by Slic3r::GCode::extrude_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ angle_importance_aligned

constexpr float Slic3r::SeamPlacer::angle_importance_aligned = 0.6f

staticconstexpr

◆ angle_importance_nearest

constexpr float Slic3r::SeamPlacer::angle_importance_nearest = 1.0f

staticconstexpr

◆ enforcer_oversampling_distance

constexpr float Slic3r::SeamPlacer::enforcer_oversampling_distance = 0.2f

staticconstexpr

Referenced by Slic3r::SeamPlacerImpl::process_perimeter_polygon().

◆ fast_decimation_triangle_count_target

constexpr size_t Slic3r::SeamPlacer::fast_decimation_triangle_count_target = 16000

staticconstexpr

Referenced by Slic3r::SeamPlacerImpl::compute_global_occlusion().

◆ m_seam_per_object

std::unordered_map<const PrintObject*, PrintObjectSeamData> Slic3r::SeamPlacer::m_seam_per_object

◆ overhang_angle_threshold

constexpr float Slic3r::SeamPlacer::overhang_angle_threshold = 50.0f * float(PI) / 180.0f

staticconstexpr

◆ raycasting_visibility_samples_count

constexpr size_t Slic3r::SeamPlacer::raycasting_visibility_samples_count = 30000

staticconstexpr

Referenced by Slic3r::SeamPlacerImpl::compute_global_occlusion().

◆ seam_align_minimum_string_seams

constexpr size_t Slic3r::SeamPlacer::seam_align_minimum_string_seams = 6

staticconstexpr

◆ seam_align_mm_per_segment

constexpr size_t Slic3r::SeamPlacer::seam_align_mm_per_segment = 4.0f

staticconstexpr

◆ seam_align_score_tolerance

constexpr float Slic3r::SeamPlacer::seam_align_score_tolerance = 0.3f

staticconstexpr

◆ seam_align_tolerable_dist_factor

constexpr float Slic3r::SeamPlacer::seam_align_tolerable_dist_factor = 4.0f

staticconstexpr

◆ sharp_angle_snapping_threshold

constexpr float Slic3r::SeamPlacer::sharp_angle_snapping_threshold = 55.0f * float(PI) / 180.0f

staticconstexpr

Referenced by Slic3r::SeamPlacerImpl::process_perimeter_polygon().

◆ sqr_rays_per_sample_point

constexpr size_t Slic3r::SeamPlacer::sqr_rays_per_sample_point = 5

staticconstexpr

Referenced by Slic3r::SeamPlacerImpl::raycast_visibility().

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

src/libslic3r/GCode/SeamPlacer.hpp
src/libslic3r/GCode/SeamPlacer.cpp

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Detailed Description

Member Function Documentation

◆ align_seam_points()

◆ calculate_candidates_visibility()

◆ calculate_overhangs_and_layer_embedding()

◆ find_next_seam_in_layer()

◆ find_seam_string()

◆ gather_seam_candidates()

◆ init()

◆ place_seam()

Member Data Documentation

◆ angle_importance_aligned

◆ angle_importance_nearest

◆ enforcer_oversampling_distance

◆ fast_decimation_triangle_count_target

◆ m_seam_per_object

◆ overhang_angle_threshold

◆ raycasting_visibility_samples_count

◆ seam_align_minimum_string_seams

◆ seam_align_mm_per_segment

◆ seam_align_score_tolerance

◆ seam_align_tolerable_dist_factor

◆ sharp_angle_snapping_threshold

◆ sqr_rays_per_sample_point