Slic3r::SeamPlacerImpl Namespace Reference

Classes
class	Frame
	Coordinate frame. More...
struct	CoordinateFunctor
struct	PaintedContour
struct	GlobalModelInfo
struct	PaintedInterval
struct	SeamComparator
struct	Perimeter
struct	SeamCandidate
struct	SeamCandidateCoordinateFunctor

Enumerations
enum class	EnforcedBlockedSeamPoint { Blocked = 0 , Neutral = 1 , Enforced = 2 }

Functions
template<typename T>
int	sgn (T val)
float	gauss (float value, float mean_x_coord, float mean_value, float falloff_speed)
float	compute_angle_penalty (float ccw_angle)
Vec3f	sample_sphere_uniform (const Vec2f &samples)
Vec3f	sample_hemisphere_uniform (const Vec2f &samples)
Vec3f	sample_power_cosine_hemisphere (const Vec2f &samples, float power)
std::vector< float >	raycast_visibility (const AABBTreeIndirect::Tree< 3, float > &raycasting_tree, const indexed_triangle_set &triangles, const TriangleSetSamples &samples, size_t negative_volumes_start_index, SeamPosition seam_position=spAligned)
std::vector< float >	calculate_polygon_angles_at_vertices (const Polygon &polygon, const std::vector< float > &lengths, float min_arm_length)
Polygons	extract_perimeter_polygons (const Layer *layer, std::vector< const LayerRegion * > &corresponding_regions_out, std::vector< std::optional< bool > > &boundary_types_out, bool has_precise_seam_modifiers)
bool	fully_enforced_loop (const std::vector< Vec2d > &loop, double z, double reach, const GlobalModelInfo &info)
std::vector< PaintedInterval >	exact_painted_intervals (const std::vector< Vec2d > &loop, const std::vector< double > &arc, double z, double reach, const PaintedContour &contour)
void	process_perimeter_polygon (const Polygon &orig_polygon, float z_coord, const LayerRegion *region, const GlobalModelInfo &global_model_info, PrintObjectSeamData::LayerSeams &result, PreciseSeam::PreciseSeamWarnings *warnings=nullptr, std::optional< bool > boundary_hole=std::nullopt)
void	compute_global_occlusion (GlobalModelInfo &result, const PrintObject *po, std::function< void(void)> throw_if_canceled, SeamPosition seam_position=spAligned)
void	append_painted_contour (PaintedContour &result, const indexed_triangle_set &painted)
void	gather_enforcers_blockers (GlobalModelInfo &result, const PrintObject *po)
void	pick_seam_point (std::vector< SeamCandidate > &perimeter_points, size_t start_index, const SeamComparator &comparator)
size_t	pick_nearest_seam_point_index (const std::vector< SeamCandidate > &perimeter_points, size_t start_index, const Vec2f &preffered_location)
void	pick_random_seam_point (const std::vector< SeamCandidate > &perimeter_points, size_t start_index)
float	smoothstep01 (float x)
float	enforced_corner_influence (const std::vector< SeamCandidate > &points, size_t index, float protect, float fade_end)
Vec2d	edge_normal (const Vec2d &a, const Vec2d &b)
Vec3f	place_on_loop (const std::vector< SeamCandidate > &points, size_t index, const Vec3f &target)

Variables
constexpr double	enforced_end_tolerance = 1e-3
constexpr float	enforced_corner_angle_min = 15.0f * float(PI) / 180.0f
constexpr float	enforced_corner_angle_max = 30.0f * float(PI) / 180.0f
constexpr float	enforced_corner_fade_factor = 2.0f

---

Class Documentation

Slic3r::SeamPlacerImpl::PaintedInterval

struct Slic3r::SeamPlacerImpl::PaintedInterval

Class Members
double	begin
double	end

Slic3r::SeamPlacerImpl::Perimeter

struct Slic3r::SeamPlacerImpl::Perimeter

Class Members
size_t	contour_index = 0
bool	contour_reliable = false
size_t	end_index {}
bool	exact_blocked_ends = false
bool	exact_enforced_ends = false
Vec3f	final_seam_position = Vec3f::Zero()
bool	finalized = false
float	flow_width {}
bool	is_hole = false
size_t	precise_seam_index {}
optional< Vec3f >	precise_seam_point
size_t	seam_index {}
size_t	start_index {}

Enumeration Type Documentation

EnforcedBlockedSeamPoint

enum class Slic3r::SeamPlacerImpl::EnforcedBlockedSeamPoint

strong

Enumerator
Blocked
Neutral
Enforced

                                    {
  Blocked = 0,
  Neutral = 1,
  Enforced = 2,
};

Function Documentation

append_painted_contour()

void Slic3r::SeamPlacerImpl::append_painted_contour	(	PaintedContour &	result,
		const indexed_triangle_set &	painted )

                                                                                         {
  const auto edge_key = [](int a, int b) { return (uint64_t(std::min(a, b)) << 32) | uint64_t(std::max(a, b)); };
  std::unordered_map<uint64_t, int> uses;
  for (const stl_triangle_vertex_indices &face : painted.indices)
    for (int i = 0; i < 3; ++i)
      ++uses[edge_key(face[i], face[(i + 1) % 3])];
  for (const stl_triangle_vertex_indices &face : painted.indices) {
    const Vec3d v[3] = {painted.vertices[face[0]].cast<double>(), painted.vertices[face[1]].cast<double>(),
                        painted.vertices[face[2]].cast<double>()};
    const Vec3d normal = (v[1] - v[0]).cross(v[2] - v[0]);
    for (int i = 0; i < 3; ++i) {
      const Vec3d inward = normal.cross(v[(i + 1) % 3] - v[i]);
      if (uses[edge_key(face[i], face[(i + 1) % 3])] == 1 && inward.squaredNorm() > 0.0) {
        result.edges.emplace_back(v[i], v[(i + 1) % 3]);
        result.inward.emplace_back(inward.normalized());
      }
    }
  }
}

References append_painted_contour(), Slic3r::cross(), Slic3r::SeamPlacerImpl::PaintedContour::edges, Slic3r::SeamPlacerImpl::PaintedContour::inward, and Slic3r::normal().

Referenced by append_painted_contour(), and gather_enforcers_blockers().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_polygon_angles_at_vertices()

std::vector< float > Slic3r::SeamPlacerImpl::calculate_polygon_angles_at_vertices	(	const Polygon &	polygon,
		const std::vector< float > &	lengths,
		float	min_arm_length )

                                                                              {
  std::vector<float> result(polygon.size());
 
  if (polygon.size() == 1) {
    result[0] = 0.0f;
  }
 
  size_t idx_prev = 0;
  size_t idx_curr = 0;
  size_t idx_next = 0;
 
  float distance_to_prev = 0;
  float distance_to_next = 0;
 
  //push idx_prev far enough back as initialization
  while (distance_to_prev < min_arm_length) {
    idx_prev = Slic3r::prev_idx_modulo(idx_prev, polygon.size());
    distance_to_prev += lengths[idx_prev];
  }
 
  for (size_t _i = 0; _i < polygon.size(); ++_i) {
    // pull idx_prev to current as much as possible, while respecting the min_arm_length
    while (distance_to_prev - lengths[idx_prev] > min_arm_length) {
      distance_to_prev -= lengths[idx_prev];
      idx_prev = Slic3r::next_idx_modulo(idx_prev, polygon.size());
    }
 
    //push idx_next forward as far as needed
    while (distance_to_next < min_arm_length) {
      distance_to_next += lengths[idx_next];
      idx_next = Slic3r::next_idx_modulo(idx_next, polygon.size());
    }
 
    // Calculate angle between idx_prev, idx_curr, idx_next.
    const Point &p0 = polygon.points[idx_prev];
    const Point &p1 = polygon.points[idx_curr];
    const Point &p2 = polygon.points[idx_next];
    result[idx_curr] = float(angle(p1 - p0, p2 - p1));
 
    // increase idx_curr by one
    float curr_distance = lengths[idx_curr];
    idx_curr++;
    distance_to_prev += curr_distance;
    distance_to_next -= curr_distance;
  }
 
  return result;
}

References Slic3r::angle(), calculate_polygon_angles_at_vertices(), Slic3r::next_idx_modulo(), Slic3r::MultiPoint::points, Slic3r::prev_idx_modulo(), and Slic3r::MultiPoint::size().

Referenced by calculate_polygon_angles_at_vertices(), and process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_angle_penalty()

float Slic3r::SeamPlacerImpl::compute_angle_penalty

(

float

ccw_angle

)

                                             {
  // This function is used:
  // ((ℯ^(((1)/(x^(2)*3+1)))-1)/(ℯ-1))*1+((1)/(2+ℯ^(-x)))
  // looks scary, but it is gaussian combined with sigmoid,
  // so that concave points have much smaller penalty over convex ones
  // https://github.com/prusa3d/PrusaSlicer/tree/master/doc/seam_placement/corner_penalty_function.png
  return gauss(ccw_angle, 0.0f, 1.0f, 3.0f) +
         1.0f / (2 + std::exp(-ccw_angle));
}

References gauss().

Referenced by Slic3r::SeamPlacerImpl::SeamComparator::is_first_not_much_worse().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_global_occlusion()

