Limit the object movement to the vincinity of the print bed.

7 files changed, 93 insertions, 3 deletions

diff --git a/xs/src/libslic3r/Line.hpp b/xs/src/libslic3r/Line.hpp
index 6c40b062f..99e1f4070 100644
--- a/xs/src/libslic3r/Line.hpp
+++ b/xs/src/libslic3r/Line.hpp
@@ -15,7 +15,7 @@ typedef std::vector<ThickLine> ThickLines;
 
 class Line
 {
-    public:
+public:
     Point a;
     Point b;
     Line() {};
diff --git a/xs/src/libslic3r/MultiPoint.cpp b/xs/src/libslic3r/MultiPoint.cpp
index 8b181d7bb..a1bc2140d 100644
--- a/xs/src/libslic3r/MultiPoint.cpp
+++ b/xs/src/libslic3r/MultiPoint.cpp
@@ -140,6 +140,29 @@ MultiPoint::intersection(const Line& line, Point* intersection) const
     return false;
 }
 
+bool MultiPoint::first_intersection(const Line& line, Point* intersection) const
+{
+    bool   found = false;
+    double dmin  = 0.;
+    for (const Line &l : this->lines()) {
+        Point ip;
+        if (l.intersection(line, &ip)) {
+            if (! found) {
+                found = true;
+                dmin = ip.distance_to(line.a);
+                *intersection = ip;
+            } else {
+                double d = ip.distance_to(line.a);
+                if (d < dmin) {
+                    dmin = d;
+                    *intersection = ip;
+                }
+            }
+        }
+    }
+    return found;
+}
+
 std::string
 MultiPoint::dump_perl() const
 {
diff --git a/xs/src/libslic3r/MultiPoint.hpp b/xs/src/libslic3r/MultiPoint.hpp
index b7a190ebf..c49a673fe 100644
--- a/xs/src/libslic3r/MultiPoint.hpp
+++ b/xs/src/libslic3r/MultiPoint.hpp
@@ -13,7 +13,7 @@ class BoundingBox;
 
 class MultiPoint
 {
-    public:
+public:
     Points points;
     
     operator Points() const;
@@ -35,8 +35,24 @@ class MultiPoint
     double length() const;
     bool is_valid() const { return this->points.size() >= 2; }
 
-    int find_point(const Point &point) const;
+    int  find_point(const Point &point) const;
     bool has_boundary_point(const Point &point) const;
+    int  closest_point_index(const Point &point) const {
+        int idx = -1;
+        if (! this->points.empty()) {
+            idx = 0;
+            double dist_min = this->points.front().distance_to(point);
+            for (int i = 1; i < int(this->points.size()); ++ i) {
+                double d = this->points[i].distance_to(point);
+                if (d < dist_min) {
+                    dist_min = d;
+                    idx = i;
+                }
+            }
+        }
+        return idx;
+    }
+    const Point* closest_point(const Point &point) const { return this->points.empty() ? nullptr : &this->points[this->closest_point_index(point)]; }
     BoundingBox bounding_box() const;
     // Return true if there are exact duplicates.
     bool has_duplicate_points() const;
@@ -56,6 +72,7 @@ class MultiPoint
     }
 
     bool intersection(const Line& line, Point* intersection) const;
+    bool first_intersection(const Line& line, Point* intersection) const;
     std::string dump_perl() const;
     
     static Points _douglas_peucker(const Points &points, const double tolerance);
diff --git a/xs/src/libslic3r/Polygon.cpp b/xs/src/libslic3r/Polygon.cpp
index 60ccd792d..27f9a2ca1 100644
--- a/xs/src/libslic3r/Polygon.cpp
+++ b/xs/src/libslic3r/Polygon.cpp
@@ -293,6 +293,44 @@ Polygon::convex_points(double angle) const
     return points;
 }
 
+// Projection of a point onto the polygon.
+Point Polygon::point_projection(const Point &point) const
+{
+    Point proj = point;
+    double dmin = std::numeric_limits<double>::max();
+    if (! this->points.empty()) {
+        for (size_t i = 0; i < this->points.size(); ++ i) {
+            const Point &pt0 = this->points[i];
+            const Point &pt1 = this->points[(i + 1 == this->points.size()) ? 0 : i + 1];
+            double d = pt0.distance_to(point);
+            if (d < dmin) {
+                dmin = d;
+                proj = pt0;
+            }
+            d = pt1.distance_to(point);
+            if (d < dmin) {
+                dmin = d;
+                proj = pt1;
+            }
+            Pointf v1(coordf_t(pt1.x - pt0.x), coordf_t(pt1.y - pt0.y));
+            coordf_t div = dot(v1);
+            if (div > 0.) {
+                Pointf v2(coordf_t(point.x - pt0.x), coordf_t(point.y - pt0.y));
+                coordf_t t = dot(v1, v2) / div;
+                if (t > 0. && t < 1.) {
+                    Point foot(coord_t(floor(coordf_t(pt0.x) + t * v1.x + 0.5)), coord_t(floor(coordf_t(pt0.y) + t * v1.y + 0.5)));
+                    d = foot.distance_to(point);
+                    if (d < dmin) {
+                        dmin = d;
+                        proj = foot;
+                    }
+                }
+            }
+        }
+    }
+    return proj;
+}
+
 BoundingBox get_extents(const Polygon &poly) 
 { 
     return poly.bounding_box();
diff --git a/xs/src/libslic3r/Polygon.hpp b/xs/src/libslic3r/Polygon.hpp
index a938492ed..65f0b1400 100644
--- a/xs/src/libslic3r/Polygon.hpp
+++ b/xs/src/libslic3r/Polygon.hpp
@@ -51,6 +51,8 @@ public:
     std::string wkt() const;
     Points concave_points(double angle = PI) const;
     Points convex_points(double angle = PI) const;
+    // Projection of a point onto the polygon.
+    Point point_projection(const Point &point) const;
 };
 
 extern BoundingBox get_extents(const Polygon &poly);
diff --git a/xs/xsp/BoundingBox.xsp b/xs/xsp/BoundingBox.xsp
index aec5be564..a326c7501 100644
--- a/xs/xsp/BoundingBox.xsp
+++ b/xs/xsp/BoundingBox.xsp
@@ -95,6 +95,8 @@ new_from_points(CLASS, points)
     void merge_point(Pointf3* point) %code{% THIS->merge(*point); %};
     void scale(double factor);
     void translate(double x, double y, double z);
+    void offset(double delta);
+    bool contains_point(Pointf3* point) %code{% RETVAL = THIS->contains(*point); %};
     Clone<Pointf3> size();
     Clone<Pointf3> center();
     double radius();
diff --git a/xs/xsp/Polygon.xsp b/xs/xsp/Polygon.xsp
index f569a899d..f5db9f515 100644
--- a/xs/xsp/Polygon.xsp
+++ b/xs/xsp/Polygon.xsp
@@ -42,12 +42,20 @@
     std::string wkt();
     Points concave_points(double angle);
     Points convex_points(double angle);
+    Clone<Point> point_projection(Point* point)
+        %code{% RETVAL = THIS->point_projection(*point); %};
     Clone<Point> intersection(Line* line)
         %code{%
             Point p;
             (void)THIS->intersection(*line, &p);
             RETVAL = p;
         %};
+    Clone<Point> first_intersection(Line* line)
+        %code{%
+            Point p;
+            (void)THIS->first_intersection(*line, &p);
+            RETVAL = p;
+        %};
 %{
 
 Polygon*