Inheritance diagram for Slic3r::TreeSupport3D::RichInterfacePlacer:

Collaboration diagram for Slic3r::TreeSupport3D::RichInterfacePlacer:

Public Member Functions
	RichInterfacePlacer (const InterfacePlacer &interface_placer, const TreeModelVolumes &volumes, bool force_tip_to_roof, size_t num_support_layers, std::vector< SupportElements > &move_bounds)
void	add_points_along_lines (LineInformations lines, LayerIndex insert_layer_idx, size_t roof_tip_layers, size_t supports_roof_layers, size_t dont_move_until)
SupportGeneratorLayersPtr &	top_contacts_mutable ()
void	add_roofs (std::vector< Polygons > &&new_roofs, const size_t insert_layer_idx)
void	add_roof (Polygons &&new_roof, const size_t insert_layer_idx, const size_t dtt_tip)
void	add_roof_build_plate (Polygons &&overhang_areas, size_t dtt_roof)
void	add_roof_unguarded (Polygons &&new_roofs, const size_t insert_layer_idx, const size_t dtt_roof)

Public Attributes
const TreeModelVolumes &	volumes
const bool	force_tip_to_roof
bool	min_xy_dist
const SlicingParameters &	slicing_parameters
const SupportParameters &	support_parameters
const TreeSupportSettings &	config

Private Member Functions
void	add_point_as_influence_area (std::pair< Point, LineStatus > p, LayerIndex insert_layer, size_t dont_move_until, bool roof, size_t roof_recovery_dtt, bool skip_ovalisation)

Private Attributes
std::vector< SupportElements > &	move_bounds
coord_t	m_base_radius
Polygon	m_base_circle
std::mutex	m_mutex_movebounds
std::vector< std::unordered_set< Point, PointHash > >	m_already_inserted
SupportGeneratorLayerStorage &	layer_storage
SupportGeneratorLayersPtr &	top_contacts
SupportGeneratorLayersPtr &	top_interfaces
SupportGeneratorLayersPtr &	top_base_interfaces
std::mutex	m_mutex_layer_storage

Detailed Description

Constructor & Destructor Documentation

◆ RichInterfacePlacer()

Slic3r::TreeSupport3D::RichInterfacePlacer::RichInterfacePlacer	(	const InterfacePlacer &	interface_placer,
		const TreeModelVolumes &	volumes,
		bool	force_tip_to_roof,
		size_t	num_support_layers,
		std::vector< SupportElements > &	move_bounds )

inline

    :
        InterfacePlacer(interface_placer),
        volumes(volumes), force_tip_to_roof(force_tip_to_roof), move_bounds(move_bounds)
    {
        m_already_inserted.assign(num_support_layers, {});
        this->min_xy_dist = this->config.xy_distance > this->config.xy_min_distance;
        m_base_radius = scaled<coord_t>(0.01);
        m_base_circle = Polygon{ make_circle(m_base_radius, SUPPORT_TREE_CIRCLE_RESOLUTION) };
 
    }

References Slic3r::TreeSupport3D::InterfacePlacer::InterfacePlacer(), force_tip_to_roof, m_already_inserted, m_base_circle, m_base_radius, Slic3r::make_circle(), min_xy_dist, move_bounds, Slic3r::scaled(), Slic3r::SUPPORT_TREE_CIRCLE_RESOLUTION, volumes, Slic3r::TreeSupport3D::TreeSupportSettings::xy_distance, and Slic3r::TreeSupport3D::TreeSupportSettings::xy_min_distance.

Here is the call graph for this function:

Member Function Documentation

◆ add_point_as_influence_area()

void Slic3r::TreeSupport3D::RichInterfacePlacer::add_point_as_influence_area	(	std::pair< Point, LineStatus >	p,
		LayerIndex	insert_layer,
		size_t	dont_move_until,
		bool	roof,
		size_t	roof_recovery_dtt,
		bool	skip_ovalisation )

