Slic3r::ArcSegment Class Reference

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

Inheritance diagram for Slic3r::ArcSegment:

Collaboration diagram for Slic3r::ArcSegment:

Public Member Functions
	ArcSegment ()
	ArcSegment (Point center, double radius, Point start, Point end, ArcDirection dir)
bool	is_valid () const
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
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_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	try_create_arc (const Points3 &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)
static bool	are_points_within_slice (const ArcSegment &test_arc, const Points3 &points)
static bool	ray_intersects_segment (const Point &rayOrigin, const Vec2d &rayDirection, const Line &segment)
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)
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
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
Point	center
double	radius

Private Member Functions
void	update_angle_and_length ()

Static Private Member Functions
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)

Detailed Description

Constructor & Destructor Documentation

ArcSegment() [1/2]

Slic3r::ArcSegment::ArcSegment ( )

inline

: Circle() {}

References Slic3r::Circle::Circle().

Referenced by are_points_within_slice(), are_points_within_slice(), split_at(), try_create_arc(), try_create_arc(), and try_create_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

ArcSegment() [2/2]

Slic3r::ArcSegment::ArcSegment ( Point center, double radius, Point start, Point end, ArcDirection dir )

inline

                                                                                      :
        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;
    }

References Slic3r::Circle::Circle(), Slic3r::Circle::center, direction, end_point, is_arc, Slic3r::Circle::radius, start_point, and update_angle_and_length().

Here is the call graph for this function:

Member Function Documentation

are_points_within_slice() [1/2]

bool Slic3r::ArcSegment::are_points_within_slice ( const ArcSegment & test_arc, const Points & points )

static

{
    //BBS: Check all the points and see if they fit inside of the angles
    double previous_polar = test_arc.polar_start_theta;
    bool will_cross_zero = false;
    bool crossed_zero = false;
    const int point_count = points.size();
 
    Vec2d start_norm(((double)test_arc.start_point.x() - (double)test_arc.center.x()) / test_arc.radius,
                     ((double)test_arc.start_point.y() - (double)test_arc.center.y()) / test_arc.radius);
    Vec2d end_norm(((double)test_arc.end_point.x() - (double)test_arc.center.x()) / test_arc.radius,
                   ((double)test_arc.end_point.y() - (double)test_arc.center.y()) / test_arc.radius);
 
    if (test_arc.direction == ArcDirection::Arc_Dir_CCW)
        will_cross_zero = test_arc.polar_start_theta > test_arc.polar_end_theta;
    else
        will_cross_zero = test_arc.polar_start_theta < test_arc.polar_end_theta;
 
    //BBS: check if point 1 to point 2 cross zero
    double polar_test;
    for (int index = point_count - 2; index < point_count; index++)
    {
        if (index < point_count - 1)
          polar_test = test_arc.get_polar_radians(points[index]);
        else
          polar_test = test_arc.polar_end_theta;
 
        //BBS: First ensure the test point is within the arc
        if (test_arc.direction == ArcDirection::Arc_Dir_CCW)
        {
            //BBS: Only check to see if we are within the arc if this isn't the endpoint
            if (index < point_count - 1) {
                if (will_cross_zero) {
                    if (!(polar_test > test_arc.polar_start_theta || polar_test < test_arc.polar_end_theta))
                        return false;
                } else if (!(test_arc.polar_start_theta < polar_test && polar_test < test_arc.polar_end_theta))
                    return false;
            }
            //BBS: check the angles are increasing
            if (previous_polar > polar_test) {
                if (!will_cross_zero)
                    return false;
 
                //BBS: Allow the angle to cross zero once
                if (crossed_zero)
                    return false;
                crossed_zero = true;
            }
        } else {
            if (index < point_count - 1) {
                if (will_cross_zero) {
                    if (!(polar_test < test_arc.polar_start_theta || polar_test > test_arc.polar_end_theta))
                        return false;
                } else if (!(test_arc.polar_start_theta > polar_test && polar_test > test_arc.polar_end_theta))
                    return false;
            }
            //BBS: Now make sure the angles are decreasing
            if (previous_polar < polar_test)
            {
                if (!will_cross_zero)
                    return false;
                //BBS: Allow the angle to cross zero once
                if (crossed_zero)
                    return false;
                crossed_zero = true;
            }
        }
 
        // BBS: check if the segment intersects either of the vector from the center of the circle to the endpoints of the arc
        Line segmemt(points[index - 1], points[index]);
        if ((index != 1 && ray_intersects_segment(test_arc.center, start_norm, segmemt)) ||
            (index != point_count - 1 && ray_intersects_segment(test_arc.center, end_norm, segmemt)))
            return false;
        previous_polar = polar_test;
    }
    //BBS: Ensure that all arcs that cross zero
    if (will_cross_zero != crossed_zero)
        return false;
    return true;
}

