#include <src/libslic3r/SlicingAdaptive.hpp>

Collaboration diagram for Slic3r::SlicingAdaptive:

Classes
struct	FaceZ

Public Member Functions
void	clear ()

void	set_slicing_parameters (SlicingParameters params)

void	prepare (const ModelObject &object)

float	next_layer_height (const float print_z, float quality, size_t &current_facet)

float	horizontal_facet_distance (float z)

Protected Attributes
SlicingParameters	m_slicing_params

std::vector< FaceZ >	m_faces

Detailed Description

Class Documentation

◆ Slic3r::SlicingAdaptive::FaceZ

struct Slic3r::SlicingAdaptive::FaceZ

Class Members
float	n_cos
float	n_sin
pair< float, float >	z_span

Member Function Documentation

◆ clear()

void Slic3r::SlicingAdaptive::clear ( )

{
  m_faces.clear();
}

References m_faces.

Referenced by prepare().

Here is the caller graph for this function:

◆ horizontal_facet_distance()

float Slic3r::SlicingAdaptive::horizontal_facet_distance ( float z )

{
  for (size_t i = 0; i < m_faces.size(); ++ i) {
        std::pair<float, float> zspan = m_faces[i].z_span;
        // facet's minimum is higher than max forward distance -> end loop
    if (zspan.first > z + m_slicing_params.max_layer_height)
      break;
    // min_z == max_z -> horizontal facet
    if (zspan.first > z && zspan.first == zspan.second)
      return zspan.first - z;
  }
  
  // objects maximum?
  return (z + (float)m_slicing_params.max_layer_height > (float)m_slicing_params.object_print_z_height()) ? 
    std::max((float)m_slicing_params.object_print_z_height() - z, 0.f) : (float)m_slicing_params.max_layer_height;
}

References m_faces, m_slicing_params, Slic3r::SlicingParameters::max_layer_height, and Slic3r::SlicingParameters::object_print_z_height().

Referenced by Slic3r::layer_height_profile_adaptive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ next_layer_height()

float Slic3r::SlicingAdaptive::next_layer_height	(	const float	print_z,
		float	quality,
		size_t &	current_facet
	)