inlineprivate

    {
        bool to_bp = p.second == LineStatus::TO_BP || p.second == LineStatus::TO_BP_SAFE;
        bool gracious = to_bp || p.second == LineStatus::TO_MODEL_GRACIOUS || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE;
        bool safe_radius = p.second == LineStatus::TO_BP_SAFE || p.second == LineStatus::TO_MODEL_GRACIOUS_SAFE;
        if (! config.support_rests_on_model && ! to_bp) {
            BOOST_LOG_TRIVIAL(warning) << "Tried to add an invalid support point";
            tree_supports_show_error("Unable to add tip. Some overhang may not be supported correctly."sv, true);
            return;
        }
        Polygons circle{ m_base_circle };
        circle.front().translate(p.first);
        {
            Point hash_pos = p.first / ((config.min_radius + 1) / 10);
            std::lock_guard<std::mutex> critical_section_movebounds(m_mutex_movebounds);
            if (!m_already_inserted[insert_layer].count(hash_pos)) {
                // normalize the point a bit to also catch points which are so close that inserting it would achieve nothing
                m_already_inserted[insert_layer].emplace(hash_pos);
                static constexpr const size_t dtt = 0;
                SupportElementState state;
                state.target_height = insert_layer;
                state.target_position = p.first;
                state.next_position = p.first;
                state.layer_idx = insert_layer;
                state.effective_radius_height = dtt;
                state.to_buildplate = to_bp;
                state.distance_to_top = dtt;
                state.result_on_layer = p.first;
                assert(state.result_on_layer_is_set());
                state.increased_to_model_radius = 0;
                state.to_model_gracious = gracious;
                state.elephant_foot_increases = 0;
                state.use_min_xy_dist = min_xy_dist;
                state.supports_roof = roof;
                state.dont_move_until = dont_move_until;
                state.can_use_safe_radius = safe_radius;
                state.set_pending_roof_recovery(force_tip_to_roof ? dont_move_until : 0, roof_recovery_dtt);
                state.skip_ovalisation = skip_ovalisation;
                move_bounds[insert_layer].emplace_back(state, std::move(circle));
            }
        }
    }

Referenced by add_points_along_lines().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_points_along_lines()

void Slic3r::TreeSupport3D::RichInterfacePlacer::add_points_along_lines	(	LineInformations	lines,
		LayerIndex	insert_layer_idx,
		size_t	roof_tip_layers,
		size_t	supports_roof_layers,
		size_t	dont_move_until )

inline

    {
        validate_range(lines);
        // Add tip area as roof (happens when minimum roof area > minimum tip area) if possible
        size_t dtt_roof_tip;
        for (dtt_roof_tip = 0; dtt_roof_tip < roof_tip_layers && insert_layer_idx - dtt_roof_tip >= 1; ++ dtt_roof_tip) {
            size_t this_layer_idx = insert_layer_idx - dtt_roof_tip;
            const size_t roof_recovery_depth = dtt_roof_tip + supports_roof_layers;
            auto evaluateRoofWillGenerate = [&](const std::pair<Point, LineStatus> &p) {
                //FIXME Vojtech: The circle is just shifted, it has a known size, the infill should fit all the time!
    #if 0
                Polygon roof_circle;
                for (Point corner : base_circle)
                    roof_circle.points.emplace_back(p.first + corner * config.min_radius);
                return !generate_support_infill_lines({ roof_circle }, config, true, insert_layer_idx - dtt_roof_tip, config.support_roof_line_distance).empty();
    #else
                return true;
    #endif
            };
 
            {
                std::pair<LineInformations, LineInformations> split =
                    // keep all lines that are still valid on the next layer
                    split_lines(lines, [this, this_layer_idx](const std::pair<Point, LineStatus> &p)
                        { return evaluate_point_for_next_layer_function(volumes, config, this_layer_idx, p); });
                LineInformations points = std::move(split.second);
                // Not all roofs are guaranteed to actually generate lines, so filter these out and add them as points.
                split = split_lines(split.first, evaluateRoofWillGenerate);
                lines = std::move(split.first);
                append(points, split.second);
                // add all points that would not be valid
                for (const LineInformation &line : points)
                    for (const std::pair<Point, LineStatus> &point_data : line)
                        add_point_as_influence_area(point_data, this_layer_idx,
                            // don't move until
                            roof_tip_layers - dtt_roof_tip,
                            // supports roof
                            roof_recovery_depth > 0,
                            // recovered roof/contact depth for this slice
                            roof_recovery_depth,
                            // disable ovalization
                            false);
            }
 
            // add all tips as roof to the roof storage
            Polygons new_roofs;
            for (const LineInformation &line : lines)
                //FIXME sweep the tip radius along the line?
                for (const std::pair<Point, LineStatus> &p : line) {
                    Polygon roof_circle{ m_base_circle };
                    roof_circle.scale(config.min_radius / m_base_radius);
                    roof_circle.translate(p.first);
                    new_roofs.emplace_back(std::move(roof_circle));
                }
            this->add_roof(std::move(new_roofs), this_layer_idx, roof_recovery_depth);
        }
 
        const size_t roof_recovery_depth = dtt_roof_tip + supports_roof_layers;
        for (const LineInformation &line : lines) {
            // If a line consists of enough tips, the assumption is that it is not a single tip, but part of a simulated support pattern.
            // Ovalisation should be disabled for these to improve the quality of the lines when tip_diameter=line_width
            bool disable_ovalistation = config.min_radius < 3 * config.support_line_width && roof_tip_layers == 0 && dtt_roof_tip == 0 && line.size() > 5;
            for (const std::pair<Point, LineStatus> &point_data : line)
                add_point_as_influence_area(point_data, insert_layer_idx - dtt_roof_tip,
                    // don't move until
                    dont_move_until > dtt_roof_tip ? dont_move_until - dtt_roof_tip : 0,
                    // supports roof
                    roof_recovery_depth > 0,
                    // recovered roof/contact depth for this slice
                    roof_recovery_depth,
                    disable_ovalistation);
        }
    }

