Store / retrieve layer height profile from the AMF file.

Reset the layer height profile when changing a print profile to an incompatible one.
Reset button on the layer height bar.
Fixed an update issue on zooming by a scroll wheel.
Fixed an issue when loading an AMF file: Object names are now retained.

xs/src/libslic3r/Model.cpp

@@ -329,8 +329,10 @@ ModelMaterial::apply(const t_model_material_attributes &attributes)
 }
 
 
-ModelObject::ModelObject(Model *model)
-    : model(model), _bounding_box_valid(false)
+ModelObject::ModelObject(Model *model) : 
+    model(model), 
+    _bounding_box_valid(false),
+    layer_height_profile_valid(false)
 {}
 
 ModelObject::ModelObject(Model *model, const ModelObject &other, bool copy_volumes)
@@ -340,6 +342,8 @@ ModelObject::ModelObject(Model *model, const ModelObject &other, bool copy_volum
     volumes(),
     config(other.config),
     layer_height_ranges(other.layer_height_ranges),
+    layer_height_profile(other.layer_height_profile),
+    layer_height_profile_valid(other.layer_height_profile_valid),
     origin_translation(other.origin_translation),
     _bounding_box(other._bounding_box),
     _bounding_box_valid(other._bounding_box_valid),
@@ -356,7 +360,7 @@ ModelObject::ModelObject(Model *model, const ModelObject &other, bool copy_volum
         this->add_instance(**i);
 }
 
-ModelObject& ModelObject::operator= (ModelObject other)
+ModelObject& ModelObject::operator=(ModelObject other)
 {
     this->swap(other);
     return *this;
@@ -370,6 +374,8 @@ ModelObject::swap(ModelObject &other)
     std::swap(this->volumes,                other.volumes);
     std::swap(this->config,                 other.config);
     std::swap(this->layer_height_ranges,    other.layer_height_ranges);
+    std::swap(this->layer_height_profile,   other.layer_height_profile);
+    std::swap(this->layer_height_profile_valid,    other.layer_height_profile_valid);
     std::swap(this->origin_translation,     other.origin_translation);
     std::swap(this->_bounding_box,          other._bounding_box);
     std::swap(this->_bounding_box_valid,    other._bounding_box_valid);

xs/src/libslic3r/Model.hpp

@@ -117,6 +117,10 @@ public:
     // Profile of increasing z to a layer height, to be linearly interpolated when calculating the layers.
     // The pairs of <z, layer_height> are packed into a 1D array to simplify handling by the Perl XS.
     std::vector<coordf_t> layer_height_profile;
+    // layer_height_profile is initialized when the layer editing mode is entered.
+    // Only if the user really modified the layer height, layer_height_profile_valid is set
+    // and used subsequently by the PrintObject.
+    bool                  layer_height_profile_valid;
 
     /* This vector accumulates the total translation applied to the object by the
         center_around_origin() method. Callers might want to apply the same translation

xs/src/libslic3r/Print.cpp

@@ -371,7 +371,7 @@ Print::add_model_object(ModelObject* model_object, int idx)
             this->objects[idx] = o = new PrintObject(this, model_object, bb);
         } else {
             o = new PrintObject(this, model_object, bb);
-            objects.push_back(o);
+            this->objects.push_back(o);
     
             // invalidate steps
             this->invalidate_step(psSkirt);
@@ -528,8 +528,26 @@ Print::apply_config(DynamicPrintConfig config)
         this->clear_objects();
         for (ModelObjectPtrs::iterator it = model_objects.begin(); it != model_objects.end(); ++it) {
             this->add_model_object(*it);
+            // Update layer_height_profile from the main thread as it may pull the data from the associated ModelObject.
+            this->objects.back()->update_layer_height_profile();
         }
         invalidated = true;
+    } else {
+        // Check validity of the layer height profiles.
+        FOREACH_OBJECT(this, o) {
+            if (! (*o)->layer_height_profile_valid) {
+                // The layer_height_profile is not valid for some reason (updated by the user or invalidated due to some option change).
+                // Start slicing of this object from scratch.
+                (*o)->invalidate_all_steps();
+                // Following line sets the layer_height_profile_valid flag.
+                (*o)->update_layer_height_profile();
+                invalidated = true;
+            } else if (! step_done(posSlice)) {
+                // Update layer_height_profile from the main thread as it may pull the data from the associated ModelObject.
+                // Only update if the slicing was not finished yet.
+                (*o)->update_layer_height_profile();
+            }
+        }
     }
     
     return invalidated;

xs/src/libslic3r/Print.hpp

@@ -85,7 +85,13 @@ public:
 
     // Profile of increasing z to a layer height, to be linearly interpolated when calculating the layers.
     // The pairs of <z, layer_height> are packed into a 1D array to simplify handling by the Perl XS.
+    // layer_height_profile must not be set by the background thread.
     std::vector<coordf_t> layer_height_profile;
+    // There is a layer_height_profile at both PrintObject and ModelObject. The layer_height_profile at the ModelObject
+    // is used for interactive editing and for loading / storing into a project file (AMF file as of today).
+    // This flag indicates that the layer_height_profile at the UI has been updated, therefore the backend needs to get it.
+    // This flag is necessary as we cannot safely clear the layer_height_profile if the background calculation is running.
+    bool                  layer_height_profile_valid;
     
     // this is set to true when LayerRegion->slices is split in top/internal/bottom
     // so that next call to make_perimeters() performs a union() before computing loops
@@ -145,10 +151,16 @@ public:
     bool invalidate_step(PrintObjectStep step);
     bool invalidate_all_steps();
 
+    // To be used over the layer_height_profile of both the PrintObject and ModelObject
+    // to initialize the height profile with the height ranges.
+    bool update_layer_height_profile(std::vector<coordf_t> &layer_height_profile) const;
+
     // Process layer_height_ranges, the raft layers and first layer thickness into layer_height_profile.
     // The layer_height_profile may be later modified interactively by the user to refine layers at sloping surfaces.
     bool update_layer_height_profile();
 
+    void reset_layer_height_profile();
+
     // Collect the slicing parameters, to be used by variable layer thickness algorithm,
     // by the interactive layer height editor and by the printing process itself.
     // The slicing parameters are dependent on various configuration values

xs/src/libslic3r/PrintObject.cpp

@@ -29,7 +29,8 @@ namespace Slic3r {
 PrintObject::PrintObject(Print* print, ModelObject* model_object, const BoundingBoxf3 &modobj_bbox)
 :   typed_slices(false),
     _print(print),
-    _model_object(model_object)
+    _model_object(model_object),
+    layer_height_profile_valid(false)
 {
     // Compute the translation to be applied to our meshes so that we work with smaller coordinates
     {
@@ -216,8 +217,11 @@ PrintObject::invalidate_state_by_config_options(const std::vector<t_config_optio
             steps.insert(posPerimeters);
         } else if (*opt_key == "layer_height"
             || *opt_key == "first_layer_height"
-            || *opt_key == "xy_size_compensation"
             || *opt_key == "raft_layers") {
+            steps.insert(posSlice);
+			this->reset_layer_height_profile();
+		}
+		else if (*opt_key == "xy_size_compensation") {
             steps.insert(posSlice);
         } else if (*opt_key == "support_material"
             || *opt_key == "support_material_angle"
@@ -283,7 +287,8 @@ PrintObject::invalidate_state_by_config_options(const std::vector<t_config_optio
             // these options only affect G-code export, so nothing to invalidate
         } else {
             // for legacy, if we can't handle this option let's invalidate all steps
-            return this->invalidate_all_steps();
+			this->reset_layer_height_profile();
+			return this->invalidate_all_steps();
         }
     }
     
@@ -950,21 +955,49 @@ SlicingParameters PrintObject::slicing_parameters() const
         unscale(this->size.z), this->print()->object_extruders());
 }
 
-bool PrintObject::update_layer_height_profile()
+bool PrintObject::update_layer_height_profile(std::vector<coordf_t> &layer_height_profile) const
 {
     bool updated = false;
-    if (this->layer_height_profile.empty()) {
+
+    // If the layer height profile is not set, try to use the one stored at the ModelObject.
+    if (layer_height_profile.empty() && layer_height_profile.data() != this->model_object()->layer_height_profile.data()) {
+        layer_height_profile = this->model_object()->layer_height_profile;
+        updated = true;
+    }
+
+    // Verify the layer_height_profile.
+    SlicingParameters slicing_params = this->slicing_parameters();
+    if (! layer_height_profile.empty() && 
+            // Must not be of even length.
+            ((layer_height_profile.size() & 1) != 0 || 
+            // Last entry must be at the top of the object.
+             std::abs(layer_height_profile[layer_height_profile.size() - 2] - slicing_params.object_print_z_height()) > 1e-3))
+        layer_height_profile.clear();
+
+    if (layer_height_profile.empty()) {
         if (0)
 //        if (this->layer_height_profile.empty())
-            this->layer_height_profile = layer_height_profile_adaptive(this->slicing_parameters(), this->layer_height_ranges,
+            layer_height_profile = layer_height_profile_adaptive(slicing_params, this->layer_height_ranges,
                 this->model_object()->volumes);
         else
-            this->layer_height_profile = layer_height_profile_from_ranges(this->slicing_parameters(), this->layer_height_ranges);
+            layer_height_profile = layer_height_profile_from_ranges(slicing_params, this->layer_height_ranges);
         updated = true;
     }
     return updated;
 }
 
+// This must be called from the main thread as it modifies the layer_height_profile.
+bool PrintObject::update_layer_height_profile()
+{
+    // If the layer height profile has been marked as invalid for some reason (modified at the UI level 
+    // or invalidated due to the slicing parameters), clear it now.
+    if (! this->layer_height_profile_valid) { 
+        this->layer_height_profile.clear();
+        this->layer_height_profile_valid = true;
+    }
+    return this->update_layer_height_profile(this->layer_height_profile);
+}
+
 // 1) Decides Z positions of the layers,
 // 2) Initializes layers and their regions
 // 3) Slices the object meshes
@@ -1267,4 +1300,13 @@ void PrintObject::_generate_support_material()
     support_material.generate(*this);
 }
 
+void PrintObject::reset_layer_height_profile()
+{
+    // Reset the layer_heigth_profile.
+    this->layer_height_profile.clear();
+    // Reset the source layer_height_profile if it exists at the ModelObject.
+    this->model_object()->layer_height_profile.clear();
+    this->model_object()->layer_height_profile_valid = false;
+}
+
 } // namespace Slic3r

xs/src/libslic3r/Slicing.cpp

@@ -18,6 +18,26 @@
 namespace Slic3r
 {
 
+static const coordf_t MIN_LAYER_HEIGHT = 0.01;
+static const coordf_t MIN_LAYER_HEIGHT_DEFAULT = 0.05;
+
+// Minimum layer height for the variable layer height algorithm.
+inline coordf_t min_layer_height_from_nozzle(const PrintConfig &print_config, int idx_nozzle)
+{
+    coordf_t min_layer_height = print_config.min_layer_height.get_at(idx_nozzle - 1);
+    return (min_layer_height == 0.) ? MIN_LAYER_HEIGHT_DEFAULT : std::max(MIN_LAYER_HEIGHT, min_layer_height);
+}
+
+// Maximum layer height for the variable layer height algorithm, 3/4 of a nozzle dimaeter by default,
+// it should not be smaller than the minimum layer height.
+inline coordf_t max_layer_height_from_nozzle(const PrintConfig &print_config, int idx_nozzle)
+{
+    coordf_t min_layer_height = min_layer_height_from_nozzle(print_config, idx_nozzle);
+    coordf_t max_layer_height = print_config.max_layer_height.get_at(idx_nozzle - 1);
+    coordf_t nozzle_dmr       = print_config.nozzle_diameter.get_at(idx_nozzle - 1);
+    return std::max(min_layer_height, (max_layer_height == 0.) ? (0.75 * nozzle_dmr) : max_layer_height);
+}
+
 SlicingParameters SlicingParameters::create_from_config(
 	const PrintConfig 		&print_config, 
 	const PrintObjectConfig &object_config,
@@ -45,6 +65,31 @@ SlicingParameters SlicingParameters::create_from_config(
     params.base_raft_layers = object_config.raft_layers.value;
     params.soluble_interface = soluble_interface;
 
+    // Miniumum/maximum of the minimum layer height over all extruders.
+    params.min_layer_height = MIN_LAYER_HEIGHT;
+    params.max_layer_height = FLT_MAX;
+    if (object_config.support_material.value || params.base_raft_layers > 0) {
+        // Has some form of support. Add the support layers to the minimum / maximum layer height limits.
+        params.min_layer_height = std::max(
+            min_layer_height_from_nozzle(print_config, object_config.support_material_extruder), 
+            min_layer_height_from_nozzle(print_config, object_config.support_material_interface_extruder));
+        params.max_layer_height = std::min(
+            max_layer_height_from_nozzle(print_config, object_config.support_material_extruder), 
+            max_layer_height_from_nozzle(print_config, object_config.support_material_interface_extruder));
+        params.max_suport_layer_height = params.max_layer_height;
+    }
+    if (object_extruders.empty()) {
+        params.min_layer_height = std::max(params.min_layer_height, min_layer_height_from_nozzle(print_config, 0));
+        params.max_layer_height = std::min(params.max_layer_height, max_layer_height_from_nozzle(print_config, 0));
+    } else {
+        for (std::set<size_t>::const_iterator it_extruder = object_extruders.begin(); it_extruder != object_extruders.end(); ++ it_extruder) {
+            params.min_layer_height = std::max(params.min_layer_height, min_layer_height_from_nozzle(print_config, *it_extruder));
+            params.max_layer_height = std::min(params.max_layer_height, max_layer_height_from_nozzle(print_config, *it_extruder));
+        }
+    }
+    params.min_layer_height = std::min(params.min_layer_height, params.layer_height);
+    params.max_layer_height = std::max(params.max_layer_height, params.layer_height);
+
     if (! soluble_interface) {
         params.gap_raft_object    = object_config.support_material_contact_distance.value;
         params.gap_object_support = object_config.support_material_contact_distance.value;
@@ -101,12 +146,6 @@ SlicingParameters SlicingParameters::create_from_config(
         params.object_print_z_max += print_z;
     }
 
-    params.min_layer_height = std::min(params.layer_height, first_layer_height);
-    params.max_layer_height = std::max(params.layer_height, first_layer_height);
-
-    //FIXME add it to the print configuration
-    params.min_layer_height = 0.05;
-
     // Calculate the maximum layer height as 0.75 from the minimum nozzle diameter.
     if (! object_extruders.empty()) {
         coordf_t min_object_extruder_dmr = 1000000.;
@@ -306,6 +345,7 @@ void adjust_layer_height_profile(
         return;
 
 	assert(layer_height_profile.size() >= 2);
+    assert(std::abs(layer_height_profile[layer_height_profile.size() - 2] - slicing_params.object_print_z_height()) < EPSILON);
 
     // 1) Get the current layer thickness at z.
     coordf_t current_layer_height = slicing_params.layer_height;
@@ -355,21 +395,21 @@ void adjust_layer_height_profile(
 	coordf_t lo = std::max(z_span_variable.first,  z - 0.5 * band_width);
 	coordf_t hi = std::min(z_span_variable.second, z + 0.5 * band_width);
     coordf_t z_step = 0.1;
-    size_t i = 0;
-    while (i < layer_height_profile.size() && layer_height_profile[i] < lo)
-        i += 2;
-    i -= 2;
+    size_t idx = 0;
+    while (idx < layer_height_profile.size() && layer_height_profile[idx] < lo)
+        idx += 2;
+    idx -= 2;
 
     std::vector<double> profile_new;
     profile_new.reserve(layer_height_profile.size());
-	assert(i >= 0 && i + 1 < layer_height_profile.size());
-	profile_new.insert(profile_new.end(), layer_height_profile.begin(), layer_height_profile.begin() + i + 2);
+	assert(idx >= 0 && idx + 1 < layer_height_profile.size());
+	profile_new.insert(profile_new.end(), layer_height_profile.begin(), layer_height_profile.begin() + idx + 2);
     coordf_t zz = lo;
     size_t i_resampled_start = profile_new.size();
     while (zz < hi) {
-        size_t next = i + 2;
-        coordf_t z1 = layer_height_profile[i];
-        coordf_t h1 = layer_height_profile[i + 1];
+        size_t next = idx + 2;
+        coordf_t z1 = layer_height_profile[idx];
+        coordf_t h1 = layer_height_profile[idx + 1];
         coordf_t height = h1;
         if (next < layer_height_profile.size()) {
             coordf_t z2 = layer_height_profile[next];
@@ -409,22 +449,23 @@ void adjust_layer_height_profile(
             profile_new.push_back(clamp(slicing_params.min_layer_height, slicing_params.max_layer_height, height));
         }
         zz += z_step;
-        i = next;
-        while (i < layer_height_profile.size() && layer_height_profile[i] < zz)
-            i += 2;
-        i -= 2;
+        idx = next;
+        while (idx < layer_height_profile.size() && layer_height_profile[idx] < zz)
+            idx += 2;
+        idx -= 2;
     }
 
-    i += 2;
-    assert(i > 0);
+    idx += 2;
+    assert(idx > 0);
     size_t i_resampled_end = profile_new.size();
-	if (i < layer_height_profile.size()) {
-        assert(zz >= layer_height_profile[i - 2]);
-        assert(zz <= layer_height_profile[i]);
-//        profile_new.push_back(zz);
-//        profile_new.push_back(layer_height_profile[i + 1]);
-		profile_new.insert(profile_new.end(), layer_height_profile.begin() + i, layer_height_profile.end());
-    }
+	if (idx < layer_height_profile.size()) {
+        assert(zz >= layer_height_profile[idx - 2]);
+        assert(zz <= layer_height_profile[idx]);
+		profile_new.insert(profile_new.end(), layer_height_profile.begin() + idx, layer_height_profile.end());
+	}
+	else if (profile_new[profile_new.size() - 2] + 0.5 * EPSILON < slicing_params.object_print_z_height()) {
+		profile_new.insert(profile_new.end(), layer_height_profile.end() - 2, layer_height_profile.end());
+	}
     layer_height_profile = std::move(profile_new);
 
     if (action == LAYER_HEIGHT_EDIT_ACTION_SMOOTH) {
@@ -448,6 +489,7 @@ void adjust_layer_height_profile(
 	assert(layer_height_profile.size() > 2);
 	assert(layer_height_profile.size() % 2 == 0);
 	assert(layer_height_profile[0] == 0.);
+    assert(std::abs(layer_height_profile[layer_height_profile.size() - 2] - slicing_params.object_print_z_height()) < EPSILON);
 #ifdef _DEBUG
 	for (size_t i = 2; i < layer_height_profile.size(); i += 2)
 		assert(layer_height_profile[i - 2] <= layer_height_profile[i]);
@@ -601,7 +643,7 @@ int generate_layer_height_texture(
                 const Point3 &color2 = palette_raw[idx2];
 
                 coordf_t z = cell_to_z1 * coordf_t(cell);
-                assert(z >= lo && z <= hi);
+                assert(z >= lo - EPSILON && z <= hi + EPSILON);
 
                 // Color mapping from layer height to RGB.
                 Pointf3 color(

xs/src/libslic3r/Slicing.hpp

@@ -52,6 +52,11 @@ struct SlicingParameters
 	// The regular layer height, applied for all but the first layer, if not overridden by layer ranges
 	// or by the variable layer thickness table.
     coordf_t    layer_height;
+    // Minimum / maximum layer height, to be used for the automatic adaptive layer height algorithm,
+    // or by an interactive layer height editor.
+    coordf_t    min_layer_height;
+    coordf_t    max_layer_height;
+    coordf_t    max_suport_layer_height;
 
     // First layer height of the print, this may be used for the first layer of the raft
     // or for the first layer of the print.
@@ -75,11 +80,6 @@ struct SlicingParameters
     // Gap when placing object over support.
     coordf_t    gap_support_object;
 
-    // Minimum / maximum layer height, to be used for the automatic adaptive layer height algorithm,
-    // or by an interactive layer height editor.
-    coordf_t    min_layer_height;
-    coordf_t    max_layer_height;
-
     // Bottom and top of the printed object.
     // If printed without a raft, object_print_z_min = 0 and object_print_z_max = object height.
     // Otherwise object_print_z_min is equal to the raft height.