Merge branch 'master' into wipe_tower_improvements

xs/src/libslic3r/BoundingBox.cpp

@@ -222,6 +222,14 @@ BoundingBox3Base<PointClass>::center() const
 }
 template Pointf3 BoundingBox3Base<Pointf3>::center() const;
 
+template <class PointClass> coordf_t
+BoundingBox3Base<PointClass>::max_size() const
+{
+    PointClass s = size();
+    return std::max(s.x, std::max(s.y, s.z));
+}
+template coordf_t BoundingBox3Base<Pointf3>::max_size() const;
+
 // Align a coordinate to a grid. The coordinate may be negative,
 // the aligned value will never be bigger than the original one.
 static inline coord_t _align_to_grid(const coord_t coord, const coord_t spacing) {

xs/src/libslic3r/BoundingBox.hpp

@@ -94,6 +94,7 @@ public:
     void translate(const Pointf3 &pos) { this->translate(pos.x, pos.y, pos.z); }
     void offset(coordf_t delta);
     PointClass center() const;
+    coordf_t max_size() const;
 
     bool contains(const PointClass &point) const {
         return BoundingBoxBase<PointClass>::contains(point) && point.z >= this->min.z && point.z <= this->max.z;

xs/src/libslic3r/Format/3mf.cpp

@@ -1271,6 +1271,7 @@ namespace Slic3r {
         if ((std::abs(sx - sy) > 0.00001) || (std::abs(sx - sz) > 0.00001))
             return;
 
+#if 0 // use quaternions
         // rotations (extracted using quaternion)
         double inv_sx = 1.0 / sx;
         double inv_sy = 1.0 / sy;
@@ -1331,6 +1332,25 @@ namespace Slic3r {
             if (angle_z < 0.0)
                 angle_z += 2.0 * PI;
         }
+#else // use eigen library
+        double inv_sx = 1.0 / sx;
+        double inv_sy = 1.0 / sy;
+        double inv_sz = 1.0 / sz;
+
+        Eigen::Matrix3d m3x3;
+        m3x3 << (double)matrix(0, 0) * inv_sx, (double)matrix(0, 1) * inv_sy, (double)matrix(0, 2) * inv_sz,
+                (double)matrix(1, 0) * inv_sx, (double)matrix(1, 1) * inv_sy, (double)matrix(1, 2) * inv_sz,
+                (double)matrix(2, 0) * inv_sx, (double)matrix(2, 1) * inv_sy, (double)matrix(2, 2) * inv_sz;
+
+        Eigen::AngleAxisd rotation;
+        rotation.fromRotationMatrix(m3x3);
+
+        // invalid rotation axis, we currently handle only rotations around Z axis
+        if ((rotation.angle() != 0.0) && (rotation.axis() != Eigen::Vector3d::UnitZ()) && (rotation.axis() != -Eigen::Vector3d::UnitZ()))
+            return;
+
+        double angle_z = (rotation.axis() == Eigen::Vector3d::UnitZ()) ? rotation.angle() : -rotation.angle();
+#endif 
 
         instance.offset.x = offset_x;
         instance.offset.y = offset_y;

xs/src/libslic3r/Format/AMF.cpp

@@ -13,6 +13,9 @@
 
 #include <boost/filesystem/operations.hpp>
 #include <boost/algorithm/string.hpp>
+//############################################################################################################################################
+#include <boost/nowide/fstream.hpp>
+//############################################################################################################################################
 #include <miniz/miniz_zip.h>
 
 #if 0
@@ -666,10 +669,21 @@ bool load_amf_archive(const char *path, PresetBundle* bundle, Model *model)
 // If bundle is not a null pointer, updates it if the amf file/archive contains config data
 bool load_amf(const char *path, PresetBundle* bundle, Model *model)
 {
-    if (boost::iends_with(path, ".zip.amf"))
-        return load_amf_archive(path, bundle, model);
-    else if (boost::iends_with(path, ".amf") || boost::iends_with(path, ".amf.xml"))
+    if (boost::iends_with(path, ".amf.xml"))
+        // backward compatibility with older slic3r output
         return load_amf_file(path, bundle, model);
+    else if (boost::iends_with(path, ".amf"))
+    {
+        boost::nowide::ifstream file(path, boost::nowide::ifstream::binary);
+        if (!file.good())
+            return false;
+
+        std::string zip_mask(2, '\0');
+        file.read(const_cast<char*>(zip_mask.data()), 2);
+        file.close();
+
+        return (zip_mask == "PK") ? load_amf_archive(path, bundle, model) : load_amf_file(path, bundle, model);
+    }
     else
         return false;
 }

xs/src/libslic3r/GCode/WipeTowerPrusaMM.cpp

@@ -141,24 +141,21 @@ public:
 		}
 
 		m_gcode += "G1";
-		if (rot.x != rotated_current_pos.x) {
-			m_gcode += set_format_X(rot.x);     // Transform current position back to wipe tower coordinates (was updated by set_format_X)
-            m_current_pos.x = x;
-        }
-		if (rot.y != rotated_current_pos.y) {
+		if (std::abs(dx) > EPSILON)
+			m_gcode += set_format_X(rot.x);
+
+		if (std::abs(dy) > EPSILON)
 			m_gcode += set_format_Y(rot.y);
-            m_current_pos.y = y;
-        }
 
 		if (e != 0.f)
 			m_gcode += set_format_E(e);
 
 		if (f != 0.f && f != m_current_feedrate)
 			m_gcode += set_format_F(f);
-		
-		
-		
-		
+
+        m_current_pos.x = x;
+        m_current_pos.y = y;
+
 		// Update the elapsed time with a rough estimate.
 		m_elapsed_time += ((len == 0) ? std::abs(e) : len) / m_current_feedrate * 60.f;
 		m_gcode += "\n";

xs/src/libslic3r/Model.cpp

@@ -603,7 +603,10 @@ void ModelObject::clear_instances()
 
 // Returns the bounding box of the transformed instances.
 // This bounding box is approximate and not snug.
-const BoundingBoxf3& ModelObject::bounding_box()
+//========================================================================================================
+const BoundingBoxf3& ModelObject::bounding_box() const
+//const BoundingBoxf3& ModelObject::bounding_box()
+//========================================================================================================
 {
     if (! m_bounding_box_valid) {
         BoundingBoxf3 raw_bbox;

xs/src/libslic3r/Model.hpp

@@ -103,7 +103,10 @@ public:
     // Returns the bounding box of the transformed instances.
     // This bounding box is approximate and not snug.
     // This bounding box is being cached.
-    const BoundingBoxf3& bounding_box();
+//========================================================================================================
+    const BoundingBoxf3& bounding_box() const;
+//    const BoundingBoxf3& bounding_box();
+//========================================================================================================
     void invalidate_bounding_box() { m_bounding_box_valid = false; }
     // Returns a snug bounding box of the transformed instances.
     // This bounding box is not being cached.
@@ -145,8 +148,10 @@ private:
     // Parent object, owning this ModelObject.
     Model          *m_model;
     // Bounding box, cached.
-    BoundingBoxf3   m_bounding_box;
-    bool            m_bounding_box_valid;
+//========================================================================================================
+    mutable BoundingBoxf3 m_bounding_box;
+    mutable bool          m_bounding_box_valid;
+//========================================================================================================
 };
 
 // An object STL, or a modifier volume, over which a different set of parameters shall be applied.

xs/src/libslic3r/Point.hpp

@@ -238,6 +238,11 @@ inline coordf_t dot(const Pointf &v1, const Pointf &v2) { return v1.x * v2.x + v
 inline coordf_t dot(const Pointf &v) { return v.x * v.x + v.y * v.y; }
 inline double length(const Vectorf &v) { return sqrt(dot(v)); }
 inline double l2(const Vectorf &v) { return dot(v); }
+inline Vectorf normalize(const Vectorf& v)
+{
+    coordf_t len = ::sqrt(sqr(v.x) + sqr(v.y));
+    return (len != 0.0) ? 1.0 / len * v : Vectorf(0.0, 0.0);
+}
 
 class Pointf3 : public Pointf
 {

xs/src/libslic3r/Polygon.cpp

@@ -103,7 +103,7 @@ double Polygon::area() const
 
     double a = 0.;
     for (size_t i = 0, j = n - 1; i < n; ++i) {
-        a += double(points[j].x + points[i].x) * double(points[i].y - points[j].y);
+        a += ((double)points[j].x + (double)points[i].x) * ((double)points[i].y - (double)points[j].y);
         j = i;
     }
     return 0.5 * a;

xs/src/libslic3r/Print.hpp

@@ -185,6 +185,8 @@ public:
 
     void reset_layer_height_profile();
 
+    void adjust_layer_height_profile(coordf_t z, coordf_t layer_thickness_delta, coordf_t band_width, int action);
+
     // 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

@@ -4,6 +4,7 @@
 #include "Geometry.hpp"
 #include "SupportMaterial.hpp"
 #include "Surface.hpp"
+#include "Slicing.hpp"
 
 #include <utility>
 #include <boost/log/trivial.hpp>
@@ -1966,4 +1967,12 @@ void PrintObject::reset_layer_height_profile()
     this->model_object()->layer_height_profile_valid = false;
 }
 
+void PrintObject::adjust_layer_height_profile(coordf_t z, coordf_t layer_thickness_delta, coordf_t band_width, int action)
+{
+    update_layer_height_profile(_model_object->layer_height_profile);
+    Slic3r::adjust_layer_height_profile(slicing_parameters(), _model_object->layer_height_profile, z, layer_thickness_delta, band_width, LayerHeightEditActionType(action));
+    _model_object->layer_height_profile_valid = true;
+    layer_height_profile_valid = false;
+}
+
 } // namespace Slic3r

xs/src/libslic3r/Utils.hpp

@@ -91,10 +91,13 @@ public:
     ~PerlCallback() { this->deregister_callback(); }
     void register_callback(void *sv);
     void deregister_callback();
-    void call();
-    void call(int i);
-    void call(int i, int j);
-//    void call(const std::vector<int> &ints);
+    void call() const;
+    void call(int i) const;
+    void call(int i, int j) const;
+    void call(const std::vector<int>& ints) const;
+    void call(double d) const;
+    void call(double x, double y) const;
+    void call(bool b) const;
 private:
     void *m_callback;
 };

xs/src/libslic3r/utils.cpp

@@ -184,7 +184,7 @@ void PerlCallback::deregister_callback()
 	}
 }
 
