Slic3r::SupportMaterialInternal Namespace Reference

Functions
static bool	has_bridging_perimeters (const ExtrusionLoop &loop)
static bool	has_bridging_perimeters (const ExtrusionEntityCollection &perimeters)
static bool	has_bridging_fills (const ExtrusionEntityCollection &fills)
static bool	has_bridging_extrusions (const Layer &layer)
static void	collect_bridging_perimeter_areas (const ExtrusionLoop &loop, const float expansion_scaled, Polygons &out)
static void	collect_bridging_perimeter_areas (const ExtrusionEntityCollection &perimeters, const float expansion_scaled, Polygons &out)
static void	remove_bridges_from_contacts (const PrintConfig &print_config, const Layer &lower_layer, const Polygons &lower_layer_polygons, const LayerRegion &layerm, float fw, Polygons &contact_polygons)

Function Documentation

collect_bridging_perimeter_areas() [1/2]

void Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas ( const ExtrusionEntityCollection & perimeters, const float expansion_scaled, Polygons & out )

static

    {
        for (const ExtrusionEntity *ee : perimeters.entities) {
            if (ee->is_collection()) {
                for (const ExtrusionEntity *ee2 : static_cast<const ExtrusionEntityCollection*>(ee)->entities) {
                    assert(! ee2->is_collection());
                    if (ee2->is_loop())
                        collect_bridging_perimeter_areas(*static_cast<const ExtrusionLoop*>(ee2), expansion_scaled, out);
                }
            } else if (ee->is_loop())
                collect_bridging_perimeter_areas(*static_cast<const ExtrusionLoop*>(ee), expansion_scaled, out);
        }
    }

References collect_bridging_perimeter_areas(), Slic3r::ExtrusionEntityCollection::entities, Slic3r::ExtrusionEntity::is_collection(), and Slic3r::ExtrusionEntity::is_loop().

Here is the call graph for this function:

collect_bridging_perimeter_areas() [2/2]

void Slic3r::SupportMaterialInternal::collect_bridging_perimeter_areas ( const ExtrusionLoop & loop, const float expansion_scaled, Polygons & out )

inlinestatic

    {
        assert(expansion_scaled >= 0.f);
        for (const ExtrusionPath &ep : loop.paths)
            if (ep.role() == erOverhangPerimeter && ! ep.polyline.empty()) {
                float exp = 0.5f * (float)scale_(ep.width) + expansion_scaled;
                if (ep.is_closed()) {
                    if (ep.size() >= 3) {
                        // This is a complete loop.
                        // Add the outer contour first.
                        Polygon poly;
                        // Convert Points3 to Points
                        for (const Point3 &p3 : ep.polyline.points)
                            poly.points.emplace_back(p3.x(), p3.y());
                        poly.points.pop_back();
                        if (poly.area() < 0)
                            poly.reverse();
                        polygons_append(out, offset(poly, exp, SUPPORT_SURFACES_OFFSET_PARAMETERS));
                        Polygons holes = offset(poly, - exp, SUPPORT_SURFACES_OFFSET_PARAMETERS);
                        polygons_reverse(holes);
                        polygons_append(out, holes);
                    }
                } else if (ep.size() >= 2) {
                    // Offset the polyline.
                    polygons_append(out, offset(ep.polyline, exp, SUPPORT_SURFACES_OFFSET_PARAMETERS));
                }
            }
    }

References Slic3r::MultiPoint3::empty(), Slic3r::erOverhangPerimeter, Slic3r::holes(), Slic3r::ExtrusionPath::is_closed(), Slic3r::offset(), Slic3r::ExtrusionLoop::paths, Slic3r::MultiPoint3::points, Slic3r::polygons_append(), Slic3r::polygons_reverse(), Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPath::role(), scale_, Slic3r::ExtrusionPath::size(), SUPPORT_SURFACES_OFFSET_PARAMETERS, and Slic3r::ExtrusionPath::width.

Referenced by collect_bridging_perimeter_areas(), and Slic3r::PrintObjectSupportMaterial::trim_support_layers_by_object().

Here is the call graph for this function:

Here is the caller graph for this function:

has_bridging_extrusions()

bool Slic3r::SupportMaterialInternal::has_bridging_extrusions ( const Layer & layer )

static

    {
        for (const LayerRegion *region : layer.regions()) {
            if (SupportMaterialInternal::has_bridging_perimeters(region->perimeters))
                return true;
            if (region->fill_surfaces.has(stBottomBridge) && has_bridging_fills(region->fills))
                return true;
        }
        return false;
    }

References has_bridging_fills(), has_bridging_perimeters(), Slic3r::Layer::regions(), and Slic3r::stBottomBridge.