void Slic3r::SeamPlacerImpl::compute_global_occlusion	(	GlobalModelInfo &	result,
		const PrintObject *	po,
		std::function< void(void)>	throw_if_canceled,
		SeamPosition	seam_position = spAligned )

                                                                      {
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: gather occlusion meshes: start";
  auto obj_transform = po->trafo_sliced();
  indexed_triangle_set triangle_set;
  indexed_triangle_set negative_volumes_set;
  //add all parts
  for (const ModelVolume *model_volume : po->model_object()->volumes) {
    if (model_volume->type() == ModelVolumeType::MODEL_PART
        || model_volume->type() == ModelVolumeType::NEGATIVE_VOLUME) {
      auto model_transformation = model_volume->get_matrix();
      indexed_triangle_set model_its = model_volume->mesh().its;
      // ORCA fix (not related to Precise Seam, discovered during its development):
      // Mirror transforms have negative determinant which flips triangle winding.
      // fix_left_handed=true swaps indices to keep normals pointing outward.
      its_transform(model_its, model_transformation, true);
      if (model_volume->type() == ModelVolumeType::MODEL_PART) {
        its_merge(triangle_set, model_its);
      } else {
        its_merge(negative_volumes_set, model_its);
      }
    }
  }
  throw_if_canceled();
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: gather occlusion meshes: end";
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: decimate: start";
  its_short_edge_collpase(triangle_set, SeamPlacer::fast_decimation_triangle_count_target);
  its_short_edge_collpase(negative_volumes_set, SeamPlacer::fast_decimation_triangle_count_target);
 
  size_t negative_volumes_start_index = triangle_set.indices.size();
  its_merge(triangle_set, negative_volumes_set);
  // ORCA fix (not related to Precise Seam, discovered during its development):
  // Object-level transform may include mirroring (negative determinant),
  // which inverts triangle winding. fix_left_handed=true corrects this
  // so visibility ray sampling sees outward-facing normals.
  its_transform(triangle_set, obj_transform, true);
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: decimate: end";
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: Compute visibility sample points: start";
 
  result.mesh_samples = sample_its_uniform_parallel(SeamPlacer::raycasting_visibility_samples_count,
                                                    triangle_set);
  result.mesh_samples_coordinate_functor = CoordinateFunctor(&result.mesh_samples.positions);
  result.mesh_samples_tree = KDTreeIndirect<3, float, CoordinateFunctor>(result.mesh_samples_coordinate_functor,
                                                                         result.mesh_samples.positions.size());
 
  // The following code determines search area for random visibility samples on the mesh when calculating visibility of each perimeter point
  // number of random samples in the given radius (area) is approximately poisson distribution
  // to compute ideal search radius (area), we use exponential distribution (complementary distr to poisson)
  // parameters of exponential distribution to compute area that will have with probability="probability" more than given number of samples="samples"
  float probability = 0.9f;
  float samples = 4;
  float density = SeamPlacer::raycasting_visibility_samples_count / result.mesh_samples.total_area;
  // exponential probability distrubtion function is : f(x) = P(X > x) = e^(l*x) where l is the rate parameter (computed as 1/u where u is mean value)
  // probability that sampled area A with S samples contains more than samples count:
  //  P(S > samples in A) = e^-(samples/(density*A));   express A:
  float search_area = samples / (-logf(probability) * density);
  float search_radius = sqrt(search_area / PI);
  result.mesh_samples_radius = search_radius;
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: Compute visiblity sample points: end";
  throw_if_canceled();
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: Mesh sample raidus: " << result.mesh_samples_radius;
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: build AABB tree: start";
  auto raycasting_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(triangle_set.vertices,
                                                                                     triangle_set.indices);
 
  throw_if_canceled();
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: build AABB tree: end";
  result.mesh_samples_visibility = raycast_visibility(raycasting_tree, triangle_set, result.mesh_samples,
                                                      negative_volumes_start_index, seam_position);
  throw_if_canceled();
#ifdef DEBUG_FILES
  result.debug_export(triangle_set);
#endif
}

References Slic3r::AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(), compute_global_occlusion(), Slic3r::SeamPlacer::fast_decimation_triangle_count_target, Slic3r::its_merge(), Slic3r::its_short_edge_collpase(), Slic3r::SeamPlacerImpl::GlobalModelInfo::mesh_samples, Slic3r::SeamPlacerImpl::GlobalModelInfo::mesh_samples_coordinate_functor, Slic3r::SeamPlacerImpl::GlobalModelInfo::mesh_samples_radius, Slic3r::SeamPlacerImpl::GlobalModelInfo::mesh_samples_tree, Slic3r::SeamPlacerImpl::GlobalModelInfo::mesh_samples_visibility, Slic3r::PrintObjectBase::model_object(), Slic3r::MODEL_PART, Slic3r::NEGATIVE_VOLUME, PI, Slic3r::TriangleSetSamples::positions, raycast_visibility(), Slic3r::SeamPlacer::raycasting_visibility_samples_count, Slic3r::sample_its_uniform_parallel(), Slic3r::spAligned, Slic3r::TriangleSetSamples::total_area, Slic3r::PrintObject::trafo_sliced(), and Slic3r::ModelObject::volumes.

Referenced by compute_global_occlusion().

Here is the call graph for this function:

Here is the caller graph for this function:

edge_normal()

Vec2d Slic3r::SeamPlacerImpl::edge_normal	(	const Vec2d &	a,
		const Vec2d &	b )

                                                  {
  const Vec2d d = b - a;
  const double length = d.norm();
  return length > 0.0 ? Vec2d(-d.y() / length, d.x() / length) : Vec2d::Zero();
}

References edge_normal(), and Slic3r::length().

Referenced by edge_normal(), and place_on_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

enforced_corner_influence()

float Slic3r::SeamPlacerImpl::enforced_corner_influence	(	const std::vector< SeamCandidate > &	points,
		size_t	index,
		float	protect,
		float	fade_end )

                                                                                                                     {
  const Perimeter &perimeter = points[index].perimeter;
  const size_t start = perimeter.start_index;
  const size_t count = perimeter.end_index - start;
  const auto contribution = [&](size_t i, float distance) {
    const float corner = smoothstep01((std::abs(points[i].local_ccw_angle) - enforced_corner_angle_min) /
                                      (enforced_corner_angle_max - enforced_corner_angle_min));
    const float weight = distance <= protect ? 1.0f : 1.0f - smoothstep01((distance - protect) / (fade_end - protect));
    return corner * weight;
  };
  float influence = contribution(index, 0.0f);
  for (const bool forward : { false, true }) {
    size_t i = index;
    float distance = 0.0f;
    // At most count - 1 steps per direction, so short loops and zero-length edges terminate.
    for (size_t step = 1; step < count && influence < 1.0f; ++step) {
      const size_t j = start + (forward ? next_idx_modulo(i - start, count) : prev_idx_modulo(i - start, count));
      distance += (points[j].position - points[i].position).head<2>().norm();
      if (distance >= fade_end)
        break;
      influence = std::max(influence, contribution(j, distance));
      i = j;
    }
  }
  return influence;
}

References count, Slic3r::SeamPlacerImpl::Perimeter::end_index, enforced_corner_angle_max, enforced_corner_angle_min, enforced_corner_influence(), Slic3r::next_idx_modulo(), Slic3r::prev_idx_modulo(), smoothstep01(), and Slic3r::SeamPlacerImpl::Perimeter::start_index.

Referenced by enforced_corner_influence().

Here is the call graph for this function:

Here is the caller graph for this function:

exact_painted_intervals()

std::vector< PaintedInterval > Slic3r::SeamPlacerImpl::exact_painted_intervals	(	const std::vector< Vec2d > &	loop,
		const std::vector< double > &	arc,
		double	z,
		double	reach,
		const PaintedContour &	contour )

                                                                                                          {
  const size_t count = loop.size();
  if (count < 3 || contour.edges.empty())
    return {};
  Vec2d min = loop.front(), max = loop.front();
  for (const Vec2d &p : loop) {
    min = min.cwiseMin(p);
    max = max.cwiseMax(p);
  }
  const auto crossings = contour.crossings(z, min - Vec2d(reach, reach), max + Vec2d(reach, reach));
  // Direction of the first edge from edge i on, forward or backward, that is longer than the tolerance: loops
  // repeat their first point and the shared ends of their paths.
  const auto direction = [&](size_t i, bool forward) {
    for (size_t step = 0; step < count; ++step, i = forward ? (i + 1) % count : (i + count - 1) % count) {
      const Vec2d d = loop[(i + 1) % count] - loop[i];
      if (d.norm() >= enforced_end_tolerance)
        return Vec2d(d.normalized());
    }
    return Vec2d(Vec2d::Zero());
  };
  std::vector<std::pair<double, bool>> ends; // Position along the loop; true if paint lies ahead.
  for (const auto &[point, inward] : crossings) {
    double best = std::numeric_limits<double>::max(), position = 0.0;
    Vec2d tangent = Vec2d::Zero();
    for (size_t i = 0; i < count; ++i) {
      const Vec2d a = loop[i], ab = loop[(i + 1) % count] - a;
      const double length2 = ab.squaredNorm();
      const double t = length2 > 0.0 ? std::clamp((point - a).dot(ab) / length2, 0.0, 1.0) : 0.0;
      const double distance2 = (a + t * ab - point).squaredNorm();
      if (distance2 < best) {
        best = distance2;
        const double along = t * (arc[i + 1] - arc[i]);
        position = arc[i] + along;
        // At a vertex the loop turns, so its direction there is the mean of the two edges; a crossing at a
        // corner may land a rounding error off the vertex, on either edge.
        const size_t vertex = along < enforced_end_tolerance                 ? i :
                              arc[i + 1] - position < enforced_end_tolerance ? (i + 1) % count :
                                                                               count;
        tangent = vertex < count ? direction((vertex + count - 1) % count, false) + direction(vertex, true) :
                                   direction(i, true);
      }
    }
    if (best > reach * reach)
      continue;
    const double side = inward.dot(tangent);
    if (std::abs(side) < 1e-6)
      return {}; // The contour runs along the loop here: no clear end.
    ends.emplace_back(position, side > 0.0);
  }
  if (ends.empty() || ends.size() % 2 != 0)
    return {};
  std::sort(ends.begin(), ends.end());
  for (size_t i = 0; i < ends.size(); ++i)
    if (ends[i].second == ends[(i + 1) % ends.size()].second)
      return {}; // Paint must start and stop in turn along the loop.
  const size_t first = ends.front().second ? 0 : 1;
  std::vector<PaintedInterval> intervals;
  for (size_t i = first; i < first + ends.size(); i += 2) {
    const double begin = ends[i % ends.size()].first;
    double end = ends[(i + 1) % ends.size()].first;
    if (end < begin)
      end += arc.back();
    intervals.push_back({begin, end});
  }
  return intervals;
}

