Slic3r::InterlockingGenerator Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/InterlockingGenerator.hpp>

Collaboration diagram for Slic3r::InterlockingGenerator:

Static Public Member Functions
static void	generate_interlocking_structure (PrintObject *print_object, const std::function< void()> &throw_on_cancel)

Private Member Functions
void	generateInterlockingStructure () const
	InterlockingGenerator (PrintObject &print_object, const size_t region_a_index, const size_t region_b_index, const coord_t beam_width, const coord_t boundary_avoidance, const float rotation, const Vec3crd &cell_size, const coord_t beam_layer_count, const DilationKernel &interface_dilation, const DilationKernel &air_dilation, const bool air_filtering, const std::function< void()> &throw_on_cancel)
std::pair< ExPolygons, ExPolygons >	growBorderAreasPerpendicular (const ExPolygons &a, const ExPolygons &b, const coord_t &detect) const
void	handleThinAreas (const std::unordered_set< GridPoint3 > &has_all_meshes) const
std::vector< std::unordered_set< GridPoint3 > >	getShellVoxels (const DilationKernel &kernel) const
void	addBoundaryCells (const std::vector< ExPolygons > &layers, const DilationKernel &kernel, std::unordered_set< GridPoint3 > &cells) const
std::vector< ExPolygons >	computeUnionedVolumeRegions () const
std::vector< std::vector< ExPolygons > >	generateMicrostructure () const
void	applyMicrostructureToOutlines (const std::unordered_set< GridPoint3 > &cells, const std::vector< ExPolygons > &layer_regions) const

Private Attributes
PrintObject &	print_object
const size_t	region_a_index
const size_t	region_b_index
const coord_t	beam_width
const coord_t	boundary_avoidance
const VoxelUtils	vu
const float	rotation
const Vec3crd	cell_size
const coord_t	beam_layer_count
const DilationKernel	interface_dilation
const DilationKernel	air_dilation
const bool	air_filtering
const std::function< void()> &	throw_on_cancel

Static Private Attributes
static const coord_t	ignored_gap_ = 100u
	Distance between models to be considered next to each other so that an interlocking structure will be generated there.

Detailed Description

Class for generating an interlocking structure between two adjacent models of a different extruder.

The structure consists of horizontal beams of the two materials interlaced. In the z direction the direction of these beams is alternated with 90*.

Example with two materials # and O Even beams: Odd beams:

##OO##OO

OOOOOO ##OO##OO

##OO##OO

OOOOOO ##OO##OO

One material of a single cell of the structure looks like this: .-*-. .-* -. |-. -. | *-. *-. .- -. *-. *-. .- -. *-. .-| .-* .-* -. *-.- | |*-. .-* .-* -. | .- | -.- .-* -|- -. | .- -|-

We set up a voxel grid of (2*beam_w,2*beam_w,2*beam_h) and mark all the voxels which contain both meshes. We then remove all voxels which also contain air, so that the interlocking pattern will not be visible from the outside. We then generate and combine the polygons for each voxel and apply those areas to the outlines ofthe meshes.

Constructor & Destructor Documentation

InterlockingGenerator()

Slic3r::InterlockingGenerator::InterlockingGenerator ( PrintObject & print_object, const size_t region_a_index, const size_t region_b_index, const coord_t beam_width, const coord_t boundary_avoidance, const float rotation, const Vec3crd & cell_size, const coord_t beam_layer_count, const DilationKernel & interface_dilation, const DilationKernel & air_dilation, const bool air_filtering, const std::function< void()> & throw_on_cancel )

inlineprivate

Private class for storing some variables used in the computation of the interlocking structure between two meshes.

Parameters

region_a_index	The first region
region_b_index	The second region
rotation	The angle by which to rotate the interlocking pattern
cell_size	The size of a voxel cell in (coord_t, coord_t, layer_count)
beam_layer_count	The number of layers for the height of the beams
interface_dilation	The thicknening kernel for the interface
air_dilation	The thickening kernel applied to air so that cells near the outside of the model won't be generated
air_filtering	Whether to fully remove all of the interlocking cells which would be visible on the outside (i.e. touching air). If no air filtering then those cells will be cut off in the middle of a beam.

        : print_object(print_object)
        , region_a_index(region_a_index)
        , region_b_index(region_b_index)
        , beam_width(beam_width)
        , boundary_avoidance(boundary_avoidance)
        , vu(cell_size)
        , rotation(rotation)
        , cell_size(cell_size)
        , beam_layer_count(beam_layer_count)
        , interface_dilation(interface_dilation)
        , air_dilation(air_dilation)
        , air_filtering(air_filtering)
        , throw_on_cancel(throw_on_cancel)
    {}

References air_dilation, air_filtering, beam_layer_count, beam_width, boundary_avoidance, cell_size, interface_dilation, print_object, region_a_index, region_b_index, rotation, throw_on_cancel, and vu.

Referenced by generate_interlocking_structure().

Here is the caller graph for this function:

Member Function Documentation

addBoundaryCells()

void Slic3r::InterlockingGenerator::addBoundaryCells ( const std::vector< ExPolygons > & layers, const DilationKernel & kernel, std::unordered_set< GridPoint3 > & cells ) const

private

Compute the voxels overlapping with the shell of some layers. This includes the walls, but also top/bottom skin.

Parameters

	layers	The layer outlines for which to compute the shell voxels
	kernel	The dilation kernel to give the returned voxel shell more thickness
[out]	cells	The output cells which elong to the shell

{
    auto voxel_emplacer = [this, &cells](GridPoint3 p) {
        this->throw_on_cancel();
        if (p.z() < 0) {
            return true;
        }
        cells.emplace(p);
        return true;
    };
 
    for (size_t layer_nr = 0; layer_nr < layers.size(); layer_nr++) {
        const coord_t z = static_cast<coord_t>(layer_nr);
        vu.walkDilatedPolygons(layers[layer_nr], z, kernel, voxel_emplacer);
        ExPolygons skin = layers[layer_nr];
        if (layer_nr > 0) {
            skin = xor_ex(skin, layers[layer_nr - 1]);
        }
        skin = opening_ex(skin, cell_size.x() / 2.f); // remove superfluous small areas, which would anyway be included because of walkPolygons
        vu.walkDilatedAreas(skin, z, kernel, voxel_emplacer);
    }
}

References cell_size, Slic3r::opening_ex(), throw_on_cancel, vu, and Slic3r::xor_ex().

Referenced by generateInterlockingStructure(), and getShellVoxels().

Here is the call graph for this function:

Here is the caller graph for this function:

applyMicrostructureToOutlines()

void Slic3r::InterlockingGenerator::applyMicrostructureToOutlines ( const std::unordered_set< GridPoint3 > & cells, const std::vector< ExPolygons > & layer_regions ) const

private

Change the outlines of the meshes with the computed interlocking structure.

Parameters

cells	The cells where we want to apply the interlocking structure.
layer_regions	The total volume of the two meshes combined (and small gaps closed)

{
    std::vector<std::vector<ExPolygons>> cell_area_per_mesh_per_layer = generateMicrostructure();
 
    const float  unapply_rotation = -rotation;
    const size_t max_layer_count  = print_object.layer_count();
 
    std::vector<ExPolygons> structure_per_layer[2]; // for each mesh the structure on each layer
 
    // Every `beam_layer_count` number of layers are combined to an interlocking beam layer
    // to store these we need ceil(max_layer_count / beam_layer_count) of these layers
    // the formula is rewritten as (max_layer_count + beam_layer_count - 1) / beam_layer_count, so it works for integer division
    size_t num_interlocking_layers = (max_layer_count + static_cast<size_t>(beam_layer_count) - 1ul) /
                                     static_cast<size_t>(beam_layer_count);
    structure_per_layer[0].resize(num_interlocking_layers);
    structure_per_layer[1].resize(num_interlocking_layers);
 
    // Only compute cell structure for half the layers, because since our beams are two layers high, every odd layer of the structure will
    // be the same as the layer below.
    for (const GridPoint3& grid_loc : cells) {
        Vec3crd bottom_corner = vu.toLowerCorner(grid_loc);
        for (size_t mesh_idx = 0; mesh_idx < 2; mesh_idx++) {
            for (size_t layer_nr = bottom_corner.z(); layer_nr < bottom_corner.z() + cell_size.z() && layer_nr < max_layer_count;
                 layer_nr += beam_layer_count) {
                ExPolygons areas_here = cell_area_per_mesh_per_layer[static_cast<size_t>(layer_nr / beam_layer_count) %
                                                                cell_area_per_mesh_per_layer.size()][mesh_idx];
                for (auto & here : areas_here) {
                    here.translate(bottom_corner.x(), bottom_corner.y());
                }
                expolygons_append(structure_per_layer[mesh_idx][static_cast<size_t>(layer_nr / beam_layer_count)], areas_here);
            }
        }
    }
 
    for (size_t mesh_idx = 0; mesh_idx < 2; mesh_idx++) {
        for (size_t layer_nr = 0; layer_nr < structure_per_layer[mesh_idx].size(); layer_nr++) {
            ExPolygons& layer_structure = structure_per_layer[mesh_idx][layer_nr];
            layer_structure = union_ex(layer_structure);
            expolygons_rotate(layer_structure, unapply_rotation);
        }
    }
 
    for (size_t region_idx = 0; region_idx < 2; region_idx++) {
        const size_t region = (region_idx == 0) ? region_a_index : region_b_index;
        for (size_t layer_nr = 0; layer_nr < max_layer_count; layer_nr++) {
            throw_on_cancel();
            ExPolygons layer_outlines = layer_regions[layer_nr];
            expolygons_rotate(layer_outlines, unapply_rotation);
 
            const ExPolygons areas_here = intersection_ex(structure_per_layer[region_idx][layer_nr / static_cast<size_t>(beam_layer_count)], layer_outlines);
            const ExPolygons& areas_other = structure_per_layer[!region_idx][layer_nr / static_cast<size_t>(beam_layer_count)];
 
            auto       layer  = print_object.get_layer(layer_nr);
            auto&      slices = layer->get_region(region)->slices;
            ExPolygons polys  = to_expolygons(slices.surfaces);
            slices.set(union_ex(diff_ex(polys, areas_other), // reduce layer areas inward with beams from other mesh
                                areas_here)                  // extend layer areas outward with newly added beams
                       , stInternal);
        }
    }
}

References beam_layer_count, cell_size, Slic3r::diff_ex(), Slic3r::expolygons_append(), Slic3r::expolygons_rotate(), generateMicrostructure(), Slic3r::intersection_ex(), print_object, region_a_index, region_b_index, rotation, Slic3r::stInternal, throw_on_cancel, Slic3r::to_expolygons(), Slic3r::union_ex(), and vu.

Referenced by generateInterlockingStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

computeUnionedVolumeRegions()

std::vector< ExPolygons > Slic3r::InterlockingGenerator::computeUnionedVolumeRegions ( ) const

private

Compute the regions occupied by both models.

A morphological close is performed so that we don't register small gaps between the two models as being separate.

Returns

layer_regions The computed layer regions

{
    const size_t max_layer_count = print_object.layer_count() +
                                   1; // introduce ghost layer on top for correct skin computation of topmost layer.
    std::vector<ExPolygons> layer_regions(max_layer_count);
 
    for (size_t layer_nr = 0; layer_nr < max_layer_count - 1; layer_nr++) {
        auto& layer_region = layer_regions[static_cast<size_t>(layer_nr)];
        for (size_t region_idx : {region_a_index, region_b_index}) {
            auto layer = print_object.get_layer(layer_nr);
            expolygons_append(layer_region, to_expolygons(layer->get_region(region_idx)->slices.surfaces));
        }
        layer_region = closing_ex(layer_region, ignored_gap_); // Morphological close to merge meshes into single volume
        expolygons_rotate(layer_region, rotation);
    }
    return layer_regions;
}

References Slic3r::closing_ex(), Slic3r::expolygons_append(), Slic3r::expolygons_rotate(), ignored_gap_, print_object, region_a_index, region_b_index, rotation, and Slic3r::to_expolygons().

Referenced by generateInterlockingStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_interlocking_structure()

void Slic3r::InterlockingGenerator::generate_interlocking_structure ( PrintObject * print_object, const std::function< void()> & throw_on_cancel )

static

Generate an interlocking structure between each two adjacent meshes.

