Slic3r::CornerSmoother Class Reference

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

Collaboration diagram for Slic3r::CornerSmoother:

Public Member Functions
	CornerSmoother (const CornerSmoothing &smoothing, double max_corner_distance=0., CornerFilter corner_filter={})
bool	enabled () const
template<typename Emit>
void	push (const Vec2d &point, Emit &emit)
template<typename Emit>
void	flush (Emit &emit)

Private Member Functions
template<typename Emit>
void	emit_corner (const Vec2d &previous, const Vec2d &corner, const Vec2d &next, Emit &emit)
void	round_corner (const Vec2d &previous, const Vec2d &corner, const Vec2d &next)
const std::vector< Vec2d > *	corner_vertices (double reach, double cosine) const

Static Private Member Functions
static bool	is_on_straight_run (const Vec2d &previous, const Vec2d &vertex, const Vec2d &next)

Private Attributes
const CornerSmoothing	m_smoothing
const double	m_corner_distance_ratio
const double	m_max_corner_distance
const CornerFilter	m_corner_filter
std::vector< Vec2d >	m_corner_points
std::array< Vec2d, 3 >	m_window { Vec2d::Zero(), Vec2d::Zero(), Vec2d::Zero() }
int	m_held { 0 }

Detailed Description

Constructor & Destructor Documentation

CornerSmoother()

Slic3r::CornerSmoother::CornerSmoother ( const CornerSmoothing & smoothing, double max_corner_distance = 0., CornerFilter corner_filter = {} )

inline

                                                                                                                   {})
        : m_smoothing(smoothing)
        , m_corner_distance_ratio(0.5 * sanitize_smooth_factor(smoothing.factor))
        , m_max_corner_distance(max_corner_distance)
        , m_corner_filter(std::move(corner_filter))
    {}

Member Function Documentation

corner_vertices()

const std::vector< Vec2d > * Slic3r::CornerSmoother::corner_vertices ( double reach, double cosine ) const

private

{
    const double tolerance = m_smoothing.tolerance > 0. && std::isfinite(m_smoothing.tolerance) ? m_smoothing.tolerance : EPSILON;
    const double turn      = std::acos(std::clamp(cosine, -1., 1.));
    const double curvature = peak_curvature_by_reach(cosine) / reach;
    // Simplifying the path to the tolerance drops a vertex standing out of the chord of its neighbours by less,
    // which the sharpest vertex of the curve does at finer steps than this.
    const size_t most  = size_t(std::min(double(max_corner_vertices), turn / std::sqrt(2. * curvature * tolerance)));
    // The count an arc of the peak curvature takes; the flatter parts of the curve may need more.
    size_t       count = std::min(most, size_t(std::ceil(turn / std::sqrt(8. * curvature * tolerance) - EPSILON)));
    if (count < 2)
        return nullptr;
    for (;;) {
        const double deviation = reach * unit_corner(cosine, count).deviation;
        if (deviation <= tolerance || count >= most)
            break;
        // The deviation falls about with the square of the count.
        count = std::min(most, std::max(count + 1, size_t(std::ceil(double(count) * std::sqrt(deviation / tolerance)))));
    }
    return &unit_corner(cosine, count).vertices;
}

References count, Slic3r::UnitCorner::deviation, EPSILON, m_smoothing, Slic3r::max_corner_vertices, Slic3r::peak_curvature_by_reach(), Slic3r::unit_corner(), and Slic3r::UnitCorner::vertices.

Referenced by round_corner().

Here is the call graph for this function:

Here is the caller graph for this function:

emit_corner()

template<typename Emit>

void Slic3r::CornerSmoother::emit_corner ( const Vec2d & previous, const Vec2d & corner, const Vec2d & next, Emit & emit )

inlineprivate

    {
        round_corner(previous, corner, next);
        for (const Vec2d &corner_point : m_corner_points)
            emit(corner_point);
    }

References m_corner_points, and round_corner().

Referenced by flush(), and push().

Here is the call graph for this function:

Here is the caller graph for this function:

enabled()

bool Slic3r::CornerSmoother::enabled ( ) const

inline

{ return m_corner_distance_ratio > 0.; }

References m_corner_distance_ratio.

Referenced by Slic3r::smooth_polygons_corners(), and Slic3r::smooth_polyline_corners().

Here is the caller graph for this function:

flush()

template<typename Emit>

void Slic3r::CornerSmoother::flush ( Emit & emit )

inline

    {
        if (m_held > 2)
            emit_corner(m_window[0], m_window[1], m_window[2], emit);
        if (m_held > 1)
            emit(m_window[m_held - 1]);
        m_held = 0;
    }

References emit_corner(), m_held, and m_window.

Referenced by Slic3r::smooth_corners().

Here is the call graph for this function:

Here is the caller graph for this function:

is_on_straight_run()

bool Slic3r::CornerSmoother::is_on_straight_run ( const Vec2d & previous, const Vec2d & vertex, const Vec2d & next )

staticprivate

