Add the full source of BambuStudio

using version 1.0.10

src/libslic3r/Circle.hpp

@@ -0,0 +1,135 @@
+#ifndef slic3r_Circle_hpp_
+#define slic3r_Circle_hpp_
+
+#include "Point.hpp"
+#include "Line.hpp"
+
+namespace Slic3r {
+
+constexpr double ZERO_TOLERANCE = 0.000005;
+
+class Circle {
+public:
+    Circle() {
+        center = Point(0,0);
+        radius = 0;
+    }
+    Circle(Point &p, double r) {
+        center = p;
+        radius = r;
+    }
+    Point center;
+    double radius;
+
+    Point get_closest_point(const Point& input) {
+        Vec2d v = (input - center).cast<double>().normalized();
+        return (center + (v * radius).cast<coord_t>());
+    }
+
+    static bool try_create_circle(const Point &p1, const Point &p2, const Point &p3, const double max_radius, Circle& new_circle);
+    static bool try_create_circle(const Points& points, const double max_radius, const double tolerance, Circle& new_circle);
+    double get_polar_radians(const Point& p1) const;
+    bool is_over_deviation(const Points& points, const double tolerance);
+    bool get_deviation_sum_squared(const Points& points, const double tolerance, double& sum_deviation);
+
+    //BBS: only support calculate on X-Y plane, Z is useless
+    static Vec3f calc_tangential_vector(const Vec3f& pos, const Vec3f& center_pos, const bool is_ccw);
+    static bool get_closest_perpendicular_point(const Point& p1, const Point& p2, const Point& c, Point& out);
+    static bool is_equal(double x, double y, double tolerance = ZERO_TOLERANCE) {
+        double abs_difference = std::fabs(x - y);
+        return abs_difference < tolerance;
+    };
+    static bool greater_than(double x, double y, double tolerance = ZERO_TOLERANCE) {
+        return x > y && !Circle::is_equal(x, y, tolerance);
+    };
+    static bool greater_than_or_equal(double x, double y, double tolerance = ZERO_TOLERANCE) {
+        return x > y || Circle::is_equal(x, y, tolerance);
+    };
+    static bool less_than(double x, double y, double tolerance = ZERO_TOLERANCE) {
+        return x < y && !Circle::is_equal(x, y, tolerance);
+    };
+    static bool less_than_or_equal(double x, double y, double tolerance = ZERO_TOLERANCE){
+        return x < y || Circle::is_equal(x, y, tolerance);
+    };
+
+};
+
+enum class ArcDirection : unsigned char {
+    Arc_Dir_unknow,
+    Arc_Dir_CCW,
+    Arc_Dir_CW,
+    Count
+};
+
+#define DEFAULT_SCALED_MAX_RADIUS scale_(2000)        // 2000mm
+#define DEFAULT_SCALED_RESOLUTION scale_(0.05)        // 0.05mm
+#define DEFAULT_ARC_LENGTH_PERCENT_TOLERANCE  0.05    // 5 percent
+
+class ArcSegment: public Circle {
+public:
+    ArcSegment(): Circle() {}
+    ArcSegment(Point center, double radius, Point start, Point end, ArcDirection dir) :
+        Circle(center, radius),
+        start_point(start),
+        end_point(end),
+        direction(dir) {
+        if (radius == 0.0 ||
+            start_point == center ||
+            end_point == center ||
+            start_point == end_point) {
+            is_arc = false;
+            return;
+        }
+        update_angle_and_length();
+        is_arc = true;
+    }
+
+    bool is_arc = false;
+    double length = 0;
+    double angle_radians = 0;
+    double polar_start_theta = 0;
+    double polar_end_theta = 0;
+    Point start_point { Point(0,0) };
+    Point end_point{ Point(0,0) };
+    ArcDirection direction = ArcDirection::Arc_Dir_unknow;
+
+    bool is_valid() const { return is_arc; }
+    bool clip_start(const Point& point);
+    bool clip_end(const Point& point);
+    bool reverse();
+    bool split_at(const Point& point, ArcSegment& p1, ArcSegment& p2);
+    bool is_point_inside(const Point& point) const;
+
+private:
+    void update_angle_and_length();
+
+public:
+    static bool try_create_arc(
+        const Points &points,
+        ArcSegment& target_arc,
+        double approximate_length,
+        double max_radius = DEFAULT_SCALED_MAX_RADIUS,
+        double tolerance = DEFAULT_SCALED_RESOLUTION,
+        double path_tolerance_percent = DEFAULT_ARC_LENGTH_PERCENT_TOLERANCE);
+
+    static bool are_points_within_slice(const ArcSegment& test_arc, const Points &points);
+    // BBS: this function is used to detect whether a ray cross the segment
+    static bool ray_intersects_segment(const Point& rayOrigin, const Vec2d& rayDirection, const Line& segment);
+    // BBS: these three functions are used to calculate related arguments of arc in unscale_field.
+    static float calc_arc_radian(Vec3f start_pos, Vec3f end_pos, Vec3f center_pos, bool is_ccw);
+    static float calc_arc_radius(Vec3f start_pos, Vec3f center_pos);
+    static float calc_arc_length(Vec3f start_pos, Vec3f end_pos, Vec3f center_pos, bool is_ccw);
+private:
+    static bool try_create_arc(
+        const Circle& c,
+        const Point& start_point,
+        const Point& mid_point,
+        const Point& end_point,
+        ArcSegment& target_arc,
+        double approximate_length,
+        double path_tolerance_percent = DEFAULT_ARC_LENGTH_PERCENT_TOLERANCE);
+};
+
+}
+
+#endif