Classes
class	ActiveObjectParts

struct	Malformations

class	ObjectPart

struct	Params

struct	PartialObject

struct	SliceConnection

struct	SupportGridFilter

struct	SupportPoint

Typedefs
using	LD = AABBTreeLines::LinesDistancer< ExtrusionLine >

using	PrecomputedSliceConnections = std::vector< std::vector< SliceConnection > >

using	SupportPoints = std::vector< SupportPoint >

using	PartialObjects = std::vector< PartialObject >

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

Functions
SliceConnection	estimate_slice_connection (size_t slice_idx, const Layer *layer)

PrecomputedSliceConnections	precompute_slices_connections (const PrintObject *po)

float	get_flow_width (const LayerRegion *region, ExtrusionRole role)

std::vector< ExtrusionLine >	to_short_lines (const ExtrusionEntity *e, float length_limit)

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

std::vector< ExtrusionLine >	check_extrusion_entity_stability (const ExtrusionEntity entity, const LayerRegion layer_region, const LD &prev_layer_lines, const AABBTreeLines::LinesDistancer< Linef > &prev_layer_boundary, const Params &params)

std::tuple< ObjectPart, float >	build_object_part_from_slice (const size_t &slice_idx, const Layer *layer, const Params &params)

std::tuple< SupportPoints, PartialObjects >	check_stability (const PrintObject *po, const PrecomputedSliceConnections &precomputed_slices_connections, const PrintTryCancel &cancel_func, const Params &params)

std::tuple< SupportPoints, PartialObjects >	full_search (const PrintObject *po, const PrintTryCancel &cancel_func, const Params &params)

void	estimate_supports_malformations (SupportLayerPtrs &layers, float flow_width, const Params &params)

void	estimate_malformations (LayerPtrs &layers, const Params &params)

std::vector< std::pair< SupportPointCause, bool > >	gather_issues (const SupportPoints &support_points, PartialObjects &partial_objects)

void	estimate_supports_malformations (std::vector< SupportLayer * > &layers, float supports_flow_width, const Params &params)

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

Class Documentation

◆ Slic3r::SupportSpotsGenerator::Malformations

struct Slic3r::SupportSpotsGenerator::Malformations

Collaboration diagram for Slic3r::SupportSpotsGenerator::Malformations:

Class Members
vector< Lines >	layers

Typedef Documentation

◆ LD

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

◆ PartialObjects

using Slic3r::SupportSpotsGenerator::PartialObjects = typedef std::vector<PartialObject>

◆ PrecomputedSliceConnections

using Slic3r::SupportSpotsGenerator::PrecomputedSliceConnections = typedef std::vector<std::vector<SliceConnection> >

◆ SupportPoints

using Slic3r::SupportSpotsGenerator::SupportPoints = typedef std::vector<SupportPoint>

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

◆ build_object_part_from_slice()

std::tuple< ObjectPart, float > Slic3r::SupportSpotsGenerator::build_object_part_from_slice	(	const size_t &	slice_idx,
		const Layer *	layer,
		const Params &	params
	)

{
    ObjectPart new_object_part;
    float      area_covered_by_extrusions = 0;
    const LayerSlice& slice = layer->lslices_ex.at(slice_idx);
 
    auto add_extrusions_to_object = [&new_object_part, &area_covered_by_extrusions, &params](const ExtrusionEntity *e,
                                                                                             const LayerRegion     *region) {
        float                      flow_width = get_flow_width(region, e->role());
        const Layer               *l          = region->layer();
        float                      slice_z    = l->slice_z;
        float                      height     = l->height;
        std::vector<ExtrusionLine> lines      = to_short_lines(e, 5.0);
        for (const ExtrusionLine &line : lines) {
            float volume = line.len * height * flow_width * PI / 4.0f;
            area_covered_by_extrusions += line.len * flow_width;
            new_object_part.volume += volume;
            new_object_part.volume_centroid_accumulator += to_3d(Vec2f((line.a + line.b) / 2.0f), slice_z) * volume;
 
            if (int(l->id()) == params.raft_layers_count) { // layer attached on bed/raft
                new_object_part.connected_to_bed = true;
                float sticking_area              = line.len * flow_width;
                new_object_part.sticking_area += sticking_area;
                Vec2f middle = Vec2f((line.a + line.b) / 2.0f);
                new_object_part.sticking_centroid_accumulator += sticking_area * to_3d(middle, slice_z);
                // Bottom infill lines can be quite long, and algined, so the middle approximaton used above does not work
                Vec2f dir            = (line.b - line.a).normalized();
                float segment_length = flow_width; // segments of size flow_width
                for (float segment_middle_dist = std::min(line.len, segment_length * 0.5f); segment_middle_dist < line.len;
                     segment_middle_dist += segment_length) {
                    Vec2f segment_middle = line.a + segment_middle_dist * dir;
                    new_object_part.sticking_second_moment_of_area_accumulator += segment_length * flow_width *
                                                                                  segment_middle.cwiseProduct(segment_middle);
                    new_object_part.sticking_second_moment_of_area_covariance_accumulator += segment_length * flow_width *
                                                                                             segment_middle.x() * segment_middle.y();
                }
            }
        }
    };
 
    for (const auto &island : slice.islands) {
        const LayerRegion *perimeter_region = layer->get_region(island.perimeters.region());
        for (size_t perimeter_idx : island.perimeters) {
            for (const ExtrusionEntity *perimeter :
                 static_cast<const ExtrusionEntityCollection *>(perimeter_region->perimeters().entities[perimeter_idx])->entities) {
                add_extrusions_to_object(perimeter, perimeter_region);
            }
        }
        for (const LayerExtrusionRange &fill_range : island.fills) {
            const LayerRegion *fill_region = layer->get_region(fill_range.region());
            for (size_t fill_idx : fill_range) {
                for (const ExtrusionEntity *fill :
                     static_cast<const ExtrusionEntityCollection *>(fill_region->fills().entities[fill_idx])->entities) {
                    add_extrusions_to_object(fill, fill_region);
                }
            }
        }
        for (size_t thin_fill_idx : island.thin_fills) {
            add_extrusions_to_object(perimeter_region->thin_fills().entities[thin_fill_idx], perimeter_region);
        }
    }
 
    //  BRIM HANDLING
    if (int(layer->id()) == params.raft_layers_count && params.raft_layers_count == 0 && params.brim_type != BrimType::btNoBrim &&
        params.brim_width > 0.0) {
        // TODO: The algorithm here should take into account that multiple slices may have coliding Brim areas and the final brim area is
        // smaller,
        //  thus has lower adhesion. For now this effect will be neglected.
        ExPolygon  slice_poly = layer->lslices[slice_idx];
        ExPolygons brim;
        if (params.brim_type == BrimType::btOuterAndInner || params.brim_type == BrimType::btOuterOnly) {
            Polygon brim_hole = slice_poly.contour;
            brim_hole.reverse();
            Polygons c = expand(slice_poly.contour, scale_(params.brim_width)); // For very small polygons, the expand may result in empty vector, even thought the input is correct.
            if (!c.empty()) {
                brim.push_back(ExPolygon{c.front(), brim_hole});
            }
        }
        if (params.brim_type == BrimType::btOuterAndInner || params.brim_type == BrimType::btInnerOnly) {
            Polygons brim_contours = slice_poly.holes;
            polygons_reverse(brim_contours);
            for (const Polygon &brim_contour : brim_contours) {
                Polygons brim_holes = shrink({brim_contour}, scale_(params.brim_width));
                polygons_reverse(brim_holes);
                ExPolygon inner_brim{brim_contour};
                inner_brim.holes = brim_holes;
                brim.push_back(inner_brim);
            }
        }
 
        for (const Polygon &poly : to_polygons(brim)) {
            Vec2f p0 = unscaled(poly.first_point()).cast<float>();
            for (size_t i = 2; i < poly.points.size(); i++) {
                Vec2f p1 = unscaled(poly.points[i - 1]).cast<float>();
                Vec2f p2 = unscaled(poly.points[i]).cast<float>();
 
                float sign = cross2(p1 - p0, p2 - p1) > 0 ? 1.0f : -1.0f;
 
                auto [area, first_moment_of_area, second_moment_area,
                      second_moment_of_area_covariance] = compute_moments_of_area_of_triangle(p0, p1, p2);
                new_object_part.sticking_area += sign * area;
                new_object_part.sticking_centroid_accumulator += sign * Vec3f(first_moment_of_area.x(), first_moment_of_area.y(),
                                                                              layer->print_z * area);
                new_object_part.sticking_second_moment_of_area_accumulator += sign * second_moment_area;
                new_object_part.sticking_second_moment_of_area_covariance_accumulator += sign * second_moment_of_area_covariance;
            }
        }
    }
 
    return {new_object_part, area_covered_by_extrusions};
}

Referenced by build_object_part_from_slice(), and check_stability().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_extrusion_entity_stability()

std::vector< ExtrusionLine > Slic3r::SupportSpotsGenerator::check_extrusion_entity_stability	(	const ExtrusionEntity *	entity,
		const LayerRegion *	layer_region,
		const LD &	prev_layer_lines,
		const AABBTreeLines::LinesDistancer< Linef > &	prev_layer_boundary,
		const Params &	params
	)

{
    assert(!entity->is_collection());
    if (entity->role().is_bridge() && !entity->role().is_perimeter()) {
        // pure bridges are handled separately, beacuse we need to align the forward and backward direction support points
        if (entity->length() < scale_(params.min_distance_to_allow_local_supports)) {
            return {};
        }
        const float                flow_width       = get_flow_width(layer_region, entity->role());
        std::vector<ExtendedPoint> annotated_points = estimate_points_properties<true, true, true, true>(entity->as_polyline().points,
                                                                                                         prev_layer_boundary, flow_width,
                                                                                                         params.bridge_distance);
 
        std::vector<ExtrusionLine> lines_out;
        lines_out.reserve(annotated_points.size());
        float bridged_distance = 0.0f;
 
        std::optional<Vec2d> bridging_dir{};
 
        for (size_t i = 0; i < annotated_points.size(); ++i) {
            ExtendedPoint &curr_point = annotated_points[i];
            const ExtendedPoint &prev_point = i > 0 ? annotated_points[i - 1] : annotated_points[i];
 
            SupportPointCause potential_cause = std::abs(curr_point.curvature) > 0.1 ? SupportPointCause::FloatingBridgeAnchor :
                                                                                       SupportPointCause::LongBridge;
            float             line_len        = (prev_point.position - curr_point.position).norm();
            Vec2d line_dir = line_len > EPSILON ? Vec2d((curr_point.position - prev_point.position) / double(line_len)) : Vec2d::Zero();
 
            ExtrusionLine line_out{prev_point.position.cast<float>(), curr_point.position.cast<float>(), line_len, entity};
 
            float max_bridge_len = std::max(params.support_points_interface_radius * 2.0f,
                                            params.bridge_distance /
                                                ((1.0f + std::abs(curr_point.curvature)) * (1.0f + std::abs(curr_point.curvature)) *
                                                 (1.0f + std::abs(curr_point.curvature))));
 
            if (!bridging_dir.has_value() && curr_point.distance > flow_width && line_len > params.bridge_distance * 0.6) {
                bridging_dir = line_dir;
            }
 
            if (curr_point.distance > flow_width && potential_cause == SupportPointCause::LongBridge && bridging_dir.has_value() &&
                bridging_dir->dot(line_dir) < 0.8) { // skip backward direction of bridge - supported by forward points enough
                bridged_distance += line_len;
            } else if (curr_point.distance > flow_width) {
                bridged_distance += line_len;
                if (bridged_distance > max_bridge_len) {
                    bridged_distance                 = 0.0f;
                    line_out.support_point_generated = potential_cause;
                }
            } else {
                bridged_distance = 0.0f;
            }
 
            lines_out.push_back(line_out);
        }
        return lines_out;
 
    } else { // single extrusion path, with possible varying parameters
        if (entity->length() < scale_(params.min_distance_to_allow_local_supports)) {
            return {};
        }
 
        const float flow_width = get_flow_width(layer_region, entity->role());
        // Compute only unsigned distance - prev_layer_lines can contain unconnected paths, thus the sign of the distance is unreliable
        std::vector<ExtendedPoint> annotated_points = estimate_points_properties<true, true, false, false>(entity->as_polyline().points,
                                                                                                           prev_layer_lines, flow_width,
                                                                                                           params.bridge_distance);
 
        std::vector<ExtrusionLine> lines_out;
        lines_out.reserve(annotated_points.size());
        float bridged_distance = annotated_points.front().position != annotated_points.back().position ? (params.bridge_distance + 1.0f) :
                                                                                                         0.0f;
        for (size_t i = 0; i < annotated_points.size(); ++i) {
            ExtendedPoint       &curr_point = annotated_points[i];
            const ExtendedPoint &prev_point = i > 0 ? annotated_points[i - 1] : annotated_points[i];
            float                line_len   = (prev_point.position - curr_point.position).norm();
            ExtrusionLine        line_out{prev_point.position.cast<float>(), curr_point.position.cast<float>(), line_len, entity};
 
            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>(curr_point.position) + 0.5f * flow_width) < 0.0f ? -1.0f : 1.0f;
            curr_point.distance *= sign;
 
            SupportPointCause potential_cause = SupportPointCause::FloatingExtrusion;
            // Bridges are now separated. While long overhang perimeter is technically bridge, it would confuse the users
            // if (bridged_distance + line_len > params.bridge_distance * 0.8 && std::abs(curr_point.curvature) < 0.1) {
            //     potential_cause = SupportPointCause::FloatingExtrusion;
            // }
 
            float max_bridge_len = std::max(params.support_points_interface_radius * 2.0f,
                                            params.bridge_distance /
                                                ((1.0f + std::abs(curr_point.curvature)) * (1.0f + std::abs(curr_point.curvature)) *
                                                 (1.0f + std::abs(curr_point.curvature))));
 
            if (curr_point.distance > 1.2f * flow_width) {
                line_out.form_quality = 0.8f;
                bridged_distance += line_len;
                if (bridged_distance > max_bridge_len) {
                    line_out.support_point_generated = potential_cause;
                    bridged_distance                 = 0.0f;
                }
            } else if (curr_point.distance > flow_width * 0.8f) {
                bridged_distance += line_len;
                line_out.form_quality = bottom_line.form_quality - 0.3f;
                if (line_out.form_quality < 0 && bridged_distance > max_bridge_len) {
                    line_out.support_point_generated = potential_cause;
                    line_out.form_quality            = 0.5f;
                    bridged_distance                 = 0.0f;
                }
            } else {
                bridged_distance = 0.0f;
            }
 
            line_out.curled_up_height = estimate_curled_up_height(middle_distance, 0.5 * (prev_point.curvature + curr_point.curvature),
                                                                  layer_region->layer()->height, flow_width, bottom_line.curled_up_height,
                                                                  params);
 
            lines_out.push_back(line_out);
        }
 
        return lines_out;
    }
}

References Slic3r::ExtrusionEntity::as_polyline(), Slic3r::SupportSpotsGenerator::Params::bridge_distance, check_extrusion_entity_stability(), Slic3r::ExtrusionLine::curled_up_height, Slic3r::ExtendedPoint::curvature, Slic3r::ExtendedPoint::distance, Slic3r::AABBTreeLines::LinesDistancer< LineType >::distance_from_lines(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::distance_from_lines_extra(), EPSILON, estimate_curled_up_height(), Slic3r::ExtrusionLine::form_quality, get_flow_width(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::get_line(), Slic3r::AABBTreeLines::LinesDistancer< LineType >::get_lines(), Slic3r::Layer::height, Slic3r::ExtrusionRole::is_bridge(), Slic3r::ExtrusionEntity::is_collection(), Slic3r::ExtrusionRole::is_perimeter(), Slic3r::LayerRegion::layer(), Slic3r::ExtrusionEntity::length(), Slic3r::SupportSpotsGenerator::Params::min_distance_to_allow_local_supports, Slic3r::MultiPoint::points, Slic3r::ExtendedPoint::position, Slic3r::ExtrusionEntity::role(), scale_, sign(), and Slic3r::SupportSpotsGenerator::Params::support_points_interface_radius.

Referenced by check_extrusion_entity_stability().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_stability()

std::tuple< SupportPoints, PartialObjects > Slic3r::SupportSpotsGenerator::check_stability	(	const PrintObject *	po,
		const PrecomputedSliceConnections &	precomputed_slices_connections,
		const PrintTryCancel &	cancel_func,
		const Params &	params
	)

{
    SupportPoints     supp_points{};
    SupportGridFilter supports_presence_grid(po, params.min_distance_between_support_points);
    ActiveObjectParts active_object_parts{};
    PartialObjects    partial_objects{};
    LD                prev_layer_ext_perim_lines;
 
    std::unordered_map<size_t, size_t>          prev_slice_idx_to_object_part_mapping;
    std::unordered_map<size_t, size_t>          next_slice_idx_to_object_part_mapping;
    std::unordered_map<size_t, SliceConnection> prev_slice_idx_to_weakest_connection;
    std::unordered_map<size_t, SliceConnection> next_slice_idx_to_weakest_connection;
 
    auto remember_partial_object = [&active_object_parts, &partial_objects](size_t object_part_id) {
        auto object_part = active_object_parts.access(object_part_id);
        if (object_part.volume > EPSILON) {
            partial_objects.emplace_back(object_part.volume_centroid_accumulator / object_part.volume, object_part.volume,
                                         object_part.connected_to_bed);
        }
    };
 
    for (size_t layer_idx = 0; layer_idx < po->layer_count(); ++layer_idx) {
        cancel_func();
        const Layer *layer                 = po->get_layer(layer_idx);
        float        bottom_z              = layer->bottom_z();
        auto create_support_point_position = [bottom_z](const Vec2f &layer_pos) { return Vec3f{layer_pos.x(), layer_pos.y(), bottom_z}; };
 
        for (size_t slice_idx = 0; slice_idx < layer->lslices_ex.size(); ++slice_idx) {
            const LayerSlice &slice             = layer->lslices_ex.at(slice_idx);
            auto [new_part, covered_area]              = build_object_part_from_slice(slice_idx, layer, params);
            const SliceConnection &connection_to_below = precomputed_slices_connections[layer_idx][slice_idx];
 
#ifdef DETAILED_DEBUG_LOGS
            std::cout << "SLICE IDX: " << slice_idx << std::endl;
            for (const auto &link : slice.overlaps_below) {
                std::cout << "connected to slice below: " << link.slice_idx << "  by area : " << link.area << std::endl;
            }
            connection_to_below.print_info("CONNECTION TO BELOW");
#endif
 
            if (connection_to_below.area < EPSILON) { // new object part emerging
                size_t part_id = active_object_parts.insert(new_part);
                next_slice_idx_to_object_part_mapping.emplace(slice_idx, part_id);
                next_slice_idx_to_weakest_connection.emplace(slice_idx, connection_to_below);
            } else {
                size_t          final_part_id{};
                SliceConnection transfered_weakest_connection{};
                // MERGE parts
                {
                    std::unordered_set<size_t> parts_ids;
                    for (const auto &link : slice.overlaps_below) {
                        size_t part_id = active_object_parts.get_flat_id(prev_slice_idx_to_object_part_mapping.at(link.slice_idx));
                        parts_ids.insert(part_id);
                        transfered_weakest_connection.add(prev_slice_idx_to_weakest_connection.at(link.slice_idx));
                    }
 
                    final_part_id = *parts_ids.begin();
                    for (size_t part_id : parts_ids) {
                        if (final_part_id != part_id) {
                            remember_partial_object(part_id);
                            active_object_parts.merge(part_id, final_part_id);
                        }
                    }
                }
                auto estimate_conn_strength = [bottom_z](const SliceConnection &conn) {
                    if (conn.area < EPSILON) { // connection is empty, does not exists. Return max strength so that it is not picked as the
                                               // weakest connection.
                        return INFINITY;
                    }
                    Vec3f centroid         = conn.centroid_accumulator / conn.area;
                    Vec2f variance         = (conn.second_moment_of_area_accumulator / conn.area -
                                      centroid.head<2>().cwiseProduct(centroid.head<2>()));
                    float xy_variance      = variance.x() + variance.y();
                    float arm_len_estimate = std::max(1.0f, bottom_z - (conn.centroid_accumulator.z() / conn.area));
                    return conn.area * sqrt(xy_variance) / arm_len_estimate;
                };
 
#ifdef DETAILED_DEBUG_LOGS
                connection_to_below.print_info("new_weakest_connection");
                transfered_weakest_connection.print_info("transfered_weakest_connection");
#endif
 
                if (estimate_conn_strength(transfered_weakest_connection) > estimate_conn_strength(connection_to_below)) {
                    transfered_weakest_connection = connection_to_below;
                }
                next_slice_idx_to_weakest_connection.emplace(slice_idx, transfered_weakest_connection);
                next_slice_idx_to_object_part_mapping.emplace(slice_idx, final_part_id);
                ObjectPart &part = active_object_parts.access(final_part_id);
                part.add(new_part);
            }
        }
 
        prev_slice_idx_to_object_part_mapping = next_slice_idx_to_object_part_mapping;
        next_slice_idx_to_object_part_mapping.clear();
        prev_slice_idx_to_weakest_connection = next_slice_idx_to_weakest_connection;
        next_slice_idx_to_weakest_connection.clear();
 
        auto get_flat_entities = [](const ExtrusionEntity *e) {
            std::vector<const ExtrusionEntity *> entities;
            std::vector<const ExtrusionEntity *> queue{e};
            while (!queue.empty()) {
                const ExtrusionEntity *next = queue.back();
                queue.pop_back();
                if (next->is_collection()) {
                    for (const ExtrusionEntity *e : static_cast<const ExtrusionEntityCollection *>(next)->entities) {
                        queue.push_back(e);
                    }
                } else {
                    entities.push_back(next);
                }
            }
            return entities;
        };
 
        struct EnitityToCheck
        {
            const ExtrusionEntity *e;
            const LayerRegion     *region;
            size_t                 slice_idx;
        };
        std::vector<EnitityToCheck> entities_to_check;
        for (size_t slice_idx = 0; slice_idx < layer->lslices_ex.size(); ++slice_idx) {
            const LayerSlice &slice = layer->lslices_ex.at(slice_idx);
            for (const auto &island : slice.islands) {
                for (const LayerExtrusionRange &fill_range : island.fills) {
                    const LayerRegion *fill_region = layer->get_region(fill_range.region());
                    for (size_t fill_idx : fill_range) {
                        for (const ExtrusionEntity *e : get_flat_entities(fill_region->fills().entities[fill_idx])) {
                            if (e->role() == ExtrusionRole::BridgeInfill) {
                                entities_to_check.push_back({e, fill_region, slice_idx});
                            }
                        }
                    }
                }
 
                const LayerRegion *perimeter_region = layer->get_region(island.perimeters.region());
                for (size_t perimeter_idx : island.perimeters) {
                    for (const ExtrusionEntity *e : get_flat_entities(perimeter_region->perimeters().entities[perimeter_idx])) {
                        entities_to_check.push_back({e, perimeter_region, slice_idx});
                    }
                }
            }
        }
 
        AABBTreeLines::LinesDistancer<Linef> prev_layer_boundary = layer->lower_layer != nullptr ?
                                                                       AABBTreeLines::LinesDistancer<Linef>{
                                                                           to_unscaled_linesf(layer->lower_layer->lslices)} :
                                                                       AABBTreeLines::LinesDistancer<Linef>{};
 
        std::vector<tbb::concurrent_vector<ExtrusionLine>> unstable_lines_per_slice(layer->lslices_ex.size());
        std::vector<tbb::concurrent_vector<ExtrusionLine>> ext_perim_lines_per_slice(layer->lslices_ex.size());
 
        tbb::parallel_for(tbb::blocked_range<size_t>(0, entities_to_check.size()),
                          [&entities_to_check, &prev_layer_ext_perim_lines, &prev_layer_boundary, &unstable_lines_per_slice,
                           &ext_perim_lines_per_slice, &params](tbb::blocked_range<size_t> r) {
                              for (size_t entity_idx = r.begin(); entity_idx < r.end(); ++entity_idx) {
                                  const auto &e_to_check = entities_to_check[entity_idx];
                                  for (const auto &line :
                                       check_extrusion_entity_stability(e_to_check.e, e_to_check.region, prev_layer_ext_perim_lines,
                                                                        prev_layer_boundary, params)) {
                                      if (line.support_point_generated.has_value()) {
                                          unstable_lines_per_slice[e_to_check.slice_idx].push_back(line);
                                      }
                                      if (line.is_external_perimeter()) {
                                          ext_perim_lines_per_slice[e_to_check.slice_idx].push_back(line);
                                      }
                                  }
                              }
                          });
 
        std::vector<ExtrusionLine> current_layer_ext_perims_lines{};
        current_layer_ext_perims_lines.reserve(prev_layer_ext_perim_lines.get_lines().size());
        // All object parts updated, and for each slice we have coresponding weakest connection.
        // We can now check each slice and its corresponding weakest connection and object part for stability.
        for (size_t slice_idx = 0; slice_idx < layer->lslices_ex.size(); ++slice_idx) {
            ObjectPart                &part         = active_object_parts.access(prev_slice_idx_to_object_part_mapping[slice_idx]);
            SliceConnection           &weakest_conn = prev_slice_idx_to_weakest_connection[slice_idx];
 
#ifdef DETAILED_DEBUG_LOGS
            weakest_conn.print_info("weakest connection info: ");
#endif
            // Function that is used when new support point is generated. It will update the ObjectPart stability, weakest conneciton info,
            // and the support presence grid and add the point to the issues.
            auto reckon_new_support_point = [&part, &weakest_conn, &supp_points, &supports_presence_grid, &params,
                                             &layer_idx](SupportPointCause cause, const Vec3f &support_point, float force,
                                                         const Vec2f &dir) {
                // if position is taken and point is for global stability (force > 0) or we are too close to the bed, do not add
                // This allows local support points (e.g. bridging) to be generated densely
                if ((supports_presence_grid.position_taken(support_point) && force > 0) || layer_idx <= 1) {
                    return;
                }
 
                float area = params.support_points_interface_radius * params.support_points_interface_radius * float(PI);
                // add the stability effect of the point only if the spot is not taken, so that the densely created local support points do
                // not add unrealistic amount of stability to the object (due to overlaping of local support points)
                if (!(supports_presence_grid.position_taken(support_point))) {
                    part.add_support_point(support_point, area);
                }
 
                float radius = params.support_points_interface_radius;
                supp_points.emplace_back(cause, support_point, force, radius, dir);
                supports_presence_grid.take_position(support_point);
 
                // The support point also increases the stability of the weakest connection of the object, which should be reflected
                if (weakest_conn.area > EPSILON) { // Do not add it to the weakest connection if it is not valid - does not exist
                    weakest_conn.area += area;
                    weakest_conn.centroid_accumulator += support_point * area;
                    weakest_conn.second_moment_of_area_accumulator += area * support_point.head<2>().cwiseProduct(support_point.head<2>());
                    weakest_conn.second_moment_of_area_covariance_accumulator += area * support_point.x() * support_point.y();
                }
            };
 
            for (const auto &l : unstable_lines_per_slice[slice_idx]) {
                assert(l.support_point_generated.has_value());
                reckon_new_support_point(*l.support_point_generated, create_support_point_position(l.b), float(-EPSILON), Vec2f::Zero());
            }
 
            LD    current_slice_lines_distancer({ext_perim_lines_per_slice[slice_idx].begin(), ext_perim_lines_per_slice[slice_idx].end()});
            float unchecked_dist = params.min_distance_between_support_points + 1.0f;
 
            for (const ExtrusionLine &line : current_slice_lines_distancer.get_lines()) {
                if ((unchecked_dist + line.len < params.min_distance_between_support_points && line.curled_up_height < params.curling_tolerance_limit) ||
                    line.len < EPSILON) {
                    unchecked_dist += line.len;
                } else {
                    unchecked_dist                = line.len;
                    Vec2f pivot_site_search_point = Vec2f(line.b + (line.b - line.a).normalized() * 300.0f);
                    auto [dist, nidx,
                          nearest_point]          = current_slice_lines_distancer.distance_from_lines_extra<false>(pivot_site_search_point);
                    Vec3f support_point           = create_support_point_position(nearest_point);
                    auto [force, cause]           = part.is_stable_while_extruding(weakest_conn, line, support_point, bottom_z, params);
                    if (force > 0) {
                        reckon_new_support_point(cause, support_point, force, (line.b - line.a).normalized());
                    }
                }
            }
            current_layer_ext_perims_lines.insert(current_layer_ext_perims_lines.end(), current_slice_lines_distancer.get_lines().begin(),
                                                  current_slice_lines_distancer.get_lines().end());
        } // slice iterations
        prev_layer_ext_perim_lines = LD(current_layer_ext_perims_lines);
    } // layer iterations
 
    for (const auto& active_obj_pair : prev_slice_idx_to_object_part_mapping) {
        remember_partial_object(active_obj_pair.second);
    }
 
    return {supp_points, partial_objects};
}

Referenced by check_stability(), and full_search().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 estimate_curled_up_height(), Slic3r::layer_height(), Slic3r::SupportSpotsGenerator::Params::malformation_distance_factors, Slic3r::SupportSpotsGenerator::Params::max_curled_height_factor, and sqrt().

Referenced by check_extrusion_entity_stability(), estimate_curled_up_height(), estimate_malformations(), and estimate_supports_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().is_external_perimeter())
                    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 &a = i > 0 ? annotated_points[i - 1] : annotated_points[i];
                    const ExtendedPoint &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, 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::SupportSpotsGenerator::Params::bridge_distance, Slic3r::ExtrusionLine::curled_up_height, Slic3r::SupportSpotsGenerator::Params::curling_tolerance_limit, Slic3r::debug_out_path(), EPSILON, estimate_curled_up_height(), estimate_malformations(), get_flow_width(), Slic3r::SupportSpotsGenerator::Params::max_curled_height_factor, sign(), Slic3r::to_unscaled_linesf(), and Slic3r::value_to_rgbf().

Referenced by estimate_malformations().

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
	)

◆ estimate_slice_connection()

SliceConnection Slic3r::SupportSpotsGenerator::estimate_slice_connection	(	size_t	slice_idx,
		const Layer *	layer
	)

{
    SliceConnection connection;
 
    const LayerSlice   &slice       = layer->lslices_ex[slice_idx];
    Polygons           slice_polys  = to_polygons(layer->lslices[slice_idx]);
    BoundingBox slice_bb = get_extents(slice_polys);
    const Layer        *lower_layer = layer->lower_layer;
 
    ExPolygons below{};
    for (const auto &link : slice.overlaps_below) { below.push_back(lower_layer->lslices[link.slice_idx]); }
    Polygons below_polys = to_polygons(below);
 
    BoundingBox below_bb = get_extents(below_polys);
 
    Polygons overlap = intersection(ClipperUtils::clip_clipper_polygons_with_subject_bbox(slice_polys, below_bb),
                                    ClipperUtils::clip_clipper_polygons_with_subject_bbox(below_polys, slice_bb));
 
    for (const Polygon &poly : overlap) {
        Vec2f p0 = unscaled(poly.first_point()).cast<float>();
        for (size_t i = 2; i < poly.points.size(); i++) {
            Vec2f p1 = unscaled(poly.points[i - 1]).cast<float>();
            Vec2f p2 = unscaled(poly.points[i]).cast<float>();
 
            float sign = cross2(p1 - p0, p2 - p1) > 0 ? 1.0f : -1.0f;
 
            auto [area, first_moment_of_area, second_moment_area,
                  second_moment_of_area_covariance] = compute_moments_of_area_of_triangle(p0, p1, p2);
            connection.area += sign * area;
            connection.centroid_accumulator += sign * Vec3f(first_moment_of_area.x(), first_moment_of_area.y(), layer->print_z * area);
            connection.second_moment_of_area_accumulator += sign * second_moment_area;
            connection.second_moment_of_area_covariance_accumulator += sign * second_moment_of_area_covariance;
        }
    }
 
    return connection;
};