References ArcSegment(), Slic3r::Arc_Dir_CCW, Slic3r::Circle::center, direction, end_point, Slic3r::Circle::get_polar_radians(), polar_end_theta, polar_start_theta, Slic3r::Circle::radius, ray_intersects_segment(), and start_point.

Referenced by try_create_arc(), and try_create_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

are_points_within_slice() [2/2]

bool Slic3r::ArcSegment::are_points_within_slice ( const ArcSegment & test_arc, const Points3 & points )

static

{
    //BBS: Check all the points and see if they fit inside of the angles
    double previous_polar = test_arc.polar_start_theta;
    bool will_cross_zero = false;
    bool crossed_zero = false;
    const int point_count = points.size();
 
    Vec2d start_norm(((double)test_arc.start_point.x() - (double)test_arc.center.x()) / test_arc.radius,
                     ((double)test_arc.start_point.y() - (double)test_arc.center.y()) / test_arc.radius);
    Vec2d end_norm(((double)test_arc.end_point.x() - (double)test_arc.center.x()) / test_arc.radius,
                   ((double)test_arc.end_point.y() - (double)test_arc.center.y()) / test_arc.radius);
 
    if (test_arc.direction == ArcDirection::Arc_Dir_CCW)
        will_cross_zero = test_arc.polar_start_theta > test_arc.polar_end_theta;
    else
        will_cross_zero = test_arc.polar_start_theta < test_arc.polar_end_theta;
 
    //BBS: check if point 1 to point 2 cross zero
    double polar_test;
    for (int index = point_count - 2; index < point_count; index++)
    {
        if (index < point_count - 1)
          polar_test = test_arc.get_polar_radians(points[index].to_point());
        else
          polar_test = test_arc.polar_end_theta;
 
        //BBS: First ensure the test point is within the arc
        if (test_arc.direction == ArcDirection::Arc_Dir_CCW)
        {
            //BBS: Only check to see if we are within the arc if this isn't the endpoint
            if (index < point_count - 1) {
                if (will_cross_zero) {
                    if (!(polar_test > test_arc.polar_start_theta || polar_test < test_arc.polar_end_theta))
                        return false;
                } else if (!(test_arc.polar_start_theta < polar_test && polar_test < test_arc.polar_end_theta))
                    return false;
            }
            //BBS: check the angles are increasing
            if (previous_polar > polar_test) {
                if (!will_cross_zero)
                    return false;
 
                //BBS: Allow the angle to cross zero once
                if (crossed_zero)
                    return false;
                crossed_zero = true;
            }
        } else {
            if (index < point_count - 1) {
                if (will_cross_zero) {
                    if (!(polar_test < test_arc.polar_start_theta || polar_test > test_arc.polar_end_theta))
                        return false;
                } else if (!(test_arc.polar_start_theta > polar_test && polar_test > test_arc.polar_end_theta))
                    return false;
            }
            //BBS: Now make sure the angles are decreasing
            if (previous_polar < polar_test)
            {
                if (!will_cross_zero)
                    return false;
                //BBS: Allow the angle to cross zero once
                if (crossed_zero)
                    return false;
                crossed_zero = true;
            }
        }
 
        // BBS: check if the segment intersects either of the vector from the center of the circle to the endpoints of the arc
        Line segmemt(points[index - 1].to_point(), points[index].to_point());
        if ((index != 1 && ray_intersects_segment(test_arc.center, start_norm, segmemt)) ||
            (index != point_count - 1 && ray_intersects_segment(test_arc.center, end_norm, segmemt)))
            return false;
        previous_polar = polar_test;
    }
    //BBS: Ensure that all arcs that cross zero
    if (will_cross_zero != crossed_zero)
        return false;
    return true;
}