{
    const auto& config = print_object->config();
    // Check if interlocking is enabled, and avoid errors like division by zero due to invalid configuration.
    if (!config.interlocking_beam || config.interlocking_beam_layer_count < 1 || config.interlocking_depth < 1 || config.interlocking_beam_width < EPSILON ) {
        return;
    }
 
    const float    rotation           = Geometry::deg2rad(config.interlocking_orientation.value);
    const coord_t  beam_layer_count   = config.interlocking_beam_layer_count;
    const int      interface_depth    = config.interlocking_depth;
    const int      boundary_avoidance = config.interlocking_boundary_avoidance;
    const coord_t  beam_width         = scaled(config.interlocking_beam_width.value);
 
    const DilationKernel interface_dilation(GridPoint3(interface_depth, interface_depth, interface_depth), DilationKernel::Type::PRISM);
 
    const bool           air_filtering = boundary_avoidance > 0;
    const DilationKernel air_dilation(GridPoint3(boundary_avoidance, boundary_avoidance, boundary_avoidance), DilationKernel::Type::PRISM);
 
    const coord_t cell_width = beam_width + beam_width;
    const Vec3crd cell_size(cell_width, cell_width, 2 * beam_layer_count);
 
    for (size_t region_a_index = 0; region_a_index < print_object->num_printing_regions(); region_a_index++) {
        const PrintRegion& region_a      = print_object->printing_region(region_a_index);
        const auto         extruder_nr_a = region_a.extruder(FlowRole::frExternalPerimeter);
 
        for (size_t region_b_index = region_a_index + 1; region_b_index < print_object->num_printing_regions(); region_b_index++) {
            const PrintRegion& region_b      = print_object->printing_region(region_b_index);
            const auto         extruder_nr_b = region_b.extruder(FlowRole::frExternalPerimeter);
            if (extruder_nr_a == extruder_nr_b) {
                continue;
            }
 
            throw_on_cancel();
 
            InterlockingGenerator gen(*print_object, region_a_index, region_b_index, beam_width, boundary_avoidance, rotation, cell_size, beam_layer_count,
                                      interface_dilation, air_dilation, air_filtering, throw_on_cancel);
            gen.generateInterlockingStructure();
        }
    }
}

References InterlockingGenerator(), air_dilation, air_filtering, beam_layer_count, beam_width, boundary_avoidance, cell_size, Slic3r::Geometry::deg2rad(), EPSILON, Slic3r::PrintRegion::extruder(), Slic3r::frExternalPerimeter, generateInterlockingStructure(), interface_dilation, print_object, Slic3r::DilationKernel::PRISM, region_a_index, region_b_index, rotation, Slic3r::scaled(), and throw_on_cancel.

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

Here is the call graph for this function:

Here is the caller graph for this function:

generateInterlockingStructure()

void Slic3r::InterlockingGenerator::generateInterlockingStructure ( ) const

private

Generate an interlocking structure between two meshes

{
    std::vector<std::unordered_set<GridPoint3>> voxels_per_mesh = getShellVoxels(interface_dilation);
 
    std::unordered_set<GridPoint3>& has_any_mesh   = voxels_per_mesh[0];
    std::unordered_set<GridPoint3>& has_all_meshes = voxels_per_mesh[1];
    has_any_mesh.merge(has_all_meshes); // perform union and intersection simultaneously. Cannibalizes voxels_per_mesh
 
    if (has_all_meshes.empty()) {
        return;
    }
 
    const std::vector<ExPolygons> layer_regions = computeUnionedVolumeRegions();
 
    if (air_filtering) {
        std::unordered_set<GridPoint3> air_cells;
        addBoundaryCells(layer_regions, air_dilation, air_cells);
 
        for (const GridPoint3& p : air_cells) {
            has_all_meshes.erase(p);
        }
 
        handleThinAreas(has_all_meshes);
    }
 
    applyMicrostructureToOutlines(has_all_meshes, layer_regions);
}

References addBoundaryCells(), air_dilation, air_filtering, applyMicrostructureToOutlines(), computeUnionedVolumeRegions(), getShellVoxels(), handleThinAreas(), and interface_dilation.

Referenced by generate_interlocking_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

generateMicrostructure()

std::vector< std::vector< ExPolygons > > Slic3r::InterlockingGenerator::generateMicrostructure ( ) const

private

Generate the polygons for the beams of a single cell

Returns

cell_area_per_mesh_per_layer The output polygons for each beam

{
    std::vector<std::vector<ExPolygons>> cell_area_per_mesh_per_layer;
    cell_area_per_mesh_per_layer.resize(2);
    cell_area_per_mesh_per_layer[0].resize(2);
    const coord_t beam_w_sum = beam_width + beam_width;
    const coord_t middle     = cell_size.x() * beam_width / beam_w_sum;
    const coord_t width[2]   = {middle, cell_size.x() - middle};
    for (size_t mesh_idx : {0ul, 1ul}) {
        Point offset(mesh_idx ? middle : 0, 0);
        Point area_size(width[mesh_idx], cell_size.y());
 
        Polygon poly;
        poly.append(offset);
        poly.append(offset + Point(area_size.x(), 0));
        poly.append(offset + area_size);
        poly.append(offset + Point(0, area_size.y()));
        cell_area_per_mesh_per_layer[0][mesh_idx].emplace_back(poly);
    }
    cell_area_per_mesh_per_layer[1] = cell_area_per_mesh_per_layer[0];
    for (ExPolygons& polys : cell_area_per_mesh_per_layer[1]) {
        for (ExPolygon& poly : polys) {
            for (Point& p : poly.contour) {
                std::swap(p.x(), p.y());
            }
        }
    }
    return cell_area_per_mesh_per_layer;
}

References beam_width, cell_size, and Slic3r::offset().

Referenced by applyMicrostructureToOutlines().

Here is the call graph for this function:

Here is the caller graph for this function:

getShellVoxels()

std::vector< std::unordered_set< GridPoint3 > > Slic3r::InterlockingGenerator::getShellVoxels ( const DilationKernel & kernel ) const

private

Compute the voxels overlapping with the shell of both models. This includes the walls, but also top/bottom skin.

Parameters

kernel

The dilation kernel to give the returned voxel shell more thickness

Returns

The shell voxels for mesh a and those for mesh b

{
    std::vector<std::unordered_set<GridPoint3>> voxels_per_mesh(2);
 
    // mark all cells which contain some boundary
    for (size_t region_idx = 0; region_idx < 2; region_idx++)
    {
        const size_t region = (region_idx == 0) ? region_a_index : region_b_index;
        std::unordered_set<GridPoint3>& mesh_voxels = voxels_per_mesh[region_idx];
 
        std::vector<ExPolygons> rotated_polygons_per_layer(print_object.layer_count());
        for (size_t layer_nr = 0; layer_nr < print_object.layer_count(); layer_nr++)
        {
            auto layer = print_object.get_layer(layer_nr);
            rotated_polygons_per_layer[layer_nr] = to_expolygons(layer->get_region(region)->slices.surfaces);
            expolygons_rotate(rotated_polygons_per_layer[layer_nr], rotation);
        }
 
        addBoundaryCells(rotated_polygons_per_layer, kernel, mesh_voxels);
    }
 
    return voxels_per_mesh;
}

References addBoundaryCells(), Slic3r::expolygons_rotate(), print_object, region_a_index, region_b_index, rotation, and Slic3r::to_expolygons().

Referenced by generateInterlockingStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

growBorderAreasPerpendicular()

std::pair< ExPolygons, ExPolygons > Slic3r::InterlockingGenerator::growBorderAreasPerpendicular ( const ExPolygons & a, const ExPolygons & b, const coord_t & detect ) const

private

Given two polygons, return the parts that border on air, and grow 'perpendicular' up to 'detect' distance.

Parameters

a	The first polygon.
b	The second polygon.
detec	The expand distance. (Not equal to offset, but a series of small offsets and differences).

Returns

A pair of polygons that repressent the 'borders' of a and b, but expanded 'perpendicularly'.

{
    const coord_t min_line =
        std::min(print_object.printing_region(region_a_index).flow(print_object, frExternalPerimeter, 0.1).scaled_width(),
                 print_object.printing_region(region_b_index).flow(print_object, frExternalPerimeter, 0.1).scaled_width());
 
    const ExPolygons total_shrunk = offset_ex(union_ex(offset_ex(a, min_line), offset_ex(b, min_line)), 2 * -min_line);
 
    ExPolygons from_border_a = diff_ex(a, total_shrunk);
    ExPolygons from_border_b = diff_ex(b, total_shrunk);
 
    ExPolygons temp_a, temp_b;
    for (coord_t i = 0; i < (detect / min_line) + 2; ++i) {
        temp_a        = offset_ex(from_border_a, min_line);
        temp_b        = offset_ex(from_border_b, min_line);
        from_border_a = diff_ex(temp_a, temp_b);
        from_border_b = diff_ex(temp_b, temp_a);
    }
 
    return {from_border_a, from_border_b};
}

References Slic3r::diff_ex(), Slic3r::frExternalPerimeter, Slic3r::offset_ex(), print_object, region_a_index, region_b_index, and Slic3r::union_ex().

Referenced by handleThinAreas().

Here is the call graph for this function:

Here is the caller graph for this function:

handleThinAreas()

void Slic3r::InterlockingGenerator::handleThinAreas ( const std::unordered_set< GridPoint3 > & has_all_meshes ) const

private

Special handling for thin strips of material.

Expand the meshes into each other where they need it, namely when a thin strip of material needs to be attached.

Parameters

has_all_meshes

Only do this special handling if there's actually microstructure nearby that needs to be adhered to.

{
    const coord_t     number_of_beams_detect = boundary_avoidance;
    const coord_t     number_of_beams_expand = boundary_avoidance - 1;
    constexpr coord_t rounding_errors        = 5;
 
    const coord_t max_beam_width = beam_width;
    const coord_t detect         = (max_beam_width * number_of_beams_detect) + rounding_errors;
    const coord_t expand         = (max_beam_width * number_of_beams_expand) + rounding_errors;
    const coord_t close_gaps =
        std::min(print_object.printing_region(region_a_index).flow(print_object, frExternalPerimeter, 0.1).scaled_width(),
                 print_object.printing_region(region_b_index).flow(print_object, frExternalPerimeter, 0.1).scaled_width()) / 4;
 
    // Make an inclusionary polygon, to only actually handle thin areas near actual microstructures (so not in skin for example).
    std::vector<Polygons> near_interlock_per_layer;
    near_interlock_per_layer.assign(print_object.layer_count(), Polygons());
    for (const auto& cell : has_all_meshes) {
        const auto bottom_corner = vu.toLowerCorner(cell);
        for (coord_t layer_nr = bottom_corner.z();
             layer_nr < bottom_corner.z() + cell_size.z() && layer_nr < static_cast<coord_t>(near_interlock_per_layer.size()); ++layer_nr) {
            near_interlock_per_layer[static_cast<size_t>(layer_nr)].push_back(vu.toPolygon(cell));
        }
    }
    for (auto& near_interlock : near_interlock_per_layer) {
        throw_on_cancel();
        near_interlock = offset(union_(closing(near_interlock, rounding_errors)), detect);
        polygons_rotate(near_interlock, rotation);
    }
 
    // Only alter layers when they are present in both meshes, zip should take care if that.
    for (size_t layer_nr = 0; layer_nr < print_object.layer_count(); layer_nr++){
        throw_on_cancel();
        auto       layer   = print_object.get_layer(layer_nr);
        ExPolygons polys_a = to_expolygons(layer->get_region(region_a_index)->slices.surfaces);
        ExPolygons polys_b = to_expolygons(layer->get_region(region_b_index)->slices.surfaces);
 
        const auto [from_border_a, from_border_b] = growBorderAreasPerpendicular(polys_a, polys_b, detect);
 
        // Get the areas of each mesh that are _not_ thin (large), by performing a morphological open.
        const ExPolygons large_a = opening_ex(polys_a, detect);
        const ExPolygons large_b = opening_ex(polys_b, detect);
 
        // Derive the area that the thin areas need to expand into (so the added areas to the thin strips) from the information we already have.
        const ExPolygons thin_expansion_a =
            offset_ex(intersection_ex(intersection_ex(intersection_ex(large_b, offset_ex(diff_ex(polys_a, large_a), expand)),
                                                      near_interlock_per_layer[layer_nr]),
                                      from_border_a),
                      rounding_errors);
        const ExPolygons thin_expansion_b =
            offset_ex(intersection_ex(intersection_ex(intersection_ex(large_a, offset_ex(diff_ex(polys_b, large_b), expand)),
                                                      near_interlock_per_layer[layer_nr]),
                                      from_border_b),
                      rounding_errors);
 
        // Expanded thin areas of the opposing polygon should 'eat into' the larger areas of the polygon,
        // and conversely, add the expansions to their own thin areas.
        layer->get_region(region_a_index)->slices.set(closing_ex(diff_ex(union_ex(polys_a, thin_expansion_a), thin_expansion_b), close_gaps), stInternal);
        layer->get_region(region_b_index)->slices.set(closing_ex(diff_ex(union_ex(polys_b, thin_expansion_b), thin_expansion_a), close_gaps), stInternal);
    }
}

