Slic3r::sla::SupportPointGenerator Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLA/SupportPointGenerator.hpp>

Collaboration diagram for Slic3r::sla::SupportPointGenerator:

Classes
struct	Config
struct	Structure
struct	MyLayer
struct	RichSupportPoint
struct	PointGrid3D

Public Types
enum	IslandCoverageFlags : uint8_t { icfNone = 0x0 , icfIsNew = 0x1 , icfWithBoundary = 0x2 }

Public Member Functions
	SupportPointGenerator (const IndexedMesh &emesh, const std::vector< ExPolygons > &slices, const std::vector< float > &heights, const Config &config, std::function< void(void)> throw_on_cancel, std::function< void(int)> statusfn)
	SupportPointGenerator (const IndexedMesh &emesh, const Config &config, std::function< void(void)> throw_on_cancel, std::function< void(int)> statusfn)
const std::vector< SupportPoint > &	output () const
std::vector< SupportPoint > &	output ()
void	execute (const std::vector< ExPolygons > &slices, const std::vector< float > &heights)
void	seed (std::mt19937::result_type s)

Private Member Functions
void	process (const std::vector< ExPolygons > &slices, const std::vector< float > &heights)
void	uniformly_cover (const ExPolygons &islands, Structure &structure, float deficit, PointGrid3D &grid3d, IslandCoverageFlags flags=icfNone)
void	add_support_points (Structure &structure, PointGrid3D &grid3d)
void	project_onto_mesh (std::vector< SupportPoint > &points) const

Private Attributes
std::vector< SupportPoint >	m_output
SupportPointGenerator::Config	m_config
const IndexedMesh &	m_emesh
std::function< void(void)>	m_throw_on_cancel
std::function< void(int)>	m_statusfn
std::mt19937	m_rng

Detailed Description

---

Class Documentation

Slic3r::sla::SupportPointGenerator::RichSupportPoint

struct Slic3r::sla::SupportPointGenerator::RichSupportPoint

Collaboration diagram for Slic3r::sla::SupportPointGenerator::RichSupportPoint:

Class Members
Structure *	island
Vec3f	position

Member Enumeration Documentation

IslandCoverageFlags

enum Slic3r::sla::SupportPointGenerator::IslandCoverageFlags : uint8_t

Enumerator
icfNone
icfIsNew
icfWithBoundary

: uint8_t { icfNone = 0x0, icfIsNew = 0x1, icfWithBoundary = 0x2 };

Constructor & Destructor Documentation

SupportPointGenerator() [1/2]

Slic3r::sla::SupportPointGenerator::SupportPointGenerator	(	const IndexedMesh &	emesh,
		const std::vector< ExPolygons > &	slices,
		const std::vector< float > &	heights,
		const Config &	config,
		std::function< void(void)>	throw_on_cancel,
		std::function< void(int)>	statusfn )

    : SupportPointGenerator(emesh, config, throw_on_cancel, statusfn)
{
    std::random_device rd;
    m_rng.seed(rd());
    execute(slices, heights);
}

References SupportPointGenerator(), execute(), and m_rng.

Referenced by SupportPointGenerator().

Here is the call graph for this function:

Here is the caller graph for this function:

SupportPointGenerator() [2/2]

Slic3r::sla::SupportPointGenerator::SupportPointGenerator	(	const IndexedMesh &	emesh,
		const Config &	config,
		std::function< void(void)>	throw_on_cancel,
		std::function< void(int)>	statusfn )

Member Function Documentation

add_support_points()

void Slic3r::sla::SupportPointGenerator::add_support_points ( SupportPointGenerator::Structure & s, SupportPointGenerator::PointGrid3D & grid3d )

private