References ArcSegment(), Slic3r::Arc_Dir_CCW, Slic3r::Circle::center, direction, end_point, Slic3r::Circle::get_polar_radians(), polar_end_theta, polar_start_theta, Slic3r::Circle::radius, ray_intersects_segment(), and start_point.

Here is the call graph for this function:

calc_arc_length()

float Slic3r::ArcSegment::calc_arc_length ( Vec3f start_pos, Vec3f end_pos, Vec3f center_pos, bool is_ccw )

static

{
    return calc_arc_radius(start_pos, center_pos) * calc_arc_radian(start_pos, end_pos, center_pos, is_ccw);
}

References calc_arc_radian(), calc_arc_radius(), and Slic3r::Geometry::is_ccw().

Referenced by Slic3r::CoolingBuffer::parse_layer_gcode().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_arc_radian()

float Slic3r::ArcSegment::calc_arc_radian ( Vec3f start_pos, Vec3f end_pos, Vec3f center_pos, bool is_ccw )

static

{
    Vec3f delta1 = center_pos - start_pos;
    Vec3f delta2 = center_pos - end_pos;
    // only consider arc in x-y plane, so clean z distance
    delta1(2,0) = 0;
    delta2(2,0) = 0;
 
    float radian;
    if ((delta1 - delta2).norm() < 1e-6) {
        // start_pos is same with end_pos, we think it's a full circle
        radian = 2 * M_PI;
    } else {
        double dot = delta1.dot(delta2);
        double cross = (double)delta1(0, 0) * (double)delta2(1, 0) - (double)delta1(1, 0) * (double)delta2(0, 0);
        radian = atan2(cross, dot);
        if (is_ccw)
            radian = (radian < 0) ? 2 * M_PI + radian : radian;
        else
            radian = (radian < 0) ? abs(radian) : 2 * M_PI - radian;
    }
    return radian;
}

References Slic3r::cross(), Slic3r::dot(), Slic3r::Geometry::is_ccw(), and M_PI.

Referenced by calc_arc_length().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_arc_radius()

float Slic3r::ArcSegment::calc_arc_radius ( Vec3f start_pos, Vec3f center_pos )

static

{
    Vec3f delta1 = center_pos - start_pos;
    delta1(2,0) = 0;
    return delta1.norm();
}

Referenced by calc_arc_length().

Here is the caller graph for this function:

calc_tangential_vector()

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

staticinherited

{
    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:

clip_end()

bool Slic3r::ArcSegment::clip_end

(

const Point &

point

)

{
    if (!is_valid() || point == center || !is_point_inside(point))
        return false;
    end_point = get_closest_point(point);
    update_angle_and_length();
    return true;
}

References Slic3r::Circle::center, end_point, Slic3r::Circle::get_closest_point(), is_point_inside(), is_valid(), and update_angle_and_length().

Here is the call graph for this function:

clip_start()

bool Slic3r::ArcSegment::clip_start

(

const Point &

point

)

{
    if (!is_valid() || point == center || !is_point_inside(point))
        return false;
    start_point = get_closest_point(point);
    update_angle_and_length();
    return true;
}

References Slic3r::Circle::center, Slic3r::Circle::get_closest_point(), is_point_inside(), is_valid(), start_point, and update_angle_and_length().

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 )

staticinherited

{
    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 )

inlineinherited

                                                {
        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 )

inherited