References beam_width, boundary_avoidance, cell_size, Slic3r::closing(), Slic3r::closing_ex(), Slic3r::diff_ex(), Slic3r::expand(), Slic3r::frExternalPerimeter, growBorderAreasPerpendicular(), Slic3r::intersection_ex(), Slic3r::offset(), Slic3r::offset_ex(), Slic3r::opening_ex(), Slic3r::polygons_rotate(), print_object, region_a_index, region_b_index, rotation, Slic3r::stInternal, throw_on_cancel, Slic3r::to_expolygons(), Slic3r::union_(), Slic3r::union_ex(), and vu.

Referenced by generateInterlockingStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

air_dilation

const DilationKernel Slic3r::InterlockingGenerator::air_dilation

private

Referenced by InterlockingGenerator(), generate_interlocking_structure(), and generateInterlockingStructure().

air_filtering

const bool Slic3r::InterlockingGenerator::air_filtering

private

Referenced by InterlockingGenerator(), generate_interlocking_structure(), and generateInterlockingStructure().

beam_layer_count

const coord_t Slic3r::InterlockingGenerator::beam_layer_count

private

Referenced by InterlockingGenerator(), applyMicrostructureToOutlines(), and generate_interlocking_structure().

beam_width

const coord_t Slic3r::InterlockingGenerator::beam_width

private

Referenced by InterlockingGenerator(), generate_interlocking_structure(), generateMicrostructure(), and handleThinAreas().

boundary_avoidance

const coord_t Slic3r::InterlockingGenerator::boundary_avoidance

private

Referenced by InterlockingGenerator(), generate_interlocking_structure(), and handleThinAreas().

cell_size

const Vec3crd Slic3r::InterlockingGenerator::cell_size

private

Referenced by InterlockingGenerator(), addBoundaryCells(), applyMicrostructureToOutlines(), generate_interlocking_structure(), generateMicrostructure(), and handleThinAreas().

ignored_gap_

const coord_t Slic3r::InterlockingGenerator::ignored_gap_ = 100u

staticprivate

Distance between models to be considered next to each other so that an interlocking structure will be generated there.

Referenced by computeUnionedVolumeRegions().

interface_dilation

const DilationKernel Slic3r::InterlockingGenerator::interface_dilation

private

Referenced by InterlockingGenerator(), generate_interlocking_structure(), and generateInterlockingStructure().

print_object

PrintObject& Slic3r::InterlockingGenerator::print_object

private

Referenced by InterlockingGenerator(), applyMicrostructureToOutlines(), computeUnionedVolumeRegions(), generate_interlocking_structure(), getShellVoxels(), growBorderAreasPerpendicular(), and handleThinAreas().

region_a_index

const size_t Slic3r::InterlockingGenerator::region_a_index

private

Referenced by InterlockingGenerator(), applyMicrostructureToOutlines(), computeUnionedVolumeRegions(), generate_interlocking_structure(), getShellVoxels(), growBorderAreasPerpendicular(), and handleThinAreas().

region_b_index

const size_t Slic3r::InterlockingGenerator::region_b_index

private

Referenced by InterlockingGenerator(), applyMicrostructureToOutlines(), computeUnionedVolumeRegions(), generate_interlocking_structure(), getShellVoxels(), growBorderAreasPerpendicular(), and handleThinAreas().

rotation

const float Slic3r::InterlockingGenerator::rotation

private

Referenced by InterlockingGenerator(), applyMicrostructureToOutlines(), computeUnionedVolumeRegions(), generate_interlocking_structure(), getShellVoxels(), and handleThinAreas().

throw_on_cancel

const std::function<void()>& Slic3r::InterlockingGenerator::throw_on_cancel

private

Referenced by InterlockingGenerator(), addBoundaryCells(), applyMicrostructureToOutlines(), generate_interlocking_structure(), and handleThinAreas().

vu

const VoxelUtils Slic3r::InterlockingGenerator::vu

private

Referenced by InterlockingGenerator(), addBoundaryCells(), applyMicrostructureToOutlines(), and handleThinAreas().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/InterlockingGenerator.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Feature/Interlocking/InterlockingGenerator.cpp