#include </home/runner/work/OrcaSlicer/OrcaSlicer/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)
const std::string &	precise_seam_warning () const
void	place_seam (const Layer *layer, ExtrusionLoop &loop, const Point &last_pos, float &overhang) 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 = 45.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, PreciseSeam::PreciseSeamWarnings warnings=nullptr)
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, const std::function< void()> &throw_if_canceled)
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 SeamContour::Resolver contours=nullptr) 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 SeamContour::Resolver *contours=nullptr, std::pair< size_t, size_t > previous={}) const

Private Attributes
std::string	m_precise_seam_warning

Detailed Description

Member Function Documentation

◆ align_seam_points()

void Slic3r::SeamPlacer::align_seam_points	(	const PrintObject *	po,
		const SeamPlacerImpl::SeamComparator &	comparator,
		const std::function< void()> &	throw_if_canceled )

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;
  // Share the largest nozzle diameter between contour bounds and corner protection.
  double max_nozzle_diameter = 0.0;
  for (double diameter : po->print()->config().nozzle_diameter.values)
    max_nozzle_diameter = std::max(max_nozzle_diameter, diameter);
  // Reuse immutable contour geometry across all alternative string starts.
  std::unique_ptr<SeamContour::Resolver> contour_resolver;
  {
    SeamContour::Layers geometry(layers.size());
    for (size_t i = 0; i < layers.size(); ++i) {
      throw_if_canceled(); // Geometry copies on dense multi-island objects must remain interruptible.
      for (const Perimeter &perimeter : layers[i].perimeters) {
        SeamContour::Contour contour;
        contour.hole = perimeter.is_hole;
        contour.reliable = perimeter.contour_reliable;
        contour.width = perimeter.flow_width;
        contour.nozzle = max_nozzle_diameter;
        for (size_t j = perimeter.start_index; j < perimeter.end_index; ++j)
          contour.points.push_back(layers[i].points[j].position.head<2>().cast<double>());
        geometry[i].push_back(std::move(contour));
      }
    }
    contour_resolver = std::make_unique<SeamContour::Resolver>(std::move(geometry), SeamContour::Options{}, throw_if_canceled);
  }
  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())) {
    throw_if_canceled();
    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, contour_resolver.get());
      size_t step_size = 1 + seam_string.size() / 20;
      for (size_t alternative_start = 0; alternative_start < seam_string.size(); alternative_start += step_size) {
        throw_if_canceled();
        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,
                                                         contour_resolver.get());
        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];
        const std::vector<SeamCandidate> &points = layers[pair.first].points;
        const SeamCandidate &candidate = points[pair.second];
        float t = std::min(1.0f, std::pow(std::abs(candidate.local_ccw_angle)
                                              / SeamPlacer::sharp_angle_snapping_threshold, 3.0f));
 
        Vec3f current_pos = candidate.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;
        if (candidate.type != EnforcedBlockedSeamPoint::Enforced) {
          final_position = t >= 1.0f ? current_pos :
              place_on_loop(points, pair.second, t * current_pos + (1.0f - t) * to_3d(fitted_pos, current_pos.z()));
        } else if (t >= 1.0f) {
          final_position = current_pos;
        } else {
          // Keep the 0.4 pull toward the candidate near a measured corner only, then keep the seam on the paint.
          float protect = std::max(candidate.perimeter.flow_width, float(max_nozzle_diameter));
          if (protect <= 0.0f)
            protect = 0.5f;
          const float corner = std::abs(candidate.local_ccw_angle) >= enforced_corner_angle_max ?
              1.0f : enforced_corner_influence(points, pair.second, protect, enforced_corner_fade_factor * protect);
          t = std::max(t, 0.4f * corner);
          final_position = place_on_loop(points, pair.second,
                                         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 align_seam_points(), Slic3r::angle(), Slic3r::Print::config(), Slic3r::contour(), Slic3r::debug_out_path(), find_seam_string(), Slic3r::Geometry::fit_cubic_bspline(), m_seam_per_object, Slic3r::PrintObjectBaseWithState< PrintType, PrintObjectStepEnum, COUNT >::print(), seam_align_minimum_string_seams, seam_align_mm_per_segment, Slic3r::SeamPlacerImpl::SeamComparator::setup, sharp_angle_snapping_threshold, Slic3r::spRear, Slic3r::to_3d(), and Slic3r::total_length().

Referenced by align_seam_points(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculate_candidates_visibility()

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

private

                                                                                                         {
 
  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);
                        }
                      }
                    });
}