{
    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

inherited

{
    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 )

inlinestaticinherited

                                                                                    {
        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 )

inlinestaticinherited

                                                                                             {
        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 )

inlinestaticinherited

                                                                                {
        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 )

inherited

{
    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:

is_point_inside()

bool Slic3r::ArcSegment::is_point_inside

(

const Point &

point

)

const

{
    double polar_theta = get_polar_radians(point);
    double radian_delta = polar_theta - polar_start_theta;
    if (radian_delta > 0 && direction == ArcDirection::Arc_Dir_CW)
        radian_delta = radian_delta - 2 * M_PI;
    else if (radian_delta < 0 && direction == ArcDirection::Arc_Dir_CCW)
        radian_delta = radian_delta + 2 * M_PI;
 
    return (direction == ArcDirection::Arc_Dir_CCW ?
            radian_delta > 0.0 && radian_delta < angle_radians :
            radian_delta < 0.0 && radian_delta > angle_radians);
}

References angle_radians, Slic3r::Arc_Dir_CCW, Slic3r::Arc_Dir_CW, direction, Slic3r::Circle::get_polar_radians(), M_PI, and polar_start_theta.

Referenced by clip_end(), clip_start(), and split_at().

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid()

bool Slic3r::ArcSegment::is_valid ( ) const

inline

{ return is_arc; }

References is_arc.

Referenced by clip_end(), clip_start(), reverse(), and split_at().

Here is the caller graph for this function:

less_than()

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

inlinestaticinherited

                                                                                 {
        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 )

inlinestaticinherited

                                                                                         {
        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:

ray_intersects_segment()

bool Slic3r::ArcSegment::ray_intersects_segment ( const Point & rayOrigin, const Vec2d & rayDirection, const Line & segment )

static

{
    Vec2d v1 = Vec2d(rayOrigin.x() - segment.a.x(), rayOrigin.y() - segment.a.y());
    Vec2d v2 = Vec2d(segment.b.x() - segment.a.x(), segment.b.y() - segment.a.y());
    Vec2d v3 = Vec2d(-rayDirection(1), rayDirection(0));
 
    double dot = v2(0) * v3(0) + v2(1) * v3(1);
    if (std::fabs(dot) < SCALED_EPSILON)
        return false;
 
    double t1 = (v2(0) * v1(1) - v2(1) * v1(0)) / dot;
    double t2 = (v1(0) * v3(0) + v1(1) * v3(1)) / dot;
 
    if (t1 >= 0.0 && (t2 >= 0.0 && t2 <= 1.0))
        return true;
 
    return false;
}

References Slic3r::dot(), and SCALED_EPSILON.

Referenced by are_points_within_slice(), and are_points_within_slice().

Here is the call graph for this function:

Here is the caller graph for this function:

reverse()

bool Slic3r::ArcSegment::reverse

(

)

{
    if (!is_valid())
        return false;
    std::swap(start_point, end_point);
    direction = (direction == ArcDirection::Arc_Dir_CCW) ? ArcDirection::Arc_Dir_CW : ArcDirection::Arc_Dir_CCW;
    angle_radians *= -1.0;
    std::swap(polar_start_theta, polar_end_theta);
    return true;
}

References angle_radians, Slic3r::Arc_Dir_CCW, Slic3r::Arc_Dir_CW, direction, end_point, is_valid(), polar_end_theta, polar_start_theta, and start_point.

Here is the call graph for this function:

split_at()

bool Slic3r::ArcSegment::split_at	(	const Point &	point,
		ArcSegment &	p1,
		ArcSegment &	p2 )

{
    if (!is_valid() || point == center || !is_point_inside(point))
        return false;
    Point segment_point = get_closest_point(point);
    p1 = ArcSegment(center, radius, this->start_point, segment_point, this->direction);
    p2 = ArcSegment(center, radius, segment_point, this->end_point,  this->direction);
    return true;
}

References ArcSegment(), Slic3r::Circle::center, direction, end_point, Slic3r::Circle::get_closest_point(), is_point_inside(), is_valid(), Slic3r::Circle::radius, and start_point.

Here is the call graph for this function:

try_create_arc() [1/3]

bool Slic3r::ArcSegment::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 )

staticprivate

{
    double polar_start_theta = c.get_polar_radians(start_point);
    double polar_mid_theta = c.get_polar_radians(mid_point);
    double polar_end_theta = c.get_polar_radians(end_point);
 
    double angle_radians = 0;
    ArcDirection direction = ArcDirection::Arc_Dir_unknow;
    //BBS: calculate the direction of the arc
    if (polar_end_theta > polar_start_theta) {
        if (polar_start_theta < polar_mid_theta && polar_mid_theta < polar_end_theta) {
            direction = ArcDirection::Arc_Dir_CCW;
            angle_radians = polar_end_theta - polar_start_theta;
        } else if ((0.0 <= polar_mid_theta && polar_mid_theta < polar_start_theta) ||
                   (polar_end_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI))) {
            direction = ArcDirection::Arc_Dir_CW;
            angle_radians = polar_start_theta + ((2.0 * PI) - polar_end_theta);
        }
    } else if (polar_start_theta > polar_end_theta) {
        if ((polar_start_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI)) ||
            (0.0 < polar_mid_theta && polar_mid_theta < polar_end_theta)) {
            direction = ArcDirection::Arc_Dir_CCW;
            angle_radians = polar_end_theta + ((2.0 * PI) - polar_start_theta);
        } else if (polar_end_theta < polar_mid_theta && polar_mid_theta < polar_start_theta) {
            direction = ArcDirection::Arc_Dir_CW;
            angle_radians = polar_start_theta - polar_end_theta;
        }
    }
 
    // BBS: this doesn't always work.. in rare situations, the angle may be backward
    if (direction == ArcDirection::Arc_Dir_unknow || std::fabs(angle_radians) < EPSILON)
        return false;
 
    // BBS: Check the length against the original length.
    // This can trigger simply due to the differing path lengths
    // but also could indicate that the vector calculation above
    // got wrong direction
    double arc_length = c.radius * angle_radians;
    double difference = (arc_length - approximate_length) / approximate_length;
    if (std::fabs(difference) >= path_tolerance_percent)
    {
        // BBS: So it's possible that vector calculation above got wrong direction.
        // This can happen if there is a crazy arrangement of points
        // extremely close to eachother. They have to be close enough to
        // break our other checks.  However, we may be able to salvage this.
        // see if an arc moving in the opposite direction had the correct length.
 
        //BBS: Find the rest of the angle across the circle
        double test_radians = std::fabs(angle_radians - 2 * PI);
        // Calculate the length of that arc
        double test_arc_length = c.radius * test_radians;
        difference = (test_arc_length - approximate_length) / approximate_length;
        if (std::fabs(difference) >= path_tolerance_percent)
            return false;
        //BBS: Set the new length and flip the direction (but not the angle)!
        arc_length = test_arc_length;
        direction = direction == ArcDirection::Arc_Dir_CCW ? ArcDirection::Arc_Dir_CW : ArcDirection::Arc_Dir_CCW;
    }
 
    if (direction == ArcDirection::Arc_Dir_CW)
        angle_radians *= -1.0;
 
    target_arc.is_arc = true;
    target_arc.direction = direction;
    target_arc.center = c.center;
    target_arc.radius = c.radius;
    target_arc.start_point = start_point;
    target_arc.end_point = end_point;
    target_arc.length = arc_length;
    target_arc.angle_radians = angle_radians;
    target_arc.polar_start_theta = polar_start_theta;
    target_arc.polar_end_theta = polar_end_theta;
 
    return true;
}

References ArcSegment(), Slic3r::Circle::Circle(), angle_radians, Slic3r::Arc_Dir_CCW, Slic3r::Arc_Dir_CW, Slic3r::Arc_Dir_unknow, Slic3r::Circle::center, direction, end_point, EPSILON, Slic3r::Circle::get_polar_radians(), is_arc, length, PI, polar_end_theta, polar_start_theta, Slic3r::Circle::radius, and start_point.

Here is the call graph for this function:

try_create_arc() [2/3]

bool Slic3r::ArcSegment::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

{
    Circle test_circle = (Circle)target_arc;
    if (!Circle::try_create_circle(points, max_radius, tolerance, test_circle))
        return false;
 
    int mid_point_index = ((points.size() - 2) / 2) + 1;
    ArcSegment test_arc;
    if (!ArcSegment::try_create_arc(test_circle, points[0], points[mid_point_index], points[points.size() - 1], test_arc, approximate_length, path_tolerance_percent))
        return false;
 
    if (ArcSegment::are_points_within_slice(test_arc, points))
    {
        target_arc = test_arc;
        return true;
    }
    return false;
}

References ArcSegment(), Slic3r::Circle::Circle(), are_points_within_slice(), try_create_arc(), and Slic3r::Circle::try_create_circle().

Referenced by Slic3r::ArcFitter::do_arc_fitting(), try_create_arc(), and try_create_arc().

Here is the call graph for this function:

Here is the caller graph for this function:

try_create_arc() [3/3]

bool Slic3r::ArcSegment::try_create_arc ( const Points3 & 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

{
    Circle test_circle = (Circle)target_arc;
    if (!Circle::try_create_circle(points, max_radius, tolerance, test_circle))
        return false;
 
    int mid_point_index = ((points.size() - 2) / 2) + 1;
    ArcSegment test_arc;
    if (!ArcSegment::try_create_arc(test_circle, points[0].to_point(), points[mid_point_index].to_point(), points[points.size() - 1].to_point(), test_arc, approximate_length, path_tolerance_percent))
        return false;
 
    if (ArcSegment::are_points_within_slice(test_arc, points))
    {
        target_arc = test_arc;
        return true;
    }
    return false;
}

References ArcSegment(), Slic3r::Circle::Circle(), are_points_within_slice(), try_create_arc(), and Slic3r::Circle::try_create_circle().

Here is the call 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 )

staticinherited

{
    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 )

staticinherited

{
    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 )

staticinherited

{
    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:

update_angle_and_length()

void Slic3r::ArcSegment::update_angle_and_length ( )

private

{
    polar_start_theta = get_polar_radians(start_point);
    polar_end_theta = get_polar_radians(end_point);
    angle_radians = polar_end_theta - polar_start_theta;
    if (angle_radians < 0 && direction == ArcDirection::Arc_Dir_CCW)
        angle_radians = angle_radians + 2 * M_PI;
    else if (angle_radians > 0 && direction == ArcDirection::Arc_Dir_CW)
        angle_radians = angle_radians - 2 * M_PI;
    length = fabs(angle_radians) * radius;
    is_arc = true;
}

References angle_radians, Slic3r::Arc_Dir_CCW, Slic3r::Arc_Dir_CW, direction, end_point, Slic3r::Circle::get_polar_radians(), is_arc, length, M_PI, polar_end_theta, polar_start_theta, Slic3r::Circle::radius, and start_point.

Referenced by ArcSegment(), clip_end(), and clip_start().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

angle_radians

double Slic3r::ArcSegment::angle_radians = 0

Referenced by Slic3r::from_json(), is_point_inside(), reverse(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

center

Point Slic3r::Circle::center

inherited

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().

direction

ArcDirection Slic3r::ArcSegment::direction = ArcDirection::Arc_Dir_unknow

Referenced by ArcSegment(), are_points_within_slice(), are_points_within_slice(), Slic3r::ArcFitter::do_arc_fitting(), Slic3r::from_json(), is_point_inside(), reverse(), split_at(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

end_point

Point Slic3r::ArcSegment::end_point { Point(0,0) }

{ Point(0,0) };

Referenced by ArcSegment(), Slic3r::GCode::_extrude(), are_points_within_slice(), are_points_within_slice(), clip_end(), Slic3r::GCode::compute_farthest_point(), Slic3r::from_json(), reverse(), split_at(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

is_arc

bool Slic3r::ArcSegment::is_arc = false

Referenced by ArcSegment(), Slic3r::from_json(), is_valid(), Slic3r::to_json(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

length

double Slic3r::ArcSegment::length = 0

Referenced by Slic3r::from_json(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

polar_end_theta

double Slic3r::ArcSegment::polar_end_theta = 0

Referenced by are_points_within_slice(), are_points_within_slice(), Slic3r::from_json(), reverse(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

polar_start_theta

double Slic3r::ArcSegment::polar_start_theta = 0

Referenced by are_points_within_slice(), are_points_within_slice(), Slic3r::from_json(), is_point_inside(), reverse(), Slic3r::to_json(), try_create_arc(), and update_angle_and_length().

radius

double Slic3r::Circle::radius

inherited

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().

start_point

Point Slic3r::ArcSegment::start_point { Point(0,0) }

{ Point(0,0) };

Referenced by ArcSegment(), Slic3r::GCode::_extrude(), are_points_within_slice(), are_points_within_slice(), clip_start(), Slic3r::from_json(), reverse(), split_at(), Slic3r::to_json(), try_create_arc(), and 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