-void PerlCallback::call()
+void PerlCallback::call() const
 {
     if (! m_callback)
         return;
@@ -198,7 +198,7 @@ void PerlCallback::call()
     LEAVE;
 }
 
-void PerlCallback::call(int i)
+void PerlCallback::call(int i) const
 {
     if (! m_callback)
         return;
@@ -213,7 +213,7 @@ void PerlCallback::call(int i)
     LEAVE;
 }
 
-void PerlCallback::call(int i, int j)
+void PerlCallback::call(int i, int j) const
 {
     if (! m_callback)
         return;
@@ -229,8 +229,7 @@ void PerlCallback::call(int i, int j)
     LEAVE;
 }
 
-/*
-void PerlCallback::call(const std::vector<int> &ints)
+void PerlCallback::call(const std::vector<int>& ints) const
 {
     if (! m_callback)
         return;
@@ -238,16 +237,51 @@ void PerlCallback::call(const std::vector<int> &ints)
     ENTER;
     SAVETMPS;
     PUSHMARK(SP);
-    AV* av = newAV();
     for (int i : ints)
-        av_push(av, newSViv(i));
-    XPUSHs(av);
+    {
+        XPUSHs(sv_2mortal(newSViv(i)));
+    }
     PUTBACK;
     perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
     FREETMPS;
     LEAVE;
 }
-*/
+
+void PerlCallback::call(double d) const
+{
+    if (!m_callback)
+        return;
+    dSP;
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(SP);
+    XPUSHs(sv_2mortal(newSVnv(d)));
+    PUTBACK;
+    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
+    FREETMPS;
+    LEAVE;
+}
+
+void PerlCallback::call(double x, double y) const
+{
+    if (!m_callback)
+        return;
+    dSP;
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(SP);
+    XPUSHs(sv_2mortal(newSVnv(x)));
+    XPUSHs(sv_2mortal(newSVnv(y)));
+    PUTBACK;
+    perl_call_sv(SvRV((SV*)m_callback), G_DISCARD);
+    FREETMPS;
+    LEAVE;
+}
+
+void PerlCallback::call(bool b) const
+{
+    call(b ? 1 : 0);
+}
 
 #ifdef WIN32
     #ifndef NOMINMAX