References calculate_candidates_visibility(), and m_seam_per_object.

Referenced by calculate_candidates_visibility(), and init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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.entities.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));
 
                        auto& layer_seams = layers[layer_idx];
                        for (SeamCandidate &perimeter_point : layer_seams.points) {
                          Vec2f point = Vec2f { perimeter_point.position.head<2>() };
                          if (prev_layer_distancer.get() != nullptr) {
                            const auto _dist = prev_layer_distancer->distance_from_lines<true>(point.cast<double>());
                            perimeter_point.overhang = _dist
                                                       + 0.65f * 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;
                            perimeter_point.unsupported_dist = _dist + 0.4f * perimeter_point.perimeter.flow_width;
                          }
 
                          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.65f * perimeter_point.perimeter.flow_width;
                          }
                        }
 
                        prev_layer_distancer.swap(current_layer_distancer);
                      }
                    }
  );
}

References calculate_overhangs_and_layer_embedding(), Slic3r::PrintObject::layers(), m_seam_per_object, and Slic3r::to_unscaled_linesf().

Referenced by calculate_overhangs_and_layer_embedding(), and init().

Here is the call graph for this function:

Here is the caller 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 SeamContour::Resolver *	contours = nullptr,
		std::pair< size_t, size_t >	previous = {} ) const

private

                                            {
  using namespace SeamPlacerImpl;
  // Contours of the geometric continuation. Empty when there is no geometric match, which preserves the legacy radius
  // search; occupancy never expands a known set.
  std::vector<size_t> continuation;
  if (contours) {
    const Perimeter &source = layers[previous.first].points[previous.second].perimeter;
    const int direction = layer_idx > previous.first ? 1 : -1;
    continuation = contours->resolve(previous.first, source.contour_index,
                                     previous.second - source.start_index, direction, max_distance).contours;
  }
 
  // Find the best nearby point and the nearest one. A layer of a fine relief has tens of thousands of candidates within
  // the radius, so they are looked at as the search finds them rather than collected into a vector first.
  constexpr size_t none = std::numeric_limits<size_t>::max();
  size_t best_nearby_point_index = none;
  size_t nearest_point_index = none;
  visit_nearby_points(*layers[layer_idx].points_tree, projected_position, max_distance,
                      [&layers, &comparator, &projected_position, &continuation, layer_idx, &best_nearby_point_index,
                       &nearest_point_index](size_t nearby_point_index) {
    // Points off the continuation are skipped before the first point is taken, as they were removed before the scan.
    if (!continuation.empty() &&
        std::find(continuation.begin(), continuation.end(),
                  layers[layer_idx].points[nearby_point_index].perimeter.contour_index) == continuation.end())
      return;
    if (best_nearby_point_index == none) {
      // The first point found starts both, as the first of the collected ones did.
      best_nearby_point_index = nearest_point_index = nearby_point_index;
    }
    const SeamCandidate &point = layers[layer_idx].points[nearby_point_index];
    if (point.perimeter.finalized) {
      return; // 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;
    }
  });
 
  if (best_nearby_point_index == none) {
    return {};
  }
 
  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::SeamContour::Result::contours, find_next_seam_in_layer(), Slic3r::SeamPlacerImpl::SeamComparator::is_first_better(), Slic3r::SeamPlacerImpl::SeamComparator::is_first_not_much_worse(), Slic3r::SeamContour::Resolver::resolve(), Slic3r::sqr(), and Slic3r::visit_nearby_points().

Referenced by find_next_seam_in_layer(), and find_seam_string().

Here is the call graph for this function:

Here is the caller 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 SeamContour::Resolver *	contours = nullptr ) 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, contours, prev_point_index);
 
    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) {
        // Continue right below the start seam; stepping now would skip that layer.
        reverse_lookup_direction();
        continue;
      } else {
        break;
      }
    }
    next_layer += step;
  }
  return seam_string;
}

References find_next_seam_in_layer(), find_seam_string(), Slic3r::PrintObject::get_layer(), m_seam_per_object, seam_align_tolerable_dist_factor, and Slic3r::Layer::slice_z.

Referenced by align_seam_points(), and find_seam_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gather_seam_candidates()

void Slic3r::SeamPlacer::gather_seam_candidates	(	const PrintObject *	po,
		const SeamPlacerImpl::GlobalModelInfo &	global_model_info,
		PreciseSeam::PreciseSeamWarnings *	warnings = nullptr )

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, warnings]
                    (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;
                        std::vector<std::optional<bool>> boundary_types;
                        //NOTE corresponding region ptr may be null, if the layer has zero perimeters
                        const bool has_precise_seam_modifiers = !global_model_info.precise_seam_strong_volumes.empty() ||
                                                               !global_model_info.precise_seam_weak_volumes.empty();
                        Polygons polygons = extract_perimeter_polygons(layer, regions, boundary_types, has_precise_seam_modifiers);
                        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,
                                                    warnings, boundary_types[poly_index]);
                        }
                        auto functor = SeamCandidateCoordinateFunctor { layer_seams.points };
                        seam_data.layers[layer_idx].points_tree =
                            std::make_unique<PrintObjectSeamData::SeamCandidatesTree>(functor,
                                                                                      layer_seams.points.size());
                      }
                    }
  );
}

References gather_seam_candidates(), Slic3r::PrintObject::layer_count(), Slic3r::PrintObject::layers(), Slic3r::PrintObjectSeamData::layers, m_seam_per_object, and Slic3r::ConstVectorOfPtrsAdaptor< T >::size().

Referenced by gather_seam_candidates(), and init().

Here is the call graph for this function:

Here is the caller 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();
  m_precise_seam_warning.clear();
 
  // Warning flags for Precise Seam processing — shared across all objects
  PreciseSeam::PreciseSeamWarnings precise_seam_warnings;
 
  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);
      PreciseSeam::init_precise_seam_data(
          global_model_info.precise_seam_strong_volumes,
          global_model_info.precise_seam_weak_volumes,
          m_seam_per_object[po].has_precise_seam_strong_volumes,
          po->model_object());
 
      // Slice each Precise Seam modifier once per object; both consumers read the cache.
      for (const ModelVolume* vol : global_model_info.precise_seam_strong_volumes)
          global_model_info.precise_seam_slices[vol] = PreciseSeam::prepare_modifier_slices(po->slice_single_volume_regions(vol));
      for (const ModelVolume* vol : global_model_info.precise_seam_weak_volumes)
          global_model_info.precise_seam_slices[vol] = PreciseSeam::prepare_modifier_slices(po->slice_single_volume_regions(vol));
      // Register usage tracking before the parallel phase; workers only set its flags. Several print
      // objects of one model object share volumes, and try_emplace keeps what earlier ones recorded.
      for (const ModelVolume* vol : global_model_info.precise_seam_strong_volumes)
          precise_seam_warnings.modifier_usage.try_emplace(vol);
      for (const ModelVolume* vol : global_model_info.precise_seam_weak_volumes)
          precise_seam_warnings.modifier_usage.try_emplace(vol);
 
      throw_if_canceled_func();
      if (configured_seam_preference == spAligned || configured_seam_preference == spNearest || configured_seam_preference == spAlignedBack) {
        compute_global_occlusion(global_model_info, po, throw_if_canceled_func, configured_seam_preference);
      }
      throw_if_canceled_func();
 
      BOOST_LOG_TRIVIAL(debug)
          << "SeamPlacer: gather_seam_candidates: start";
      gather_seam_candidates(po, global_model_info, &precise_seam_warnings);
      BOOST_LOG_TRIVIAL(debug)
          << "SeamPlacer: gather_seam_candidates: end";
      throw_if_canceled_func();
      if (configured_seam_preference == spAligned || configured_seam_preference == spNearest || configured_seam_preference == spAlignedBack) {
        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 || configured_seam_preference == spAlignedBack) {
      BOOST_LOG_TRIVIAL(debug)
          << "SeamPlacer: align_seam_points : start";
      align_seam_points(po, comparator, throw_if_canceled_func);
      BOOST_LOG_TRIVIAL(debug)
          << "SeamPlacer: align_seam_points : end";
    }
 
    // Restore precise seam positions that were potentially modified
    if (m_seam_per_object[po].has_precise_seam_strong_volumes) {
      PreciseSeam::restore_precise_seam_positions(m_seam_per_object[po].layers);
    }
 