{
  float  height = (float)m_slicing_params.max_layer_height;
 
  float  max_surface_deviation;
 
  {
#if 0
// @platch's formula for quality:
      double delta_min = SURFACE_CONST * m_slicing_params.min_layer_height;
      double delta_mid = (SURFACE_CONST + 0.5) * m_slicing_params.layer_height;
      double delta_max = (SURFACE_CONST + 0.5) * m_slicing_params.max_layer_height;
#else
// Vojtech's formula for triangle area error metric.
      double delta_min = m_slicing_params.min_layer_height;
      double delta_mid = m_slicing_params.layer_height;
      double delta_max = m_slicing_params.max_layer_height;
#endif
      max_surface_deviation = (quality_factor < 0.5f) ?
        lerp(delta_min, delta_mid, 2. * quality_factor) :
        lerp(delta_max, delta_mid, 2. * (1. - quality_factor));
  }
  
  // find all facets intersecting the slice-layer
  size_t ordered_id = current_facet;
  {
    bool first_hit = false;
    for (; ordered_id < m_faces.size(); ++ ordered_id) {
          const std::pair<float, float> &zspan = m_faces[ordered_id].z_span;
          // facet's minimum is higher than slice_z -> end loop
      if (zspan.first >= print_z)
        break;
      // facet's maximum is higher than slice_z -> store the first event for next cusp_height call to begin at this point
      if (zspan.second > print_z) {
        // first event?
        if (! first_hit) {
          first_hit = true;
          current_facet = ordered_id;
              }
        // skip touching facets which could otherwise cause small cusp values
        if (zspan.second < print_z + EPSILON)
          continue;
        // compute cusp-height for this facet and store minimum of all heights
        height = std::min(height, layer_height_from_slope(m_faces[ordered_id], max_surface_deviation));
          }
    }
  }
 
  // lower height limit due to printer capabilities
  height = std::max(height, float(m_slicing_params.min_layer_height));
 
  // check for sloped facets inside the determined layer and correct height if necessary
  if (height > float(m_slicing_params.min_layer_height)) {
    for (; ordered_id < m_faces.size(); ++ ordered_id) {
            const std::pair<float, float> &zspan = m_faces[ordered_id].z_span;
            // facet's minimum is higher than slice_z + height -> end loop
      if (zspan.first >= print_z + height)
        break;
 
      // skip touching facets which could otherwise cause small cusp values
      if (zspan.second < print_z + EPSILON)
        continue;
 
      // Compute cusp-height for this facet and check against height.
            float reduced_height = layer_height_from_slope(m_faces[ordered_id], max_surface_deviation);
 
      float z_diff = zspan.first - print_z;
      if (reduced_height < z_diff) {
        assert(z_diff < height + EPSILON);
        // The currently visited triangle's slope limits the next layer height so much, that
        // the lowest point of the currently visible triangle is already above the newly proposed layer height.
        // This means, that we need to limit the layer height so that the offending newly visited triangle
        // is just above of the new layer.
#ifdef ADAPTIVE_LAYER_HEIGHT_DEBUG
                BOOST_LOG_TRIVIAL(trace) << "cusp computation, height is reduced from " << height << "to " << z_diff << " due to z-diff";
#endif /* ADAPTIVE_LAYER_HEIGHT_DEBUG */
        height = z_diff;
      } else if (reduced_height < height) {
#ifdef ADAPTIVE_LAYER_HEIGHT_DEBUG
        BOOST_LOG_TRIVIAL(trace) << "adaptive layer computation: height is reduced from " << height << "to " << reduced_height << " due to higher facet";
#endif /* ADAPTIVE_LAYER_HEIGHT_DEBUG */
        height = reduced_height;
      }
    }
    // lower height limit due to printer capabilities again
    height = std::max(height, float(m_slicing_params.min_layer_height));
  }
 
#ifdef ADAPTIVE_LAYER_HEIGHT_DEBUG
    BOOST_LOG_TRIVIAL(trace) << "adaptive layer computation, layer-bottom at z:" << print_z << ", quality_factor:" << quality_factor << ", resulting layer height:" << height;
#endif  /* ADAPTIVE_LAYER_HEIGHT_DEBUG */
  return height; 
}

References EPSILON, Slic3r::SlicingParameters::layer_height, Slic3r::layer_height_from_slope(), Slic3r::lerp(), m_faces, m_slicing_params, Slic3r::SlicingParameters::max_layer_height, and Slic3r::SlicingParameters::min_layer_height.

Referenced by Slic3r::layer_height_profile_adaptive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare()

void Slic3r::SlicingAdaptive::prepare ( const ModelObject & object )

{
    this->clear();
 
    TriangleMesh     mesh     = object.raw_mesh();
    const ModelInstance &first_instance = *object.instances.front();
    mesh.transform(first_instance.get_matrix(), first_instance.is_left_handed());
 
    // 1) Collect faces from mesh.
    m_faces.reserve(mesh.facets_count());
  for (stl_triangle_vertex_indices face : mesh.its.indices) {
    stl_vertex vertex[3] = { mesh.its.vertices[face[0]], mesh.its.vertices[face[1]], mesh.its.vertices[face[2]] };
    stl_vertex n         = face_normal_normalized(vertex);
    std::pair<float, float> face_z_span {
      std::min(std::min(vertex[0].z(), vertex[1].z()), vertex[2].z()),
      std::max(std::max(vertex[0].z(), vertex[1].z()), vertex[2].z())
    };
    m_faces.emplace_back(FaceZ({ face_z_span, std::abs(n.z()), std::sqrt(n.x() * n.x() + n.y() * n.y()) }));
    }
 
  // 2) Sort faces lexicographically by their Z span.
  std::sort(m_faces.begin(), m_faces.end(), [](const FaceZ &f1, const FaceZ &f2) { return f1.z_span < f2.z_span; });
}