{
    const Vec2d  incoming_leg    = vertex - previous;
    const Vec2d  outgoing_leg    = next - vertex;
    const double incoming_length = incoming_leg.norm();
    const double outgoing_length = outgoing_leg.norm();
    // A vertex repeating one of its neighbours carries no direction of its own.
    if (incoming_length < EPSILON || outgoing_length < EPSILON)
        return true;
 
    const Vec2d incoming = incoming_leg / incoming_length;
    const Vec2d outgoing = outgoing_leg / outgoing_length;
    return incoming.dot(outgoing) > 0. &&
           std::abs(incoming.x() * outgoing.y() - incoming.y() * outgoing.x()) < EPSILON;
}

References EPSILON.

Referenced by push().

Here is the caller graph for this function:

push()

template<typename Emit>

void Slic3r::CornerSmoother::push ( const Vec2d & point, Emit & emit )

inline

    {
        if (m_held == 0) {
            // The first point of a path is an end, not a corner, and stays where it is.
            emit(point);
            m_window[m_held++] = point;
            return;
        }
        if (m_held > 1 && is_on_straight_run(m_window[m_held - 2], m_window[m_held - 1], point)) {
            // The newest vertex only splits a straight leg, so the leg runs on to this point instead.
            m_window[m_held - 1] = point;
            return;
        }
        if (m_held < 3) {
            m_window[m_held++] = point;
            return;
        }
        // Both legs of the middle vertex are complete now, so its curve can no longer grow.
        emit_corner(m_window[0], m_window[1], m_window[2], emit);
        m_window[0] = m_window[1];
        m_window[1] = m_window[2];
        m_window[2] = point;
    }

References emit_corner(), is_on_straight_run(), m_held, and m_window.

Referenced by Slic3r::smooth_corners().

Here is the call graph for this function:

Here is the caller graph for this function:

round_corner()

void Slic3r::CornerSmoother::round_corner ( const Vec2d & previous, const Vec2d & corner, const Vec2d & next )

private

{
    m_corner_points.clear();
 
    const Vec2d  incoming_leg = corner - previous;
    const Vec2d  outgoing_leg = next - corner;
    const double incoming_length = incoming_leg.norm();
    const double outgoing_length = outgoing_leg.norm();
    if (incoming_length < EPSILON || outgoing_length < EPSILON) {
        m_corner_points.emplace_back(corner);
        return;
    }
 
    const Vec2d  incoming = incoming_leg / incoming_length;
    const Vec2d  outgoing = outgoing_leg / outgoing_length;
    const double cross    = incoming.x() * outgoing.y() - incoming.y() * outgoing.x();
    // Snapped, so that the corners of one turn share the cached shapes whatever rounding their legs carry.
    const double cosine   = std::round(incoming.dot(outgoing) * 1e12) * 1e-12;
    // A collinear vertex is no corner at all, and a hairpin cannot be rounded, see above.
    if (std::abs(cross) < EPSILON || cosine < min_smoothed_turn_cosine) {
        m_corner_points.emplace_back(corner);
        return;
    }
 
    // Consuming at most half of the shorter leg keeps the curves of two adjacent corners apart.
    double reach = m_corner_distance_ratio * std::min(incoming_length, outgoing_length);
    if (m_max_corner_distance > 0.)
        reach = std::min(reach, m_max_corner_distance);
 
    const std::vector<Vec2d> *vertices = corner_vertices(reach, cosine);
    if (vertices == nullptr || (m_corner_filter && !m_corner_filter(corner - reach * incoming, corner + reach * outgoing))) {
        m_corner_points.emplace_back(corner);
        return;
    }
 
    m_corner_points.reserve(vertices->size());
    for (const Vec2d &vertex : *vertices)
        m_corner_points.emplace_back(corner + reach * (vertex.x() * incoming + vertex.y() * outgoing));
}

References corner_vertices(), Slic3r::cross(), EPSILON, m_corner_distance_ratio, m_corner_filter, m_corner_points, m_max_corner_distance, and Slic3r::min_smoothed_turn_cosine.

Referenced by emit_corner().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_corner_distance_ratio

const double Slic3r::CornerSmoother::m_corner_distance_ratio

private

Referenced by enabled(), and round_corner().

m_corner_filter

const CornerFilter Slic3r::CornerSmoother::m_corner_filter

private

Referenced by round_corner().

m_corner_points

std::vector<Vec2d> Slic3r::CornerSmoother::m_corner_points

private

Referenced by emit_corner(), and round_corner().

m_held

int Slic3r::CornerSmoother::m_held { 0 }

private

{ 0 };

Referenced by flush(), and push().

m_max_corner_distance

const double Slic3r::CornerSmoother::m_max_corner_distance

private

Referenced by round_corner().

m_smoothing

const CornerSmoothing Slic3r::CornerSmoother::m_smoothing

private

Referenced by corner_vertices().

m_window

std::array<Vec2d, 3> Slic3r::CornerSmoother::m_window { Vec2d::Zero(), Vec2d::Zero(), Vec2d::Zero() }

private

{ Vec2d::Zero(), Vec2d::Zero(), Vec2d::Zero() };

Referenced by flush(), and push().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/FillCornerSmoothing.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Fill/FillCornerSmoothing.cpp