Referenced by Slic3r::new_contact_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

has_bridging_fills()

bool Slic3r::SupportMaterialInternal::has_bridging_fills ( const ExtrusionEntityCollection & fills )

static

    {
        for (const ExtrusionEntity *ee : fills.entities) {
            assert(ee->is_collection());
            for (const ExtrusionEntity *ee2 : static_cast<const ExtrusionEntityCollection*>(ee)->entities) {
                assert(! ee2->is_collection());
                assert(! ee2->is_loop());
                if (ee2->role() == erBridgeInfill || ee2->role() == erInternalBridgeInfill)
                    return true;
            }
        }
        return false;
    }

References Slic3r::ExtrusionEntityCollection::entities, Slic3r::erBridgeInfill, Slic3r::erInternalBridgeInfill, and Slic3r::ExtrusionEntity::is_collection().

Referenced by has_bridging_extrusions().

Here is the call graph for this function:

Here is the caller graph for this function:

has_bridging_perimeters() [1/2]

bool Slic3r::SupportMaterialInternal::has_bridging_perimeters ( const ExtrusionEntityCollection & perimeters )

static

    {
        for (const ExtrusionEntity *ee : perimeters.entities) {
            if (ee->is_collection()) {
                for (const ExtrusionEntity *ee2 : static_cast<const ExtrusionEntityCollection*>(ee)->entities) {
                    assert(! ee2->is_collection());
                    if (ee2->is_loop())
                        if (has_bridging_perimeters(*static_cast<const ExtrusionLoop*>(ee2)))
                            return true;
                }
            } else if (ee->is_loop() && has_bridging_perimeters(*static_cast<const ExtrusionLoop*>(ee)))
                return true;
        }
        return false;
    }

References Slic3r::ExtrusionEntityCollection::entities, has_bridging_perimeters(), Slic3r::ExtrusionEntity::is_collection(), and Slic3r::ExtrusionEntity::is_loop().

Here is the call graph for this function:

has_bridging_perimeters() [2/2]

bool Slic3r::SupportMaterialInternal::has_bridging_perimeters ( const ExtrusionLoop & loop )

inlinestatic

    {
        for (const ExtrusionPath &ep : loop.paths)
            if (ep.role() == erOverhangPerimeter && ! ep.polyline.empty())
                return int(ep.size()) >= (ep.is_closed() ? 3 : 2);
        return false;
    }

References Slic3r::MultiPoint3::empty(), Slic3r::erOverhangPerimeter, Slic3r::ExtrusionPath::is_closed(), Slic3r::ExtrusionLoop::paths, Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPath::role(), and Slic3r::ExtrusionPath::size().

Referenced by has_bridging_extrusions(), and has_bridging_perimeters().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_bridges_from_contacts()

void Slic3r::SupportMaterialInternal::remove_bridges_from_contacts ( const PrintConfig & print_config, const Layer & lower_layer, const Polygons & lower_layer_polygons, const LayerRegion & layerm, float fw, Polygons & contact_polygons )

static

    {
        // compute the area of bridging perimeters
        Polygons bridges;
        {
            // Surface supporting this layer, expanded by 0.5 * nozzle_diameter, as we consider this kind of overhang to be sufficiently supported.
            Polygons lower_grown_slices = expand(lower_layer_polygons,
                //FIXME to mimic the decision in the perimeter generator, we should use half the external perimeter width.
                0.5f * float(scale_(print_config.nozzle_diameter.get_at(layerm.region().config().outer_wall_filament_id-1))),
                SUPPORT_SURFACES_OFFSET_PARAMETERS);
            // Collect perimeters of this layer.
            //FIXME split_at_first_point() could split a bridge mid-way
        #if 0
            Polylines overhang_perimeters = layerm.perimeters.as_polylines();
            // workaround for Clipper bug, see Slic3r::Polygon::clip_as_polyline()
            for (Polyline &polyline : overhang_perimeters)
                polyline.points[0].x += 1;
            // Trim the perimeters of this layer by the lower layer to get the unsupported pieces of perimeters.
            overhang_perimeters = diff_pl(overhang_perimeters, lower_grown_slices);
        #else
            Polylines overhang_perimeters = diff_pl(layerm.perimeters.as_polylines(), lower_grown_slices);
        #endif
            
            // only consider straight overhangs
            // only consider overhangs having endpoints inside layer's slices
            // convert bridging polylines into polygons by inflating them with their thickness
            // since we're dealing with bridges, we can't assume width is larger than spacing,
            // so we take the largest value and also apply safety offset to be ensure no gaps
            // are left in between
            // BBS
            const PrintObjectConfig& object_config = layerm.layer()->object()->config();
            Flow perimeter_bridge_flow = layerm.bridging_flow(frPerimeter, object_config.thick_bridges);
            //FIXME one may want to use a maximum of bridging flow width and normal flow width, as the perimeters are calculated using the normal flow
            // and then turned to bridging flow, thus their centerlines are derived from non-bridging flow and expanding them by a bridging flow
            // may not expand them to the edge of their respective islands.
            const float w = float(0.5 * std::max(perimeter_bridge_flow.scaled_width(), perimeter_bridge_flow.scaled_spacing())) + scaled<float>(0.001);
            for (Polyline &polyline : overhang_perimeters)
                if (polyline.is_straight()) {
                    // This is a bridge 
                    polyline.extend_start(fw);
                    polyline.extend_end(fw);
                    // Is the straight perimeter segment supported at both sides?
                    Point pts[2]       = { polyline.first_point(), polyline.last_point() };
                    bool  supported[2] = { false, false };
                    for (size_t i = 0; i < lower_layer.lslices.size() && ! (supported[0] && supported[1]); ++ i)
                        for (int j = 0; j < 2; ++ j)
                            if (! supported[j] && lower_layer.lslices_bboxes[i].contains(pts[j]) && lower_layer.lslices[i].contains(pts[j]))
                                supported[j] = true;
                    if (supported[0] && supported[1])
                        // Offset a polyline into a thick line.
                        polygons_append(bridges, offset(polyline, w));
                }
            bridges = union_(bridges);
        }
        // remove the entire bridges and only support the unsupported edges
        //FIXME the brided regions are already collected as layerm.bridged. Use it?
        for (const Surface &surface : layerm.fill_surfaces.surfaces)
            if (surface.surface_type == stBottomBridge && surface.bridge_angle >= 0.0)
                polygons_append(bridges, surface.expolygon);
        //FIXME add the gap filled areas. Extrude the gaps with a bridge flow?
        // Remove the unsupported ends of the bridges from the bridged areas.
        //FIXME add supports at regular intervals to support long bridges!
        bridges = diff(bridges,
                // Offset unsupported edges into polygons.
                offset(layerm.unsupported_bridge_edges, scale_(SUPPORT_MATERIAL_MARGIN), SUPPORT_SURFACES_OFFSET_PARAMETERS));
        // Remove bridged areas from the supported areas.
        contact_polygons = diff(contact_polygons, bridges, ApplySafetyOffset::Yes);
 
        #ifdef SLIC3R_DEBUG
            static int iRun = 0;
            SVG::export_expolygons(debug_out_path("support-top-contacts-remove-bridges-run%d.svg", iRun ++),
                { { { union_ex(offset(layerm.unsupported_bridge_edges, scale_(SUPPORT_MATERIAL_MARGIN), SUPPORT_SURFACES_OFFSET_PARAMETERS)) }, { "unsupported_bridge_edges", "orange", 0.5f } },
                  { { union_ex(contact_polygons) },            { "contact_polygons",           "blue",   0.5f } },
                  { { union_ex(bridges) },                     { "bridges",                    "red",    "black", "", scaled<coord_t>(0.1f), 0.5f } } });
        #endif /* SLIC3R_DEBUG */
    }

References Slic3r::ExtrusionEntity::as_polylines(), Slic3r::Surface::bridge_angle, Slic3r::LayerRegion::bridging_flow(), Slic3r::PrintObject::config(), Slic3r::PrintRegion::config(), Slic3r::debug_out_path(), Slic3r::diff(), Slic3r::diff_pl(), Slic3r::expand(), Slic3r::Surface::expolygon, Slic3r::SVG::export_expolygons(), Slic3r::LayerRegion::fill_surfaces, Slic3r::frPerimeter, Slic3r::LayerRegion::layer(), Slic3r::Layer::lslices, Slic3r::Layer::lslices_bboxes, Slic3r::Layer::object(), Slic3r::offset(), Slic3r::LayerRegion::perimeters, Slic3r::polygons_append(), Slic3r::PrintObjectConfig, Slic3r::LayerRegion::region(), scale_, Slic3r::scaled(), Slic3r::Flow::scaled_spacing(), Slic3r::Flow::scaled_width(), Slic3r::stBottomBridge, SUPPORT_MATERIAL_MARGIN, SUPPORT_SURFACES_OFFSET_PARAMETERS, Slic3r::Surface::surface_type, Slic3r::SurfaceCollection::surfaces, Slic3r::union_(), Slic3r::union_ex(), Slic3r::LayerRegion::unsupported_bridge_edges, and Slic3r::Yes.

Referenced by Slic3r::detect_overhangs().

Here is the call graph for this function:

Here is the caller graph for this function: