improved concurrency for perimeter & infill (doesn't block the compli…

…cated stuff on only one thread)

and various little modification (types, debug test)

src/libslic3r/Fill/Fill.cpp

@@ -716,11 +716,25 @@ void Layer::make_fills(FillAdaptive::Octree* adaptive_fill_octree, FillAdaptive:
  for(auto &t : temp) real_surface += t.area();
  assert(compute_volume.volume < unscaled(unscaled(surface_fill.surface.area())) * surface_fill.params.layer_height + EPSILON);
  double area = unscaled(unscaled(real_surface));
- assert(compute_volume.volume <= area * surface_fill.params.layer_height * 1.001 || f->debug_verify_flow_mult <= 0.8);
- if(compute_volume.volume > 0) //can fail for thin regions
- assert(compute_volume.volume >= area * surface_fill.params.layer_height * 0.999 || f->debug_verify_flow_mult >= 1.3 || f->debug_verify_flow_mult == 0 // sawtooth output more filament,as it's 3D (debug_verify_flow_mult==0)
- || area < std::max(1.,surface_fill.params.config->solid_infill_below_area.value) || area < std::max(1.,surface_fill.params.config->solid_infill_below_layer_area.value));
- }
+ if(surface_fill.surface.has_pos_top())
+ area *= surface_fill.params.config->fill_top_flow_ratio.value;
+ if(surface_fill.surface.has_pos_bottom() && f->layer_id == 0)
+ area *= surface_fill.params.config->first_layer_flow_ratio.value;
+ if(surface_fill.surface.has_mod_bridge() && f->layer_id == 0)
+ area *= surface_fill.params.config->first_layer_flow_ratio.value;
+ //TODO: over-bridge mod
+ if(surface_fill.params.config->over_bridge_flow_ratio.value == 1){
+ assert(compute_volume.volume <= area * surface_fill.params.layer_height * 1.001 || f->debug_verify_flow_mult <= 0.8);
+ if(compute_volume.volume > 0) //can fail for thin regions
+ assert(
+ compute_volume.volume >= area * surface_fill.params.layer_height * 0.999 ||
+ f->debug_verify_flow_mult >= 1.3 ||
+ f->debug_verify_flow_mult ==
+ 0 // sawtooth output more filament,as it's 3D (debug_verify_flow_mult==0)
+ || area < std::max(1., surface_fill.params.config->solid_infill_below_area.value) ||
+ area < std::max(1., surface_fill.params.config->solid_infill_below_layer_area.value));
+ }
+ }
 #endif
  }
  }

src/libslic3r/GCode.cpp

@@ -4142,6 +4142,18 @@ void GCode::split_at_seam_pos(ExtrusionLoop& loop, bool was_clockwise)
  if (loop.paths.empty())
  return;
 
+#if _DEBUG
+ ExtrusionLoop old_loop = loop;
+ for (const ExtrusionPath &path : loop.paths)
+ for (int i = 1; i < path.polyline.get_points().size(); ++i)
+ assert(!path.polyline.get_points()[i - 1].coincides_with_epsilon(path.polyline.get_points()[i]));
+ for (auto it = std::next(loop.paths.begin()); it != loop.paths.end(); ++it) {
+ assert(it->polyline.size() >= 2);
+ assert(std::prev(it)->polyline.back() == it->polyline.front());
+ }
+ assert(loop.first_point() == loop.last_point());
+#endif
+
 // SeamPosition seam_position = m_config.seam_position;
 // if (loop.loop_role() == elrSkirt)
 // seam_position = spNearest;

src/libslic3r/MultiPoint.cpp

@@ -63,16 +63,16 @@ int MultiPoint::find_point(const Point &point) const
  return -1; // not found
 }
 
-int MultiPoint::find_point(const Point &point, double scaled_epsilon) const
+int MultiPoint::find_point(const Point &point, coordf_t scaled_epsilon) const
 {
  if (scaled_epsilon == 0)
  return this->find_point(point);
 
- auto dist2_min = std::numeric_limits<double>::max();
- auto eps2 = scaled_epsilon * scaled_epsilon;
- int idx_min = -1;
+ coordf_t dist2_min = std::numeric_limits<coordf_t>::max();
+ coordf_t eps2 = scaled_epsilon * scaled_epsilon;
+ int  idx_min  = -1;
  for (const Point &pt : this->points) {
- double d2 = (pt - point).cast<double>().squaredNorm();
+ coordf_t d2 = pt.distance_to_square(point); //(pt - point).cast<coordf_t>().squaredNorm();
  if (d2 < dist2_min) {
  idx_min = int(&pt - &this->points.front());
  dist2_min = d2;

src/libslic3r/MultiPoint.hpp

@@ -50,7 +50,7 @@ class MultiPoint
  int find_point(const Point &point) const;
  // Return index of the closest point to point closer than scaled_epsilon.
  // Return -1 if no such point exists.
- int find_point(const Point &point, const double scaled_epsilon) const;
+ int find_point(const Point &point, const coordf_t scaled_epsilon) const;
  bool has_boundary_point(const Point &point) const;
  int closest_point_index(const Point &point) const {
  int idx = -1;

src/libslic3r/Point.hpp

@@ -179,13 +179,13 @@ class Point : public Vec2crd
  Point projection_onto(const Line &line) const;
  Point interpolate(const double percent, const Point &p) const;
 
- double distance_to(const Point &point) const { return (point - *this).cast<double>().norm(); }
- double distance_to_square(const Point &point) const {
- double dx = double(point.x() - this->x());
- double dy = double(point.y() - this->y());
+ coordf_t distance_to(const Point &point) const { return (point - *this).cast<coordf_t>().norm(); }
+ coordf_t distance_to_square(const Point &point) const {
+ coordf_t dx = double(point.x() - this->x());
+ coordf_t dy = double(point.y() - this->y());
  return dx*dx + dy*dy;
  }
- double distance_to(const Line &line) const;
+ coordf_t distance_to(const Line &line) const;
  bool coincides_with(const Point &point) const { return this->x() == point.x() && this->y() == point.y(); }
  bool coincides_with_epsilon(const Point &point) const {
  return std::abs(this->x() - point.x()) < SCALED_EPSILON/2 && std::abs(this->y() - point.y()) < SCALED_EPSILON/2;

src/libslic3r/PrintObject.cpp

@@ -150,16 +150,20 @@ namespace Slic3r {
  // but we don't generate any extra perimeter if fill density is zero, as they would be floating
  // inside the object - infill_only_where_needed should be the method of choice for printing
  // hollow objects
- for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id) {
- const PrintRegion &region = this->printing_region(region_id);
+  for (size_t region_id = 0; region_id < this->num_printing_regions(); ++ region_id) {
+  const PrintRegion &region = this->printing_region(region_id);
  if (!region.config().extra_perimeters || region.config().perimeters == 0 || region.config().fill_density == 0 || this->layer_count() < 2)
  continue;
-
+ // use an antomic idx instead of the range, to avoid a thread being very late because it's on the difficult layers.
+ //TODO: sort the layers by difficulty (difficult first) (number of points, region, surfaces, .. ?)
+ std::atomic_size_t next_layer_idx(0);
  BOOST_LOG_TRIVIAL(debug) << "Generating extra perimeters for region " << region_id << " in parallel - start";
  tbb::parallel_for(
  tbb::blocked_range<size_t>(0, m_layers.size() - 1),
- [this, &region, region_id](const tbb::blocked_range<size_t>& range) {
- for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ [this, &region, region_id, &next_layer_idx](const tbb::blocked_range<size_t>& range) {
+ //TODO: find a better wya to just fire the threads.
+ //for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ for (size_t layer_idx = next_layer_idx++; layer_idx < m_layers.size() - 1; layer_idx = next_layer_idx++) {
  m_print->throw_if_canceled();
  LayerRegion &layerm = *m_layers[layer_idx]->get_region(region_id);
  const LayerRegion &upper_layerm = *m_layers[layer_idx+1]->get_region(region_id);
@@ -214,10 +218,12 @@ namespace Slic3r {
  }
 
  BOOST_LOG_TRIVIAL(debug) << "Generating perimeters in parallel - start";
+ std::atomic_size_t next_layer_idx(0);
  tbb::parallel_for(
  tbb::blocked_range<size_t>(0, m_layers.size()),
- [this, &atomic_count, nb_layers_update](const tbb::blocked_range<size_t>& range) {
- for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ [this, &atomic_count, nb_layers_update, &next_layer_idx](const tbb::blocked_range<size_t>& range) {
+ //for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ for (size_t layer_idx = next_layer_idx++; layer_idx < m_layers.size(); layer_idx = next_layer_idx++) {
  std::chrono::time_point<std::chrono::system_clock> start_make_perimeter = std::chrono::system_clock::now();
  m_print->throw_if_canceled();
  m_layers[layer_idx]->make_perimeters();
@@ -456,10 +462,13 @@ namespace Slic3r {
  const int nb_layers_update = std::max(1, (int)m_layers.size() / 20);
 
  BOOST_LOG_TRIVIAL(debug) << "Filling layers in parallel - start";
+ std::atomic_size_t next_layer_idx(0);
  tbb::parallel_for(
  tbb::blocked_range<size_t>(0, m_layers.size()),
- [this, &adaptive_fill_octree = adaptive_fill_octree, &support_fill_octree = support_fill_octree, &lightning_generator, &atomic_count, nb_layers_update](const tbb::blocked_range<size_t>& range) {
- for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ [this, &adaptive_fill_octree = adaptive_fill_octree, &support_fill_octree = support_fill_octree, &lightning_generator, &atomic_count, nb_layers_update, &next_layer_idx]
+ (const tbb::blocked_range<size_t>& range) {
+ //for (size_t layer_idx = range.begin(); layer_idx < range.end(); ++layer_idx) {
+ for (size_t layer_idx = next_layer_idx++; layer_idx < m_layers.size(); layer_idx = next_layer_idx++) {
  std::chrono::time_point<std::chrono::system_clock> start_make_fill = std::chrono::system_clock::now();
  m_print->throw_if_canceled();
  m_layers[layer_idx]->make_fills(adaptive_fill_octree.get(), support_fill_octree.get(), lightning_generator.get());