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

Collaboration diagram for Slic3r::sla::SupportPointGenerator::Structure:

Classes
struct	Link

Public Member Functions
	Structure (MyLayer &layer, const ExPolygon &poly, const BoundingBox &bbox, const Vec2f &centroid, float area, float h)
float	supports_force_total () const
bool	overlaps (const Structure &rhs) const
float	overlap_area (const Structure &rhs) const
float	area_below () const
Polygons	polygons_below () const
ExPolygons	expolygons_below () const
float	support_force_deficit (const float tear_pressure) const

Public Attributes
MyLayer *	layer
const ExPolygon *	polygon = nullptr
const BoundingBox	bbox
const Vec2f	centroid = Vec2f::Zero()
const float	area = 0.f
float	zlevel = 0
float	supports_force_this_layer = 0.f
float	supports_force_inherited = 0.f
std::vector< Link >	islands_above
std::vector< Link >	islands_below
ExPolygons	dangling_areas
ExPolygons	overhangs
ExPolygons	overhangs_slopes
float	overhangs_area = 0.f

Detailed Description

Constructor & Destructor Documentation

◆ Structure()

Slic3r::sla::SupportPointGenerator::Structure::Structure	(	MyLayer &	layer,
		const ExPolygon &	poly,
		const BoundingBox &	bbox,
		const Vec2f &	centroid,
		float	area,
		float	h )

inline

                                                                                                                              :
            layer(&layer), polygon(&poly), bbox(bbox), centroid(centroid), area(area), zlevel(h)
#ifdef SLA_SUPPORTPOINTGEN_DEBUG
            , unique_id(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()))
#endif /* SLA_SUPPORTPOINTGEN_DEBUG */
        {}

References area, bbox, centroid, layer, polygon, and zlevel.

Referenced by Slic3r::sla::SupportPointGenerator::Structure::Link::Link(), overlap_area(), and overlaps().

Here is the caller graph for this function:

Member Function Documentation

◆ area_below()

float Slic3r::sla::SupportPointGenerator::Structure::area_below ( ) const

inline

                                 { 
            float area = 0.f; 
            for (const Link &below : this->islands_below) 
                area += below.island->area; 
            return area;
        }

References area.

◆ expolygons_below()

ExPolygons Slic3r::sla::SupportPointGenerator::Structure::expolygons_below ( ) const

inline

                                            { 
            ExPolygons out;
            out.reserve(this->islands_below.size());
            for (const Link &below : this->islands_below)
                out.emplace_back(*below.island->polygon);
            return out;
        }

◆ overlap_area()

float Slic3r::sla::SupportPointGenerator::Structure::overlap_area ( const Structure & rhs ) const

inline

                                                       { 
            double out = 0.;
            if (this->bbox.overlap(rhs.bbox)) {
                Polygons polys = intersection(*this->polygon, *rhs.polygon);
                for (const Polygon &poly : polys)
                    out += poly.area();
            }
            return float(out);
        }

References Structure(), bbox, Slic3r::intersection(), Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), and polygon.

Here is the call graph for this function:

◆ overlaps()

bool Slic3r::sla::SupportPointGenerator::Structure::overlaps ( const Structure & rhs ) const

inline

                                                  { 
            //FIXME ExPolygon::overlaps() shall be commutative, it is not!
            return this->bbox.overlap(rhs.bbox) && (this->polygon->overlaps(*rhs.polygon) || rhs.polygon->overlaps(*this->polygon)); 
        }

References Structure(), bbox, Slic3r::BoundingBoxBase< PointType, APointsType >::overlap(), Slic3r::ExPolygon::overlaps(), and polygon.

Here is the call graph for this function:

◆ polygons_below()

Polygons Slic3r::sla::SupportPointGenerator::Structure::polygons_below ( ) const

inline

                                        { 
            size_t cnt = 0;
            for (const Link &below : this->islands_below)
                cnt += 1 + below.island->polygon->holes.size();
            Polygons out;
            out.reserve(cnt);
            for (const Link &below : this->islands_below) {
                out.emplace_back(below.island->polygon->contour);
                append(out, below.island->polygon->holes);
            }
            return out;
        }