{
    // Select each type of surface (overrhang, dangling, slope), derive the support
    // force deficit for it and call uniformly conver with the right params
 
    float tp      = m_config.tear_pressure();
    float current = s.supports_force_total();
 
    if (s.islands_below.empty()) {
        // completely new island - needs support no doubt
        // deficit is full, there is nothing below that would hold this island
        uniformly_cover({ *s.polygon }, s, s.area * tp, grid3d, IslandCoverageFlags(icfIsNew | icfWithBoundary) );
        return;
    }
 
    if (! s.overhangs.empty()) {
        uniformly_cover(s.overhangs, s, s.overhangs_area * tp, grid3d);
    }
 
    auto areafn = [](double sum, auto &p) { return sum + p.area() * SCALING_FACTOR * SCALING_FACTOR; };
 
    current = s.supports_force_total();
    if (! s.dangling_areas.empty()) {
        // Let's see if there's anything that overlaps enough to need supports:
        // What we now have in polygons needs support, regardless of what the forces are, so we can add them.
 
        double a = std::accumulate(s.dangling_areas.begin(), s.dangling_areas.end(), 0., areafn);
        uniformly_cover(s.dangling_areas, s, a * tp - a * current * s.area, grid3d, icfWithBoundary);
    }
 
    current = s.supports_force_total();
    if (! s.overhangs_slopes.empty()) {
        double a = std::accumulate(s.overhangs_slopes.begin(), s.overhangs_slopes.end(), 0., areafn);
        uniformly_cover(s.overhangs_slopes, s, a * tp - a * current / s.area, grid3d, icfWithBoundary);
    }
}

References add_support_points(), Slic3r::sla::SupportPointGenerator::Structure::area, Slic3r::sla::SupportPointGenerator::Structure::dangling_areas, icfIsNew, icfWithBoundary, Slic3r::sla::SupportPointGenerator::Structure::islands_below, m_config, Slic3r::sla::SupportPointGenerator::Structure::overhangs, Slic3r::sla::SupportPointGenerator::Structure::overhangs_area, Slic3r::sla::SupportPointGenerator::Structure::overhangs_slopes, Slic3r::sla::SupportPointGenerator::Structure::polygon, SCALING_FACTOR, Slic3r::sla::SupportPointGenerator::Structure::supports_force_total(), and uniformly_cover().

