Add the full source of BambuStudio

using version 1.0.10

src/libslic3r/GCode/SeamPlacer.hpp

@@ -0,0 +1,134 @@
+#ifndef libslic3r_SeamPlacer_hpp_
+#define libslic3r_SeamPlacer_hpp_
+
+#include <optional>
+#include <vector>
+
+#include "libslic3r/ExtrusionEntity.hpp"
+#include "libslic3r/Polygon.hpp"
+#include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/BoundingBox.hpp"
+#include "libslic3r/AABBTreeIndirect.hpp"
+
+namespace Slic3r {
+
+class PrintObject;
+class ExtrusionLoop;
+class Print;
+class Layer;
+namespace EdgeGrid { class Grid; }
+
+
+class SeamHistory {
+public:
+    SeamHistory() { clear(); }
+    std::optional<Point> get_last_seam(const PrintObject* po, size_t layer_id, const BoundingBox& island_bb);
+    void add_seam(const PrintObject* po, const Point& pos, const BoundingBox& island_bb);
+    void clear();
+
+private:
+    struct SeamPoint {
+        Point m_pos;
+        BoundingBox m_island_bb;
+    };
+
+    std::map<const PrintObject*, std::vector<SeamPoint>> m_data_last_layer;
+    std::map<const PrintObject*, std::vector<SeamPoint>> m_data_this_layer;
+    size_t m_layer_id;
+};
+
+
+
+class SeamPlacer {
+public:
+    void init(const Print& print);
+
+    // When perimeters are printed, first call this function with the respective
+    // external perimeter. SeamPlacer will find a location for its seam and remember it.
+    // Subsequent calls to get_seam will return this position.
+
+
+    void plan_perimeters(const std::vector<const ExtrusionEntity*> perimeters,
+        const Layer& layer, SeamPosition seam_position,
+        Point last_pos, coordf_t nozzle_dmr, const PrintObject* po,
+        const EdgeGrid::Grid* lower_layer_edge_grid);
+
+    void place_seam(ExtrusionLoop& loop, const Point& last_pos, bool external_first, double nozzle_diameter,
+                    const EdgeGrid::Grid* lower_layer_edge_grid);
+    
+
+    using TreeType = AABBTreeIndirect::Tree<2, coord_t>;
+    using AlignedBoxType = Eigen::AlignedBox<TreeType::CoordType, TreeType::NumDimensions>;
+
+private:
+
+    // When given an external perimeter (!), returns the seam.
+    Point calculate_seam(const Layer& layer, const SeamPosition seam_position,
+        const ExtrusionLoop& loop, coordf_t nozzle_dmr, const PrintObject* po,
+        const EdgeGrid::Grid* lower_layer_edge_grid, Point last_pos);
+
+    struct CustomTrianglesPerLayer {
+        Polygons polys;
+        TreeType tree;
+    };
+
+    // Just a cache to save some lookups.
+    const Layer* m_last_layer_po = nullptr;
+    coordf_t m_last_print_z = -1.;
+    const PrintObject* m_last_po = nullptr;
+
+    struct SeamPoint {
+        Point pt;
+        bool precalculated = false;
+        bool external = false;
+        const Layer* layer = nullptr;
+        SeamPosition seam_position;
+        const PrintObject* po = nullptr;
+    };
+    std::vector<SeamPoint> m_plan;
+    size_t m_plan_idx;
+
+    std::vector<std::vector<CustomTrianglesPerLayer>> m_enforcers;
+    std::vector<std::vector<CustomTrianglesPerLayer>> m_blockers;
+    std::vector<const PrintObject*> m_po_list;
+
+    //std::map<const PrintObject*, Point>  m_last_seam_position;
+    SeamHistory  m_seam_history;
+
+    // Get indices of points inside enforcers and blockers.
+    void get_enforcers_and_blockers(size_t layer_id,
+                                    const Polygon& polygon,
+                                    size_t po_id,
+                                    std::vector<size_t>& enforcers_idxs,
+                                    std::vector<size_t>& blockers_idxs) const;
+
+    // Apply penalties to points inside enforcers/blockers.
+    void apply_custom_seam(const Polygon& polygon, size_t po_id,
+                           std::vector<float>& penalties,
+                           const std::vector<float>& lengths,
+                           int layer_id, SeamPosition seam_position) const;
+
+    // Return random point of a polygon. The distribution will be uniform
+    // along the contour and account for enforcers and blockers.
+    Point get_random_seam(size_t layer_idx, const Polygon& polygon, size_t po_id,
+                          bool* saw_custom = nullptr) const;
+
+    // Is there any enforcer/blocker on this layer?
+    bool is_custom_seam_on_layer(size_t layer_id, size_t po_idx) const {
+        return is_custom_enforcer_on_layer(layer_id, po_idx)
+            || is_custom_blocker_on_layer(layer_id, po_idx);
+    }
+
+    bool is_custom_enforcer_on_layer(size_t layer_id, size_t po_idx) const {
+        return (! m_enforcers.at(po_idx).empty() && ! m_enforcers.at(po_idx)[layer_id].polys.empty());
+    }
+
+    bool is_custom_blocker_on_layer(size_t layer_id, size_t po_idx) const {
+        return (! m_blockers.at(po_idx).empty() && ! m_blockers.at(po_idx)[layer_id].polys.empty());
+    }
+};
+
+
+}
+
+#endif // libslic3r_SeamPlacer_hpp_