Slic3r::Circle Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Circle.hpp>

Inheritance diagram for Slic3r::Circle:

Collaboration diagram for Slic3r::Circle:

Public Member Functions
	Circle ()
	Circle (Point &p, double r)
Point	get_closest_point (const Point &input)
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)

Static Public Member Functions
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)
static bool	try_create_circle (const Points3 &points, const double max_radius, const double tolerance, Circle &new_circle)
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)
static bool	greater_than (double x, double y, double tolerance=ZERO_TOLERANCE)
static bool	greater_than_or_equal (double x, double y, double tolerance=ZERO_TOLERANCE)
static bool	less_than (double x, double y, double tolerance=ZERO_TOLERANCE)
static bool	less_than_or_equal (double x, double y, double tolerance=ZERO_TOLERANCE)

Public Attributes
Point	center
double	radius

Detailed Description

Constructor & Destructor Documentation

Circle() [1/2]

Slic3r::Circle::Circle ( )

inline

             {
        center = Point(0,0);
        radius = 0;
    }

References center, and radius.

Referenced by Slic3r::ArcSegment::ArcSegment(), Slic3r::ArcSegment::ArcSegment(), Slic3r::ArcSegment::try_create_arc(), Slic3r::ArcSegment::try_create_arc(), Slic3r::ArcSegment::try_create_arc(), try_create_circle(), try_create_circle(), and try_create_circle().

Here is the caller graph for this function:

Circle() [2/2]

Slic3r::Circle::Circle ( Point & p, double r )

inline

                               {
        center = p;
        radius = r;
    }

References center, and radius.

Member Function Documentation

calc_tangential_vector()

Vec3f Slic3r::Circle::calc_tangential_vector ( const Vec3f & pos, const Vec3f & center_pos, const bool is_ccw )

static

{
    Vec3f dir = center_pos - pos;
    dir(2,0) = 0;
    dir.normalize();
    Vec3f res;
    if (is_ccw)
        res = { dir(1, 0), -dir(0, 0), 0.0f };
    else
        res = { -dir(1, 0), dir(0, 0), 0.0f };
    return res;
}

References Slic3r::Geometry::is_ccw().

Here is the call graph for this function:

get_closest_perpendicular_point()

bool Slic3r::Circle::get_closest_perpendicular_point ( const Point & p1, const Point & p2, const Point & c, Point & out )

static

{
    double x1 = p1.x();
    double y1 = p1.y();
    double x2 = p2.x();
    double y2 = p2.y();
    double x_dif = x2 - x1;
    double y_dif = y2 - y1;
    //BBS: [(Cx - Ax)(Bx - Ax) + (Cy - Ay)(By - Ay)] / [(Bx - Ax) ^ 2 + (By - Ay) ^ 2]
    double num = (c[0] - x1) * x_dif + (c[1] - y1) * y_dif;
    double denom = (x_dif * x_dif) + (y_dif * y_dif);
    double t = num / denom;
 
    //BBS: Considering this a failure if t == 0 or t==1 within tolerance.  In that case we hit the endpoint, which is OK.
    if (Circle::less_than_or_equal(t, 0) || Circle::greater_than_or_equal(t, 1))
        return false;
 
    out[0] = x1 + t * (x2 - x1);
    out[1] = y1 + t * (y2 - y1);
    return true;
}

References greater_than_or_equal(), and less_than_or_equal().

Referenced by get_deviation_sum_squared(), and is_over_deviation().

Here is the call graph for this function:

Here is the caller graph for this function:

get_closest_point()

Point Slic3r::Circle::get_closest_point ( const Point & input )

inline

                                                {
        Vec2d v = (input - center).cast<double>().normalized();
        return (center + (v * radius).cast<coord_t>());
    }

References Slic3r::cast(), center, and radius.

Referenced by Slic3r::ArcSegment::clip_end(), Slic3r::ArcSegment::clip_start(), and Slic3r::ArcSegment::split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

get_deviation_sum_squared()

bool Slic3r::Circle::get_deviation_sum_squared	(	const Points &	points,
		const double	tolerance,
		double &	sum_deviation )

{
    total_deviation = 0;
    Point temp;
    double distance_from_center,  deviation;
    // BBS: skip the first and last points since they are on the circle
    for (int index = 1; index < points.size() - 1; index++)
    {
        //BBS: make sure the length from the center of our circle to the test point is 
        // at or below our max distance.
        temp = points[index] - center;
        distance_from_center = sqrt((double)temp.x() * (double)temp.x() + (double)temp.y() * (double)temp.y());
        deviation = std::fabs(distance_from_center - radius);
        total_deviation += deviation * deviation;
        if (deviation > tolerance)
            return false;
 
    }
    Point closest_point;
    //BBS: check the point perpendicular from the segment to the circle's center
    for (int index = 0; index < points.size() - 1; index++)
    {
        if (get_closest_perpendicular_point(points[index], points[(size_t)index + 1], center, closest_point)) {
            temp = closest_point - center;
            distance_from_center = sqrt((double)temp.x() * (double)temp.x() + (double)temp.y() * (double)temp.y());
            deviation = std::fabs(distance_from_center - radius);
            total_deviation += deviation * deviation;
            if (deviation > tolerance)
                return false;
        }
    }
    return true;
}

References center, get_closest_perpendicular_point(), and radius.

Referenced by try_create_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

get_polar_radians()

double Slic3r::Circle::get_polar_radians

(

const Point &

p1

)

const

{
    double polar_radians = atan2(p1.y() - center.y(), p1.x() - center.x());
    if (polar_radians < 0)
        polar_radians = (2.0 * PI) + polar_radians;
    return polar_radians;
}

References center, and PI.

Referenced by Slic3r::ArcSegment::are_points_within_slice(), Slic3r::ArcSegment::are_points_within_slice(), Slic3r::ArcSegment::is_point_inside(), Slic3r::ArcSegment::try_create_arc(), and Slic3r::ArcSegment::update_angle_and_length().

Here is the caller graph for this function:

greater_than()

bool Slic3r::Circle::greater_than ( double x, double y, double tolerance = ZERO_TOLERANCE )

inlinestatic

                                                                                    {
        return x > y && !Circle::is_equal(x, y, tolerance);
    };

References is_equal(), and Slic3r::ZERO_TOLERANCE.

Here is the call graph for this function:

greater_than_or_equal()

bool Slic3r::Circle::greater_than_or_equal ( double x, double y, double tolerance = ZERO_TOLERANCE )

inlinestatic

                                                                                             {
        return x > y || Circle::is_equal(x, y, tolerance);
    };

References is_equal(), and Slic3r::ZERO_TOLERANCE.

Referenced by get_closest_perpendicular_point().

Here is the call graph for this function:

Here is the caller graph for this function:

is_equal()

bool Slic3r::Circle::is_equal ( double x, double y, double tolerance = ZERO_TOLERANCE )

inlinestatic

                                                                                {
        double abs_difference = std::fabs(x - y);
        return abs_difference < tolerance;
    };

References Slic3r::ZERO_TOLERANCE.

Referenced by greater_than(), greater_than_or_equal(), less_than(), and less_than_or_equal().

Here is the caller graph for this function:

is_over_deviation()

bool Slic3r::Circle::is_over_deviation	(	const Points &	points,
		const double	tolerance )

{
    Point closest_point;
    Point temp;
    double distance_from_center;
    // BBS: skip the first and last points since they has fit perfectly.
    for (size_t index = 0; index < points.size() - 1; index++)
    {
        if (index != 0)
        {
            //BBS: check fitting tolerance
            temp = points[index] - center;
            distance_from_center = sqrt((double)temp.x() * (double)temp.x() + (double)temp.y() * (double)temp.y());
            if (std::fabs(distance_from_center - radius) > tolerance)
                return true;
        }
 
        //BBS: Check the point perpendicular from the segment to the circle's center
        if (get_closest_perpendicular_point(points[index], points[(size_t)index + 1], center, closest_point)) {
            temp = closest_point - center;
            distance_from_center = sqrt((double)temp.x() * (double)temp.x() + (double)temp.y() * (double)temp.y());
            if (std::fabs(distance_from_center - radius) > tolerance)
                return true;
        }
    }
    return false;
}

References center, get_closest_perpendicular_point(), and radius.

Referenced by try_create_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

less_than()

bool Slic3r::Circle::less_than ( double x, double y, double tolerance = ZERO_TOLERANCE )

inlinestatic

                                                                                 {
        return x < y && !Circle::is_equal(x, y, tolerance);
    };

References is_equal(), and Slic3r::ZERO_TOLERANCE.

Here is the call graph for this function:

less_than_or_equal()

bool Slic3r::Circle::less_than_or_equal ( double x, double y, double tolerance = ZERO_TOLERANCE )

inlinestatic

                                                                                         {
        return x < y || Circle::is_equal(x, y, tolerance);
    };

References is_equal(), and Slic3r::ZERO_TOLERANCE.

Referenced by get_closest_perpendicular_point().

Here is the call graph for this function:

Here is the caller graph for this function:

try_create_circle() [1/3]

bool Slic3r::Circle::try_create_circle ( const Point & p1, const Point & p2, const Point & p3, const double max_radius, Circle & new_circle )

static

{
    double x1 = p1.x();
    double y1 = p1.y();
    double x2 = p2.x();
    double y2 = p2.y();
    double x3 = p3.x();
    double y3 = p3.y();
 
    //BBS: use area of triangle to judge whether three points are almostly on one line
    //Because the point is scale_ once, so area should scale_ twice.
    if (fabs((y1 - y2) * (x1 - x3) - (y1 - y3) * (x1 - x2)) <= scale_(scale_(Parallel_area_threshold)))
        return false;
 
    double a = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2;
    //BBS: take out to figure out how we handle very small values
    if (fabs(a) < SCALED_EPSILON)
        return false;
 
    double b = (x1 * x1 + y1 * y1) * (y3 - y2)
        + (x2 * x2 + y2 * y2) * (y1 - y3)
        + (x3 * x3 + y3 * y3) * (y2 - y1);
 
    double c = (x1 * x1 + y1 * y1) * (x2 - x3)
        + (x2 * x2 + y2 * y2) * (x3 - x1)
        + (x3 * x3 + y3 * y3) * (x1 - x2);
 
    double center_x = -b / (2.0 * a);
    double center_y = -c / (2.0 * a);
 
    double delta_x = center_x - x1;
    double delta_y = center_y - y1;
    double radius = sqrt(delta_x * delta_x + delta_y * delta_y);
    if (radius > max_radius)
        return false;
 
    new_circle.center = Point(center_x, center_y);
    new_circle.radius = radius;
 
    return true;
}

References Circle(), center, Slic3r::Parallel_area_threshold, radius, scale_, and SCALED_EPSILON.

Referenced by Slic3r::ArcSegment::try_create_arc(), Slic3r::ArcSegment::try_create_arc(), try_create_circle(), and try_create_circle().

Here is the call graph for this function:

Here is the caller graph for this function:

try_create_circle() [2/3]

bool Slic3r::Circle::try_create_circle ( const Points & points, const double max_radius, const double tolerance, Circle & new_circle )

static

{
    size_t count = points.size();
    size_t middle_index = count / 2;
    // BBS: the middle point will almost always produce the best arcs with high possibility.
    if (count == 3) {
        return (Circle::try_create_circle(points[0], points[middle_index], points[count - 1], max_radius, new_circle)
                && !new_circle.is_over_deviation(points, tolerance));
    } else {
        Point middle_point = (count % 2 == 0) ? (points[middle_index] + points[middle_index - 1]) / 2 :
                                                (points[middle_index - 1] + points[middle_index + 1]) / 2;
        if (Circle::try_create_circle(points[0], middle_point, points[count - 1], max_radius, new_circle)
            && !new_circle.is_over_deviation(points, tolerance))
            return true;
    }
 
    // BBS: Find the circle with the least deviation, if one exists.
    Circle test_circle;
    double least_deviation;
    bool found_circle = false;
    double current_deviation;
    for (int index = 1; index < count - 1; index++)
    {
        if (index == middle_index)
            // BBS: We already checked this one, and it failed. don't need to do again
            continue;
 
        if (Circle::try_create_circle(points[0], points[index], points[count - 1], max_radius, test_circle) && test_circle.get_deviation_sum_squared(points, tolerance, current_deviation))
        {
            if (!found_circle || current_deviation < least_deviation)
            {
                found_circle = true;
                least_deviation = current_deviation;
                new_circle = test_circle;
            }
        }
    }
    return found_circle;
}

References Circle(), count, get_deviation_sum_squared(), is_over_deviation(), and try_create_circle().

Here is the call graph for this function:

try_create_circle() [3/3]

bool Slic3r::Circle::try_create_circle ( const Points3 & points, const double max_radius, const double tolerance, Circle & new_circle )

static

{
    return Circle::try_create_circle(to_points(points), max_radius, tolerance, new_circle);
}

References Circle(), Slic3r::to_points(), and try_create_circle().

Here is the call graph for this function:

Member Data Documentation

center

Point Slic3r::Circle::center

Referenced by Slic3r::ArcSegment::ArcSegment(), Circle(), Circle(), Slic3r::GCode::_extrude(), Slic3r::ArcSegment::are_points_within_slice(), Slic3r::ArcSegment::are_points_within_slice(), Slic3r::ArcSegment::clip_end(), Slic3r::ArcSegment::clip_start(), Slic3r::from_json(), get_closest_point(), get_deviation_sum_squared(), get_polar_radians(), is_over_deviation(), Slic3r::ArcSegment::split_at(), Slic3r::to_json(), Slic3r::ArcSegment::try_create_arc(), and try_create_circle().

radius

double Slic3r::Circle::radius

Referenced by Slic3r::ArcSegment::ArcSegment(), Circle(), Circle(), Slic3r::ArcSegment::are_points_within_slice(), Slic3r::ArcSegment::are_points_within_slice(), Slic3r::from_json(), get_closest_point(), get_deviation_sum_squared(), is_over_deviation(), Slic3r::ArcSegment::split_at(), Slic3r::to_json(), Slic3r::ArcSegment::try_create_arc(), try_create_circle(), and Slic3r::ArcSegment::update_angle_and_length().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Circle.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Circle.cpp