References Slic3r::contour(), count, Slic3r::dot(), enforced_end_tolerance, and exact_painted_intervals().

Referenced by exact_painted_intervals(), and process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_perimeter_polygons()

Polygons Slic3r::SeamPlacerImpl::extract_perimeter_polygons	(	const Layer *	layer,
		std::vector< const LayerRegion * > &	corresponding_regions_out,
		std::vector< std::optional< bool > > &	boundary_types_out,
		bool	has_precise_seam_modifiers )

                                                                    {
  Polygons polygons;
  const auto boundary_type = [](const ExtrusionEntity *entity) -> std::optional<bool> {
    if (!entity->is_loop()) return std::nullopt;
    return (static_cast<const ExtrusionLoop*>(entity)->loop_role() & elrHole) != 0;
  };
  for (const LayerRegion *layer_region : layer->regions()) {
    for (const ExtrusionEntity *ex_entity : layer_region->perimeters.entities) {
      if (ex_entity->is_collection()) { //collection of inner, outer, and overhang perimeters
        const size_t collection_begin = polygons.size(); // The fallback below applies per collection, not per layer.
        for (const ExtrusionEntity *perimeter : static_cast<const ExtrusionEntityCollection*>(ex_entity)->entities) {
          ExtrusionRole role = perimeter->role();
          if (perimeter->is_loop()) {
            for (const ExtrusionPath &path : static_cast<const ExtrusionLoop*>(perimeter)->paths) {
              if (path.role() == ExtrusionRole::erExternalPerimeter) {
                role = ExtrusionRole::erExternalPerimeter;
              }
            }
            // A fully overhanging outer loop has no external paths but keeps inset_idx 0.
            if (perimeter->inset_idx == 0)
              role = ExtrusionRole::erExternalPerimeter;
          }
 
          if (role == ExtrusionRole::erExternalPerimeter) {
            Points p;
            perimeter->collect_points(p);
            polygons.emplace_back(std::move(p));
            corresponding_regions_out.push_back(layer_region);
            boundary_types_out.push_back(boundary_type(perimeter));
          }
        }
        if (polygons.size() == collection_begin) {
          Points p;
          ex_entity->collect_points(p);
          polygons.emplace_back(std::move(p));
          corresponding_regions_out.push_back(layer_region);
          boundary_types_out.push_back(boundary_type(ex_entity));
        }
      } else {
        Points p;
        ex_entity->collect_points(p);
        polygons.emplace_back(std::move(p));
        corresponding_regions_out.push_back(layer_region);
        boundary_types_out.push_back(boundary_type(ex_entity));
      }
    }
  }
 
  if (has_precise_seam_modifiers) {
    // Extrusion loops repeat their start point; Polygon closes the contour implicitly.
    // Normalize here for Precise Seam without changing ordinary seam candidates.
    for (Polygon &polygon : polygons) {
      // Adjacent extrusion paths share endpoints; zero-length edges would prevent refinement at their junctions.
      // Remove only consecutive duplicates, preserving distinct visits to a self-touching contour point.
      polygon.points.erase(std::unique(polygon.points.begin(), polygon.points.end()), polygon.points.end());
      while (polygon.size() > 1 && polygon.points.front() == polygon.points.back())
        polygon.points.pop_back();
    }
  }
 
  if (polygons.empty()) { // If there are no perimeter polygons for whatever reason (disabled perimeters .. ) insert dummy point
    // it is easier than checking everywhere if the layer is not emtpy, no seam will be placed to this layer anyway
    polygons.emplace_back(Points{ { 0, 0 } });
    corresponding_regions_out.push_back(nullptr);
    boundary_types_out.push_back(std::nullopt);
  }
 
  return polygons;
}

References Slic3r::ExtrusionEntity::collect_points(), Slic3r::elrHole, Slic3r::erExternalPerimeter, extract_perimeter_polygons(), Slic3r::ExtrusionEntity::is_collection(), and Slic3r::Layer::regions().

Referenced by extract_perimeter_polygons().

Here is the call graph for this function:

Here is the caller graph for this function:

fully_enforced_loop()

bool Slic3r::SeamPlacerImpl::fully_enforced_loop	(	const std::vector< Vec2d > &	loop,
		double	z,
		double	reach,
		const GlobalModelInfo &	info )

                                                                                                            {
  if (loop.size() < 3 || info.enforcers.empty())
    return false;
  if (info.non_enforcers.empty())
    return true; // Every relevant model surface is green, so paint adds no seam information.
  if (reach <= enforced_end_tolerance)
    return false;
  Vec2d min = loop.front(), max = loop.front();
  for (const Vec2d &point : loop) {
    min = min.cwiseMin(point);
    max = max.cwiseMax(point);
  }
  // A conservative box also rejects tiny gaps and a nearby opposite unpainted wall.
  const Eigen::AlignedBox<float, 3> box(Vec3f(float(min.x() - reach), float(min.y() - reach), float(z - reach)),
                                       Vec3f(float(max.x() + reach), float(max.y() + reach), float(z + reach)));
  bool non_green_nearby = false;
  AABBTreeIndirect::traverse(info.non_enforcers_tree, AABBTreeIndirect::intersecting(box), [&](const auto &) {
    non_green_nearby = true;
    return false; // Stop on the first uncertain surface rather than infer a full painted ring.
  });
  if (non_green_nearby)
    return false;
  const auto covered = [&](const auto &self, const Vec3d &a, const Vec3d &b, unsigned depth) -> bool {
    const Vec3d middle = 0.5 * (a + b);
    // A paint point this close to the midpoint covers the entire segment by the triangle inequality.
    const double radius = reach - 0.5 * (b - a).norm() - enforced_end_tolerance;
    if (radius > 0.0 && info.is_enforced(middle.cast<float>(), float(radius)))
      return true;
    if (depth == 8)
      return false; // A bounded proof failure preserves the existing conservative paint behavior.
    return self(self, a, middle, depth + 1) && self(self, middle, b, depth + 1);
  };
  for (size_t i = 0; i < loop.size(); ++i) {
    const Vec2d &a = loop[i], &b = loop[(i + 1) % loop.size()];
    if (!covered(covered, Vec3d(a.x(), a.y(), z), Vec3d(b.x(), b.y(), z), 0))
      return false;
  }
  return true;
}

References enforced_end_tolerance, Slic3r::SeamPlacerImpl::GlobalModelInfo::enforcers, fully_enforced_loop(), Slic3r::AABBTreeIndirect::intersecting(), Slic3r::SeamPlacerImpl::GlobalModelInfo::is_enforced(), Slic3r::SeamPlacerImpl::GlobalModelInfo::non_enforcers, Slic3r::SeamPlacerImpl::GlobalModelInfo::non_enforcers_tree, and Slic3r::AABBTreeIndirect::traverse().

Referenced by fully_enforced_loop(), and process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

gather_enforcers_blockers()