References Slic3r::area(), Slic3r::SupportSpotsGenerator::SliceConnection::area, Slic3r::SupportSpotsGenerator::SliceConnection::centroid_accumulator, Slic3r::ClipperUtils::clip_clipper_polygons_with_subject_bbox(), Slic3r::compute_moments_of_area_of_triangle(), Slic3r::cross2(), Slic3r::get_extents(), Slic3r::intersection(), Slic3r::Layer::lower_layer, Slic3r::Layer::lslices, Slic3r::Layer::lslices_ex, Slic3r::Layer::print_z, Slic3r::SupportSpotsGenerator::SliceConnection::second_moment_of_area_accumulator, Slic3r::SupportSpotsGenerator::SliceConnection::second_moment_of_area_covariance_accumulator, sign(), Slic3r::to_polygons(), and Slic3r::unscaled().

Here is the call graph for this function:

◆ estimate_supports_malformations() [1/2]

void Slic3r::SupportSpotsGenerator::estimate_supports_malformations	(	std::vector< SupportLayer * > &	layers,
		float	supports_flow_width,
		const Params &	params
	)

◆ estimate_supports_malformations() [2/2]

void Slic3r::SupportSpotsGenerator::estimate_supports_malformations	(	SupportLayerPtrs &	layers,
		float	flow_width,
		const Params &	params
	)

{
#ifdef DEBUG_FILES
    FILE *debug_file = boost::nowide::fopen(debug_out_path("supports_malformations.obj").c_str(), "w");
    FILE *full_file = boost::nowide::fopen(debug_out_path("supports_full.obj").c_str(), "w");
#endif
 
    AABBTreeLines::LinesDistancer<ExtrusionLine> prev_layer_lines{};
 
    for (SupportLayer *l : layers) {
        l->curled_lines.clear();
        std::vector<ExtrusionLine> current_layer_lines;
 
        for (const ExtrusionEntity *extrusion : l->support_fills.flatten().entities) {
            Polyline pl = extrusion->as_polyline();
            Polygon  pol(pl.points);
            pol.make_counter_clockwise();
 
            auto annotated_points = estimate_points_properties<true, true, false, false>(pol.points, prev_layer_lines, flow_width);
 
            for (size_t i = 0; i < annotated_points.size(); ++i) {
                const ExtendedPoint &a = i > 0 ? annotated_points[i - 1] : annotated_points[i];
                const ExtendedPoint &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);
 
                Vec2f v1   = (bottom_line.b - bottom_line.a);
                Vec2f v2   = (a.position.cast<float>() - bottom_line.a);
                auto  d    = (v1.x() * v2.y()) - (v1.y() * v2.x());
                float sign = (d > 0) ? -1.0f : 1.0f;
 
                line_out.curled_up_height = estimate_curled_up_height(middle_distance * sign, 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::ExtrusionLine::curled_up_height, Slic3r::SupportSpotsGenerator::Params::curling_tolerance_limit, Slic3r::debug_out_path(), EPSILON, estimate_curled_up_height(), estimate_supports_malformations(), Slic3r::Polygon::make_counter_clockwise(), Slic3r::SupportSpotsGenerator::Params::max_curled_height_factor, Slic3r::MultiPoint::points, sign(), and Slic3r::value_to_rgbf().

Referenced by estimate_supports_malformations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ full_search()

std::tuple< SupportPoints, PartialObjects > Slic3r::SupportSpotsGenerator::full_search	(	const PrintObject *	po,
		const PrintTryCancel &	cancel_func,
		const Params &	params
	)

{
    auto precomputed_slices_connections = precompute_slices_connections(po);
    auto results = check_stability(po, precomputed_slices_connections, cancel_func, params);
#ifdef DEBUG_FILES
    auto [supp_points, objects] = results;
    debug_export(supp_points, objects, "issues");
#endif
 
    return results;
}

References check_stability(), full_search(), and precompute_slices_connections().

Referenced by full_search().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gather_issues()

std::vector< std::pair< SupportPointCause, bool > > Slic3r::SupportSpotsGenerator::gather_issues	(	const SupportPoints &	support_points,
		PartialObjects &	partial_objects
	)

{
    std::vector<std::pair<SupportPointCause, bool>> result;
    // The partial object are most likely sorted from smaller to larger as the print continues, so this should save some sorting time
    std::reverse(partial_objects.begin(), partial_objects.end());
    std::sort(partial_objects.begin(), partial_objects.end(),
              [](const PartialObject &left, const PartialObject &right) { return left.volume > right.volume; });
 
    // Object may have zero extrusions and thus no partial objects. (e.g. very tiny object)
    float max_volume_part = partial_objects.empty() ? 0.0f : partial_objects.front().volume;
    for (const PartialObject &p : partial_objects) {
        if (p.volume > max_volume_part / 200.0f && !p.connected_to_bed) {
                result.emplace_back(SupportPointCause::UnstableFloatingPart, true);
                break;
        }
    }
 
    // should be detected in previous step
    // if (!unstable_floating_part_added) {
    //     for (const SupportPoint &sp : support_points) {
    //             if (sp.cause == SupportPointCause::UnstableFloatingPart) {
    //             result.emplace_back(SupportPointCause::UnstableFloatingPart, true);
    //             break;
    //             }
    //     }
    // }
 
    std::vector<SupportPoint> ext_supp_points{};
    ext_supp_points.reserve(support_points.size());
    for (const SupportPoint &sp : support_points) {
        switch (sp.cause) {
        case SupportPointCause::FloatingBridgeAnchor:
        case SupportPointCause::FloatingExtrusion: ext_supp_points.push_back(sp); break;
        default: break;
        }
    }
 
    auto coord_fn = [&ext_supp_points](size_t idx, size_t dim) { return ext_supp_points[idx].position[dim]; };
    KDTreeIndirect<3, float, decltype(coord_fn)> ext_points_tree{coord_fn, ext_supp_points.size()};
    for (const SupportPoint &sp : ext_supp_points) {
        auto cluster         = find_nearby_points(ext_points_tree, sp.position, 3.0);
        int  score           = 0;
        bool floating_bridge = false;
        for (size_t idx : cluster) {
                score += ext_supp_points[idx].cause == SupportPointCause::FloatingBridgeAnchor ? 3 : 1;
                floating_bridge = floating_bridge || ext_supp_points[idx].cause == SupportPointCause::FloatingBridgeAnchor;
        }
        if (score > 5) {
                if (floating_bridge) {
                result.emplace_back(SupportPointCause::FloatingBridgeAnchor, true);
                } else {
                result.emplace_back(SupportPointCause::FloatingExtrusion, true);
                }
                break;
        }
    }
 
    for (const SupportPoint &sp : support_points) {
        if (sp.cause == SupportPointCause::SeparationFromBed) {
                result.emplace_back(SupportPointCause::SeparationFromBed, true);
                break;
        }
    }
 
    for (const SupportPoint &sp : support_points) {
        if (sp.cause == SupportPointCause::WeakObjectPart) {
                result.emplace_back(SupportPointCause::WeakObjectPart, true);
                break;
        }
    }
 
    if (ext_supp_points.size() > max_volume_part / 200.0f) {
        result.emplace_back(SupportPointCause::FloatingExtrusion, false);
    }
 
    for (const SupportPoint &sp : support_points) {
        if (sp.cause == SupportPointCause::LongBridge) {
                result.emplace_back(SupportPointCause::LongBridge, false);
                break;
        }
    }
 
    return result;
}

References Slic3r::find_nearby_points(), and gather_issues().

Referenced by Slic3r::Print::alert_when_supports_needed(), and gather_issues().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_flow_width()

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

{
    if (role == ExtrusionRole::BridgeInfill) return region->flow(FlowRole::frExternalPerimeter).width();
    if (role == ExtrusionRole::ExternalPerimeter) return region->flow(FlowRole::frExternalPerimeter).width();
    if (role == ExtrusionRole::GapFill) return region->flow(FlowRole::frInfill).width();
    if (role == ExtrusionRole::Perimeter) return region->flow(FlowRole::frPerimeter).width();
    if (role == ExtrusionRole::SolidInfill) return region->flow(FlowRole::frSolidInfill).width();
    if (role == ExtrusionRole::InternalInfill) return region->flow(FlowRole::frInfill).width();
    if (role == ExtrusionRole::TopSolidInfill) return region->flow(FlowRole::frTopSolidInfill).width();
    // default
    return region->flow(FlowRole::frPerimeter).width();
}

References Slic3r::ExtrusionRole::BridgeInfill, Slic3r::ExtrusionRole::ExternalPerimeter, Slic3r::LayerRegion::flow(), Slic3r::frExternalPerimeter, Slic3r::frInfill, Slic3r::frPerimeter, Slic3r::frSolidInfill, Slic3r::frTopSolidInfill, Slic3r::ExtrusionRole::GapFill, get_flow_width(), Slic3r::ExtrusionRole::InternalInfill, Slic3r::ExtrusionRole::Perimeter, Slic3r::ExtrusionRole::SolidInfill, Slic3r::ExtrusionRole::TopSolidInfill, and Slic3r::Flow::width().

Referenced by build_object_part_from_slice(), check_extrusion_entity_stability(), estimate_malformations(), and get_flow_width().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ precompute_slices_connections()

PrecomputedSliceConnections Slic3r::SupportSpotsGenerator::precompute_slices_connections ( const PrintObject * po )

{
    PrecomputedSliceConnections result{};
    for (size_t lidx = 0; lidx < po->layer_count(); lidx++) {
        result.emplace_back(std::vector<SliceConnection>{});
        for (size_t slice_idx = 0; slice_idx < po->get_layer(lidx)->lslices_ex.size(); slice_idx++) {
            result[lidx].push_back(SliceConnection{});
        }
    }
 
    tbb::parallel_for(tbb::blocked_range<size_t>(0, po->layers().size()), [po, &result](tbb::blocked_range<size_t> r) {
        for (size_t lidx = r.begin(); lidx < r.end(); lidx++) {
            const Layer *l = po->get_layer(lidx);
            tbb::parallel_for(tbb::blocked_range<size_t>(0, l->lslices_ex.size()), [lidx, l, &result](tbb::blocked_range<size_t> r2) {
                for (size_t slice_idx = r2.begin(); slice_idx < r2.end(); slice_idx++) {
                    result[lidx][slice_idx] = estimate_slice_connection(slice_idx, l);
                }
            });
        }
    });
 
    return result;
};

References Slic3r::PrintObject::get_layer(), Slic3r::PrintObject::layer_count(), and Slic3r::PrintObject::layers().

Referenced by full_search().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_short_lines()

std::vector< ExtrusionLine > Slic3r::SupportSpotsGenerator::to_short_lines	(	const ExtrusionEntity *	e,
		float	length_limit
	)

{
    assert(!e->is_collection());
    Polyline                   pl = e->as_polyline();
    std::vector<ExtrusionLine> lines;
    lines.reserve(pl.points.size() * 1.5f);
    for (int point_idx = 0; point_idx < int(pl.points.size()) - 1; ++point_idx) {
        Vec2f start        = unscaled(pl.points[point_idx]).cast<float>();
        Vec2f next         = unscaled(pl.points[point_idx + 1]).cast<float>();
        Vec2f v            = next - start; // vector from next to current
        float dist_to_next = v.norm();
        v.normalize();
        int   lines_count = int(std::ceil(dist_to_next / length_limit));
        float step_size   = dist_to_next / lines_count;
        for (int i = 0; i < lines_count; ++i) {
            Vec2f a(start + v * (i * step_size));
            Vec2f b(start + v * ((i + 1) * step_size));
            lines.emplace_back(a, b, (a-b).norm(), e);
        }
    }
    return lines;
}

References Slic3r::ExtrusionEntity::as_polyline(), Slic3r::ExtrusionEntity::is_collection(), Slic3r::MultiPoint::points, to_short_lines(), and Slic3r::unscaled().

Referenced by build_object_part_from_slice(), and to_short_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Typedefs

Enumerations

Functions

Class Documentation

◆ Slic3r::SupportSpotsGenerator::Malformations

Typedef Documentation

◆ LD

◆ PartialObjects

◆ PrecomputedSliceConnections

◆ SupportPoints

Enumeration Type Documentation

◆ SupportPointCause

Function Documentation

◆ build_object_part_from_slice()

◆ check_extrusion_entity_stability()

◆ check_stability()

◆ estimate_curled_up_height()

◆ estimate_malformations() [1/2]

◆ estimate_malformations() [2/2]

◆ estimate_slice_connection()

◆ estimate_supports_malformations() [1/2]

◆ estimate_supports_malformations() [2/2]

◆ full_search()

◆ gather_issues()

◆ get_flow_width()

◆ precompute_slices_connections()

◆ to_short_lines()