Referenced by add_support_points(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

execute()

void Slic3r::sla::SupportPointGenerator::execute	(	const std::vector< ExPolygons > &	slices,
		const std::vector< float > &	heights )

{
    process(slices, heights);
    project_onto_mesh(m_output);
}

References m_output, process(), and project_onto_mesh().

Referenced by SupportPointGenerator().

Here is the call graph for this function:

Here is the caller graph for this function:

output() [1/2]

std::vector< SupportPoint > & Slic3r::sla::SupportPointGenerator::output ( )

inline

{ return m_output; }

References m_output.

output() [2/2]

const std::vector< SupportPoint > & Slic3r::sla::SupportPointGenerator::output ( ) const

inline

{ return m_output; }

References m_output.

Referenced by Slic3r::SLAPrint::Steps::support_points().

Here is the caller graph for this function:

process()

void Slic3r::sla::SupportPointGenerator::process ( const std::vector< ExPolygons > & slices, const std::vector< float > & heights )

private

{
#ifdef SLA_SUPPORTPOINTGEN_DEBUG
    std::vector<std::pair<ExPolygon, coord_t>> islands;
#endif /* SLA_SUPPORTPOINTGEN_DEBUG */
 
    std::vector<SupportPointGenerator::MyLayer> layers = make_layers(slices, heights, m_throw_on_cancel);
 
    PointGrid3D point_grid;
    point_grid.cell_size = Vec3f(10.f, 10.f, 10.f);
 
    double increment = 100.0 / layers.size();
    double status    = 0;
 
    for (unsigned int layer_id = 0; layer_id < layers.size(); ++ layer_id) {
        SupportPointGenerator::MyLayer *layer_top     = &layers[layer_id];
        SupportPointGenerator::MyLayer *layer_bottom  = (layer_id > 0) ? &layers[layer_id - 1] : nullptr;
        std::vector<float>        support_force_bottom;
        if (layer_bottom != nullptr) {
            support_force_bottom.assign(layer_bottom->islands.size(), 0.f);
            for (size_t i = 0; i < layer_bottom->islands.size(); ++ i)
                support_force_bottom[i] = layer_bottom->islands[i].supports_force_total();
        }
        for (Structure &top : layer_top->islands)
            for (Structure::Link &bottom_link : top.islands_below) {
                Structure &bottom = *bottom_link.island;
                //float centroids_dist = (bottom.centroid - top.centroid).norm();
                // Penalization resulting from centroid offset:
//                  bottom.supports_force *= std::min(1.f, 1.f - std::min(1.f, (1600.f * layer_height) * centroids_dist * centroids_dist / bottom.area));
                float &support_force = support_force_bottom[&bottom - layer_bottom->islands.data()];
//FIXME this condition does not reflect a bifurcation into a one large island and one tiny island well, it incorrectly resets the support force to zero.
// One should rather work with the overlap area vs overhang area.
//                support_force *= std::min(1.f, 1.f - std::min(1.f, 0.1f * centroids_dist * centroids_dist / bottom.area));
                // Penalization resulting from increasing polygon area:
                support_force *= std::min(1.f, 20.f * bottom.area / top.area);
            }
        // Let's assign proper support force to each of them:
        if (layer_id > 0) {
            for (Structure &below : layer_bottom->islands) {
                float below_support_force = support_force_bottom[&below - layer_bottom->islands.data()];
                float above_overlap_area = 0.f;
                for (Structure::Link &above_link : below.islands_above)
                    above_overlap_area += above_link.overlap_area;
                for (Structure::Link &above_link : below.islands_above)
                    above_link.island->supports_force_inherited += below_support_force * above_link.overlap_area / above_overlap_area;
            }
        }
        // Now iterate over all polygons and append new points if needed.
        for (Structure &s : layer_top->islands) {
            // Penalization resulting from large diff from the last layer:
            s.supports_force_inherited /= std::max(1.f, 0.17f * (s.overhangs_area) / s.area);
 
            add_support_points(s, point_grid);
        }
 
        m_throw_on_cancel();
 
        status += increment;
        m_statusfn(int(std::round(status)));
 
#ifdef SLA_SUPPORTPOINTGEN_DEBUG
        /*std::string layer_num_str = std::string((i<10 ? "0" : "")) + std::string((i<100 ? "0" : "")) + std::to_string(i);
        output_expolygons(expolys_top, "top" + layer_num_str + ".svg");
        output_expolygons(diff, "diff" + layer_num_str + ".svg");
        if (!islands.empty())
            output_expolygons(islands, "islands" + layer_num_str + ".svg");*/
#endif /* SLA_SUPPORTPOINTGEN_DEBUG */
    }
}

References add_support_points(), Slic3r::sla::SupportPointGenerator::Structure::area, Slic3r::sla::SupportPointGenerator::PointGrid3D::cell_size, Slic3r::sla::SupportPointGenerator::Structure::Link::island, Slic3r::sla::SupportPointGenerator::MyLayer::islands, Slic3r::sla::SupportPointGenerator::Structure::islands_above, Slic3r::sla::SupportPointGenerator::Structure::islands_below, m_statusfn, m_throw_on_cancel, Slic3r::sla::make_layers(), Slic3r::sla::SupportPointGenerator::Structure::overhangs_area, Slic3r::sla::SupportPointGenerator::Structure::Link::overlap_area, process(), and Slic3r::sla::SupportPointGenerator::Structure::supports_force_inherited.

Referenced by execute(), and process().

Here is the call graph for this function:

Here is the caller graph for this function:

project_onto_mesh()

void Slic3r::sla::SupportPointGenerator::project_onto_mesh ( std::vector< SupportPoint > & points ) const

private

{
    // The function  makes sure that all the points are really exactly placed on the mesh.
 
    // Use a reasonable granularity to account for the worker thread synchronization cost.
    static constexpr size_t gransize = 64;
 
    ccr_par::for_each(size_t(0), points.size(), [this, &points](size_t idx)
    {
        if ((idx % 16) == 0)
            // Don't call the following function too often as it flushes CPU write caches due to synchronization primitves.
            m_throw_on_cancel();
 
        Vec3f& p = points[idx].pos;
        // Project the point upward and downward and choose the closer intersection with the mesh.
        sla::IndexedMesh::hit_result hit_up   = m_emesh.query_ray_hit(p.cast<double>(), Vec3d(0., 0., 1.));
        sla::IndexedMesh::hit_result hit_down = m_emesh.query_ray_hit(p.cast<double>(), Vec3d(0., 0., -1.));
 
        bool up   = hit_up.is_hit();
        bool down = hit_down.is_hit();
 
        if (!up && !down)
            return;
 
        sla::IndexedMesh::hit_result& hit = (!down || (hit_up.distance() < hit_down.distance())) ? hit_up : hit_down;
        p = p + (hit.distance() * hit.direction()).cast<float>();
    }, gransize);
}

References Slic3r::sla::_ccr< true >::for_each().

Referenced by execute().

Here is the call graph for this function:

Here is the caller graph for this function:

seed()

void Slic3r::sla::SupportPointGenerator::seed ( std::mt19937::result_type s )

inline

{ m_rng.seed(s); }

References m_rng.

uniformly_cover()

void Slic3r::sla::SupportPointGenerator::uniformly_cover ( const ExPolygons & islands, Structure & structure, float deficit, PointGrid3D & grid3d, IslandCoverageFlags flags = icfNone )

private

{
    //int num_of_points = std::max(1, (int)((island.area()*pow(SCALING_FACTOR, 2) * m_config.tear_pressure)/m_config.support_force));
 
    float support_force_deficit = deficit;
//    auto bb = get_extents(islands);
 
    if (flags & icfIsNew) {
        auto chull = Geometry::convex_hull(islands);
        auto rotbox = MinAreaBoundigBox{chull, MinAreaBoundigBox::pcConvex};
        Vec2d bbdim = {unscaled(rotbox.width()), unscaled(rotbox.height())};
 
        if (bbdim.x() > bbdim.y()) std::swap(bbdim.x(), bbdim.y());
        double aspectr = bbdim.y() / bbdim.x();
 
        support_force_deficit *= (1 + aspectr / 2.);
    }
 
    if (support_force_deficit < 0)
        return;
 
    // Number of newly added points.
    const size_t poisson_samples_target = size_t(ceil(support_force_deficit / m_config.support_force()));
 
    const float density_horizontal = m_config.tear_pressure() / m_config.support_force();
    //FIXME why?
    float poisson_radius    = std::max(m_config.minimal_distance, 1.f / (5.f * density_horizontal));
//    const float poisson_radius     = 1.f / (15.f * density_horizontal);
    const float samples_per_mm2 = 30.f / (float(M_PI) * poisson_radius * poisson_radius);
    // Minimum distance between samples, in 3D space.
//    float min_spacing     = poisson_radius / 3.f;
    float min_spacing     = poisson_radius;
 
    //FIXME share the random generator. The random generator may be not so cheap to initialize, also we don't want the random generator to be restarted for each polygon.
 
    std::vector<Vec2f> raw_samples =
        flags & icfWithBoundary ?
            sample_expolygon_with_boundary(islands, samples_per_mm2,
                                           5.f / poisson_radius, m_rng) :
            sample_expolygon(islands, samples_per_mm2, m_rng);
 
    std::vector<Vec2f>  poisson_samples;
    for (size_t iter = 0; iter < 4; ++ iter) {
        poisson_samples = poisson_disk_from_samples(raw_samples, poisson_radius,
            [&structure, &grid3d, min_spacing](const Vec2f &pos) {
                return grid3d.collides_with(pos, structure.layer->print_z, min_spacing);
            });
        if (poisson_samples.size() >= poisson_samples_target || m_config.minimal_distance > poisson_radius-EPSILON)
            break;
        float coeff = 0.5f;
        if (poisson_samples.size() * 2 > poisson_samples_target)
            coeff = float(poisson_samples.size()) / float(poisson_samples_target);
        poisson_radius = std::max(m_config.minimal_distance, poisson_radius * coeff);
        min_spacing    = std::max(m_config.minimal_distance, min_spacing * coeff);
    }
 
#ifdef SLA_SUPPORTPOINTGEN_DEBUG
    {
        static int irun = 0;
        Slic3r::SVG svg(debug_out_path("SLA_supports-uniformly_cover-%d.svg", irun ++), get_extents(islands));
        for (const ExPolygon &island : islands)
            svg.draw(island);
        for (const Vec2f &pt : raw_samples)
            svg.draw(Point(scale_(pt.x()), scale_(pt.y())), "red");
        for (const Vec2f &pt : poisson_samples)
            svg.draw(Point(scale_(pt.x()), scale_(pt.y())), "blue");
    }
#endif /* NDEBUG */
 
//    assert(! poisson_samples.empty());
    if (poisson_samples_target < poisson_samples.size()) {
        std::shuffle(poisson_samples.begin(), poisson_samples.end(), m_rng);
        poisson_samples.erase(poisson_samples.begin() + poisson_samples_target, poisson_samples.end());
    }
    for (const Vec2f &pt : poisson_samples) {
        m_output.emplace_back(float(pt(0)), float(pt(1)), structure.zlevel, m_config.head_diameter/2.f, flags & icfIsNew);
        structure.supports_force_this_layer += m_config.support_force();
        grid3d.insert(pt, &structure);
    }
}

References Slic3r::sla::SupportPointGenerator::PointGrid3D::collides_with(), Slic3r::Geometry::convex_hull(), Slic3r::debug_out_path(), Slic3r::SVG::draw(), EPSILON, Slic3r::get_extents(), icfIsNew, icfWithBoundary, Slic3r::sla::SupportPointGenerator::PointGrid3D::insert(), Slic3r::sla::SupportPointGenerator::Structure::layer, m_config, m_output, M_PI, m_rng, Slic3r::MinAreaBoundigBox::pcConvex, Slic3r::sla::poisson_disk_from_samples(), Slic3r::sla::pos(), Slic3r::sla::SupportPointGenerator::MyLayer::print_z, Slic3r::sla::sample_expolygon(), Slic3r::sla::sample_expolygon_with_boundary(), scale_, Slic3r::sla::SupportPointGenerator::Structure::supports_force_this_layer, uniformly_cover(), Slic3r::unscaled(), and Slic3r::sla::SupportPointGenerator::Structure::zlevel.

Referenced by add_support_points(), and uniformly_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_config

SupportPointGenerator::Config Slic3r::sla::SupportPointGenerator::m_config

private

Referenced by add_support_points(), and uniformly_cover().

m_emesh

const IndexedMesh& Slic3r::sla::SupportPointGenerator::m_emesh

private

m_output

std::vector<SupportPoint> Slic3r::sla::SupportPointGenerator::m_output

private

Referenced by execute(), output(), output(), and uniformly_cover().

m_rng

std::mt19937 Slic3r::sla::SupportPointGenerator::m_rng

private

Referenced by SupportPointGenerator(), seed(), and uniformly_cover().

m_statusfn

std::function<void(int)> Slic3r::sla::SupportPointGenerator::m_statusfn

private

Referenced by process().

m_throw_on_cancel

std::function<void(void)> Slic3r::sla::SupportPointGenerator::m_throw_on_cancel

private

Referenced by process().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLA/SupportPointGenerator.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/SLA/SupportPointGenerator.cpp