void Slic3r::SeamPlacerImpl::gather_enforcers_blockers	(	GlobalModelInfo &	result,
		const PrintObject *	po )

                                                                               {
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: build AABB trees for raycasting enforcers/blockers: start";
 
  auto obj_transform = po->trafo_sliced();
 
  indexed_triangle_set painted_non_green; // Used only if the object has green paint.
  for (const ModelVolume *mv : po->model_object()->volumes) {
    // Collect painting only from model parts (what the gizmo edits) and negative volumes (the only way
    // to paint a hole's wall); painting left on modifiers and helpers after a type change is ignored.
    // TODO: painting on negative volumes still affects the seam, but the gizmo neither shows nor edits it;
    // making it editable also needs model_custom_seam_data_changed() to track it.
    if (!mv->is_model_part() && !mv->is_negative_volume())
      continue;
    const auto model_transformation = obj_transform * mv->get_matrix();
    if (mv->is_seam_painted()) {
      // One selector serves every paint state; each FacetsAnnotation query would rebuild it from the mesh.
      TriangleSelector selector(mv->mesh());
      selector.deserialize(mv->seam_facets.get_data(), false);
      indexed_triangle_set enforcers = selector.get_facets(EnforcerBlockerType::ENFORCER);
      // ORCA fix (not related to Precise Seam): fix winding for mirrored transforms
      its_transform(enforcers, model_transformation, true);
      its_merge(result.enforcers, enforcers);
 
      indexed_triangle_set painted = selector.get_facets_strict(EnforcerBlockerType::ENFORCER);
      its_transform(painted, model_transformation, true);
      append_painted_contour(result.enforcer_contour, painted);
 
      indexed_triangle_set blockers = selector.get_facets(EnforcerBlockerType::BLOCKER);
      // ORCA fix (not related to Precise Seam): fix winding for mirrored transforms
      its_transform(blockers, model_transformation, true);
      its_merge(result.blockers, blockers);
      painted = selector.get_facets_strict(EnforcerBlockerType::BLOCKER);
      its_transform(painted, model_transformation, true);
      append_painted_contour(result.blocker_contour, painted);
 
      indexed_triangle_set non_green = selector.get_facets(EnforcerBlockerType::NONE);
      its_transform(non_green, model_transformation, true);
      its_merge(painted_non_green, non_green);
    }
  }
 
  // Unpainted objects need no extra surface copy or tree; only green paint requires a coverage proof.
  if (!result.enforcers.empty()) {
    result.non_enforcers = std::move(painted_non_green);
    for (const ModelVolume *mv : po->model_object()->volumes) {
      if ((!mv->is_model_part() && !mv->is_negative_volume()) || mv->is_seam_painted())
        continue;
      indexed_triangle_set non_green = mv->mesh().its;
      its_transform(non_green, obj_transform * mv->get_matrix(), true);
      its_merge(result.non_enforcers, non_green);
    }
    its_merge(result.non_enforcers, result.blockers); // Red paint must also prevent full-green normalization.
    result.non_enforcers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(result.non_enforcers.vertices,
                                                                                          result.non_enforcers.indices);
  }
 
  result.enforcers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(result.enforcers.vertices,
                                                                                      result.enforcers.indices);
  result.blockers_tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(result.blockers.vertices,
                                                                                     result.blockers.indices);
  result.enforcer_contour.tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(result.enforcer_contour.edges);
  result.blocker_contour.tree = AABBTreeLines::build_aabb_tree_over_indexed_lines(result.blocker_contour.edges);
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: build AABB trees for raycasting enforcers/blockers: end";
}

References append_painted_contour(), Slic3r::BLOCKER, Slic3r::SeamPlacerImpl::GlobalModelInfo::blocker_contour, Slic3r::SeamPlacerImpl::GlobalModelInfo::blockers, Slic3r::SeamPlacerImpl::GlobalModelInfo::blockers_tree, Slic3r::AABBTreeLines::build_aabb_tree_over_indexed_lines(), Slic3r::AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(), Slic3r::TriangleSelector::deserialize(), Slic3r::SeamPlacerImpl::PaintedContour::edges, Slic3r::ENFORCER, Slic3r::SeamPlacerImpl::GlobalModelInfo::enforcer_contour, Slic3r::SeamPlacerImpl::GlobalModelInfo::enforcers, Slic3r::SeamPlacerImpl::GlobalModelInfo::enforcers_tree, gather_enforcers_blockers(), Slic3r::TriangleSelector::get_facets(), Slic3r::TriangleSelector::get_facets_strict(), Slic3r::its_merge(), Slic3r::PrintObjectBase::model_object(), Slic3r::SeamPlacerImpl::GlobalModelInfo::non_enforcers, Slic3r::SeamPlacerImpl::GlobalModelInfo::non_enforcers_tree, Slic3r::NONE, Slic3r::PrintObject::trafo_sliced(), Slic3r::SeamPlacerImpl::PaintedContour::tree, and Slic3r::ModelObject::volumes.

Referenced by gather_enforcers_blockers().

Here is the call graph for this function:

Here is the caller graph for this function:

gauss()

float Slic3r::SeamPlacerImpl::gauss	(	float	value,
		float	mean_x_coord,
		float	mean_value,
		float	falloff_speed )

                                                                                    {
  float shifted = value - mean_x_coord;
  float denominator = falloff_speed * shifted * shifted + 1.0f;
  float exponent = 1.0f / denominator;
  return mean_value * (std::exp(exponent) - 1.0f) / (std::exp(1.0f) - 1.0f);
}

Referenced by compute_angle_penalty().

Here is the caller graph for this function:

pick_nearest_seam_point_index()

size_t Slic3r::SeamPlacerImpl::pick_nearest_seam_point_index	(	const std::vector< SeamCandidate > &	perimeter_points,
		size_t	start_index,
		const Vec2f &	preffered_location )

                                                                      {
  size_t end_index = perimeter_points[start_index].perimeter.end_index;
  SeamComparator comparator { spNearest };
 
  size_t seam_index = start_index;
  for (size_t index = start_index; index < end_index; ++index) {
    if (comparator.is_first_better(perimeter_points[index], perimeter_points[seam_index], preffered_location)) {
      seam_index = index;
    }
  }
  return seam_index;
}

References Slic3r::SeamPlacerImpl::SeamComparator::is_first_better(), pick_nearest_seam_point_index(), and Slic3r::spNearest.

Referenced by pick_nearest_seam_point_index().

Here is the call graph for this function:

Here is the caller graph for this function:

pick_random_seam_point()

void Slic3r::SeamPlacerImpl::pick_random_seam_point	(	const std::vector< SeamCandidate > &	perimeter_points,
		size_t	start_index )

                                                                                                  {
  SeamComparator comparator { spRandom };
 
  // algorithm keeps a list of viable points and their lengths. If it finds a point
  // that is much better than the viable_example_index (e.g. better type, no overhang; see is_first_not_much_worse)
  // then it throws away stored lists and starts from start
  // in the end, the list should contain points with same type (Enforced > Neutral > Blocked) and also only those which are not
  // big overhang.
  size_t viable_example_index = start_index;
  size_t end_index = perimeter_points[start_index].perimeter.end_index;
  struct Viable {
    // Candidate seam point index.
    size_t index;
    float edge_length;
    Vec3f edge;
  };
  std::vector<Viable> viables;
 
  const auto edge_from = [&](size_t index) -> Vec3f {
    const size_t next = index == end_index - 1 ? start_index : index + 1;
    // The exact green endpoint is Enforced, but its outgoing edge leaves the permitted painted run.
    if (perimeter_points[index].perimeter.exact_enforced_ends &&
        perimeter_points[index].type == EnforcedBlockedSeamPoint::Enforced &&
        perimeter_points[next].type != EnforcedBlockedSeamPoint::Enforced)
      return Vec3f::Zero();
    // Random samples the outgoing edge, not just the candidate; do not sample toward a closed red boundary.
    if (perimeter_points[index].perimeter.exact_blocked_ends &&
        perimeter_points[index].type != EnforcedBlockedSeamPoint::Blocked &&
        perimeter_points[next].type == EnforcedBlockedSeamPoint::Blocked)
      return Vec3f::Zero();
    return perimeter_points[next].position - perimeter_points[index].position;
  };
 
  const Vec3f pseudornd_seed = perimeter_points[viable_example_index].position;
  float rand = std::abs(sin(pseudornd_seed.dot(Vec3f(12.9898f,78.233f, 133.3333f))) * 43758.5453f);
  rand = rand - (int) rand;
 
  for (size_t index = start_index; index < end_index; ++index) {
    if (comparator.are_similar(perimeter_points[index], perimeter_points[viable_example_index])) {
      // index ok, push info into viables
      Vec3f edge_to_next = edge_from(index);
      float dist_to_next = edge_to_next.norm();
      viables.push_back( { index, dist_to_next, edge_to_next });
    } else if (comparator.is_first_not_much_worse(perimeter_points[viable_example_index],
                                                  perimeter_points[index])) {
      // index is worse then viable_example_index, skip this point
    } else {
      // index is better than viable example index, update example, clear gathered info, start again
      // clear up all gathered info, start from scratch, update example index
      viable_example_index = index;
      viables.clear();
 
      Vec3f edge_to_next = edge_from(index);
      float dist_to_next = edge_to_next.norm();
      viables.push_back( { index, dist_to_next, edge_to_next });
    }
  }
 
  // now pick random point from the stored options
  float len_sum = std::accumulate(viables.begin(), viables.end(), 0.0f, [](const float acc, const Viable &v) {
    return acc + v.edge_length;
  });
  float picked_len = len_sum * rand;
 
  size_t point_idx = 0;
  // Float accumulation can leave a positive residual after the final edge, including a zero-length edge.
  while (point_idx + 1 < viables.size() && picked_len - viables[point_idx].edge_length > 0) {
    picked_len = picked_len - viables[point_idx].edge_length;
    point_idx++;
  }
  picked_len = std::clamp(picked_len, 0.0f, viables[point_idx].edge_length);
 
  Perimeter &perimeter = perimeter_points[start_index].perimeter;
  perimeter.seam_index = viables[point_idx].index;
  perimeter.final_seam_position = perimeter_points[perimeter.seam_index].position
                                  + (viables[point_idx].edge_length > 0.f ?
                                     Vec3f(viables[point_idx].edge.normalized() * picked_len) : Vec3f::Zero());
  perimeter.finalized = true;
}

References Slic3r::SeamPlacerImpl::SeamComparator::are_similar(), Blocked, Slic3r::edge_length(), Enforced, Slic3r::SeamPlacerImpl::Perimeter::final_seam_position, Slic3r::SeamPlacerImpl::Perimeter::finalized, Slic3r::SeamPlacerImpl::SeamComparator::is_first_not_much_worse(), pick_random_seam_point(), Slic3r::SeamPlacerImpl::Perimeter::seam_index, and Slic3r::spRandom.

Referenced by pick_random_seam_point().

Here is the call graph for this function:

Here is the caller graph for this function:

pick_seam_point()

void Slic3r::SeamPlacerImpl::pick_seam_point	(	std::vector< SeamCandidate > &	perimeter_points,
		size_t	start_index,
		const SeamComparator &	comparator )

                                                       {
  size_t end_index = perimeter_points[start_index].perimeter.end_index;
 
  size_t seam_index = start_index;
  for (size_t index = start_index; index < end_index; ++index) {
    if (comparator.is_first_better(perimeter_points[index], perimeter_points[seam_index])) {
      seam_index = index;
    }
  }
  perimeter_points[start_index].perimeter.seam_index = seam_index;
}

References Slic3r::SeamPlacerImpl::SeamComparator::is_first_better(), and pick_seam_point().

Referenced by pick_seam_point().

Here is the call graph for this function:

Here is the caller graph for this function:

place_on_loop()

Vec3f Slic3r::SeamPlacerImpl::place_on_loop	(	const std::vector< SeamCandidate > &	points,
		size_t	index,
		const Vec3f &	target )

                                                                                               {
  const Perimeter &perimeter = points[index].perimeter;
  const size_t start = perimeter.start_index;
  const size_t count = perimeter.end_index - start;
  if (count < 2)
    return points[index].position;
  const auto next = [&](size_t i) { return start + next_idx_modulo(i - start, count); };
  const auto prev = [&](size_t i) { return start + prev_idx_modulo(i - start, count); };
  const auto xy = [&](size_t i) { return Vec2d(points[i].position.head<2>().cast<double>()); };
  // Nearest neighbor at a different position, so that duplicated points share one normal.
  const auto distinct = [&](size_t i, bool forward) {
    size_t j = i;
    for (size_t step = 1; step < count; ++step) {
      j = forward ? next(j) : prev(j);
      if (xy(j) != xy(i))
        return j;
    }
    return i;
  };
  const auto vertex_normal = [&](size_t i) {
    const Vec2d sum = edge_normal(xy(distinct(i, false)), xy(i)) + edge_normal(xy(i), xy(distinct(i, true)));
    return sum.squaredNorm() > 0.0 ? Vec2d(sum.normalized()) : Vec2d::Zero();
  };
  const auto cross = [](const Vec2d &a, const Vec2d &b) { return a.x() * b.y() - a.y() * b.x(); };
 
  // Allowed arc on one side: the Enforced run for an Enforced candidate, plus the oversampling distance unless
  // the run ends exactly at the paint; up to a Blocked candidate otherwise. Returns its length and end point;
  // infinite length if unlimited.
  const bool enforced = points[index].type == EnforcedBlockedSeamPoint::Enforced;
  const bool blocked = points[index].type == EnforcedBlockedSeamPoint::Blocked;
  const auto allowed_arc = [&](bool forward) {
    double arc = 0.0;
    double extension = enforced && !perimeter.exact_enforced_ends ? SeamPlacer::enforcer_oversampling_distance : 0.0;
    bool in_run = true;
    size_t i = index;
    // All count edges, the closing one back to the candidate included, before the arc is unlimited.
    for (size_t visited = 1; visited <= count; ++visited) {
      const size_t j = forward ? next(i) : prev(i);
      const EnforcedBlockedSeamPoint type = points[j].type;
      if (in_run && (enforced ? type != EnforcedBlockedSeamPoint::Enforced :
                                !blocked && type == EnforcedBlockedSeamPoint::Blocked))
        in_run = false;
      if (!in_run && (!enforced || type == EnforcedBlockedSeamPoint::Blocked))
        return std::make_pair(arc, xy(i)); // Only an Enforced run is extended, and never into a Blocked candidate.
      const double length = (xy(j) - xy(i)).norm();
      if (!in_run) {
        const double reach = std::min(length, extension);
        extension -= reach;
        if (reach < length)
          return std::make_pair(arc + reach, Vec2d(xy(i) + (reach / length) * (xy(j) - xy(i))));
      }
      arc += length;
      i = j;
    }
    return std::make_pair(std::numeric_limits<double>::infinity(), xy(index));
  };
 
  // Closest solution over the whole loop, walking outward on the shorter side first so that solutions near
  // the candidate prune the edges farther from the target than them.
  const Vec2d p = target.head<2>().cast<double>();
  std::optional<Vec2d> best;
  double best_distance = std::numeric_limits<double>::infinity();
  bool best_forward = true;
  double best_arc = 0.0;
  double arc[2] = { 0.0, 0.0 }; // Walked arc behind and ahead of the candidate.
  size_t cursor[2] = { index, index };
  for (size_t visited = 0; visited < count; ++visited) {
    const bool forward = arc[1] <= arc[0];
    const size_t i = cursor[forward];
    const size_t j = forward ? next(i) : prev(i);
    // The edge in index order; P(u) = xy(a) + u * d.
    const size_t a = forward ? i : j;
    const size_t b = forward ? j : i;
    const Vec2d d = xy(b) - xy(a);
    const double length = d.norm();
    const Vec2d g = p - xy(a);
    const double u_closest = length > 0.0 ? std::clamp(g.dot(d) / (length * length), 0.0, 1.0) : 0.0;
    if (length > 0.0 && (g - u_closest * d).squaredNorm() < best_distance) {
      // Solve cross(p - P(u), N(u)) = 0 with the normal N blended linearly between the vertex normals.
      Vec2d na = vertex_normal(a);
      Vec2d nb = vertex_normal(b);
      if (na.squaredNorm() == 0.0 || nb.squaredNorm() == 0.0)
        na = nb = edge_normal(xy(a), xy(b));
      const Vec2d m = nb - na;
      const double c0 = cross(g, na);
      const double c1 = cross(g, m) - cross(d, na);
      const double c2 = -cross(d, m);
      const auto consider = [&](double u) {
        if (u < 0.0 || u > 1.0)
          return;
        const double distance = (g - u * d).squaredNorm();
        if (distance < best_distance) {
          best = Vec2d(xy(a) + u * d);
          best_distance = distance;
          best_forward = forward;
          best_arc = arc[forward] + (forward ? u : 1.0 - u) * length;
        }
      };
      // Absolute threshold on the coefficients (mm), only to tell the degenerate equations apart.
      constexpr double eps = 1e-12;
      if (std::abs(c2) < eps && std::abs(c1) < eps) {
        if (std::abs(c0) < eps)
          consider(u_closest); // Every point is a solution.
      } else if (std::abs(c2) < eps) {
        consider(-c0 / c1);
      } else {
        const double discriminant = c1 * c1 - 4.0 * c2 * c0;
        if (discriminant >= 0.0) {
          const double root = std::sqrt(discriminant);
          consider((-c1 - root) / (2.0 * c2));
          consider((-c1 + root) / (2.0 * c2));
        }
      }
    }
    arc[forward] += length;
    cursor[forward] = j;
  }
  if (!best)
    return points[index].position;
 
  // A solution outside the allowed arc gives way to the arc end closer to it, so that a solution leaving
  // the arc stays at the end it left through.
  Vec2d result = *best;
  const double loop_length = arc[0] + arc[1];
  const double ahead = best_forward ? best_arc : loop_length - best_arc;
  const auto [ahead_limit, ahead_end] = allowed_arc(true);
  const auto [behind_limit, behind_end] = allowed_arc(false);
  if (ahead > ahead_limit && loop_length - ahead > behind_limit)
    result = (ahead_end - *best).squaredNorm() <= (behind_end - *best).squaredNorm() ? ahead_end : behind_end;
  return to_3d(Vec2f(result.cast<float>()), points[index].position.z());
}

References Blocked, Slic3r::cast(), count, Slic3r::cross(), edge_normal(), Slic3r::SeamPlacerImpl::Perimeter::end_index, Enforced, Slic3r::SeamPlacer::enforcer_oversampling_distance, Slic3r::SeamPlacerImpl::Perimeter::exact_enforced_ends, Slic3r::length(), Slic3r::next_idx_modulo(), place_on_loop(), Slic3r::prev_idx_modulo(), Slic3r::SeamPlacerImpl::Perimeter::start_index, and Slic3r::to_3d().

Referenced by place_on_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

process_perimeter_polygon()

void Slic3r::SeamPlacerImpl::process_perimeter_polygon	(	const Polygon &	orig_polygon,
		float	z_coord,
		const LayerRegion *	region,
		const GlobalModelInfo &	global_model_info,
		PrintObjectSeamData::LayerSeams &	result,
		PreciseSeam::PreciseSeamWarnings *	warnings = nullptr,
		std::optional< bool >	boundary_hole = std::nullopt )

                                                                             {
  if (orig_polygon.size() == 0) {
    return;
  }
  Polygon polygon = orig_polygon;
  bool was_clockwise = polygon.make_counter_clockwise();
 
  // Process Precise Seam modifiers to find seam placement
  const Layer* layer = region ? region->layer() : nullptr;
 
  // Use pre-computed Precise Seam volumes from global_model_info (computed once in init)
  const auto& strong_volumes = global_model_info.precise_seam_strong_volumes;
  const auto& weak_volumes = global_model_info.precise_seam_weak_volumes;
 
  std::optional<Point> seam_point;
  std::vector<PreciseSeam::WeakModifierSegment> weak_segments;
  if (layer != nullptr && (!strong_volumes.empty() || !weak_volumes.empty())) {
    // Share validation, bounds and clipping line across all modifiers while the polygon is unchanged.
    // A strong insertion ends processing; otherwise weak reads the same preparation before inserting.
    const PreciseSeam::PreparedPerimeter prepared(polygon);
    seam_point = PreciseSeam::insert_strong_seam_point(
        strong_volumes, polygon, prepared, layer, global_model_info.precise_seam_slices, warnings);
    if (!seam_point.has_value())
      weak_segments = PreciseSeam::collect_weak_modifier_segments(
          weak_volumes, polygon, prepared, layer, global_model_info.precise_seam_slices, warnings);
  }
 
  // Store the inserted point position for marking as central_enforcer later.
  std::optional<Vec3f> inserted_seam_position;
  if (seam_point.has_value()) {
    Vec2f unscaled_p = unscale(seam_point.value()).cast<float>();
    inserted_seam_position = Vec3f(unscaled_p.x(), unscaled_p.y(), z_coord);
  }
 
  float angle_arm_len = region != nullptr ? region->flow(FlowRole::frExternalPerimeter).nozzle_diameter() : 0.5f;
 
  std::vector<float> lengths { };
  for (size_t point_idx = 0; point_idx < polygon.size() - 1; ++point_idx) {
    lengths.push_back((unscale(polygon[point_idx]) - unscale(polygon[point_idx + 1])).norm());
  }
  lengths.push_back(std::max((unscale(polygon[0]) - unscale(polygon[polygon.size() - 1])).norm(), 0.1));
  std::vector<float> polygon_angles = calculate_polygon_angles_at_vertices(polygon, lengths,
                                                                           angle_arm_len);
 
  result.perimeters.push_back( { });
  Perimeter &perimeter = result.perimeters.back();
  // The loop role is independent of the configured printing direction.
  perimeter.is_hole = boundary_hole.value_or(was_clockwise);
  perimeter.contour_reliable = boundary_hole.has_value(); // Keep unknown roles out of geometric matching.
  perimeter.contour_index = result.perimeters.size() - 1;
 
  std::queue<Vec3f> orig_polygon_points { };
  for (size_t index = 0; index < polygon.size(); ++index) {
    Vec2f unscaled_p = unscale(polygon[index]).cast<float>();
    orig_polygon_points.emplace(unscaled_p.x(), unscaled_p.y(), z_coord);
  }
  Vec3f first = orig_polygon_points.front();
  std::queue<Vec3f> oversampled_points { };
  size_t orig_angle_index = 0;
  perimeter.start_index = result.points.size();
  perimeter.flow_width = region != nullptr ? region->flow(FlowRole::frExternalPerimeter).width() : 0.0f;
 
  // Painted ranges bounded exactly by the paint contour crossing this layer; without them, points within
  // flow_width of paint are Enforced.
  std::vector<Vec2d> loop_xy;
  std::vector<double> loop_arc { 0.0 };
  for (const Point &point : polygon.points)
    loop_xy.push_back(unscale(point));
  for (size_t i = 0; i < loop_xy.size(); ++i)
    loop_arc.push_back(loop_arc.back() + (loop_xy[(i + 1) % loop_xy.size()] - loop_xy[i]).norm());
  const double loop_length = loop_arc.back();
  const auto intervals = exact_painted_intervals(loop_xy, loop_arc, z_coord, perimeter.flow_width,
                                                 global_model_info.enforcer_contour);
  const auto blocked_intervals = exact_painted_intervals(loop_xy, loop_arc, z_coord, perimeter.flow_width,
                                                         global_model_info.blocker_contour);
  perimeter.exact_blocked_ends = !blocked_intervals.empty();
  const bool exact_marks = !intervals.empty() || perimeter.exact_blocked_ends;
  // Keep active Precise Seam modifiers authoritative; normalize ordinary full paint only.
  const bool ignore_full_paint = intervals.empty() && !inserted_seam_position && weak_segments.empty() &&
      fully_enforced_loop(loop_xy, z_coord, perimeter.flow_width, global_model_info);
  if (ignore_full_paint)
    BOOST_LOG_TRIVIAL(debug) << "[SeamPaint] full_perimeter z=" << z_coord << " normalized=true";
  perimeter.exact_enforced_ends = !intervals.empty();
  const auto in_interval = [&](double at, const std::vector<PaintedInterval> &ranges) {
    for (const PaintedInterval &interval : ranges)
      for (const double s : { at, at + loop_length })
        if (s >= interval.begin - enforced_end_tolerance && s <= interval.end + enforced_end_tolerance)
          return true;
    return false;
  };
  const auto point_at = [&](double s) {
    const size_t i = std::min(size_t(std::upper_bound(loop_arc.begin(), loop_arc.end(), s) - loop_arc.begin()),
                              loop_xy.size()) - 1;
    const double length = loop_arc[i + 1] - loop_arc[i];
    const Vec2d p = loop_xy[i] + (length > 0.0 ? (s - loop_arc[i]) / length : 0.0) *
                                     (loop_xy[(i + 1) % loop_xy.size()] - loop_xy[i]);
    return Vec3f(float(p.x()), float(p.y()), z_coord);
  };
  // Green paint without exact ends: an edge whose start is within the edge length of paint gets a point every
  // enforcer_oversampling_distance, passed to emit as its distance from the start.
  const auto oversample_green = [&](const Vec3f &start, float length, const auto &emit) {
    if (ignore_full_paint || !global_model_info.is_enforced(start, length))
      return;
    for (float step = SeamPlacer::enforcer_oversampling_distance; step < length;
         step += SeamPlacer::enforcer_oversampling_distance)
      emit(step);
  };
  // Points to insert: the range ends, middles and every enforcer_oversampling_distance from their begin, and the
  // middle of each gap between ranges, which keeps neighboring ranges apart as patches; as sorted loop positions
  // in [0, loop_length).
  std::vector<double> marks;
  std::vector<std::pair<Vec3f, double>> interval_middles; // Middle point and length of each range.
  for (size_t k = 0; k < intervals.size(); ++k) {
    const PaintedInterval &interval = intervals[k];
    const double middle = 0.5 * (interval.begin + interval.end);
    // Ranges come in loop order from the first vertex.
    const double next_begin = k + 1 < intervals.size() ? intervals[k + 1].begin : intervals.front().begin + loop_length;
    marks.insert(marks.end(), { interval.begin, interval.end, middle, 0.5 * (interval.end + next_begin) });
    for (double s = interval.begin + SeamPlacer::enforcer_oversampling_distance; s < interval.end - enforced_end_tolerance;
         s += SeamPlacer::enforcer_oversampling_distance)
      marks.push_back(s);
    interval_middles.emplace_back(point_at(std::fmod(middle, loop_length)), interval.end - interval.begin);
  }
  for (size_t k = 0; k < blocked_intervals.size(); ++k) {
    const auto &interval = blocked_intervals[k];
    const double next_begin = k + 1 < blocked_intervals.size() ? blocked_intervals[k + 1].begin :
                                                              blocked_intervals.front().begin + loop_length;
    const double gap = next_begin - interval.end;
    // Keep the boundary itself blocked, with a permitted sample just outside it. Both alignment and
    // the iterative solvers stop at these samples, within 2 um of the geometric paint edge.
    const double guard = std::min(2.0 * enforced_end_tolerance, 0.25 * gap);
    marks.insert(marks.end(), {interval.begin, interval.end, 0.5 * (interval.begin + interval.end),
                               interval.end + guard, next_begin - guard, 0.5 * (interval.end + next_begin)});
  }
  if (perimeter.exact_blocked_ends && !perimeter.exact_enforced_ends) {
    // Red marks must not suppress legacy green oversampling when its boundary is uncertain.
    for (size_t i = 0; i < loop_xy.size(); ++i)
      oversample_green(point_at(loop_arc[i]), float(loop_arc[i + 1] - loop_arc[i]),
                       [&](float step) { marks.push_back(loop_arc[i] + step); });
  }
  for (double &s : marks)
    s = std::fmod(s, loop_length);
  std::sort(marks.begin(), marks.end());
  // A mark closer than the tolerance to the last one kept is the same point.
  size_t kept = 0;
  for (size_t i = 0; i < marks.size(); ++i)
    if (kept == 0 || marks[i] - marks[kept - 1] >= enforced_end_tolerance)
      marks[kept++] = marks[i];
  marks.resize(kept);
 
  std::queue<double> oversampled_arcs { }; // Loop positions of the inserted points with exact ranges.
  bool some_point_enforced = false;
  while (!orig_polygon_points.empty() || !oversampled_points.empty()) {
    EnforcedBlockedSeamPoint type = EnforcedBlockedSeamPoint::Neutral;
    Vec3f position;
    float local_ccw_angle = 0;
    bool orig_point = false;
    double at = 0.0; // Loop position, used with exact ranges.
    if (!oversampled_points.empty()) {
      position = oversampled_points.front();
      oversampled_points.pop();
      if (exact_marks) {
        at = oversampled_arcs.front();
        oversampled_arcs.pop();
      }
    } else {
      position = orig_polygon_points.front();
      orig_polygon_points.pop();
      local_ccw_angle = was_clockwise ? -polygon_angles[orig_angle_index] : polygon_angles[orig_angle_index];
      at = loop_arc[orig_angle_index];
      orig_angle_index++;
      orig_point = true;
    }
 
    // Projected ends bound paint but cannot prove that a detour between them stays near its surface.
    if (!ignore_full_paint && (!perimeter.exact_enforced_ends || in_interval(at, intervals)) &&
        global_model_info.is_enforced(position, perimeter.flow_width)) {
      type = EnforcedBlockedSeamPoint::Enforced;
    }
 
    if ((!perimeter.exact_blocked_ends || in_interval(at, blocked_intervals)) &&
        global_model_info.is_blocked(position, perimeter.flow_width)) {
      type = EnforcedBlockedSeamPoint::Blocked;
    }
    some_point_enforced = some_point_enforced || type == EnforcedBlockedSeamPoint::Enforced;
 
    if (orig_point && exact_marks) {
      // Marks strictly inside the edge from this vertex; one at a vertex is the vertex itself.
      const double from = loop_arc[orig_angle_index - 1], to = loop_arc[orig_angle_index];
      for (auto it = std::upper_bound(marks.begin(), marks.end(), from + enforced_end_tolerance);
           it != marks.end() && *it < to - enforced_end_tolerance; ++it) {
        oversampled_points.push(point_at(*it));
        oversampled_arcs.push(*it);
      }
    } else if (orig_point) {
      const Vec3f pos_of_next = orig_polygon_points.empty() ? first : orig_polygon_points.front();
      const Vec3f vec_to_next = (pos_of_next - position).normalized();
      oversample_green(position, (position - pos_of_next).norm(),
                       [&](float step) { oversampled_points.push(position + vec_to_next * step); });
    }
 
    result.points.emplace_back(position, perimeter, local_ccw_angle, type);
  }
 
  perimeter.end_index = result.points.size();
 
  // Apply weak modifiers if no strong modifier was inserted
  if (!inserted_seam_position.has_value() && !weak_segments.empty()) {
    PreciseSeam::apply_weak_modifiers_to_perimeter(
        weak_segments, result, perimeter, some_point_enforced, warnings);
  }
 
  if (some_point_enforced) {
    // Choose the continuous enforced patch with the most candidates, then select its middle
    // candidate or a sharp corner. Patch length here is a point count, not geometric distance.
    size_t perimeter_size = perimeter.end_index - perimeter.start_index;
    const auto next_index = [&](size_t idx) {
      return perimeter.start_index + Slic3r::next_idx_modulo(idx - perimeter.start_index, perimeter_size);
    };
 
    std::vector<size_t> patches_starts_ends;
    for (size_t i = perimeter.start_index; i < perimeter.end_index; ++i) {
      if (result.points[i].type != EnforcedBlockedSeamPoint::Enforced &&
          result.points[next_index(i)].type == EnforcedBlockedSeamPoint::Enforced) {
        patches_starts_ends.push_back(next_index(i));
      }
      if (result.points[i].type == EnforcedBlockedSeamPoint::Enforced &&
          result.points[next_index(i)].type != EnforcedBlockedSeamPoint::Enforced) {
        patches_starts_ends.push_back(next_index(i));
      }
    }
    // If patches_starts_ends are empty, the whole perimeter is enforced, or no point is enforced any more
    // (Precise Seam weak zones retyped every painted enforcer); don't do anything in either case.
    if (!patches_starts_ends.empty()) {
      //if the first point in the patches is not enforced, it marks a patch end. in that case, put it to the end and start on next
      // to simplify the processing
      assert(patches_starts_ends.size() % 2 == 0);
      bool start_on_second = false;
      if (result.points[patches_starts_ends[0]].type != EnforcedBlockedSeamPoint::Enforced) {
        start_on_second = true;
        patches_starts_ends.push_back(patches_starts_ends[0]);
      }
      //now pick the longest patch
      std::pair<size_t, size_t> longest_patch { 0, 0 };
      auto patch_len = [perimeter_size](const std::pair<size_t, size_t> &start_end) {
        if (start_end.second < start_end.first) {
          // Count [start, end) across the closing edge, independently of the contour's start.
          // Subtract indices first: they are offsets in the layer, not local perimeter indices.
          return perimeter_size - (start_end.first - start_end.second);
        } else {
          return start_end.second - start_end.first;
        }
      };
      for (size_t patch_idx = start_on_second ? 1 : 0; patch_idx < patches_starts_ends.size(); patch_idx += 2) {
        std::pair<size_t, size_t> current_patch { patches_starts_ends[patch_idx], patches_starts_ends[patch_idx
                                                                                                    + 1] };
        if (patch_len(longest_patch) < patch_len(current_patch)) {
          longest_patch = current_patch;
        }
      }
      std::vector<size_t> viable_points_indices;
      std::vector<size_t> large_angle_points_indices;
      for (size_t point_idx = longest_patch.first; point_idx != longest_patch.second;
           point_idx = next_index(point_idx)) {
        viable_points_indices.push_back(point_idx);
        if (std::abs(result.points[point_idx].local_ccw_angle)
            > SeamPlacer::sharp_angle_snapping_threshold) {
          large_angle_points_indices.push_back(point_idx);
        }
      }
      assert(viable_points_indices.size() > 0);
      if (large_angle_points_indices.empty()) {
        size_t central_idx = viable_points_indices[viable_points_indices.size() / 2];
        // With exact ranges, the middle of the longest range in the patch.
        double longest = -1.0;
        for (const size_t idx : viable_points_indices)
          for (const auto &[middle, length] : interval_middles)
            if (length > longest && (result.points[idx].position - middle).norm() <= enforced_end_tolerance) {
              central_idx = idx;
              longest = length;
            }
        result.points[central_idx].central_enforcer = true;
      } else {
        size_t central_idx = large_angle_points_indices.size() / 2;
        result.points[large_angle_points_indices[central_idx]].central_enforcer = true;
      }
    }
  }
 
  // Apply precise seam point if it was inserted
  if (inserted_seam_position.has_value()) {
    // Set single point as Enforced, block all others
    for (size_t i = perimeter.start_index; i < perimeter.end_index; ++i) {
      if (result.points[i].position == inserted_seam_position.value()) {
        // Mark as the single enforced point with highest priority
        result.points[i].type = EnforcedBlockedSeamPoint::Enforced;
        result.points[i].central_enforcer = true;
        perimeter.precise_seam_point = inserted_seam_position;
        perimeter.precise_seam_index = i;
      } else {
        // Block all other points
        result.points[i].type = EnforcedBlockedSeamPoint::Blocked;
        result.points[i].central_enforcer = false;
      }
    }
  }
 
}