References add_point_as_influence_area(), Slic3r::TreeSupport3D::InterfacePlacer::add_roof(), Slic3r::append(), Slic3r::TreeSupport3D::InterfacePlacer::config, Slic3r::empty(), Slic3r::TreeSupport3D::evaluate_point_for_next_layer_function(), Slic3r::TreeSupport3D::generate_support_infill_lines(), m_base_circle, m_base_radius, Slic3r::MultiPoint::points, Slic3r::MultiPoint::scale(), Slic3r::TreeSupport3D::split_lines(), Slic3r::MultiPoint::translate(), Slic3r::TreeSupport3D::validate_range(), and volumes.

Referenced by Slic3r::TreeSupport3D::sample_overhang_area().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_roof()

void Slic3r::TreeSupport3D::InterfacePlacer::add_roof	(	Polygons &&	new_roof,
		const size_t	insert_layer_idx,
		const size_t	dtt_tip )

inlineinherited

    {
        std::lock_guard<std::mutex> lock(m_mutex_layer_storage);
        add_roof_unguarded(std::move(new_roof), insert_layer_idx, dtt_tip);
    }

References add_roof_unguarded(), and m_mutex_layer_storage.

Referenced by Slic3r::TreeSupport3D::RichInterfacePlacer::add_points_along_lines(), and Slic3r::TreeSupport3D::recover_pending_branch_roofs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_roof_build_plate()

void Slic3r::TreeSupport3D::InterfacePlacer::add_roof_build_plate	(	Polygons &&	overhang_areas,
		size_t	dtt_roof )

inlineinherited

    {
        std::lock_guard<std::mutex> lock(m_mutex_layer_storage);
        this->add_roof_unguarded(std::move(overhang_areas), 0, std::min(dtt_roof, this->support_parameters.num_top_interface_layers));
    }

References add_roof_unguarded(), m_mutex_layer_storage, and Slic3r::SupportParameters::num_top_interface_layers.

Referenced by Slic3r::TreeSupport3D::sample_overhang_area().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_roof_unguarded()

void Slic3r::TreeSupport3D::InterfacePlacer::add_roof_unguarded	(	Polygons &&	new_roofs,
		const size_t	insert_layer_idx,
		const size_t	dtt_roof )

inlineinherited

    {
        assert(support_parameters.has_top_contacts);
        assert(dtt_roof <= support_parameters.num_top_interface_layers);
        // ORCA: Reserve one top interface layer but only when top base-interface layers exist.
        // This prevents all interface layers from being classified as base-interface layers
        // and preserves correct top contact and interface behavior.
        size_t interface_threshold = support_parameters.num_top_interface_layers_only();
        if (interface_threshold > 0 && support_parameters.num_top_base_interface_layers > 0)
            --interface_threshold;
        SupportGeneratorLayersPtr &layers =
            dtt_roof == 0 ? this->top_contacts :
            dtt_roof <= interface_threshold ? this->top_interfaces : this->top_base_interfaces;
        SupportGeneratorLayer*& l = layers[insert_layer_idx];
        if (l == nullptr)
            l = &layer_allocate_unguarded(layer_storage, dtt_roof == 0 ? SupporLayerType::TopContact : SupporLayerType::TopInterface, 
                    slicing_parameters, config, insert_layer_idx);
        // will be unioned in finalize_interface_and_support_areas()
        append(l->polygons, std::move(new_roofs));
    }

References Slic3r::append(), config, Slic3r::TreeSupport3D::layer_allocate_unguarded(), layer_storage, Slic3r::SupportGeneratorLayer::polygons, slicing_parameters, support_parameters, top_base_interfaces, top_contacts, top_interfaces, Slic3r::TopContact, and Slic3r::TopInterface.

Referenced by add_roof(), add_roof_build_plate(), add_roofs(), and Slic3r::TreeSupport3D::generate_raft_contact().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_roofs()

void Slic3r::TreeSupport3D::InterfacePlacer::add_roofs	(	std::vector< Polygons > &&	new_roofs,
		const size_t	insert_layer_idx )

inlineinherited

    {
        if (! new_roofs.empty()) {
            std::lock_guard<std::mutex> lock(m_mutex_layer_storage);
            for (size_t idx = 0; idx < new_roofs.size(); ++ idx)
                if (! new_roofs[idx].empty())
                    add_roof_unguarded(std::move(new_roofs[idx]), insert_layer_idx - idx, idx);
        }
    }