Improve adaptive layer height quality control

Refactored adaptive layer height calculation to use explicit min/max settings and improved quality factor handling. Advanced algorithms now allow more dynamic layer height changes based on quality, and default to quality-based heights when no geometry constraints are present.

Author: HellAholic

src/FffPolygonGenerator.cpp

@@ -139,10 +139,9 @@ bool FffPolygonGenerator::sliceModel(MeshGroup* meshgroup, TimeKeeper& timeKeepe
         {
             // Use advanced quality-based algorithm
             const auto quality_factor = mesh_group_settings.get<double>("adaptive_layer_height_quality_factor");
-            const auto variable_layer_height_max_variation = mesh_group_settings.get<coord_t>("adaptive_layer_height_variation");
-            const coord_t min_layer_height = std::max(coord_t(10), layer_thickness - variable_layer_height_max_variation); // Minimum 0.01mm
-            const coord_t max_layer_height = layer_thickness + variable_layer_height_max_variation;
-
+            const coord_t min_layer_height = mesh_group_settings.get<coord_t>("adaptive_layer_height_min");
+            const coord_t max_layer_height = mesh_group_settings.get<coord_t>("adaptive_layer_height_max");
+            
             adaptive_layer_heights = new AdaptiveLayerHeights(layer_thickness, min_layer_height, max_layer_height, quality_factor, meshgroup);
         }
         else

src/settings/AdaptiveLayerHeights.cpp

@@ -238,7 +238,10 @@ void AdaptiveLayerHeights::calculateLayersAdvanced()
 
     // Use advanced adaptive algorithm
     size_t current_facet = 0;
-    const double LAYER_HEIGHT_CHANGE_STEP = 40.0; // microns, gradual change limit
+    // Allow larger height changes for quality-based control
+    // Quality factor 0.0 (best quality) allows more dramatic changes for precision
+    // Quality factor 1.0 (speed) uses more gradual changes for stability
+    const double LAYER_HEIGHT_CHANGE_STEP = 100.0 + quality_factor_ * 100.0; // 100-200 microns range
 
     while (z_level < model_max_z && layers_.size() < 10000) // Safety limit
     {
@@ -251,11 +254,11 @@ void AdaptiveLayerHeights::calculateLayersAdvanced()
             coord_t previous_height = layers_.back().layer_height_;
             if (previous_height < height && height - previous_height > LAYER_HEIGHT_CHANGE_STEP)
             {
-                height = previous_height + LAYER_HEIGHT_CHANGE_STEP;
+                height = previous_height + coord_t(LAYER_HEIGHT_CHANGE_STEP);
             }
             else if (previous_height > height && previous_height - height > LAYER_HEIGHT_CHANGE_STEP)
             {
-                height = previous_height - LAYER_HEIGHT_CHANGE_STEP;
+                height = previous_height - coord_t(LAYER_HEIGHT_CHANGE_STEP);
             }
         }
 

src/settings/SlicingAdaptive.cpp

@@ -95,17 +95,18 @@ coord_t SlicingAdaptive::next_layer_height(const double print_z, double quality_
     // Calculate max surface deviation based on quality factor
     double max_surface_deviation;
     {
-        // Convert layer heights from microns to mm for calculation
-        double delta_min = m_slicing_params.min_layer_height / 1000.0;
-        double delta_mid = m_slicing_params.layer_height / 1000.0;
-        double delta_max = m_slicing_params.max_layer_height / 1000.0;
-
-        max_surface_deviation = (quality_factor < 0.5) ? lerp(delta_min, delta_mid, 2.0 * quality_factor) : lerp(delta_max, delta_mid, 2.0 * (1.0 - quality_factor));
+        // Quality factor 0.0 = best quality (smallest surface deviation, thinner layers)
+        // Quality factor 1.0 = fastest speed (larger surface deviation, thicker layers)
+        const double min_surface_deviation = 0.01; // 0.01mm for highest quality
+        const double max_surface_deviation_val = 0.2;  // 0.2mm for fastest speed
+        
+        max_surface_deviation = min_surface_deviation + quality_factor * (max_surface_deviation_val - min_surface_deviation);
     }
 
     // Find all facets intersecting the slice layer
     size_t ordered_id = current_facet;
     bool first_hit = false;
+    bool found_influencing_geometry = false;
 
     for (; ordered_id < m_faces.size(); ++ordered_id)
     {
@@ -132,11 +133,22 @@ coord_t SlicingAdaptive::next_layer_height(const double print_z, double quality_
             // Compute cusp height for this facet and store minimum
             coord_t facet_height = layer_height_from_slope(m_faces[ordered_id], max_surface_deviation);
             height = std::min(height, facet_height);
+            found_influencing_geometry = true;
         }
     }
 
     // Apply printer capability limits
     height = std::max(height, m_slicing_params.min_layer_height);
+    
+    // If no geometry influenced the layer height, use quality-based default
+    if (!found_influencing_geometry)
+    {
+        // Create a quality-based layer height when no geometry constraints exist
+        // Quality 0.0 -> use minimum layer height, Quality 1.0 -> use maximum layer height
+        coord_t quality_based_height = coord_t(m_slicing_params.min_layer_height + 
+            quality_factor * (m_slicing_params.max_layer_height - m_slicing_params.min_layer_height));
+        height = std::min(height, quality_based_height);
+    }
 
     // Check for sloped facets inside the determined layer and correct height if necessary
     if (height > m_slicing_params.min_layer_height)