References Slic3r::PreciseSeam::apply_weak_modifiers_to_perimeter(), Slic3r::SeamPlacerImpl::PaintedInterval::begin, Blocked, Slic3r::SeamPlacerImpl::GlobalModelInfo::blocker_contour, calculate_polygon_angles_at_vertices(), Slic3r::PreciseSeam::collect_weak_modifier_segments(), Slic3r::SeamPlacerImpl::Perimeter::contour_index, Slic3r::SeamPlacerImpl::Perimeter::contour_reliable, Slic3r::SeamPlacerImpl::PaintedInterval::end, Slic3r::SeamPlacerImpl::Perimeter::end_index, Enforced, enforced_end_tolerance, Slic3r::SeamPlacerImpl::GlobalModelInfo::enforcer_contour, Slic3r::SeamPlacer::enforcer_oversampling_distance, Slic3r::SeamPlacerImpl::Perimeter::exact_blocked_ends, Slic3r::SeamPlacerImpl::Perimeter::exact_enforced_ends, exact_painted_intervals(), Slic3r::LayerRegion::flow(), Slic3r::SeamPlacerImpl::Perimeter::flow_width, Slic3r::frExternalPerimeter, fully_enforced_loop(), Slic3r::PreciseSeam::insert_strong_seam_point(), Slic3r::SeamPlacerImpl::GlobalModelInfo::is_blocked(), Slic3r::SeamPlacerImpl::GlobalModelInfo::is_enforced(), Slic3r::SeamPlacerImpl::Perimeter::is_hole, Slic3r::LayerRegion::layer(), Slic3r::length(), Slic3r::Polygon::make_counter_clockwise(), Neutral, Slic3r::next_idx_modulo(), Slic3r::Flow::nozzle_diameter(), Slic3r::PrintObjectSeamData::LayerSeams::perimeters, Slic3r::MultiPoint::points, Slic3r::PrintObjectSeamData::LayerSeams::points, Slic3r::SeamPlacerImpl::Perimeter::precise_seam_index, Slic3r::SeamPlacerImpl::Perimeter::precise_seam_point, Slic3r::SeamPlacerImpl::GlobalModelInfo::precise_seam_slices, Slic3r::SeamPlacerImpl::GlobalModelInfo::precise_seam_strong_volumes, Slic3r::SeamPlacerImpl::GlobalModelInfo::precise_seam_weak_volumes, process_perimeter_polygon(), Slic3r::SeamPlacer::sharp_angle_snapping_threshold, Slic3r::MultiPoint::size(), Slic3r::SeamPlacerImpl::Perimeter::start_index, Slic3r::unscale(), and Slic3r::Flow::width().