#ifdef DEBUG_FILES
    debug_export_points(m_seam_per_object[po].layers, po->bounding_box(), comparator);
#endif
  }
 
  // Prepare one combined Precise Seam warning; G-code export issues it. Keep it single: separate
  // warnings would each re-push all warnings and duplicate text in the notification.
  {
      const unsigned failed_types = precise_seam_warnings.failed_types.load(std::memory_order_relaxed);
      const unsigned mi = precise_seam_warnings.multiple_intersections.load(std::memory_order_relaxed);
      const unsigned fc = precise_seam_warnings.full_containment.load(std::memory_order_relaxed);
      const size_t failed = precise_seam_warnings.failed_fragments.load(std::memory_order_relaxed);
      // All workers have finished; cancellation before this point may omit the summary.
      if (failed > PreciseSeam::failed_fragment_log_limit)
          BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamIntersectionFailed] " << failed
              << " fragments discarded; first " << PreciseSeam::failed_fragment_log_limit
              << " logged (parallel processing order), " << (failed - PreciseSeam::failed_fragment_log_limit)
              << " omitted";
      // Recoveries are log-only: no user warning, but the same bounded detail and a total.
      const size_t recovered = precise_seam_warnings.recovered_fragments.load(std::memory_order_relaxed);
      if (recovered > PreciseSeam::failed_fragment_log_limit)
          BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamFragmentRecovered] " << recovered
              << " fragments recovered; first " << PreciseSeam::failed_fragment_log_limit
              << " logged (parallel processing order), " << (recovered - PreciseSeam::failed_fragment_log_limit)
              << " omitted";
      // Reasons name the modifier types, as the menu does, not individual modifiers: "Seam Left, Seam
      // Enforced" in menu order, each type once. The same msgids as the menu share its translations.
      const auto type_list = [](unsigned mask) {
          const std::pair<ModelVolumeType, std::string> types[] = {
              {ModelVolumeType::PRECISE_SEAM_CENTER, _u8L("Seam Center")},
              {ModelVolumeType::PRECISE_SEAM_LEFT, _u8L("Seam Left")},
              {ModelVolumeType::PRECISE_SEAM_RIGHT, _u8L("Seam Right")},
              {ModelVolumeType::PRECISE_SEAM_ENFORCED, _u8L("Seam Enforced")},
              {ModelVolumeType::PRECISE_SEAM_BLOCKED, _u8L("Seam Blocked")},
              {ModelVolumeType::PRECISE_SEAM_NEUTRAL, _u8L("Seam Neutral")}};
          std::string list;
          for (const auto &[type, name] : types)
              if (mask & PreciseSeam::PreciseSeamWarnings::type_bit(type))
                  list += (list.empty() ? "" : ", ") + name;
          return list;
      };
      std::vector<std::string> parts;
      if (failed_types != 0)
          parts.push_back((boost::format(_u8L("failed to process some intersections (%1%)")) % type_list(failed_types)).str());
      if (mi != 0)
          parts.push_back((boost::format(_u8L("multiple intersections with a perimeter, only one was used (%1%)")) % type_list(mi)).str());
      if (fc != 0)
          parts.push_back((boost::format(_u8L("a perimeter is fully inside a modifier, the modifier was not applied to it (%1%)")) % type_list(fc)).str());
      // Modifiers whose usage flags match, in print and volume order, so the named one is deterministic.
      const auto collect_modifiers = [&print, &precise_seam_warnings](const auto &matches) {
          std::vector<const ModelVolume*> found;
          for (const PrintObject *po : print.objects())
              for (const ModelVolume *volume : po->model_object()->volumes) {
                  const auto it = precise_seam_warnings.modifier_usage.find(volume);
                  if (it != precise_seam_warnings.modifier_usage.end() && matches(it->second) &&
                      std::find(found.begin(), found.end(), volume) == found.end())
                      found.push_back(volume);
              }
          return found;
      };
      // Seam Blocked modifiers whose whole perimeter stayed Blocked; the user warning names only the
      // first one, the log lists them all.
      const std::vector<const ModelVolume*> fully_blocked = collect_modifiers(
          [](const PreciseSeam::PreciseSeamWarnings::ModifierUsage &usage) { return usage.fully_blocked.load(std::memory_order_relaxed); });
      for (const ModelVolume *volume : fully_blocked)
          BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamFullyBlocked] object=\"" << volume->get_object()->name
              << "\" modifier=\"" << volume->name << "\"";
      if (!fully_blocked.empty()) {
          const ModelVolume *first = fully_blocked.front();
          if (fully_blocked.size() == 1) {
              // TRN: %1% is the modifier type "Seam Blocked" as in the menu, %2% the modifier name, %3% the object name.
              parts.push_back((boost::format(_u8L("%1% modifier \"%2%\" of \"%3%\" covers an entire perimeter"))
                  % _u8L("Seam Blocked") % first->name % first->get_object()->name).str());
          } else {
              // TRN: %1% is the modifier type "Seam Blocked" as in the menu, %2% the modifier name, %3% the object name, %4% the number of modifiers.
              parts.push_back((boost::format(_u8L("%1% modifier \"%2%\" of \"%3%\" (%4% in total) covers an entire perimeter"))
                  % _u8L("Seam Blocked") % first->name % first->get_object()->name % fully_blocked.size()).str());
          }
      }
      // Modifiers evaluated somewhere that never reached a perimeter; never-evaluated ones are not reported.
      const std::vector<const ModelVolume*> no_effect = collect_modifiers(
          [](const PreciseSeam::PreciseSeamWarnings::ModifierUsage &usage) {
              return usage.checked.load(std::memory_order_relaxed) && !usage.reached.load(std::memory_order_relaxed);
          });
      // The user warning names only the first one; the log lists them all.
      for (const ModelVolume *volume : no_effect)
          BOOST_LOG_TRIVIAL(warning) << "[PreciseSeamNoEffect] object=\"" << volume->get_object()->name
              << "\" modifier=\"" << volume->name << "\"";
      if (!no_effect.empty()) {
          const ModelVolume *first = no_effect.front();
          if (no_effect.size() == 1)
              parts.push_back((boost::format(_u8L("modifier \"%1%\" of \"%2%\" had no effect on the seam (it might not reach the centerline of the printed perimeter)"))
                  % first->name % first->get_object()->name).str());
          else
              parts.push_back((boost::format(_u8L("modifier \"%1%\" of \"%2%\" (%3% in total) had no effect on the seam (it might not reach the centerline of the printed perimeter)"))
                  % first->name % first->get_object()->name % no_effect.size()).str());
      }
      if (!parts.empty()) {
          // One line: the export warnings dialog shows only the first line of each warning.
          std::string warning_text = _u8L("Precise Seam") + ": ";
          for (size_t i = 0; i < parts.size(); ++i) {
              if (i > 0) warning_text += "; ";
              warning_text += parts[i];
          }
          warning_text += ". ";
          warning_text += _u8L("Seam placement may differ from expected.");
          m_precise_seam_warning = std::move(warning_text);
      }
  }
}

References align_seam_points(), Slic3r::PrintObject::bounding_box(), calculate_candidates_visibility(), calculate_overhangs_and_layer_embedding(), Slic3r::PrintObject::config(), gather_seam_candidates(), init(), Slic3r::PreciseSeam::init_precise_seam_data(), m_precise_seam_warning, m_seam_per_object, Slic3r::PreciseSeam::PreciseSeamWarnings::modifier_usage, Slic3r::Print::objects(), Slic3r::PreciseSeam::prepare_modifier_slices(), Slic3r::PreciseSeam::restore_precise_seam_positions(), Slic3r::spAligned, Slic3r::spAlignedBack, Slic3r::spNearest, and Slic3r::spRear.

Referenced by init().

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,
		const Point &	last_pos,
		float &	overhang ) 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].to_point();
    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].to_point()};
    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());
  overhang = layer_perimeters.points[seam_index].unsupported_dist;
 
  if (loop.role() == ExtrusionRole::erPerimeter) { //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);
  }
 
}