wip

src/libslic3r/Print.hpp

@@ -11,6 +11,7 @@
 #include "TriangleMeshSlicer.hpp"
 #include "GCode/ToolOrdering.hpp"
 #include "GCode/WipeTower.hpp"
+#include "GCode/WipeTower2.hpp"
 #include "GCode/ThumbnailData.hpp"
 #include "GCode/GCodeProcessor.hpp"
 #include "MultiMaterialSegmentation.hpp"
@@ -545,7 +546,10 @@ struct FakeWipeTower
     float height;
     float layer_height;
     float depth;
+    std::vector<std::pair<float, float>> z_and_depth_pairs;
     float brim_width;
+    float rotation_angle;
+    float cone_angle;
     Vec2d plate_origin;
 
     void set_fake_extrusion_data(Vec2f p, float w, float h, float lh, float d, float bd, Vec2d o)
@@ -558,8 +562,21 @@ struct FakeWipeTower
         brim_width   = bd;
         plate_origin = o;
     }
-
+    void set_fake_extrusion_data(const Vec2f& p, float w, float h, float lh, float d, const std::vector<std::pair<float, float>>& zad, float bd, float ra, float ca, const Vec2d& o)
+    {
+        pos = p;
+        width = w;
+        height = h;
+        layer_height = lh;
+        depth = d;
+        z_and_depth_pairs = zad;
+        brim_width = bd;
+        rotation_angle = ra;
+        cone_angle = ca;
+        plate_origin = o;
+    }
     void set_pos(Vec2f p) { pos = p; }
+    void set_pos_and_rotation(const Vec2f& p, float rotation) { pos = p; rotation_angle = rotation; }
 
     std::vector<ExtrusionPaths> getFakeExtrusionPathsFromWipeTower() const
     {
@@ -587,6 +604,82 @@ struct FakeWipeTower
         }
         return paths;
     }
+
+    std::vector<ExtrusionPaths> getFakeExtrusionPathsFromWipeTower2() const
+    {
+        float h = height;
+        float lh = layer_height;
+        int   d = scale_(depth);
+        int   w = scale_(width);
+        int   bd = scale_(brim_width);
+        Point minCorner = { -bd, -bd };
+        Point maxCorner = { minCorner.x() + w + bd, minCorner.y() + d + bd };
+
+        const auto [cone_base_R, cone_scale_x] = WipeTower2::get_wipe_tower_cone_base(width, height, depth, cone_angle);
+
+        std::vector<ExtrusionPaths> paths;
+        for (float hh = 0.f; hh < h; hh += lh) {
+            
+            if (hh != 0.f) {
+                // The wipe tower may be getting smaller. Find the depth for this layer.
+                size_t i = 0;
+                for (i=0; i<z_and_depth_pairs.size()-1; ++i)
+                    if (hh >= z_and_depth_pairs[i].first && hh < z_and_depth_pairs[i+1].first)
+                        break;
+                d = scale_(z_and_depth_pairs[i].second);
+                minCorner = {0.f, -d/2 + scale_(z_and_depth_pairs.front().second/2.f)};
+                maxCorner = { minCorner.x() + w, minCorner.y() + d };
+            }
+
+
+            ExtrusionPath path(ExtrusionRole::erWipeTower, 0.0, 0.0, lh);
+            path.polyline = { minCorner, {maxCorner.x(), minCorner.y()}, maxCorner, {minCorner.x(), maxCorner.y()}, minCorner };
+            paths.push_back({ path });
+
+            // We added the border, now add several parallel lines so we can detect an object that is fully inside the tower.
+            // For now, simply use fixed spacing of 3mm.
+            for (coord_t y=minCorner.y()+scale_(3.); y<maxCorner.y(); y+=scale_(3.)) {
+                path.polyline = { {minCorner.x(), y}, {maxCorner.x(), y} };
+                paths.back().emplace_back(path);
+            }
+
+            // And of course the stabilization cone and its base...
+            if (cone_base_R > 0.) {
+                path.polyline.clear();
+                double r = cone_base_R * (1 - hh/height);
+                for (double alpha=0; alpha<2.01*M_PI; alpha+=2*M_PI/20.)
+                    path.polyline.points.emplace_back(Point::new_scale(width/2. + r * std::cos(alpha)/cone_scale_x, depth/2. + r * std::sin(alpha)));
+                paths.back().emplace_back(path);
+                if (hh == 0.f) { // Cone brim.
+                    for (float bw=brim_width; bw>0.f; bw-=3.f) {
+                        path.polyline.clear();
+                        for (double alpha=0; alpha<2.01*M_PI; alpha+=2*M_PI/20.) // see load_wipe_tower_preview, where the same is a bit clearer
+                            path.polyline.points.emplace_back(Point::new_scale(
+                                width/2. + cone_base_R * std::cos(alpha)/cone_scale_x * (1. + cone_scale_x*bw/cone_base_R),
+                                depth/2. + cone_base_R * std::sin(alpha) * (1. + bw/cone_base_R))
+                            );
+                        paths.back().emplace_back(path);
+                    }
+                }
+            }
+
+            // Only the first layer has brim.
+            if (hh == 0.f) {
+                minCorner = minCorner + Point(bd, bd);
+                maxCorner = maxCorner - Point(bd, bd);
+            }
+        }
+
+        // Rotate and translate the tower into the final position.
+        for (ExtrusionPaths& ps : paths) {
+            for (ExtrusionPath& p : ps) {
+                p.polyline.rotate(Geometry::deg2rad(rotation_angle));
+                p.polyline.translate(scale_(pos.x()), scale_(pos.y()));
+            }
+        }
+
+        return paths;
+    }
 };
 
 struct WipeTowerData
@@ -604,7 +697,9 @@ struct WipeTowerData
 
     // Depth of the wipe tower to pass to GLCanvas3D for exact bounding box:
     float                                                 depth;
+    std::vector<std::pair<float, float>>                  z_and_depth_pairs;
     float                                                 brim_width;
+    float                                                 height;
 
     void clear() {
         priming.reset(nullptr);
@@ -617,7 +712,7 @@ struct WipeTowerData
     }
 
 private:
-	// Only allow the WipeTowerData to be instantiated internally by Print,
+	// Only allow the WipeTowerData to be instantiated internally by Print, 
 	// as this WipeTowerData shares reference to Print::m_tool_ordering.
 	friend class Print;
 	WipeTowerData(ToolOrdering &tool_ordering) : tool_ordering(tool_ordering) { clear(); }