Slic3r::SupportSpotsGenerator Namespace Reference

Classes
struct	Params

Typedefs
using	LD = AABBTreeLines::LinesDistancer<ExtrusionLine>

Enumerations
enum class	SupportPointCause {   LongBridge , FloatingBridgeAnchor , FloatingExtrusion , SeparationFromBed ,   UnstableFloatingPart , WeakObjectPart }

Functions
float	get_flow_width (const LayerRegion *region, ExtrusionRole role)
float	estimate_curled_up_height (float distance, float curvature, float layer_height, float flow_width, float prev_line_curled_height, Params params)
void	estimate_malformations (LayerPtrs &layers, const Params &params)
void	estimate_malformations (std::vector< Layer * > &layers, const Params &params)

Typedef Documentation

LD

using Slic3r::SupportSpotsGenerator::LD = AABBTreeLines::LinesDistancer<ExtrusionLine>

Enumeration Type Documentation

SupportPointCause

enum class Slic3r::SupportSpotsGenerator::SupportPointCause

strong

Enumerator
LongBridge
FloatingBridgeAnchor
FloatingExtrusion
SeparationFromBed
UnstableFloatingPart
WeakObjectPart

                             { 
    LongBridge, // point generated on bridge and straight perimeter extrusion longer than the allowed length 
    FloatingBridgeAnchor, // point generated on unsupported bridge endpoint
    FloatingExtrusion, // point generated on extrusion that does not hold on its own
    SeparationFromBed, // point generated for object parts that are connected to the bed, but the area is too small and there is a risk of separation (brim may help)
    UnstableFloatingPart, // point generated for object parts not connected to the bed, holded only by the other support points (brim will not help here)
    WeakObjectPart // point generated when some part of the object is too weak to hold the upper part and may break (imagine hourglass)
    };

Function Documentation

estimate_curled_up_height()

float Slic3r::SupportSpotsGenerator::estimate_curled_up_height	(	float	distance,
		float	curvature,
		float	layer_height,
		float	flow_width,
		float	prev_line_curled_height,
		Params	params )

{
    float curled_up_height = 0;
    if (fabs(distance) < 3.0 * flow_width) {
        curled_up_height = std::max(prev_line_curled_height - layer_height * 0.75f, 0.0f);
    }
 
    if (distance > params.malformation_distance_factors.first * flow_width &&
        distance < params.malformation_distance_factors.second * flow_width) {
        // imagine the extrusion profile. The part that has been glued (melted) with the previous layer will be called anchored section
        // and the rest will be called curling section
        // float anchored_section = flow_width - point.distance;
        float curling_section = distance;
 
        // after extruding, the curling (floating) part of the extrusion starts to shrink back to the rounded shape of the nozzle
        // The anchored part not, because the melted material holds to the previous layer well.
        // We can assume for simplicity perfect equalization of layer height and raising part width, from which:
        float swelling_radius = (layer_height + curling_section) / 2.0f;
        curled_up_height += std::max(0.f, (swelling_radius - layer_height) / 2.0f);
 
        // On convex turns, there is larger tension on the floating edge of the extrusion then on the middle section.
        // The tension is caused by the shrinking tendency of the filament, and on outer edge of convex trun, the expansion is greater and
        // thus shrinking force is greater. This tension will cause the curling section to curle up
        if (curvature > 0.01) {
            float radius    = (1.0 / curvature);
            float curling_t = sqrt(radius / 100);
            float b         = curling_t * flow_width;
            float a         = curling_section;
            float c         = sqrt(std::max(0.0f, a * a - b * b));
 
            curled_up_height += c;
        }
        curled_up_height = std::min(curled_up_height, params.max_curled_height_factor * layer_height);
    }
 
    return curled_up_height;
}

References Slic3r::layer_height(), Slic3r::SupportSpotsGenerator::Params::malformation_distance_factors, and Slic3r::SupportSpotsGenerator::Params::max_curled_height_factor.

Referenced by estimate_malformations().

Here is the call graph for this function:

Here is the caller graph for this function:

estimate_malformations() [1/2]

void Slic3r::SupportSpotsGenerator::estimate_malformations	(	LayerPtrs &	layers,
		const Params &	params )