Referenced by process_perimeter_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

raycast_visibility()

std::vector< float > Slic3r::SeamPlacerImpl::raycast_visibility	(	const AABBTreeIndirect::Tree< 3, float > &	raycasting_tree,
		const indexed_triangle_set &	triangles,
		const TriangleSetSamples &	samples,
		size_t	negative_volumes_start_index,
		SeamPosition	seam_position = spAligned )

                                                                              {
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size()
      << " triangles: end";
 
  //prepare uniform samples of a hemisphere
  float step_size = 1.0f / SeamPlacer::sqr_rays_per_sample_point;
  std::vector<Vec3f> precomputed_sample_directions(
      SeamPlacer::sqr_rays_per_sample_point * SeamPlacer::sqr_rays_per_sample_point);
  for (size_t x_idx = 0; x_idx < SeamPlacer::sqr_rays_per_sample_point; ++x_idx) {
    float sample_x = x_idx * step_size + step_size / 2.0;
    for (size_t y_idx = 0; y_idx < SeamPlacer::sqr_rays_per_sample_point; ++y_idx) {
      size_t dir_index = x_idx * SeamPlacer::sqr_rays_per_sample_point + y_idx;
      float sample_y = y_idx * step_size + step_size / 2.0;
      precomputed_sample_directions[dir_index] = sample_hemisphere_uniform( { sample_x, sample_y });
    }
  }
 
  bool model_contains_negative_parts = negative_volumes_start_index < triangles.indices.size();
 
  std::vector<float> result(samples.positions.size());
  tbb::parallel_for(tbb::blocked_range<size_t>(0, result.size()),
                    [&triangles, &precomputed_sample_directions, model_contains_negative_parts, negative_volumes_start_index,
                     &raycasting_tree, &result, &samples, seam_position](tbb::blocked_range<size_t> r) {
                      // Maintaining hits memory outside of the loop, so it does not have to be reallocated for each query.
                      std::vector<igl::Hit<float>> hits;
                      for (size_t s_idx = r.begin(); s_idx < r.end(); ++s_idx) {
                        result[s_idx] = 1.0f;
                        constexpr float decrease_step = 1.0f
                                                        / (SeamPlacer::sqr_rays_per_sample_point * SeamPlacer::sqr_rays_per_sample_point);
 
                        const Vec3f &center = samples.positions[s_idx];
                        const Vec3f &normal = samples.normals[s_idx];
                        if (seam_position == spAlignedBack) {
                            const float front_adjustment = std::clamp((normal.dot(Vec3f(0.0f, -1.0f, 0.0f)) + 1.2f) * 0.5f, 0.0f, 1.0f);
                            result[s_idx] += front_adjustment;
                        }
 
                        // apply the local direction via Frame struct - the local_dir is with respect to +Z being forward
                        Frame f;
                        f.set_from_z(normal);
 
                        for (const auto &dir : precomputed_sample_directions) {
                          Vec3f final_ray_dir = (f.to_world(dir));
                          if (!model_contains_negative_parts) {
                            igl::Hit<float> hitpoint;
                            // FIXME: This AABBTTreeIndirect query will not compile for float ray origin and
                            // direction.
                            Vec3d final_ray_dir_d = final_ray_dir.cast<double>();
                            Vec3d ray_origin_d = (center + normal * 0.01f).cast<double>(); // start above surface.
                            bool hit = AABBTreeIndirect::intersect_ray_first_hit(triangles.vertices,
                                                                                 triangles.indices, raycasting_tree, ray_origin_d, final_ray_dir_d, hitpoint);
                            if (hit && its_face_normal(triangles, hitpoint.id).dot(final_ray_dir) <= 0) {
                              result[s_idx] -= decrease_step;
                            }
                          } else { //TODO improve logic for order based boolean operations - consider order of volumes
                            bool casting_from_negative_volume = samples.triangle_indices[s_idx]
                                                                >= negative_volumes_start_index;
 
                            Vec3d ray_origin_d = (center + normal * 0.01f).cast<double>(); // start above surface.
                            if (casting_from_negative_volume) { // if casting from negative volume face, invert direction, change start pos
                              final_ray_dir = -1.0 * final_ray_dir;
                              ray_origin_d = (center - normal * 0.01f).cast<double>();
                            }
                            Vec3d final_ray_dir_d = final_ray_dir.cast<double>();
                            bool some_hit = AABBTreeIndirect::intersect_ray_all_hits(triangles.vertices,
                                                                                     triangles.indices, raycasting_tree,
                                                                                     ray_origin_d, final_ray_dir_d, hits);
                            if (some_hit) {
                              int counter = 0;
                              // NOTE: iterating in reverse, from the last hit for one simple reason: We know the state of the ray at that point;
                              //  It cannot be inside model, and it cannot be inside negative volume
                              for (int hit_index = int(hits.size()) - 1; hit_index >= 0; --hit_index) {
                                Vec3f face_normal = its_face_normal(triangles, hits[hit_index].id);
                                if (hits[hit_index].id >= int(negative_volumes_start_index)) { //negative volume hit
                                  counter -= sgn(face_normal.dot(final_ray_dir)); // if volume face aligns with ray dir, we are leaving negative space
                                                                                               // which in reverse hit analysis means, that we are entering negative space :) and vice versa
                                } else {
                                  counter += sgn(face_normal.dot(final_ray_dir));
                                }
                              }
                              if (counter == 0) {
                                result[s_idx] -= decrease_step;
                              }
                            }
                          }
                        }
                      }
                    });
 
  BOOST_LOG_TRIVIAL(debug)
      << "SeamPlacer: raycast visibility of " << samples.positions.size() << " samples over " << triangles.indices.size()
      << " triangles: end";
 
  return result;
}

References Slic3r::TriangleSetSamples::positions, sample_hemisphere_uniform(), Slic3r::spAligned, and Slic3r::SeamPlacer::sqr_rays_per_sample_point.

Referenced by compute_global_occlusion().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_hemisphere_uniform()

Vec3f Slic3r::SeamPlacerImpl::sample_hemisphere_uniform

(

const Vec2f &

samples

)

                                                      {
  float term1 = 2.0f * float(PI) * samples.x();
  float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y());
  return {cos(term1) * term2, sin(term1) * term2,
          abs(1.0f - 2.0f * samples.y())};
}

References PI.

Referenced by raycast_visibility().

Here is the caller graph for this function:

sample_power_cosine_hemisphere()

Vec3f Slic3r::SeamPlacerImpl::sample_power_cosine_hemisphere	(	const Vec2f &	samples,
		float	power )

                                                                        {
  float term1 = 2.f * float(PI) * samples.x();
  float term2 = pow(samples.y(), 1.f / (power + 1.f));
  float term3 = sqrt(1.f - term2 * term2);
 
  return Vec3f(cos(term1) * term3, sin(term1) * term3, term2);
}

References PI.

sample_sphere_uniform()

Vec3f Slic3r::SeamPlacerImpl::sample_sphere_uniform

(

const Vec2f &

samples

)

                                                  {
  float term1 = 2.0f * float(PI) * samples.x();
  float term2 = 2.0f * sqrt(samples.y() - samples.y() * samples.y());
  return {cos(term1) * term2, sin(term1) * term2,
          1.0f - 2.0f * samples.y()};
}

References PI.

sgn()

template<typename T>

int Slic3r::SeamPlacerImpl::sgn

(

T

val

)

                                    {
  return int(T(0) < val) - int(val < T(0));
}

smoothstep01()

float Slic3r::SeamPlacerImpl::smoothstep01

(

float

x

)

                            {
  x = std::clamp(x, 0.0f, 1.0f);
  return x * x * (3.0f - 2.0f * x);
}

References smoothstep01().

Referenced by enforced_corner_influence(), and smoothstep01().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

enforced_corner_angle_max

float Slic3r::SeamPlacerImpl::enforced_corner_angle_max = 30.0f * float(PI) / 180.0f

constexpr

Referenced by enforced_corner_influence().

enforced_corner_angle_min

float Slic3r::SeamPlacerImpl::enforced_corner_angle_min = 15.0f * float(PI) / 180.0f

constexpr

Referenced by enforced_corner_influence().

enforced_corner_fade_factor

float Slic3r::SeamPlacerImpl::enforced_corner_fade_factor = 2.0f

constexpr

enforced_end_tolerance

double Slic3r::SeamPlacerImpl::enforced_end_tolerance = 1e-3

constexpr

Referenced by exact_painted_intervals(), fully_enforced_loop(), and process_perimeter_polygon().