{
#ifdef DEBUG_FILES
    FILE *debug_file = boost::nowide::fopen(debug_out_path("object_malformations.obj").c_str(), "w");
    FILE *full_file  = boost::nowide::fopen(debug_out_path("object_full.obj").c_str(), "w");
#endif
 
    LD prev_layer_lines{};
 
    for (Layer *l : layers) {
        l->curled_lines.clear();
        std::vector<Linef> boundary_lines = l->lower_layer != nullptr ? to_unscaled_linesf(l->lower_layer->lslices) : std::vector<Linef>();
        AABBTreeLines::LinesDistancer<Linef> prev_layer_boundary{std::move(boundary_lines)};
        std::vector<ExtrusionLine>           current_layer_lines;
        for (const LayerRegion *layer_region : l->regions()) {
            for (const ExtrusionEntity *extrusion : layer_region->perimeters.flatten().entities) {
                if (extrusion->role() != Slic3r::erExternalPerimeter)
                    continue;
 
                Points extrusion_pts;
                extrusion->collect_points(extrusion_pts);
                float flow_width       = get_flow_width(layer_region, extrusion->role());
                auto  annotated_points = estimate_points_properties<true, true, false, false>(extrusion_pts,
                                                                                                                 prev_layer_lines,
                                                                                                                 flow_width,
                                                                                                                 params.bridge_distance);
                for (size_t i = 0; i < annotated_points.size(); ++i) {
                    const ExtendedPoint<2>& a = i > 0 ? annotated_points[i - 1] : annotated_points[i];
                    const ExtendedPoint<2>& b = annotated_points[i];
                    ExtrusionLine line_out{a.position.cast<float>(), b.position.cast<float>(), float((a.position - b.position).norm()),
                                           extrusion};
 
                    Vec2f middle                               = 0.5 * (line_out.a + line_out.b);
                    auto [middle_distance, bottom_line_idx, x] = prev_layer_lines.distance_from_lines_extra<false>(middle);
                    ExtrusionLine bottom_line                  = prev_layer_lines.get_lines().empty() ? ExtrusionLine{} :
                                                                                                        prev_layer_lines.get_line(bottom_line_idx);
 
                    // correctify the distance sign using slice polygons
                    float sign = (prev_layer_boundary.distance_from_lines<true>(middle.cast<double>()) + 0.5f * flow_width) < 0.0f ? -1.0f :
                                                                                                                                     1.0f;
 
                    line_out.curled_up_height = estimate_curled_up_height(middle_distance * sign * params.curled_distance_expansion, 0.5 * (a.curvature + b.curvature),
                                                                          l->height, flow_width, bottom_line.curled_up_height, params);
 
                    current_layer_lines.push_back(line_out);
                }
            }
        }
 
        for (const ExtrusionLine &line : current_layer_lines) {
            if (line.curled_up_height > params.curling_tolerance_limit) {
                l->curled_lines.push_back(CurledLine{Point::new_scale(line.a), Point::new_scale(line.b), line.curled_up_height});
            }
        }
 
#ifdef DEBUG_FILES
        for (const ExtrusionLine &line : current_layer_lines) {
            if (line.curled_up_height > params.curling_tolerance_limit) {
                Vec3f color = value_to_rgbf(-EPSILON, l->height * params.max_curled_height_factor, line.curled_up_height);
                fprintf(debug_file, "v %f %f %f  %f %f %f\n", line.b[0], line.b[1], l->print_z, color[0], color[1], color[2]);
            }
        }
        for (const ExtrusionLine &line : current_layer_lines) {
            Vec3f color = value_to_rgbf(-EPSILON, l->height * params.max_curled_height_factor, line.curled_up_height);
            fprintf(full_file, "v %f %f %f  %f %f %f\n", line.b[0], line.b[1], l->print_z, color[0], color[1], color[2]);
        }
#endif
 
        prev_layer_lines = LD{current_layer_lines};
    }
 
#ifdef DEBUG_FILES
    fclose(debug_file);
    fclose(full_file);
#endif
}

References Slic3r::ExtrusionLine::a, Slic3r::ExtrusionLine::b, Slic3r::SupportSpotsGenerator::Params::bridge_distance, Slic3r::SupportSpotsGenerator::Params::curled_distance_expansion, Slic3r::ExtrusionLine::curled_up_height, Slic3r::SupportSpotsGenerator::Params::curling_tolerance_limit, Slic3r::ExtendedPoint< Dim >::curvature, Slic3r::debug_out_path(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::distance_from_lines(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::distance_from_lines_extra(), EPSILON, Slic3r::erExternalPerimeter, estimate_curled_up_height(), Slic3r::estimate_points_properties(), get_flow_width(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::get_line(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::get_lines(), Slic3r::SupportSpotsGenerator::Params::max_curled_height_factor, Slic3r::Point::new_scale(), Slic3r::ExtendedPoint< Dim >::position, and Slic3r::to_unscaled_linesf().

Referenced by Slic3r::PrintObject::estimate_curled_extrusions().

Here is the call graph for this function:

Here is the caller graph for this function:

estimate_malformations() [2/2]

void Slic3r::SupportSpotsGenerator::estimate_malformations	(	std::vector< Layer * > &	layers,
		const Params &	params )

get_flow_width()

float Slic3r::SupportSpotsGenerator::get_flow_width	(	const LayerRegion *	region,
		ExtrusionRole	role )

{
    if (role == ExtrusionRole::erBridgeInfill) return region->flow(FlowRole::frExternalPerimeter).width();
    if (role == ExtrusionRole::erExternalPerimeter) return region->flow(FlowRole::frExternalPerimeter).width();
    if (role == ExtrusionRole::erGapFill) return region->flow(FlowRole::frInfill).width();
    if (role == ExtrusionRole::erPerimeter) return region->flow(FlowRole::frPerimeter).width();
    if (role == ExtrusionRole::erSolidInfill) return region->flow(FlowRole::frSolidInfill).width();
    if (role == ExtrusionRole::erInternalInfill) return region->flow(FlowRole::frInfill).width();
    if (role == ExtrusionRole::erTopSolidInfill) return region->flow(FlowRole::frTopSolidInfill).width();
    // default
    return region->flow(FlowRole::frPerimeter).width();
}

References Slic3r::erBridgeInfill, Slic3r::erExternalPerimeter, Slic3r::erGapFill, Slic3r::erInternalInfill, Slic3r::erPerimeter, Slic3r::erSolidInfill, Slic3r::erTopSolidInfill, Slic3r::LayerRegion::flow(), Slic3r::frExternalPerimeter, Slic3r::frInfill, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::frTopSolidInfill, and Slic3r::Flow::width().

Referenced by estimate_malformations().

Here is the call graph for this function:

Here is the caller graph for this function: