Slic3r::sla Namespace Reference

Namespaces
namespace	anonymous_namespace{Clustering.cpp}
namespace	anonymous_namespace{Pad.cpp}
namespace	anonymous_namespace{Rotfinder.cpp}

Classes
class	AGGRaster
struct	Anchor
struct	Ball
struct	Beam_
struct	BeamSamples
struct	BeamSamples< DefaultWideningModel >
class	BoxIndex
class	BranchingTreeBuilder
struct	Bridge
struct	Colors
class	ConcaveHull
	A fake concave hull that is constructed by connecting separate shapes with explicit bridges. Bridges are generated from each shape's centroid to the center of the "scene" which is the centroid calculated from the shape centroids (a star is created...) More...
class	DefaultSupportTree
struct	DefaultWideningModel
struct	DiffBridge
struct	DivFace
struct	DrainHole
class	EncodedRaster
struct	FaceHash
struct	GroundConnection
struct	Head
struct	HollowingConfig
struct	Interior
struct	InteriorDeleter
struct	JobController
	A Control structure for the support calculation. Consists of the status indicator callback and the stop condition predicate. More...
struct	Junction
struct	PadConfig
struct	Pedestal
struct	Pillar
class	PillarIndex
struct	PixelDim
	Types that represents the dimension of a pixel in millimeters. More...
struct	PNGRasterEncoder
class	PointIndex
class	PointRing
struct	PPMRasterEncoder
class	RasterBase
class	RasterGrayscaleAA
class	RasterGrayscaleAAGammaPower
struct	Resolution
	Type that represents a resolution in pixels. More...
struct	RotfinderBoilerplate
class	RotOptimizeParams
struct	SupportableMesh
struct	SupportPoint
class	SupportPointGenerator
class	SupportTreeBuilder
struct	SupportTreeConfig
struct	SupportTreeNode
struct	TriangleBubble

Typedefs
using	_RasterGrayscaleAA = AGGRaster< agg::pixfmt_gray8, agg::renderer_scanline_aa_solid >
using	Index3D = bgi::rtree< PointIndexEl, bgi::rstar< 16, 4 > >
using	ClusterEl = std::vector< unsigned >
using	ClusteredPoints = std::vector< ClusterEl >
using	ThrowOnCancel = std::function< void()>
using	InteriorPtr = std::unique_ptr< Interior, InteriorDeleter >
using	DrainHoles = std::vector< DrainHole >
using	RasterEncoder = std::function< EncodedRaster(const void *ptr, size_t w, size_t h, size_t num_components)>
using	RotOptimizeStatusCB = std::function< bool(int)>
typedef Eigen::Matrix< double, 3, 1, Eigen::DontAlign >	Vec3d
using	PointIndexEl = std::pair< Vec3d, unsigned >
using	BoxIndexEl = std::pair< Slic3r::BoundingBox, unsigned >
using	SupportPoints = std::vector< SupportPoint >
using	Portion = std::tuple< double, double >
using	Hit = AABBMesh::hit_result
using	Beam = Beam_<>

Enumerations
enum	{ NEW_FACE = -1 }
enum	HollowingFlags { hfRemoveInsideTriangles = 0x1 }
enum class	HollowMeshResult { Ok = 0 , FaultyMesh = 1 , FaultyHoles = 2 , DrillingFailed = 4 }
enum class	PointsStatus { NoPoints , Generating , AutoGenerated , UserModified }
enum class	MeshType { Support , Pad }
enum class	SupportTreeType { Default , Branching , Organic }
enum class	PillarConnectionMode { zigzag , cross , dynamic }
enum class	GroundRouteCheck { Full , PillarOnly }

Functions
static std::optional< Vec3f >	get_avoidance (const GroundConnection &conn, float maxdist)
void	build_pillars (SupportTreeBuilder &builder, BranchingTreeBuilder &vbuilder, const SupportableMesh &sm)
void	create_branching_tree (SupportTreeBuilder &builder, const SupportableMesh &sm)
ClusteredPoints	cluster (const std::vector< unsigned > &indices, std::function< Vec3d(unsigned)> pointfn, double dist, unsigned max_points)
ClusteredPoints	cluster (const std::vector< unsigned > &indices, std::function< Vec3d(unsigned)> pointfn, std::function< bool(const PointIndexEl &, const PointIndexEl &)> predicate, unsigned max_points)
ClusteredPoints	cluster (const Eigen::MatrixXd &pts, double dist, unsigned max_points)
template<class DistFn , class PointFn >
long	cluster_centroid (const ClusterEl &clust, PointFn pointfn, DistFn df)
Vec3d	to_vec3 (const Vec2crd &v2)
Vec2crd	to_vec2 (const Vec3d &v3)
ExPolygons	offset_waffle_style_ex (const ConcaveHull &hull, coord_t delta)
Polygons	offset_waffle_style (const ConcaveHull &hull, coord_t delta)
Polygons	get_contours (const ExPolygons &poly)
void	create_default_tree (SupportTreeBuilder &builder, const SupportableMesh &sm)
indexed_triangle_set &	get_mesh (Interior &interior)
const indexed_triangle_set &	get_mesh (const Interior &interior)
const VoxelGrid &	get_grid (const Interior &interior)
VoxelGrid &	get_grid (Interior &interior)
InteriorPtr	generate_interior (const VoxelGrid &vgrid, const HollowingConfig &hc, const JobController &ctl)
void	cut_drainholes (std::vector< ExPolygons > &obj_slices, const std::vector< float > &slicegrid, float closing_radius, const sla::DrainHoles &holes, std::function< void(void)> thr)
void	hollow_mesh (TriangleMesh &mesh, const HollowingConfig &cfg, int flags)
void	hollow_mesh (TriangleMesh &mesh, const Interior &interior, int flags)
void	hollow_mesh (indexed_triangle_set &mesh, const Interior &interior, int flags)
static double	get_distance_raw (const Vec3f &p, const Interior &interior)
static double	get_distance (const TriangleBubble &b, const Interior &interior)
double	get_distance (const Vec3f &p, const Interior &interior)
template<class T >
FloatingOnly< T >	get_distance (const Vec< 3, T > &p, const Interior &interior)
template<class Fn >
void	divide_triangle (const DivFace &face, Fn &&visitor)
void	remove_inside_triangles (indexed_triangle_set &mesh, const Interior &interior, const std::vector< bool > &exclude_mask)
void	remove_inside_triangles (TriangleMesh &mesh, const Interior &interior, const std::vector< bool > &exclude_mask)
static void	exclude_neighbors (const Vec3i &face, std::vector< bool > &mask, const indexed_triangle_set &its, const VertexFaceIndex &index, size_t recursions)
std::vector< bool >	create_exclude_mask (const indexed_triangle_set &its, const Interior &interior, const std::vector< DrainHole > &holes)
DrainHoles	transformed_drainhole_points (const ModelObject &mo, const Transform3d &trafo)
double	get_voxel_scale (double mesh_volume, const HollowingConfig &hc)
static indexed_triangle_set	remove_unconnected_vertices (const indexed_triangle_set &its)
int	hollow_mesh_and_drill (indexed_triangle_set &hollowed_mesh, const Interior &interior, const DrainHoles &drainholes, std::function< void(size_t)> on_hole_fail)
InteriorPtr	generate_interior (const indexed_triangle_set &mesh, const HollowingConfig &hc={}, const JobController &ctl={})
template<class Cont >
double	csgmesh_positive_maxvolume (const Cont &csg)
template<class It >
InteriorPtr	generate_interior (const Range< It > &csgparts, const HollowingConfig &hc={}, const JobController &ctl={})
void	hollow_mesh (indexed_triangle_set &mesh, const HollowingConfig &cfg, int flags=0)
void	swap_normals (indexed_triangle_set &its)
void	pad_blueprint (const indexed_triangle_set &mesh, ExPolygons &output, const std::vector< float > &, ThrowOnCancel thrfn=[] {})
	Calculate the polygon representing the silhouette.
void	pad_blueprint (const indexed_triangle_set &mesh, ExPolygons &output, float h, float layerh, ThrowOnCancel thrfn)
void	create_pad (const ExPolygons &sup_blueprint, const ExPolygons &model_blueprint, indexed_triangle_set &out, const PadConfig &cfg, ThrowOnCancel thr)
std::ostream &	operator<< (std::ostream &stream, const EncodedRaster &bytes)
std::unique_ptr< RasterBase >	create_raster_grayscale_aa (const Resolution &res, const PixelDim &pxdim, double gamma, const RasterBase::Trafo &tr)
template<class Fn >
void	foreach_vertex (ExPolygon &poly, Fn &&fn)
ExPolygons	raster_to_polygons (const RasterGrayscaleAA &rst, Vec2i windowsize)
template<class Pt >
Vec3d	pos (const Pt &p)
template<class Pt >
void	pos (Pt &p, const Vec3d &pp)
template<class PointType >
void	reproject_support_points (const AABBMesh &mesh, std::vector< PointType > &pts)
void	reproject_points_and_holes (ModelObject *object)
Vec2d	find_best_misalignment_rotation (const ModelObject &mo, const RotOptimizeParams &params)
Vec2d	find_least_supports_rotation (const ModelObject &mo, const RotOptimizeParams &params)
BoundingBoxf3	bounding_box_with_tr (const indexed_triangle_set &its, const Transform3f &tr)
Vec2d	find_min_z_height_rotation (const ModelObject &mo, const RotOptimizeParams &params)
SupportPoints	transformed_support_points (const ModelObject &mo, const Transform3d &trafo)
static std::vector< SupportPointGenerator::MyLayer >	make_layers (const std::vector< ExPolygons > &slices, const std::vector< float > &heights, std::function< void(void)> throw_on_cancel)
std::vector< Vec2f >	sample_expolygon (const ExPolygon &expoly, float samples_per_mm2, std::mt19937 &rng)
std::vector< Vec2f >	sample_expolygon (const ExPolygons &expolys, float samples_per_mm2, std::mt19937 &rng)
void	sample_expolygon_boundary (const ExPolygon &expoly, float samples_per_mm, std::vector< Vec2f > &out, std::mt19937 &)
std::vector< Vec2f >	sample_expolygon_with_boundary (const ExPolygon &expoly, float samples_per_mm2, float samples_per_mm_boundary, std::mt19937 &rng)
std::vector< Vec2f >	sample_expolygon_with_boundary (const ExPolygons &expolys, float samples_per_mm2, float samples_per_mm_boundary, std::mt19937 &rng)
template<typename REFUSE_FUNCTION >
static std::vector< Vec2f >	poisson_disk_from_samples (const std::vector< Vec2f > &raw_samples, float radius, REFUSE_FUNCTION refuse_function)
void	remove_bottom_points (std::vector< SupportPoint > &pts, float lvl)
indexed_triangle_set	create_support_tree (const SupportableMesh &sm, const JobController &ctl)
indexed_triangle_set	create_pad (const SupportableMesh &sm, const indexed_triangle_set &support_mesh, const JobController &ctl)
std::vector< ExPolygons >	slice (const indexed_triangle_set &sup_mesh, const indexed_triangle_set &pad_mesh, const std::vector< float > &grid, float cr, const JobController &ctl)
double	ground_level (const SupportableMesh &sm)
template<class T , int I>
T	distance (const Vec< I, T > &p)
template<class T , int I>
T	distance (const Vec< I, T > &pp1, const Vec< I, T > &pp2)
indexed_triangle_set	sphere (double rho, Portion portion, double fa)
indexed_triangle_set	pinhead (double r_pin, double r_back, double length, size_t steps)
indexed_triangle_set	halfcone (double baseheight, double r_bottom, double r_top, const Vec3d &pos, size_t steps)
indexed_triangle_set	get_mesh (const Head &h, size_t steps)
indexed_triangle_set	get_mesh (const Bridge &br, size_t steps)
indexed_triangle_set	get_mesh (const DiffBridge &br, size_t steps)
Portion	make_portion (double a, double b)
indexed_triangle_set	cylinder (double r, double h, size_t steps=45)
indexed_triangle_set	get_mesh (const Pillar &p, size_t steps)
indexed_triangle_set	get_mesh (const Pedestal &p, size_t steps)
indexed_triangle_set	get_mesh (const Junction &j, size_t steps)
template<class T , int N>
Vec< N, T >	dirv (const Vec< N, T > &startp, const Vec< N, T > &endp)
template<class It >
Hit	min_hit (It from, It to)
StopCriteria	get_criteria (const SupportTreeConfig &cfg)
template<class Ex , size_t RayCount = Beam::SAMPLES>
Hit	beam_mesh_hit (Ex policy, const AABBMesh &mesh, const Beam_< RayCount > &beam, double sd)
template<class Ex >
Hit	pinhead_mesh_hit (Ex ex, const AABBMesh &mesh, const Vec3d &s, const Vec3d &dir, double r_pin, double r_back, double width, double sd)
template<class Ex >
Hit	pinhead_mesh_hit (Ex ex, const AABBMesh &mesh, const Head &head, double safety_d)
double	distance (const SupportPoint &a, const SupportPoint &b)
template<class PtIndex >
std::vector< size_t >	non_duplicate_suppt_indices (const PtIndex &index, const SupportPoints &suppts, double eps)
template<class Ex >
bool	optimize_pinhead_placement (Ex policy, const SupportableMesh &m, Head &head)
template<class Ex >
std::optional< Head >	calculate_pinhead_placement (Ex policy, const SupportableMesh &sm, size_t suppt_idx)
long	build_ground_connection (SupportTreeBuilder &builder, const SupportableMesh &sm, const GroundConnection &conn)
template<class Ex , class WideningFn , class = std::enable_if_t<IsWideningFn<WideningFn>>>
Vec3d	check_ground_route (Ex policy, const SupportableMesh &sm, const Junction &source, const Vec3d &dir, double bridge_len, WideningFn &&wideningfn, GroundRouteCheck type=GroundRouteCheck::Full)
template<class Ex , class WideningFn , class = std::enable_if_t<IsWideningFn<WideningFn>>>
GroundConnection	deepsearch_ground_connection (Ex policy, const SupportableMesh &sm, const Junction &source, WideningFn &&wideningfn, const Vec3d &init_dir=DOWN)
template<class Ex >
GroundConnection	deepsearch_ground_connection (Ex policy, const SupportableMesh &sm, const Junction &source, double end_radius, const Vec3d &init_dir=DOWN)
template<class Ex >
GroundConnection	deepsearch_ground_connection (Ex policy, const SupportableMesh &sm, const Junction &source, const Vec3d &init_dir=DOWN)
template<class Ex >
bool	optimize_anchor_placement (Ex policy, const SupportableMesh &sm, const Junction &from, Anchor &anchor)
template<class Ex >
std::optional< Anchor >	calculate_anchor_placement (Ex policy, const SupportableMesh &sm, const Junction &from, const Vec3d &to_hint)
bool	is_outside_support_cone (const Vec3f &supp, const Vec3f &pt, float angle)
std::optional< Vec3f >	find_merge_pt (const Vec3f &A, const Vec3f &B, float critical_angle)
template<class I , class DoubleI = IntegerOnly<I>>
IntegerOnly< DoubleI >	pairhash (I a, I b)
template<class Ex >
std::optional< DiffBridge >	search_widening_path (Ex policy, const SupportableMesh &sm, const Vec3d &jp, const Vec3d &dir, double radius, double new_radius)
template<class Ex >
std::pair< bool, long >	create_ground_pillar (Ex policy, SupportTreeBuilder &builder, const SupportableMesh &sm, const Vec3d &pinhead_junctionpt, const Vec3d &sourcedir, double radius, double end_radius, long head_id=SupportTreeNode::ID_UNSET)
template<class Ex >
std::pair< bool, long >	connect_to_ground (Ex policy, SupportTreeBuilder &builder, const SupportableMesh &sm, const Junction &j, const Vec3d &dir, double end_r)
template<class Ex >
std::pair< bool, long >	search_ground_route (Ex policy, SupportTreeBuilder &builder, const SupportableMesh &sm, const Junction &j, double end_radius, const Vec3d &init_dir=DOWN)

Variables
constexpr const auto &	beam_ex_policy = ex_tbb
constexpr const auto &	suptree_ex_policy = ex_tbb
constexpr float	HoleStickOutLength = 1.f
const Vec3d	DOWN = {0.0, 0.0, -1.0}
template<class Fn >
constexpr bool	IsWideningFn
template<class WFn >
constexpr size_t	BeamSamplesV = BeamSamples<remove_cvref_t<WFn>>::Value

---

Class Documentation

Slic3r::sla::Ball

struct Slic3r::sla::Ball

Collaboration diagram for Slic3r::sla::Ball:

Class Members
Vec3d	p
double	R

Slic3r::sla::DivFace

struct Slic3r::sla::DivFace

Collaboration diagram for Slic3r::sla::DivFace:

Class Members
long	faceid = NEW_FACE
Vec3i	indx
long	parent = NEW_FACE
array< Vec3f, 3 >	verts

Slic3r::sla::HollowingConfig

struct Slic3r::sla::HollowingConfig

Class Members
double	closing_distance = 0.5
bool	enabled = true
double	min_thickness = 2.
double	quality = 0.5

Slic3r::sla::JobController

struct Slic3r::sla::JobController

A Control structure for the support calculation. Consists of the status indicator callback and the stop condition predicate.

Class Members
typedef function< void(void)>	CancelFn
typedef function< void(unsigned, const string &)>	StatusFn
typedef function< bool(void)>	StopCond

Class Members
CancelFn	cancelfn = [](){}
StatusFn	statuscb = [](unsigned, const std::string&){}
StopCond	stopcondition = [](){ return false; }

Slic3r::sla::TriangleBubble

struct Slic3r::sla::TriangleBubble

Collaboration diagram for Slic3r::sla::TriangleBubble:

Class Members
Vec3f	center
double	R

Typedef Documentation

_RasterGrayscaleAA

using Slic3r::sla::_RasterGrayscaleAA = typedef AGGRaster<agg::pixfmt_gray8, agg::renderer_scanline_aa_solid>

Beam

using Slic3r::sla::Beam = typedef Beam_<>

BoxIndexEl

using Slic3r::sla::BoxIndexEl = typedef std::pair<Slic3r::BoundingBox, unsigned>

ClusteredPoints

using Slic3r::sla::ClusteredPoints = typedef std::vector<ClusterEl>

ClusterEl

using Slic3r::sla::ClusterEl = typedef std::vector<unsigned>

DrainHoles

using Slic3r::sla::DrainHoles = typedef std::vector<DrainHole>

Hit

using Slic3r::sla::Hit = typedef AABBMesh::hit_result

Index3D

using Slic3r::sla::Index3D = typedef bgi::rtree< PointIndexEl, bgi::rstar<16, 4> >

InteriorPtr

using Slic3r::sla::InteriorPtr = typedef std::unique_ptr<Interior, InteriorDeleter>

PointIndexEl

using Slic3r::sla::PointIndexEl = typedef std::pair<Vec3d, unsigned>

Portion

using Slic3r::sla::Portion = typedef std::tuple<double, double>

RasterEncoder

using Slic3r::sla::RasterEncoder = typedef std::function<EncodedRaster(const void *ptr, size_t w, size_t h, size_t num_components)>

RotOptimizeStatusCB

using Slic3r::sla::RotOptimizeStatusCB = typedef std::function<bool(int)>

SupportPoints

using Slic3r::sla::SupportPoints = typedef std::vector<SupportPoint>

ThrowOnCancel

typedef std::function< void(void)> Slic3r::sla::ThrowOnCancel

Vec3d

typedef Eigen::Matrix<double, 3, 1, Eigen::DontAlign> Slic3r::sla::Vec3d

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NEW_FACE

{ NEW_FACE = -1};

GroundRouteCheck

enum class Slic3r::sla::GroundRouteCheck

strong

Enumerator
Full
PillarOnly

{ Full, PillarOnly };

HollowingFlags

enum Slic3r::sla::HollowingFlags

Enumerator
hfRemoveInsideTriangles

{ hfRemoveInsideTriangles = 0x1 };

HollowMeshResult

enum class Slic3r::sla::HollowMeshResult

strong

Enumerator
Ok
FaultyMesh
FaultyHoles
DrillingFailed

                            {
    Ok = 0,
    FaultyMesh = 1,
    FaultyHoles = 2,
    DrillingFailed = 4
};

MeshType

enum class Slic3r::sla::MeshType

strong

Enumerator
Support
Pad

{ Support, Pad };

PillarConnectionMode

enum class Slic3r::sla::PillarConnectionMode

strong

Enumerator
zigzag
cross
dynamic

{ zigzag, cross, dynamic };

PointsStatus

enum class Slic3r::sla::PointsStatus

strong

Enumerator
NoPoints
Generating
AutoGenerated
UserModified

                        {
    NoPoints,           // No points were generated so far.
    Generating,     // The autogeneration algorithm triggered, but not yet finished.
    AutoGenerated,  // Points were autogenerated (i.e. copied from the backend).
    UserModified    // User has done some edits.
};

SupportTreeType

enum class Slic3r::sla::SupportTreeType

strong

Enumerator
Default
Branching
Organic

{ Default, Branching, Organic };

Function Documentation

beam_mesh_hit()

template<class Ex , size_t RayCount = Beam::SAMPLES>

Hit Slic3r::sla::beam_mesh_hit	(	Ex	policy,
		const AABBMesh &	mesh,
		const Beam_< RayCount > &	beam,
		double	sd
	)

{
    Vec3d src = beam.src;
    Vec3d dst = src + beam.dir;
    double r_src = beam.r1;
    double r_dst = beam.r2;
 
    Vec3d D = (dst - src);
    Vec3d dir = D.normalized();
    PointRing<RayCount>  ring{dir};
 
    using Hit = AABBMesh::hit_result;
 
    // Hit results
    std::array<Hit, RayCount> hits;
 
    execution::for_each(
        policy, size_t(0), hits.size(),
        [&mesh, r_src, r_dst, src, dst, &ring, dir, sd, &hits](size_t i) {
            Hit &hit = hits[i];
 
            // Point on the circle on the pin sphere
            Vec3d p_src = ring.get(i, src, r_src + sd);
            Vec3d p_dst = ring.get(i, dst, r_dst + sd);
            Vec3d raydir = (p_dst - p_src).normalized();
 
            auto hr = mesh.query_ray_hit(p_src + r_src * raydir, raydir);
 
            if (hr.is_inside()) {
                if (hr.distance() > 2 * r_src + sd)
                    hit = Hit(0.0);
                else {
                    // re-cast the ray from the outside of the object
                    auto q = p_src + (hr.distance() + EPSILON) * raydir;
                    hit = mesh.query_ray_hit(q, raydir);
                }
            } else
                hit = hr;
        }, std::min(execution::max_concurrency(policy), RayCount));
 
    return min_hit(hits.begin(), hits.end());
}

References Slic3r::sla::Beam_< Samples >::dir, Slic3r::execution::for_each(), Slic3r::sla::Beam_< Samples >::r1, Slic3r::sla::Beam_< Samples >::r2, and Slic3r::sla::Beam_< Samples >::src.

Referenced by Slic3r::sla::BranchingTreeBuilder::add_bridge(), Slic3r::sla::BranchingTreeBuilder::add_merger(), Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), Slic3r::sla::DefaultSupportTree::bridge_mesh_intersect(), check_ground_route(), connect_to_ground(), create_ground_pillar(), search_ground_route(), and search_widening_path().

Here is the call graph for this function:

Here is the caller graph for this function:

bounding_box_with_tr()

BoundingBoxf3 Slic3r::sla::bounding_box_with_tr ( const indexed_triangle_set &  its, const Transform3f &  tr  )

inline

{
    if (its.vertices.empty())
        return {};
 
    Vec3f bmin = tr * its.vertices.front(), bmax = tr * its.vertices.front();
 
    for (const Vec3f &p : its.vertices) {
        Vec3f pp = tr * p;
        bmin = pp.cwiseMin(bmin);
        bmax = pp.cwiseMax(bmax);
    }
 
    return {bmin.cast<double>(), bmax.cast<double>()};
}

References indexed_triangle_set::vertices.

Referenced by find_min_z_height_rotation().

Here is the caller graph for this function:

build_ground_connection()

long Slic3r::sla::build_ground_connection ( SupportTreeBuilder &  builder, const SupportableMesh &  sm, const GroundConnection &  conn  )

inline

{
    long ret = SupportTreeNode::ID_UNSET;
 
    if (!conn)
        return ret;
 
    auto it = conn.path.begin();
    auto itnx = std::next(it);
 
    while (itnx != conn.path.end()) {
        builder.add_diffbridge(*it, *itnx);
        builder.add_junction(*itnx);
        ++it; ++itnx;
    }
 
    auto gp = conn.path.back().pos;
    gp.z() = ground_level(sm);
    double h = conn.path.back().pos.z() - gp.z();
 
    if (conn.pillar_base->r_top < sm.cfg.head_back_radius_mm) {
        h += sm.pad_cfg.wall_thickness_mm;
        gp.z() -= sm.pad_cfg.wall_thickness_mm;
    }
 
// TODO: does not work yet
//    if (conn.path.back().id < 0) {
//        // this is a head
//        long head_id = std::abs(conn.path.back().id);
//        ret = builder.add_pillar(head_id, h);
//    } else
 
    ret = builder.add_pillar(gp, h, conn.path.back().r, conn.pillar_base->r_top);
 
    if (conn.pillar_base->r_top >= sm.cfg.head_back_radius_mm)
        builder.add_pillar_base(ret, conn.pillar_base->height, conn.pillar_base->r_bottom);
 
    return ret;
}

References Slic3r::sla::SupportTreeBuilder::add_diffbridge(), Slic3r::sla::SupportTreeBuilder::add_junction(), Slic3r::sla::SupportTreeBuilder::add_pillar(), Slic3r::sla::SupportTreeBuilder::add_pillar_base(), build_ground_connection(), Slic3r::sla::SupportableMesh::cfg, ground_level(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportableMesh::pad_cfg, Slic3r::sla::GroundConnection::path, Slic3r::sla::GroundConnection::pillar_base, and Slic3r::sla::PadConfig::wall_thickness_mm.

Referenced by build_ground_connection(), and build_pillars().

Here is the call graph for this function:

Here is the caller graph for this function:

build_pillars()

void Slic3r::sla::build_pillars ( SupportTreeBuilder &  builder, BranchingTreeBuilder &  vbuilder, const SupportableMesh &  sm  )

inline

{
    for (size_t pill_id = 0; pill_id < vbuilder.pillars().size(); ++pill_id) {
        auto * conn = vbuilder.ground_conn(pill_id);
        if (conn)
            build_ground_connection(builder, sm, *conn);
    }
}

References build_ground_connection(), build_pillars(), Slic3r::sla::BranchingTreeBuilder::ground_conn(), and Slic3r::sla::BranchingTreeBuilder::pillars().

Referenced by build_pillars(), and create_branching_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_anchor_placement()

template<class Ex >

std::optional< Anchor > Slic3r::sla::calculate_anchor_placement	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	from,
		const Vec3d &	to_hint
	)

{
    double back_r    = from.r;
    double pin_r     = sm.cfg.head_front_radius_mm;
    double penetr    = sm.cfg.head_penetration_mm;
    double hwidth    = sm.cfg.head_width_mm;
    Vec3d  bridgedir = dirv(from.pos, to_hint);
    Vec3d  anchordir = -bridgedir;
 
    std::optional<Anchor> ret;
 
    Anchor anchor(back_r, pin_r, hwidth, penetr, anchordir, to_hint);
 
    if (optimize_anchor_placement(policy, sm, from, anchor)) {
        ret = anchor;
    } else if (anchor.r_back_mm = sm.cfg.head_fallback_radius_mm;
               optimize_anchor_placement(policy, sm, from, anchor)) {
        // Retrying with the fallback strut radius as a last resort.
        ret = anchor;
    }
 
    return anchor;
}

References calculate_anchor_placement(), Slic3r::sla::SupportableMesh::cfg, dirv(), Slic3r::sla::SupportTreeConfig::head_fallback_radius_mm, Slic3r::sla::SupportTreeConfig::head_front_radius_mm, Slic3r::sla::SupportTreeConfig::head_penetration_mm, Slic3r::sla::SupportTreeConfig::head_width_mm, optimize_anchor_placement(), Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, and Slic3r::sla::Head::r_back_mm.

Referenced by Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), and calculate_anchor_placement().

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_pinhead_placement()

template<class Ex >

std::optional< Head > Slic3r::sla::calculate_pinhead_placement	(	Ex	policy,
		const SupportableMesh &	sm,
		size_t	suppt_idx
	)

{
    if (suppt_idx >= sm.pts.size())
        return {};
 
    const SupportPoint &sp = sm.pts[suppt_idx];
    Head                head{
        sm.cfg.head_back_radius_mm,
        sp.head_front_radius,
        0.,
        sm.cfg.head_penetration_mm,
        Vec3d::Zero(),        // dir
        sp.pos.cast<double>() // displacement
    };
 
    if (optimize_pinhead_placement(policy, sm, head)) {
        head.id = long(suppt_idx);
 
        return head;
    }
 
    return {};
}

References calculate_pinhead_placement(), Slic3r::sla::SupportableMesh::cfg, head(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportPoint::head_front_radius, Slic3r::sla::SupportTreeConfig::head_penetration_mm, long, optimize_pinhead_placement(), Slic3r::sla::SupportPoint::pos, and Slic3r::sla::SupportableMesh::pts.

Referenced by calculate_pinhead_placement().

Here is the call graph for this function:

Here is the caller graph for this function:

check_ground_route()

template<class Ex , class WideningFn , class = std::enable_if_t<IsWideningFn<WideningFn>>>

Vec3d Slic3r::sla::check_ground_route	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	source,
		const Vec3d &	dir,
		double	bridge_len,
		WideningFn &&	wideningfn,
		GroundRouteCheck	type = GroundRouteCheck::Full
	)

{
    static const constexpr auto Samples = BeamSamplesV<WideningFn>;
 
    Vec3d ret;
 
    const auto sd     = sm.cfg.safety_distance(source.r);
    const auto gndlvl = ground_level(sm);
 
    // Intersection of the suggested bridge with ground plane. If the bridge
    // spans below ground, stop it at ground level.
    double t = (gndlvl - source.pos.z()) / dir.z();
    bridge_len = std::min(t, bridge_len);
 
    Vec3d bridge_end = source.pos + bridge_len * dir;
 
    double down_l     = bridge_end.z() - gndlvl;
    double bridge_r   = wideningfn(Ball{source.pos, source.r}, dir, bridge_len);
    double brhit_dist = 0.;
 
    if (bridge_len > EPSILON && type == GroundRouteCheck::Full) {
        // beam_mesh_hit with a zero lenght bridge is invalid
 
        Beam_<Samples> bridgebeam{Ball{source.pos, source.r},
                                  Ball{bridge_end, bridge_r}};
 
        auto brhit = beam_mesh_hit(policy, sm.emesh, bridgebeam, sd);
        brhit_dist = brhit.distance();
    } else {
        brhit_dist = bridge_len;
    }
 
    if (brhit_dist < bridge_len) {
        ret = (source.pos + brhit_dist * dir);
    } else if (down_l > 0.) {
        // check if pillar can be placed below
        auto   gp         = Vec3d{bridge_end.x(), bridge_end.y(), gndlvl};
        double end_radius = wideningfn(
            Ball{bridge_end, bridge_r}, DOWN, bridge_end.z() - gndlvl);
 
        Beam_<Samples> gndbeam {{bridge_end, bridge_r}, {gp, end_radius}};
        auto gndhit = beam_mesh_hit(policy, sm.emesh, gndbeam, sd);
        double gnd_hit_d = std::min(gndhit.distance(), down_l + EPSILON);
 
        if (source.r >= sm.cfg.head_back_radius_mm && gndhit.distance() > down_l && sm.cfg.object_elevation_mm < EPSILON) {
            // Dealing with zero elevation mode, to not route pillars
            // into the gap between the optional pad and the model
            double gap     = std::sqrt(sm.emesh.squared_distance(gp));
            double base_r  = std::max(sm.cfg.base_radius_mm, end_radius);
            double min_gap = sm.cfg.pillar_base_safety_distance_mm + base_r;
 
            if (gap < min_gap) {
                gnd_hit_d = down_l - min_gap + gap;
            }
        }
 
        ret = Vec3d{bridge_end.x(), bridge_end.y(), bridge_end.z() - gnd_hit_d};
    } else {
        ret = bridge_end;
    }
 
    return ret;
}

References Slic3r::sla::SupportTreeConfig::base_radius_mm, beam_mesh_hit(), Slic3r::sla::SupportableMesh::cfg, check_ground_route(), Slic3r::sla::SupportableMesh::emesh, EPSILON, ground_level(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportTreeConfig::object_elevation_mm, Slic3r::sla::SupportTreeConfig::pillar_base_safety_distance_mm, Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, Slic3r::sla::SupportTreeConfig::safety_distance(), and Slic3r::AABBMesh::squared_distance().

Referenced by check_ground_route(), and deepsearch_ground_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

cluster() [1/3]

ClusteredPoints Slic3r::sla::cluster	(	const Eigen::MatrixXd &	pts,
		double	dist,
		unsigned	max_points
	)

{
    // A spatial index for querying the nearest points
    Index3D sindex;
 
    // Build the index
    for(Eigen::Index i = 0; i < pts.rows(); i++)
        sindex.insert(std::make_pair(Vec3d(pts.row(i)), unsigned(i)));
 
    return cluster(sindex, max_points,
                   [dist, max_points](const Index3D& sidx, const PointIndexEl& p)
                   {
                       return distance_queryfn(sidx, p, dist, max_points);
                   });
}

References cluster().

Here is the call graph for this function:

cluster() [2/3]

ClusteredPoints Slic3r::sla::cluster	(	const std::vector< unsigned > &	indices,
		std::function< Vec3d(unsigned)>	pointfn,
		double	dist,
		unsigned	max_points
	)

{
    // A spatial index for querying the nearest points
    Index3D sindex;
 
    // Build the index
    for(auto idx : indices) sindex.insert( std::make_pair(pointfn(idx), idx));
 
    return cluster(sindex, max_points,
                   [dist, max_points](const Index3D& sidx, const PointIndexEl& p)
                   {
                       return distance_queryfn(sidx, p, dist, max_points);
                   });
}

References cluster().

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), Slic3r::sla::DefaultSupportTree::classify(), cluster(), cluster(), and cluster().

Here is the call graph for this function:

Here is the caller graph for this function:

cluster() [3/3]

ClusteredPoints Slic3r::sla::cluster	(	const std::vector< unsigned > &	indices,
		std::function< Vec3d(unsigned)>	pointfn,
		std::function< bool(const PointIndexEl &, const PointIndexEl &)>	predicate,
		unsigned	max_points
	)

{
    // A spatial index for querying the nearest points
    Index3D sindex;
 
    // Build the index
    for(auto idx : indices) sindex.insert( std::make_pair(pointfn(idx), idx));
 
    return cluster(sindex, max_points,
                   [max_points, predicate](const Index3D& sidx, const PointIndexEl& p)
                   {
                       std::vector<PointIndexEl> tmp; tmp.reserve(max_points);
                       sidx.query(bgi::satisfies([p, predicate](const PointIndexEl& e){
                                      return predicate(p, e);
                                  }), std::back_inserter(tmp));
                       return tmp;
                   });
}

References cluster().

Here is the call graph for this function:

cluster_centroid()

template<class DistFn , class PointFn >

long Slic3r::sla::cluster_centroid	(	const ClusterEl &	clust,
		PointFn	pointfn,
		DistFn	df
	)

{
    switch(clust.size()) {
    case 0: /* empty cluster */ return -1;
    case 1: /* only one element */ return 0;
    case 2: /* if two elements, there is no center */ return 0;
    default: ;
    }
 
    // The function works by calculating for each point the average distance
    // from all the other points in the cluster. We create a selector bitmask of
    // the same size as the cluster. The bitmask will have two true bits and
    // false bits for the rest of items and we will loop through all the
    // permutations of the bitmask (combinations of two points). Get the
    // distance for the two points and add the distance to the averages.
    // The point with the smallest average than wins.
 
    // The complexity should be O(n^2) but we will mostly apply this function
    // for small clusters only (cca 3 elements)
 
    std::vector<bool> sel(clust.size(), false);   // create full zero bitmask
    std::fill(sel.end() - 2, sel.end(), true);    // insert the two ones
    std::vector<double> avgs(clust.size(), 0.0);  // store the average distances
 
    do {
        std::array<size_t, 2> idx;
        for(size_t i = 0, j = 0; i < clust.size(); i++)
            if(sel[i]) idx[j++] = i;
 
        double d = df(pointfn(clust[idx[0]]),
                      pointfn(clust[idx[1]]));
 
        // add the distance to the sums for both associated points
        for(auto i : idx) avgs[i] += d;
 
        // now continue with the next permutation of the bitmask with two 1s
    } while(std::next_permutation(sel.begin(), sel.end()));
 
    // Divide by point size in the cluster to get the average (may be redundant)
    for(auto& a : avgs) a /= clust.size();
 
    // get the lowest average distance and return the index
    auto minit = std::min_element(avgs.begin(), avgs.end());
    return long(minit - avgs.begin());
}

References long.

Referenced by Slic3r::sla::DefaultSupportTree::routing_to_ground().

Here is the caller graph for this function:

connect_to_ground()

template<class Ex >

std::pair< bool, long > Slic3r::sla::connect_to_ground	(	Ex	policy,
		SupportTreeBuilder &	builder,
		const SupportableMesh &	sm,
		const Junction &	j,
		const Vec3d &	dir,
		double	end_r
	)

{
    auto   hjp = j.pos;
    double r   = j.r;
    auto   sd  = r * sm.cfg.safety_distance_mm / sm.cfg.head_back_radius_mm;
    double r2  = j.r + (end_r - j.r) / (j.pos.z() - ground_level(sm));
 
    double t   = beam_mesh_hit(policy, sm.emesh, Beam{hjp, dir, r, r2}, sd).distance();
    double d   = 0, tdown = 0;
    t          = std::min(t, sm.cfg.max_bridge_length_mm * r / sm.cfg.head_back_radius_mm);
 
    while (d < t &&
           !std::isinf(tdown = beam_mesh_hit(policy, sm.emesh,
                                             Beam{hjp + d * dir, DOWN, r, r2}, sd)
                                   .distance())) {
        d += r;
    }
 
    if(!std::isinf(tdown))
        return {false, SupportTreeNode::ID_UNSET};
 
    Vec3d endp = hjp + d * dir;
    auto ret = create_ground_pillar(policy, builder, sm, endp, dir, r, end_r);
 
    if (ret.second >= 0) {
        builder.add_bridge(hjp, endp, r);
        builder.add_junction(endp, r);
    }
 
    return ret;
}

References Slic3r::sla::SupportTreeBuilder::add_bridge(), Slic3r::sla::SupportTreeBuilder::add_junction(), beam_mesh_hit(), Slic3r::sla::SupportableMesh::cfg, create_ground_pillar(), Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, ground_level(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportTreeNode::ID_UNSET, Slic3r::sla::SupportTreeConfig::max_bridge_length_mm, Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, and Slic3r::sla::SupportTreeConfig::safety_distance_mm.

Referenced by search_ground_route().

Here is the call graph for this function:

Here is the caller graph for this function:

create_branching_tree()

void Slic3r::sla::create_branching_tree	(	SupportTreeBuilder &	builder,
		const SupportableMesh &	sm
	)

{
    auto coordfn = [&sm](size_t id, size_t dim) { return sm.pts[id].pos(dim); };
    KDTreeIndirect<3, float, decltype (coordfn)> tree{coordfn, sm.pts.size()};
 
    auto nondup_idx = non_duplicate_suppt_indices(tree, sm.pts, 0.1);
    std::vector<std::optional<Head>> heads(nondup_idx.size());
    auto leafs = reserve_vector<branchingtree::Node>(nondup_idx.size());
 
    execution::for_each(
        ex_tbb, size_t(0), nondup_idx.size(),
        [&sm, &heads, &nondup_idx, &builder](size_t i) {
            if (!builder.ctl().stopcondition())
                heads[i] = calculate_pinhead_placement(ex_seq, sm, nondup_idx[i]);
        },
        execution::max_concurrency(ex_tbb)
    );
 
    if (builder.ctl().stopcondition())
        return;
 
    for (auto &h : heads)
        if (h && h->is_valid()) {
            leafs.emplace_back(h->junction_point().cast<float>(), h->r_back_mm);
            h->id = long(leafs.size() - 1);
            builder.add_head(h->id, *h);
        }
 
    auto &its = *sm.emesh.get_triangle_mesh();
    ExPolygons bedpolys = {branchingtree::make_bed_poly(its)};
 
    auto props = branchingtree::Properties{}
                     .bed_shape(bedpolys)
                     .ground_level(sla::ground_level(sm))
                     .max_slope(sm.cfg.bridge_slope)
                     .max_branch_length(sm.cfg.max_bridge_length_mm);
 
    auto meshpts = sm.cfg.ground_facing_only ?
                       std::vector<branchingtree::Node>{} :
                       branchingtree::sample_mesh(its,
                                                  props.sampling_radius());
 
    auto bedpts  = branchingtree::sample_bed(props.bed_shape(),
                                             float(props.ground_level()),
                                             props.sampling_radius());
 
    for (auto &bp : bedpts)
        bp.Rmin = sm.cfg.head_back_radius_mm;
 
    branchingtree::PointCloud nodes{std::move(meshpts), std::move(bedpts),
                                    std::move(leafs), props};
 
    BranchingTreeBuilder vbuilder{builder, sm, nodes};
 
    execution::for_each(ex_tbb,
                        size_t(0),
                        nodes.get_leafs().size(),
                        [&nodes, &vbuilder](size_t leaf_idx) {
                            vbuilder.suggest_avoidance(nodes.get_leafs()[leaf_idx],
                                                       nodes.properties().max_branch_length());
                        });
 
    branchingtree::build_tree(nodes, vbuilder);
 
    build_pillars(builder, vbuilder, sm);
 
    for (size_t id : vbuilder.unroutable_pinheads())
        builder.head(id).invalidate();
 
}

References Slic3r::sla::SupportTreeBuilder::add_head(), Slic3r::branchingtree::Properties::bed_shape(), Slic3r::sla::SupportTreeConfig::bridge_slope, build_pillars(), Slic3r::branchingtree::build_tree(), Slic3r::sla::SupportableMesh::cfg, create_branching_tree(), Slic3r::sla::SupportTreeBuilder::ctl(), Slic3r::sla::SupportableMesh::emesh, Slic3r::ex_tbb, Slic3r::execution::for_each(), Slic3r::AABBMesh::get_triangle_mesh(), Slic3r::sla::SupportTreeConfig::ground_facing_only, ground_level(), Slic3r::branchingtree::Properties::ground_level(), Slic3r::sla::SupportTreeBuilder::head(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::Head::invalidate(), long, Slic3r::branchingtree::make_bed_poly(), Slic3r::branchingtree::Properties::max_branch_length(), Slic3r::sla::SupportTreeConfig::max_bridge_length_mm, Slic3r::execution::max_concurrency(), Slic3r::branchingtree::Properties::max_slope(), non_duplicate_suppt_indices(), Slic3r::sla::SupportableMesh::pts, Slic3r::branchingtree::sample_bed(), Slic3r::branchingtree::sample_mesh(), and Slic3r::sla::JobController::stopcondition.

Referenced by create_branching_tree(), and create_support_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

create_default_tree()

void Slic3r::sla::create_default_tree ( SupportTreeBuilder &  builder, const SupportableMesh &  sm  )

inline

{
    DefaultSupportTree::execute(builder, sm);
}

References Slic3r::sla::DefaultSupportTree::execute().

Referenced by create_support_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

create_exclude_mask()

std::vector< bool > Slic3r::sla::create_exclude_mask	(	const indexed_triangle_set &	its,
		const Interior &	interior,
		const std::vector< DrainHole > &	holes
	)

{
    FaceHash interior_hash{sla::get_mesh(interior)};
 
    std::vector<bool> exclude_mask(its.indices.size(), false);
 
    VertexFaceIndex neighbor_index{its};
 
    for (size_t fi = 0; fi < its.indices.size(); ++fi) {
        auto &face = its.indices[fi];
 
        if (interior_hash.find(FaceHash::facekey(face, its.vertices))) {
            exclude_mask[fi] = true;
            continue;
        }
 
        if (exclude_mask[fi]) {
            exclude_neighbors(face, exclude_mask, its, neighbor_index, 1);
            continue;
        }
 
        // Lets deal with the holes. All the triangles of a hole and all the
        // neighbors of these triangles need to be kept. The neigbors were
        // created by CGAL mesh boolean operation that modified the original
        // interior inside the input mesh to contain the holes.
        Vec3d tr_center = (
                              its.vertices[face(0)] +
                              its.vertices[face(1)] +
                              its.vertices[face(2)]
                              ).cast<double>() / 3.;
 
        // If the center is more than half a mm inside the interior,
        // it cannot possibly be part of a hole wall.
        if (sla::get_distance(tr_center, interior) < -0.5)
            continue;
 
        Vec3f U = its.vertices[face(1)] - its.vertices[face(0)];
        Vec3f V = its.vertices[face(2)] - its.vertices[face(0)];
        Vec3f C = U.cross(V);
        Vec3f face_normal = C.normalized();
 
        for (const sla::DrainHole &dh : holes) {
            if (dh.failed) continue;
 
            Vec3d dhpos = dh.pos.cast<double>();
            Vec3d dhend = dhpos + dh.normal.cast<double>() * dh.height;
 
            Linef3 holeaxis{dhpos, dhend};
 
            double D_hole_center = line_alg::distance_to(holeaxis, tr_center);
            double D_hole        = std::abs(D_hole_center - dh.radius);
            float dot            = dh.normal.dot(face_normal);
 
            // Empiric tolerances for center distance and normals angle.
            // For triangles that are part of a hole wall the angle of
            // triangle normal and the hole axis is around 90 degrees,
            // so the dot product is around zero.
            double D_tol = dh.radius / sla::DrainHole::steps;
            float normal_angle_tol = 1.f / sla::DrainHole::steps;
 
            if (D_hole < D_tol && std::abs(dot) < normal_angle_tol) {
                exclude_mask[fi] = true;
                exclude_neighbors(face, exclude_mask, its, neighbor_index, 1);
            }
        }
    }
 
    return exclude_mask;
}

References create_exclude_mask(), exclude_neighbors(), Slic3r::face_normal(), indexed_triangle_set::indices, and indexed_triangle_set::vertices.

Referenced by create_exclude_mask(), and hollow_mesh_and_drill().

Here is the call graph for this function:

Here is the caller graph for this function:

create_ground_pillar()

template<class Ex >

std::pair< bool, long > Slic3r::sla::create_ground_pillar	(	Ex	policy,
		SupportTreeBuilder &	builder,
		const SupportableMesh &	sm,
		const Vec3d &	pinhead_junctionpt,
		const Vec3d &	sourcedir,
		double	radius,
		double	end_radius,
		long	head_id = SupportTreeNode::ID_UNSET
	)

{
    Vec3d  jp           = pinhead_junctionpt, endp = jp, dir = sourcedir;
    long   pillar_id    = SupportTreeNode::ID_UNSET;
    bool   can_add_base = false, non_head = false;
 
    double gndlvl = 0.; // The Z level where pedestals should be
    double jp_gnd = 0.; // The lowest Z where a junction center can be
    double gap_dist = 0.; // The gap distance between the model and the pad
 
    double r2 = radius + (end_radius - radius) / (jp.z() - ground_level(sm));
 
    auto to_floor = [&gndlvl](const Vec3d &p) { return Vec3d{p.x(), p.y(), gndlvl}; };
 
    auto eval_limits = [&sm, &radius, &can_add_base, &gndlvl, &gap_dist, &jp_gnd]
        (bool base_en = true)
    {
        can_add_base  = base_en && radius >= sm.cfg.head_back_radius_mm;
        double base_r = can_add_base ? sm.cfg.base_radius_mm : 0.;
        gndlvl        = ground_level(sm);
        if (!can_add_base) gndlvl -= sm.pad_cfg.wall_thickness_mm;
        jp_gnd   = gndlvl + (can_add_base ? 0. : sm.cfg.head_back_radius_mm);
        gap_dist = sm.cfg.pillar_base_safety_distance_mm + base_r + EPSILON;
    };
 
    eval_limits();
 
         // We are dealing with a mini pillar that's potentially too long
    if (radius < sm.cfg.head_back_radius_mm && jp.z() - gndlvl > 20 * radius)
    {
        std::optional<DiffBridge> diffbr =
            search_widening_path(policy, sm, jp, dir, radius,
                                 sm.cfg.head_back_radius_mm);
 
        if (diffbr && diffbr->endp.z() > jp_gnd) {
            auto &br = builder.add_diffbridge(*diffbr);
            if (head_id >= 0) builder.head(head_id).bridge_id = br.id;
            endp = diffbr->endp;
            radius = diffbr->end_r;
            end_radius = diffbr->end_r;
            builder.add_junction(endp, radius);
            non_head = true;
            dir = diffbr->get_dir();
            eval_limits();
        } else return {false, pillar_id};
    }
 
    if (sm.cfg.object_elevation_mm < EPSILON)
    {
        // get a suitable direction for the corrector bridge. It is the
        // original sourcedir's azimuth but the polar angle is saturated to the
        // configured bridge slope.
        auto [polar, azimuth] = dir_to_spheric(dir);
        polar = PI - sm.cfg.bridge_slope;
        Vec3d d = spheric_to_dir(polar, azimuth).normalized();
        auto sd = radius * sm.cfg.safety_distance_mm / sm.cfg.head_back_radius_mm;
        double t = beam_mesh_hit(policy, sm.emesh, Beam{endp, d, radius, r2}, sd).distance();
        double tmax = std::min(sm.cfg.max_bridge_length_mm, t);
        t = 0.;
 
        double zd = endp.z() - jp_gnd;
        double tmax2 = zd / std::sqrt(1 - sm.cfg.bridge_slope * sm.cfg.bridge_slope);
        tmax = std::min(tmax, tmax2);
 
        Vec3d nexp = endp;
        double dlast = 0.;
        while (((dlast = std::sqrt(sm.emesh.squared_distance(to_floor(nexp)))) < gap_dist ||
                !std::isinf(beam_mesh_hit(policy, sm.emesh, Beam{nexp, DOWN, radius, r2}, sd).distance())) &&
               t < tmax)
        {
            t += radius;
            nexp = endp + t * d;
        }
 
        if (dlast < gap_dist && can_add_base) {
            nexp         = endp;
            t            = 0.;
            can_add_base = false;
            eval_limits(can_add_base);
 
            zd = endp.z() - jp_gnd;
            tmax2 = zd / std::sqrt(1 - sm.cfg.bridge_slope * sm.cfg.bridge_slope);
            tmax = std::min(tmax, tmax2);
 
            while (((dlast = std::sqrt(sm.emesh.squared_distance(to_floor(nexp)))) < gap_dist ||
                    !std::isinf(beam_mesh_hit(policy, sm.emesh, Beam{nexp, DOWN, radius}, sd).distance())) && t < tmax) {
                t += radius;
                nexp = endp + t * d;
            }
        }
 
        // Could not find a path to avoid the pad gap
        if (dlast < gap_dist) return {false, pillar_id};
 
        if (t > 0.) { // Need to make additional bridge
            const Bridge& br = builder.add_bridge(endp, nexp, radius);
            if (head_id >= 0) builder.head(head_id).bridge_id = br.id;
 
            builder.add_junction(nexp, radius);
            endp = nexp;
            non_head = true;
        }
    }
 
    Vec3d gp = to_floor(endp);
    double h = endp.z() - gp.z();
 
    pillar_id = head_id >= 0 && !non_head ? builder.add_pillar(head_id, h) :
                                            builder.add_pillar(gp, h, radius, end_radius);
 
    if (can_add_base)
        builder.add_pillar_base(pillar_id, sm.cfg.base_height_mm,
                                sm.cfg.base_radius_mm);
 
    return {true, pillar_id};
}

References Slic3r::sla::SupportTreeBuilder::add_bridge(), Slic3r::sla::SupportTreeBuilder::add_diffbridge(), Slic3r::sla::SupportTreeBuilder::add_junction(), Slic3r::sla::SupportTreeBuilder::add_pillar(), Slic3r::sla::SupportTreeBuilder::add_pillar_base(), Slic3r::sla::SupportTreeConfig::base_height_mm, Slic3r::sla::SupportTreeConfig::base_radius_mm, beam_mesh_hit(), Slic3r::sla::Head::bridge_id, Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, EPSILON, ground_level(), Slic3r::sla::SupportTreeBuilder::head(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportTreeNode::id, Slic3r::sla::SupportTreeNode::ID_UNSET, Slic3r::sla::SupportTreeConfig::max_bridge_length_mm, Slic3r::sla::SupportTreeConfig::object_elevation_mm, Slic3r::sla::SupportableMesh::pad_cfg, PI, Slic3r::sla::SupportTreeConfig::pillar_base_safety_distance_mm, Slic3r::sla::SupportTreeConfig::safety_distance_mm, search_widening_path(), Slic3r::AABBMesh::squared_distance(), and Slic3r::sla::PadConfig::wall_thickness_mm.

Referenced by connect_to_ground(), and Slic3r::sla::DefaultSupportTree::create_ground_pillar().

Here is the call graph for this function:

Here is the caller graph for this function:

create_pad() [1/2]

void Slic3r::sla::create_pad	(	const ExPolygons &	sup_blueprint,
		const ExPolygons &	model_blueprint,
		indexed_triangle_set &	out,
		const PadConfig &	cfg,
		ThrowOnCancel	thr
	)

{
    auto t = create_pad_geometry(sup_blueprint, model_blueprint, cfg, thr);
    its_merge(out, t);
}

References Slic3r::its_merge().

Referenced by Slic3r::SLAPrintObject::SupportData::create_pad(), and create_pad().

Here is the call graph for this function:

Here is the caller graph for this function:

create_pad() [2/2]

indexed_triangle_set Slic3r::sla::create_pad	(	const SupportableMesh &	sm,
		const indexed_triangle_set &	support_mesh,
		const JobController &	ctl
	)

{
    constexpr float PadSamplingLH = 0.1f;
 
    ExPolygons model_contours; // This will store the base plate of the pad.
    double pad_h  = sm.pad_cfg.full_height();
    auto   gndlvl = float(ground_level(sm));
    float  zstart = gndlvl - bool(sm.pad_cfg.embed_object) * sm.pad_cfg.wall_thickness_mm;
    float  zend   = zstart + float(pad_h + PadSamplingLH + EPSILON);
    auto  heights = grid(zstart, zend, PadSamplingLH);
 
    if (!sm.cfg.enabled || sm.pad_cfg.embed_object) {
        // No support (thus no elevation) or zero elevation mode
        // we sometimes call it "builtin pad" is enabled so we will
        // get a sample from the bottom of the mesh and use it for pad
        // creation.
        sla::pad_blueprint(*sm.emesh.get_triangle_mesh(), model_contours,
                           heights, ctl.cancelfn);
    }
 
    ExPolygons sup_contours;
    pad_blueprint(support_mesh, sup_contours, heights, ctl.cancelfn);
 
    indexed_triangle_set out;
    create_pad(sup_contours, model_contours, out, sm.pad_cfg);
 
    Vec3f offs{.0f, .0f, gndlvl};
    for (auto &p : out.vertices) p += offs;
 
    its_merge_vertices(out);
 
    return out;
}

References Slic3r::sla::JobController::cancelfn, Slic3r::sla::SupportableMesh::cfg, create_pad(), Slic3r::sla::PadConfig::embed_object, Slic3r::sla::SupportableMesh::emesh, Slic3r::sla::SupportTreeConfig::enabled, EPSILON, Slic3r::sla::PadConfig::full_height(), Slic3r::AABBMesh::get_triangle_mesh(), Slic3r::grid(), ground_level(), Slic3r::its_merge_vertices(), pad_blueprint(), Slic3r::sla::SupportableMesh::pad_cfg, indexed_triangle_set::vertices, and Slic3r::sla::PadConfig::wall_thickness_mm.

Here is the call graph for this function:

create_raster_grayscale_aa()

std::unique_ptr< RasterBase > Slic3r::sla::create_raster_grayscale_aa	(	const Resolution &	res,
		const PixelDim &	pxdim,
		double	gamma,
		const RasterBase::Trafo &	tr
	)

{
    std::unique_ptr<RasterBase> rst;
    
    if (gamma > 0)
        rst = std::make_unique<RasterGrayscaleAAGammaPower>(res, pxdim, tr, gamma);
    else if (std::abs(gamma - 1.) < 1e-6)
        rst = std::make_unique<RasterGrayscaleAA>(res, pxdim, tr, agg::gamma_none());
    else
        rst = std::make_unique<RasterGrayscaleAA>(res, pxdim, tr, agg::gamma_threshold(.5));
    
    return rst;
}

Referenced by Slic3r::AnycubicSLAArchive::create_raster(), Slic3r::SL1Archive::create_raster(), Slic3r::GUI::CreateFontImageJob::process(), and Slic3r::GUI::Emboss::CreateFontStyleImagesJob::process().

Here is the caller graph for this function:

create_support_tree()

indexed_triangle_set Slic3r::sla::create_support_tree	(	const SupportableMesh &	sm,
		const JobController &	ctl
	)

{
    auto builder = make_unique<SupportTreeBuilder>(ctl);
 
    if (sm.cfg.enabled) {
        Benchmark bench;
        bench.start();
 
        switch (sm.cfg.tree_type) {
        case SupportTreeType::Default: {
            create_default_tree(*builder, sm);
            break;
        }
        case SupportTreeType::Branching: {
            create_branching_tree(*builder, sm);
            break;
        }
        case SupportTreeType::Organic: {
            // TODO
        }
        default:;
        }
 
        bench.stop();
 
        BOOST_LOG_TRIVIAL(info) << "Support tree creation took: "
                                << bench.getElapsedSec()
                                << " seconds";
 
        builder->merge_and_cleanup();   // clean metadata, leave only the meshes.
    }
 
    indexed_triangle_set out = builder->retrieve_mesh(MeshType::Support);
 
    return out;
}

References Branching, Slic3r::sla::SupportableMesh::cfg, create_branching_tree(), create_default_tree(), Default, Slic3r::sla::SupportTreeConfig::enabled, Benchmark::getElapsedSec(), Organic, Benchmark::start(), Benchmark::stop(), Support, and Slic3r::sla::SupportTreeConfig::tree_type.

Referenced by Slic3r::SLAPrintObject::SupportData::create_support_tree().

Here is the call graph for this function:

Here is the caller graph for this function:

csgmesh_positive_maxvolume()

template<class Cont >

double Slic3r::sla::csgmesh_positive_maxvolume

(

const Cont &

csg

)

{
    double mesh_vol = 0;
 
    bool skip = false;
    for (const auto &m : csg) {
        auto op = csg::get_operation(m);
        auto stackop = csg::get_stack_operation(m);
        if (stackop == csg::CSGStackOp::Push && op != csg::CSGType::Union)
            skip = true;
 
        if (!skip && csg::get_mesh(m) && op == csg::CSGType::Union)
            mesh_vol = std::max(mesh_vol,
                                double(its_volume(*(csg::get_mesh(m)))));
 
        if (stackop == csg::CSGStackOp::Pop)
            skip = false;
    }
 
    return mesh_vol;
}

References Slic3r::csg::get_mesh(), Slic3r::csg::get_operation(), Slic3r::csg::get_stack_operation(), Slic3r::its_volume(), Slic3r::csg::Pop, Slic3r::csg::Push, and Slic3r::csg::Union.

Here is the call graph for this function:

cut_drainholes()

void Slic3r::sla::cut_drainholes	(	std::vector< ExPolygons > &	obj_slices,
		const std::vector< float > &	slicegrid,
		float	closing_radius,
		const sla::DrainHoles &	holes,
		std::function< void(void)>	thr
	)

{
    TriangleMesh mesh;
    for (const sla::DrainHole &holept : holes)
        mesh.merge(TriangleMesh{holept.to_mesh()});
    
    if (mesh.empty()) return;
    
    std::vector<ExPolygons> hole_slices = slice_mesh_ex(mesh.its, slicegrid, closing_radius, thr);
    
    if (obj_slices.size() != hole_slices.size())
        BOOST_LOG_TRIVIAL(warning)
            << "Sliced object and drain-holes layer count does not match!";
 
    size_t until = std::min(obj_slices.size(), hole_slices.size());
    
    for (size_t i = 0; i < until; ++i)
        obj_slices[i] = diff_ex(obj_slices[i], hole_slices[i]);
}

References Slic3r::holes(), and Slic3r::TriangleMesh::merge().

Here is the call graph for this function:

cylinder()

indexed_triangle_set Slic3r::sla::cylinder ( double  r, double  h, size_t  steps = 45  )

inline

{
    return its_make_cylinder(r, h, 2 * PI / steps);
}

References Slic3r::its_make_cylinder(), and PI.

Referenced by get_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

deepsearch_ground_connection() [1/3]

template<class Ex >

GroundConnection Slic3r::sla::deepsearch_ground_connection	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	source,
		const Vec3d &	init_dir = DOWN
	)

{
    return deepsearch_ground_connection(policy, sm, source,
                                        DefaultWideningModel{sm}, init_dir);
}

References deepsearch_ground_connection().

Here is the call graph for this function:

deepsearch_ground_connection() [2/3]

template<class Ex >

GroundConnection Slic3r::sla::deepsearch_ground_connection	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	source,
		double	end_radius,
		const Vec3d &	init_dir = DOWN
	)

{
    double gndlvl = ground_level(sm);
    auto wfn = [end_radius, gndlvl](const Ball &src, const Vec3d &dir, double len) {
        if (len < EPSILON)
            return src.R;
 
        Vec3d  dst = src.p + len * dir;
        double widening = end_radius - src.R;
        double zlen = dst.z() - gndlvl;
        double full_len = len + zlen;
        double r = src.R + widening * len / full_len;
 
        return r;
    };
 
    static_assert(IsWideningFn<decltype(wfn)>, "Not a widening function");
 
    return deepsearch_ground_connection(policy, sm, source, wfn, init_dir);
}

References deepsearch_ground_connection(), EPSILON, ground_level(), and IsWideningFn.

Here is the call graph for this function:

deepsearch_ground_connection() [3/3]

template<class Ex , class WideningFn , class = std::enable_if_t<IsWideningFn<WideningFn>>>

GroundConnection Slic3r::sla::deepsearch_ground_connection	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	source,
		WideningFn &&	wideningfn,
		const Vec3d &	init_dir = DOWN
	)

{
    constexpr unsigned MaxIterationsGlobal = 5000;
    constexpr unsigned MaxIterationsLocal  = 100;
    constexpr double   RelScoreDiff        = 0.05;
 
    const auto gndlvl = ground_level(sm);
 
    // The used solver (AlgNLoptMLSL_Subplx search method) is composed of a global (MLSL)
    // and a local (Subplex) search method. Criteria can be set in a way that
    // local searches are quick and less accurate. The global method will only
    // consider the max iteration number and the stop score (Z level <= ground)
 
    auto criteria = get_criteria(sm.cfg); // get defaults from cfg
    criteria.max_iterations(MaxIterationsGlobal);
    criteria.abs_score_diff(NaNd);
    criteria.rel_score_diff(NaNd);
    criteria.stop_score(gndlvl);
 
    auto criteria_loc = criteria;
    criteria_loc.max_iterations(MaxIterationsLocal);
    criteria_loc.abs_score_diff(EPSILON);
    criteria_loc.rel_score_diff(RelScoreDiff);
 
    Optimizer<opt::AlgNLoptMLSL_Subplx> solver(criteria);
    solver.set_loc_criteria(criteria_loc);
    solver.seed(0); // require repeatability
 
    // functor returns the z height of collision point, given a polar and
    // azimuth angles as bridge direction and bridge length. The route is
    // traced from source, through this bridge and an attached pillar. If there
    // is a collision with the mesh, the Z height is returned. Otherwise the
    // z level of ground is returned.
    auto z_fn = [&](const opt::Input<3> &input) {
        // solver suggests polar, azimuth and bridge length values:
        auto &[plr, azm, bridge_len] = input;
 
        Vec3d n = spheric_to_dir(plr, azm);
 
        Vec3d hitpt = check_ground_route(policy, sm, source, n, bridge_len, wideningfn);
 
        return hitpt.z();
    };
 
    // Calculate the initial direction of the search by
    // saturating the polar angle to max tilt defined in config
    auto [plr_init, azm_init] = dir_to_spheric(init_dir);
    plr_init = std::max(plr_init, PI - sm.cfg.bridge_slope);
 
    auto bound_constraints =
        bounds({
                {PI - sm.cfg.bridge_slope, PI},   // bounds for polar angle
                {-PI, PI},                        // bounds for azimuth
                {0., sm.cfg.max_bridge_length_mm} // bounds bridge length
        });
 
    // The optimizer can navigate fairly well on the mesh surface, finding
    // lower and lower Z coordinates as collision points. MLSL is not a local
    // search method, so it should not be trapped in a local minima. Eventually,
    // this search should arrive at a ground location.
    auto oresult = solver.to_min().optimize(
        z_fn,
        initvals({plr_init, azm_init, 0.}),
        bound_constraints
    );
 
    GroundConnection conn;
 
    // Extract and apply the result
    auto [plr, azm, bridge_l] = oresult.optimum;
    Vec3d n = spheric_to_dir(plr, azm);
    assert(std::abs(n.norm() - 1.) < EPSILON);
 
    double t = (gndlvl - source.pos.z()) / n.z();
    bridge_l = std::min(t, bridge_l);
 
    // Now the optimizer gave a possible route to ground with a bridge direction
    // and length. This length can be shortened further by brute-force queries
    // of free route straigt down for a possible pillar.
    // NOTE: This requirement could be incorporated into the optimization as a
    // constraint, but it would not find quickly enough an accurate solution,
    // and it would be very hard to define a stop score which is very useful in
    // terminating the search as soon as the ground is found.
    double l = 0., l_max = bridge_l;
    double zlvl = std::numeric_limits<double>::infinity();
    while(zlvl > gndlvl && l <= l_max) {
 
        zlvl = check_ground_route(policy, sm, source, n, l, wideningfn,
                                  GroundRouteCheck::PillarOnly).z();
 
        if (zlvl <= gndlvl)
            bridge_l = l;
 
        l += source.r;
    }
 
    Vec3d bridge_end = source.pos + bridge_l * n;
    Vec3d gp{bridge_end.x(), bridge_end.y(), gndlvl};
 
    double bridge_r = wideningfn(Ball{source.pos, source.r}, n, bridge_l);
    double down_l = bridge_end.z() - gndlvl;
    double end_radius = wideningfn(Ball{bridge_end, bridge_r}, DOWN, down_l);
    double base_r = std::max(sm.cfg.base_radius_mm, end_radius);
 
    // Even if the search was not succesful, the result is populated by the
    // source and the last best result of the optimization.
    conn.path.emplace_back(source);
    if (bridge_l > EPSILON)
        conn.path.emplace_back(Junction{bridge_end, bridge_r});
 
    // The resulting ground connection is only valid if the pillar base is set.
    // At this point it will only be set if the search was succesful.
    if (z_fn(opt::Input<3>({plr, azm, bridge_l})) <= gndlvl)
        conn.pillar_base =
            Pedestal{gp, sm.cfg.base_height_mm, base_r, end_radius};
 
    return conn;
}

References Slic3r::sla::SupportTreeConfig::base_height_mm, Slic3r::sla::SupportTreeConfig::base_radius_mm, Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, check_ground_route(), deepsearch_ground_connection(), EPSILON, get_criteria(), ground_level(), input(), Slic3r::sla::SupportTreeConfig::max_bridge_length_mm, Slic3r::NaNd, Slic3r::opt::Optimizer< Method, Enable >::optimize(), Slic3r::sla::GroundConnection::path, PI, Slic3r::sla::GroundConnection::pillar_base, Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, Slic3r::opt::Optimizer< Method, Enable >::seed(), and Slic3r::opt::Optimizer< Method, Enable >::to_min().

Referenced by Slic3r::sla::BranchingTreeBuilder::add_ground_bridge(), deepsearch_ground_connection(), deepsearch_ground_connection(), deepsearch_ground_connection(), and Slic3r::sla::BranchingTreeBuilder::suggest_avoidance().

Here is the call graph for this function:

Here is the caller graph for this function:

dirv()

template<class T , int N>

Vec< N, T > Slic3r::sla::dirv	(	const Vec< N, T > &	startp,
		const Vec< N, T > &	endp
	)

                                                               {
    return (endp - startp).normalized();
}

Referenced by calculate_anchor_placement(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), Slic3r::sla::DefaultSupportTree::interconnect(), and Slic3r::sla::DefaultSupportTree::interconnect_pillars().

Here is the caller graph for this function:

distance() [1/3]

double Slic3r::sla::distance ( const SupportPoint &  a, const SupportPoint &  b  )

inline

{
    return (a.pos - b.pos).norm();
}

distance() [2/3]

template<class T , int I>

T Slic3r::sla::distance

(

const Vec< I, T > &

p

)

Terminology:

Support point: The point on the model surface that needs support.

Pillar: A thick column that spans from a support point to the ground and has a thick cone shaped base where it touches the ground.

Ground facing support point: A support point that can be directly connected with the ground with a pillar that does not collide or cut through the model.

Non ground facing support point: A support point that cannot be directly connected with the ground (only with the model surface).

Head: The pinhead that connects to the model surface with the sharp end end to a pillar or bridge stick with the dull end.

Headless support point: A support point on the model surface for which there is not enough place for the head. It is either in a hole or there is some barrier that would collide with the head geometry. The headless support point can be ground facing and non ground facing as well.

Bridge: A stick that connects two pillars or a head with a pillar.

Junction: A small ball in the intersection of two or more sticks (pillar, bridge, ...)

CompactBridge: A bridge that connects a headless support point with the model surface or a nearby pillar.

                                                        {
    return p.norm();
}

Referenced by Slic3r::sla::Beam_< Samples >::Beam_(), Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), Slic3r::sla::DefaultSupportTree::classify(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), Slic3r::sla::DefaultSupportTree::interconnect(), and Slic3r::sla::DefaultSupportTree::routing_to_ground().

Here is the caller graph for this function:

distance() [3/3]

template<class T , int I>

T Slic3r::sla::distance	(	const Vec< I, T > &	pp1,
		const Vec< I, T > &	pp2
	)

                                                       {
    return (pp1 - pp2).norm();
}

divide_triangle()

template<class Fn >

void Slic3r::sla::divide_triangle	(	const DivFace &	face,
		Fn &&	visitor
	)

{
    std::array<Vec3f, 3> edges = {(face.verts[0] - face.verts[1]),
                                  (face.verts[1] - face.verts[2]),
                                  (face.verts[2] - face.verts[0])};
 
    std::array<size_t, 3> edgeidx = {0, 1, 2};
 
    std::sort(edgeidx.begin(), edgeidx.end(), [&edges](size_t e1, size_t e2) {
        return edges[e1].squaredNorm() > edges[e2].squaredNorm();
    });
 
    DivFace child1, child2;
 
    child1.parent   = face.faceid == NEW_FACE ? face.parent : face.faceid;
    child1.indx(0)  = -1;
    child1.indx(1)  = face.indx(edgeidx[1]);
    child1.indx(2)  = face.indx((edgeidx[1] + 1) % 3);
    child1.verts[0] = (face.verts[edgeidx[0]] + face.verts[(edgeidx[0] + 1) % 3]) / 2.;
    child1.verts[1] = face.verts[edgeidx[1]];
    child1.verts[2] = face.verts[(edgeidx[1] + 1) % 3];
 
    if (visitor(child1))
        divide_triangle(child1, std::forward<Fn>(visitor));
 
    child2.parent   = face.faceid == NEW_FACE ? face.parent : face.faceid;
    child2.indx(0)  = -1;
    child2.indx(1)  = face.indx(edgeidx[2]);
    child2.indx(2)  = face.indx((edgeidx[2] + 1) % 3);
    child2.verts[0] = child1.verts[0];
    child2.verts[1] = face.verts[edgeidx[2]];
    child2.verts[2] = face.verts[(edgeidx[2] + 1) % 3];
 
    if (visitor(child2))
        divide_triangle(child2, std::forward<Fn>(visitor));
}

References divide_triangle(), Slic3r::sla::DivFace::faceid, Slic3r::sla::DivFace::indx, NEW_FACE, Slic3r::sla::DivFace::parent, and Slic3r::sla::DivFace::verts.

Referenced by divide_triangle(), and remove_inside_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

exclude_neighbors()

static void Slic3r::sla::exclude_neighbors ( const Vec3i &  face, std::vector< bool > &  mask, const indexed_triangle_set &  its, const VertexFaceIndex &  index, size_t  recursions  )

static

{
    for (int i = 0; i < 3; ++i) {
        const auto &neighbors_range = index[face(i)];
        for (size_t fi_n : neighbors_range) {
            mask[fi_n] = true;
            if (recursions > 0)
                exclude_neighbors(its.indices[fi_n], mask, its, index, recursions - 1);
        }
    }
}

References exclude_neighbors(), and indexed_triangle_set::indices.

Referenced by create_exclude_mask(), and exclude_neighbors().

Here is the call graph for this function:

Here is the caller graph for this function:

find_best_misalignment_rotation()

Vec2d Slic3r::sla::find_best_misalignment_rotation	(	const ModelObject &	modelobj,
		const RotOptimizeParams &	= {}
	)

The function should find the best rotation for SLA upside down printing.

Parameters

modelobj	The model object representing the 3d mesh.
accuracy	The optimization accuracy from 0.0f to 1.0f. Currently, the nlopt genetic optimizer is used and the number of iterations is accuracy * 100000. This can change in the future.
statuscb	A status indicator callback called with the int argument spanning from 0 to 100. May not reach 100 if the optimization finds an optimum before max iterations are reached. It should return a boolean signaling if the operation may continue (true) or not (false). A status value lower than 0 shall not update the status but still return a valid continuation indicator.

Returns

Returns the rotations around each axis (x, y, z)

{
    RotfinderBoilerplate<1000> bp{mo, params};
 
    // Preparing the optimizer.
    size_t gridsize = std::sqrt(bp.max_tries);
    opt::Optimizer<opt::AlgBruteForce> solver(
        opt::StopCriteria{}.max_iterations(bp.max_tries)
                           .stop_condition([&bp] { return bp.stopcond(); }),
        gridsize
    );
 
    // We are searching rotations around only two axes x, y. Thus the
    // problem becomes a 2 dimensional optimization task.
    // We can specify the bounds for a dimension in the following way:
    auto bounds = opt::bounds({ {-PI, PI}, {-PI, PI} });
 
    auto result = solver.to_max().optimize(
        [&bp] (const XYRotation &rot)
        {
            bp.statusfn();
            return get_misalginment_score(bp.mesh, to_transform3f(rot));
        }, opt::initvals({0., 0.}), bounds);
 
    return {result.optimum[0], result.optimum[1]};
}

References Slic3r::opt::bounds(), Slic3r::opt::initvals(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, Slic3r::opt::StopCriteria::stop_condition(), and Slic3r::opt::Optimizer< Method, Enable >::to_max().

Here is the call graph for this function:

find_least_supports_rotation()

Vec2d Slic3r::sla::find_least_supports_rotation	(	const ModelObject &	mo,
		const RotOptimizeParams &	params
	)

{
    RotfinderBoilerplate<1000> bp{mo, params};
 
    SLAPrintObjectConfig pocfg;
    if (params.print_config())
        pocfg.apply(*params.print_config(), true);
 
    pocfg.apply(mo.config.get());
 
    XYRotation rot;
 
    // Different search methods have to be used depending on the model elevation
    if (is_on_floor(pocfg)) {
 
        std::vector<XYRotation> inputs = get_chull_rotations(bp.mesh, bp.max_tries);
        bp.max_tries = inputs.size();
 
        // If the model can be placed on the bed directly, we only need to
        // check the 3D convex hull face rotations.
 
        auto objfn = [&bp](const XYRotation &rot) {
            bp.statusfn();
            Transform3f tr = to_transform3f(rot);
            return get_supportedness_onfloor_score(bp.mesh, tr);
        };
 
        rot = find_min_score<2>(objfn, inputs.begin(), inputs.end(), [&bp] {
            return bp.stopcond();
        });
 
    } else {
        // Preparing the optimizer.
        size_t gridsize = std::sqrt(bp.max_tries); // 2D grid has gridsize^2 calls
        opt::Optimizer<opt::AlgBruteForce> solver(
            opt::StopCriteria{}.max_iterations(bp.max_tries)
                               .stop_condition([&bp] { return bp.stopcond(); }),
            gridsize
        );
 
        // We are searching rotations around only two axes x, y. Thus the
        // problem becomes a 2 dimensional optimization task.
        // We can specify the bounds for a dimension in the following way:
        auto bounds = opt::bounds({ {-PI, PI}, {-PI, PI} });
 
        auto result = solver.to_min().optimize(
            [&bp] (const XYRotation &rot)
            {
                bp.statusfn();
                return get_supportedness_score(bp.mesh, to_transform3f(rot));
            }, opt::initvals({0., 0.}), bounds);
 
        // Save the result
        rot = result.optimum;
    }
 
    return {rot[0], rot[1]};
}

References Slic3r::opt::bounds(), Slic3r::ModelObject::config, Slic3r::ModelConfig::get(), Slic3r::opt::initvals(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, Slic3r::sla::RotOptimizeParams::print_config(), Slic3r::SLAPrintObjectConfig, Slic3r::opt::StopCriteria::stop_condition(), and Slic3r::opt::Optimizer< Method, Enable >::to_min().

Here is the call graph for this function:

find_merge_pt()

std::optional< Vec3f > Slic3r::sla::find_merge_pt ( const Vec3f &  A, const Vec3f &  B, float  critical_angle  )

inline

{
    // The idea is that A and B both have their support cones. But searching
    // for the intersection of these support cones is difficult and its enough
    // to reduce this problem to 2D and search for the intersection of two
    // rays that merge somewhere between A and B. The 2D plane is a vertical
    // slice of the 3D scene where the 2D Y axis is equal to the 3D Z axis and
    // the 2D X axis is determined by the XY direction of the AB vector.
    //
    // Z^
    //  |    A *
    //  |     . .   B *
    //  |    .   .   . .
    //  |   .     . .   .
    //  |  .       x     .
    //  -------------------> XY
 
    // Determine the transformation matrix for the 2D projection:
    Vec3f diff = {B.x() - A.x(), B.y() - A.y(), 0.f};
    Vec3f dir  = diff.normalized(); // TODO: avoid normalization
 
    Eigen::Matrix<float, 2, 3> tr2D;
    tr2D.row(0) = Vec3f{dir.x(), dir.y(), dir.z()};
    tr2D.row(1) = Vec3f{0.f, 0.f, 1.f};
 
    // Transform the 2 vectors A and B into 2D vector 'a' and 'b'. Here we can
    // omit 'a', pretend that its the origin and use BA as the vector b.
    Vec2f b = tr2D * (B - A);
 
    // Get the square sine of the ray emanating from 'a' towards 'b'. This ray might
    // exceed the allowed angle but that is corrected subsequently.
    // The sign of the original sine is also needed, hence b.y is multiplied by
    // abs(b.y)
    float b_sqn = b.squaredNorm();
    float sin2sig_a = b_sqn > EPSILON ? (b.y() * std::abs(b.y())) / b_sqn : 0.f;
 
    // sine2 from 'b' to 'a' is the opposite of sine2 from a to b
    float sin2sig_b = -sin2sig_a;
 
    // Derive the allowed angles from the given critical angle.
    // critical_angle is measured from the horizontal X axis.
    // The rays need to go downwards which corresponds to negative angles
 
    float sincrit = std::sin(critical_angle);  // sine of the critical angle
    float sin2crit = -sincrit * sincrit;       // signed sine squared
    sin2sig_a = std::min(sin2sig_a, sin2crit); // Do the angle saturation of both rays
    sin2sig_b = std::min(sin2sig_b, sin2crit); //
    float sin2_a = std::abs(sin2sig_a);        // Get cosine squared values
    float sin2_b = std::abs(sin2sig_b);
    float cos2_a = 1.f - sin2_a;
    float cos2_b = 1.f - sin2_b;
 
    // Derive the new direction vectors. This is by square rooting the sin2
    // and cos2 values and restoring the original signs
    Vec2f Da = {std::copysign(std::sqrt(cos2_a), b.x()), std::copysign(std::sqrt(sin2_a), sin2sig_a)};
    Vec2f Db = {-std::copysign(std::sqrt(cos2_b), b.x()), std::copysign(std::sqrt(sin2_b), sin2sig_b)};
 
    // Determine where two rays ([0, 0], Da), (b, Db) intersect.
    // Based on
    // https://stackoverflow.com/questions/27459080/given-two-points-and-two-direction-vectors-find-the-point-where-they-intersect
    // One ray is emanating from (0, 0) so the formula is simplified
    double t1 = (Db.y() * b.x() - b.y() * Db.x()) /
                (Da.x() * Db.y() - Da.y() * Db.x());
 
    Vec2f mp = t1 * Da;
    Vec3f Mp = A + tr2D.transpose() * mp;
 
    return t1 >= 0.f ? Mp : Vec3f{};
}

References Slic3r::diff(), and EPSILON.

Referenced by Slic3r::branchingtree::find_merge_pt().

Here is the call graph for this function:

Here is the caller graph for this function:

find_min_z_height_rotation()

Vec2d Slic3r::sla::find_min_z_height_rotation	(	const ModelObject &	mo,
		const RotOptimizeParams &	params
	)

{
    RotfinderBoilerplate<1000> bp{mo, params};
 
    TriangleMesh chull = bp.mesh.convex_hull_3d();
    auto inputs = reserve_vector<XYRotation>(chull.its.indices.size());
    auto rotcmp = [](const XYRotation &r1, const XYRotation &r2) {
        double xdiff = r1[X] - r2[X], ydiff = r1[Y] - r2[Y];
        return std::abs(xdiff) < EPSILON ? ydiff < 0. : xdiff < 0.;
    };
    auto eqcmp = [](const XYRotation &r1, const XYRotation &r2) {
        double xdiff = r1[X] - r2[X], ydiff = r1[Y] - r2[Y];
        return std::abs(xdiff) < EPSILON  && std::abs(ydiff) < EPSILON;
    };
 
    for (size_t fi = 0; fi < chull.its.indices.size(); ++fi) {
        Facestats fc{get_triangle_vertices(chull, fi)};
 
        auto q = Eigen::Quaternionf{}.FromTwoVectors(fc.normal, DOWN);
        XYRotation rot = from_transform3f(Transform3f::Identity() * q);
 
        auto it = std::lower_bound(inputs.begin(), inputs.end(), rot, rotcmp);
 
        if (it == inputs.end() || !eqcmp(*it, rot))
            inputs.insert(it, rot);
    }
 
    inputs.shrink_to_fit();
    bp.max_tries = inputs.size();
 
    auto objfn = [&bp, &chull](const XYRotation &rot) {
        bp.statusfn();
        Transform3f tr = to_transform3f(rot);
        return bounding_box_with_tr(chull.its, tr).size().z();
    };
 
    XYRotation rot = find_min_score<2>(objfn, inputs.begin(), inputs.end(), [&bp] {
        return bp.stopcond();
    });
 
    return {rot[0], rot[1]};
}

References bounding_box_with_tr(), Slic3r::TriangleMesh::convex_hull_3d(), DOWN, EPSILON, Eigen::Quaternion< _Scalar, _Options >::FromTwoVectors(), Eigen::Transform< float, 3, Eigen::Affine, Eigen::DontAlign >::Identity(), indexed_triangle_set::indices, Slic3r::TriangleMesh::its, Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

foreach_vertex()

template<class Fn >

void Slic3r::sla::foreach_vertex	(	ExPolygon &	poly,
		Fn &&	fn
	)

{
    for (auto &p : poly.contour.points) fn(p);
    for (auto &h : poly.holes)
        for (auto &p : h.points) fn(p);
}

References Slic3r::ExPolygon::contour, Slic3r::ExPolygon::holes, and Slic3r::MultiPoint::points.

Referenced by raster_to_polygons().

Here is the caller graph for this function:

generate_interior() [1/3]

InteriorPtr Slic3r::sla::generate_interior ( const indexed_triangle_set &  mesh, const HollowingConfig &  hc = {}, const JobController &  ctl = {}  )

inline

                                                                 {},
                                     const JobController &ctl = {})
{
    auto voxel_scale = get_voxel_scale(its_volume(mesh), hc);
    auto statusfn = [&ctl](int){ return ctl.stopcondition && ctl.stopcondition(); };
    auto grid = mesh_to_grid(mesh, MeshToGridParams{}
                                              .voxel_scale(voxel_scale)
                                              .exterior_bandwidth(3.f)
                                              .interior_bandwidth(3.f)
                                              .statusfn(statusfn));
 
    if (!grid || (ctl.stopcondition && ctl.stopcondition()))
        return {};
 
//    if (its_is_splittable(mesh))
    grid = redistance_grid(*grid, 0.0f, 3.f, 3.f);
 
    return grid ? generate_interior(*grid, hc, ctl) : InteriorPtr{};
}

generate_interior() [2/3]

template<class It >

InteriorPtr Slic3r::sla::generate_interior	(	const Range< It > &	csgparts,
		const HollowingConfig &	hc = {},
		const JobController &	ctl = {}
	)

                                                           {},
                              const JobController   &ctl = {})
{
    double mesh_vol = csgmesh_positive_maxvolume(csgparts);
    double voxsc    = get_voxel_scale(mesh_vol, hc);
 
    auto params = csg::VoxelizeParams{}
                      .voxel_scale(voxsc)
                      .exterior_bandwidth(3.f)
                      .interior_bandwidth(3.f)
                      .statusfn([&ctl](int){ return ctl.stopcondition && ctl.stopcondition(); });
 
    auto ptr = csg::voxelize_csgmesh(csgparts, params);
 
    if (!ptr || (ctl.stopcondition && ctl.stopcondition()))
        return {};
 
    // TODO: figure out issues without the redistance
//    if (csgparts.size() > 1 || its_is_splittable(*csg::get_mesh(*csgparts.begin())))
 
    ptr = redistance_grid(*ptr, 0.0f, 3.f, 3.f);
 
    return ptr ? generate_interior(*ptr, hc, ctl) : InteriorPtr{};
}

generate_interior() [3/3]

InteriorPtr Slic3r::sla::generate_interior	(	const VoxelGrid &	vgrid,
		const HollowingConfig &	hc,
		const JobController &	ctl
	)

{
    double voxsc    = get_voxel_scale(vgrid);
    double offset   = hc.min_thickness;              // world units
    double D        = hc.closing_distance;           // world units
    float  in_range = 1.1f * float(offset + D);      // world units
    float  out_range = 1.f / voxsc; // world units
    auto   narrowb  = 1.f;  // voxel units (voxel count)
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(0, _u8L("Hollowing"));
 
    auto gridptr = dilate_grid(vgrid, out_range, in_range);
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(30, _u8L("Hollowing"));
 
    double iso_surface = D;
    if (D > EPSILON) {
        gridptr = redistance_grid(*gridptr, -(offset + D), narrowb, narrowb);
 
        gridptr = dilate_grid(*gridptr, 1.1 * std::ceil(iso_surface), 0.f);
 
        out_range = iso_surface;
        in_range  = narrowb / voxsc;
    } else {
        iso_surface = -offset;
    }
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(70, _u8L("Hollowing"));
 
    double adaptivity = 0.;
    InteriorPtr interior = InteriorPtr{new Interior{}};
 
    interior->mesh = grid_to_mesh(*gridptr, iso_surface, adaptivity);
    interior->gridptr = std::move(gridptr);
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(100, _u8L("Hollowing"));
 
    interior->iso_surface = iso_surface;
    interior->thickness   = offset;
    interior->full_narrowb = (out_range + in_range) / 2.;
 
    return interior;
}

References _u8L, Slic3r::sla::HollowingConfig::closing_distance, Slic3r::dilate_grid(), EPSILON, get_voxel_scale(), Slic3r::grid_to_mesh(), Slic3r::sla::Interior::mesh, Slic3r::sla::HollowingConfig::min_thickness, Slic3r::offset(), Slic3r::redistance_grid(), Slic3r::sla::JobController::statuscb, and Slic3r::sla::JobController::stopcondition.

Referenced by hollow_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

get_avoidance()

static std::optional< Vec3f > Slic3r::sla::get_avoidance ( const GroundConnection &  conn, float  maxdist  )

static

{
    std::optional<Vec3f> ret;
 
    if (conn) {
        if (conn.path.size() > 1) {
            ret = conn.path[1].pos.cast<float>();
        } else {
            Vec3f pbeg = conn.path[0].pos.cast<float>();
            Vec3f pend = conn.pillar_base->pos.cast<float>();
            pbeg.z()   = std::max(pbeg.z() - maxdist, pend.z());
            ret = pbeg;
        }
    }
 
    return ret;
}

References get_avoidance(), Slic3r::sla::GroundConnection::path, and Slic3r::sla::GroundConnection::pillar_base.

Referenced by get_avoidance(), and Slic3r::sla::BranchingTreeBuilder::suggest_avoidance().

Here is the call graph for this function:

Here is the caller graph for this function:

get_contours()

Polygons Slic3r::sla::get_contours ( const ExPolygons &  poly )

inline

{
    Polygons ret; ret.reserve(poly.size());
    for (const ExPolygon &p : poly) ret.emplace_back(p.contour);
 
    return ret;
}

Referenced by Slic3r::sla::ConcaveHull::merge_polygons().

Here is the caller graph for this function:

get_criteria()

StopCriteria Slic3r::sla::get_criteria ( const SupportTreeConfig &  cfg )

inline

{
    return StopCriteria{}
        .rel_score_diff(cfg.optimizer_rel_score_diff)
        .max_iterations(cfg.optimizer_max_iterations);
}

References Slic3r::opt::StopCriteria::max_iterations(), Slic3r::sla::SupportTreeConfig::optimizer_max_iterations, Slic3r::sla::SupportTreeConfig::optimizer_rel_score_diff, and Slic3r::opt::StopCriteria::rel_score_diff().

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), deepsearch_ground_connection(), optimize_anchor_placement(), optimize_pinhead_placement(), search_ground_route(), and search_widening_path().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distance() [1/3]

static double Slic3r::sla::get_distance ( const TriangleBubble &  b, const Interior &  interior  )

static

{
    double R = b.R;
    double D = 2. * R;
    double Dst = get_distance_raw(b.center, interior);
 
    return D > interior.full_narrowb ||
           ((Dst - R) < 0. && 2 * R > interior.thickness) ?
                std::nan("") :
                Dst - interior.iso_surface;
}

References Dst, Slic3r::sla::Interior::full_narrowb, get_distance(), Slic3r::get_distance_raw(), Slic3r::sla::Interior::iso_surface, and Slic3r::sla::Interior::thickness.

Referenced by get_distance(), get_distance(), get_distance(), and remove_inside_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distance() [2/3]

double Slic3r::sla::get_distance ( const Vec3f &  p, const Interior &  interior  )

inline

{
    double d = get_distance_raw(p, interior) - interior.iso_surface;
    return d;
}

References get_distance(), Slic3r::get_distance_raw(), and Slic3r::sla::Interior::iso_surface.

Here is the call graph for this function:

get_distance() [3/3]

template<class T >

FloatingOnly< T > Slic3r::sla::get_distance	(	const Vec< 3, T > &	p,
		const Interior &	interior
	)

{
    return get_distance(Vec3f(p.template cast<float>()), interior);
}

References get_distance().

Here is the call graph for this function:

get_distance_raw()

static double Slic3r::sla::get_distance_raw ( const Vec3f &  p, const Interior &  interior  )

static

{
    assert(interior.gridptr);
 
    return Slic3r::get_distance_raw(p, *interior.gridptr);
}

References Slic3r::get_distance_raw(), and Slic3r::sla::Interior::gridptr.

Here is the call graph for this function:

get_grid() [1/2]

const VoxelGrid & Slic3r::sla::get_grid

(

const Interior &

interior

)

{
    return *interior.gridptr;
}

References Slic3r::sla::Interior::gridptr.

get_grid() [2/2]

VoxelGrid & Slic3r::sla::get_grid

(

Interior &

interior

)

{
    return *interior.gridptr;
}

References Slic3r::sla::Interior::gridptr.

get_mesh() [1/8]

indexed_triangle_set Slic3r::sla::get_mesh	(	const Bridge &	br,
		size_t	steps
	)

{
    using Quaternion = Eigen::Quaternion<float>;
    Vec3d v = (br.endp - br.startp);
    Vec3d dir = v.normalized();
    double d = v.norm();
 
    indexed_triangle_set mesh = cylinder(br.r, d, steps);
 
    auto quater = Quaternion::FromTwoVectors(Vec3f{0.f, 0.f, 1.f},
                                             dir.cast<float>());
 
    Vec3f startp = br.startp.cast<float>();
    for(auto& p : mesh.vertices) p = quater * p + startp;
 
    return mesh;
}

References cylinder(), Slic3r::sla::Bridge::endp, Slic3r::sla::Bridge::r, Slic3r::sla::Bridge::startp, and indexed_triangle_set::vertices.

Here is the call graph for this function:

get_mesh() [2/8]

indexed_triangle_set Slic3r::sla::get_mesh	(	const DiffBridge &	br,
		size_t	steps
	)

{
    double h = br.get_length();
    indexed_triangle_set mesh = halfcone(h, br.r, br.end_r, Vec3d::Zero(), steps);
 
    using Quaternion = Eigen::Quaternion<float>;
 
       // We rotate the head to the specified direction. The head's pointing
       // side is facing upwards so this means that it would hold a support
       // point with a normal pointing straight down. This is the reason of
       // the -1 z coordinate
    auto quatern = Quaternion::FromTwoVectors(Vec3f{0.f, 0.f, 1.f},
                                              br.get_dir().cast<float>());
 
    Vec3f startp = br.startp.cast<float>();
    for(auto& p : mesh.vertices) p = quatern * p + startp;
 
    return mesh;
}

References Slic3r::sla::DiffBridge::end_r, Slic3r::sla::Bridge::get_dir(), Slic3r::sla::Bridge::get_length(), halfcone(), Slic3r::sla::Bridge::r, Slic3r::sla::Bridge::startp, and indexed_triangle_set::vertices.

Here is the call graph for this function:

get_mesh() [3/8]

indexed_triangle_set Slic3r::sla::get_mesh	(	const Head &	h,
		size_t	steps
	)

{
    indexed_triangle_set mesh = pinhead(h.r_pin_mm, h.r_back_mm, h.width_mm, steps);
 
    for (auto& p : mesh.vertices) p.z() -= (h.fullwidth() - h.r_back_mm);
 
    using Quaternion = Eigen::Quaternion<float>;
 
       // We rotate the head to the specified direction. The head's pointing
       // side is facing upwards so this means that it would hold a support
       // point with a normal pointing straight down. This is the reason of
       // the -1 z coordinate
    auto quatern = Quaternion::FromTwoVectors(Vec3f{0.f, 0.f, -1.f},
                                              h.dir.cast<float>());
 
    Vec3f pos = h.pos.cast<float>();
    for (auto& p : mesh.vertices) p = quatern * p + pos;
 
    return mesh;
}

References Slic3r::sla::Head::dir, Slic3r::sla::Head::fullwidth(), pinhead(), pos(), Slic3r::sla::Head::pos, Slic3r::sla::Head::r_back_mm, Slic3r::sla::Head::r_pin_mm, indexed_triangle_set::vertices, and Slic3r::sla::Head::width_mm.

Here is the call graph for this function:

get_mesh() [4/8]

const indexed_triangle_set & Slic3r::sla::get_mesh

(

const Interior &

interior

)

{
    return interior.mesh;
}

References Slic3r::sla::Interior::mesh.

get_mesh() [5/8]

indexed_triangle_set Slic3r::sla::get_mesh ( const Junction &  j, size_t  steps  )

inline

{
    indexed_triangle_set mesh = sphere(j.r, make_portion(0, PI), 2 * PI / steps);
    Vec3f pos = j.pos.cast<float>();
    for(auto& p : mesh.vertices) p += pos;
    return mesh;
}

References make_portion(), PI, pos(), Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, sphere(), and indexed_triangle_set::vertices.

Here is the call graph for this function:

get_mesh() [6/8]

indexed_triangle_set Slic3r::sla::get_mesh ( const Pedestal &  p, size_t  steps  )

inline

{
    return halfcone(p.height, p.r_bottom, p.r_top, p.pos, steps);
}

References halfcone(), Slic3r::sla::Pedestal::height, Slic3r::sla::Pedestal::pos, Slic3r::sla::Pedestal::r_bottom, and Slic3r::sla::Pedestal::r_top.

Here is the call graph for this function:

get_mesh() [7/8]

indexed_triangle_set Slic3r::sla::get_mesh ( const Pillar &  p, size_t  steps  )

inline

{
    if(p.height > EPSILON) { // Endpoint is below the starting point
        // We just create a bridge geometry with the pillar parameters and
        // move the data.
        //return cylinder(p.r_start, p.height, steps, p.endpoint());
        return halfcone(p.height, p.r_end, p.r_start, p.endpt, steps);
    }
 
    return {};
}

References Slic3r::sla::Pillar::endpt, EPSILON, halfcone(), Slic3r::sla::Pillar::height, Slic3r::sla::Pillar::r_end, and Slic3r::sla::Pillar::r_start.

Here is the call graph for this function:

get_mesh() [8/8]

indexed_triangle_set & Slic3r::sla::get_mesh

(

Interior &

interior

)

{
    return interior.mesh;
}

References Slic3r::sla::Interior::mesh.

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), Slic3r::sla::Anchor::Head(), Slic3r::SLAPrint::Steps::hollow_model(), and Slic3r::sla::SupportTreeBuilder::merged_mesh().

Here is the caller graph for this function:

get_voxel_scale()

double Slic3r::sla::get_voxel_scale	(	double	mesh_volume,
		const HollowingConfig &	hc
	)

{
    static constexpr double MIN_SAMPLES_IN_WALL = 3.5;
    static constexpr double MAX_OVERSAMPL = 8.;
    static constexpr double UNIT_VOLUME   = 500000; // empiric
 
    // I can't figure out how to increase the grid resolution through openvdb
    // API so the model will be scaled up before conversion and the result
    // scaled down. Voxels have a unit size. If I set voxelSize smaller, it
    // scales the whole geometry down, and doesn't increase the number of
    // voxels.
    //
    // First an allowed range for voxel scale is determined from an initial
    // range of <MIN_SAMPLES_IN_WALL, MAX_OVERSAMPL>. The final voxel scale is
    // then chosen from this range using the 'quality:<0, 1>' parameter.
    // The minimum can be lowered if the wall thickness is great enough and
    // the maximum is lowered if the model volume very big.
 
    double sc_divider    = std::max(1.0, (mesh_volume / UNIT_VOLUME));
    double min_oversampl = std::max(MIN_SAMPLES_IN_WALL / hc.min_thickness, 1.);
    double max_oversampl_scaled = std::max(min_oversampl, MAX_OVERSAMPL / sc_divider);
    auto   voxel_scale          = min_oversampl + (max_oversampl_scaled - min_oversampl) * hc.quality;
 
    BOOST_LOG_TRIVIAL(debug) << "Hollowing: max oversampl will be: " << max_oversampl_scaled;
    BOOST_LOG_TRIVIAL(debug) << "Hollowing: voxel scale will be: " << voxel_scale;
    BOOST_LOG_TRIVIAL(debug) << "Hollowing: mesh volume is: " << mesh_volume;
 
    return voxel_scale;
}

References Slic3r::get_voxel_scale(), Slic3r::sla::HollowingConfig::min_thickness, and Slic3r::sla::HollowingConfig::quality.

Referenced by generate_interior().

Here is the call graph for this function:

Here is the caller graph for this function:

ground_level()

double Slic3r::sla::ground_level ( const SupportableMesh &  sm )

inline

{
    double lvl = sm.zoffset -
                 !bool(sm.pad_cfg.embed_object) * sm.cfg.enabled * sm.cfg.object_elevation_mm +
                  bool(sm.pad_cfg.embed_object) * sm.pad_cfg.wall_thickness_mm;
 
    return lvl;
}

References Slic3r::sla::SupportableMesh::cfg, Slic3r::sla::PadConfig::embed_object, Slic3r::sla::SupportTreeConfig::enabled, Slic3r::sla::SupportTreeConfig::object_elevation_mm, Slic3r::sla::SupportableMesh::pad_cfg, Slic3r::sla::PadConfig::wall_thickness_mm, and Slic3r::sla::SupportableMesh::zoffset.

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), build_ground_connection(), check_ground_route(), connect_to_ground(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), create_branching_tree(), create_ground_pillar(), create_pad(), deepsearch_ground_connection(), deepsearch_ground_connection(), Slic3r::sla::BranchingTreeBuilder::discard_subtree_rescure(), Slic3r::sla::DefaultSupportTree::interconnect(), Slic3r::sla::DefaultSupportTree::interconnect_pillars(), optimize_pinhead_placement(), Slic3r::sla::BranchingTreeBuilder::report_unroutable(), search_ground_route(), Slic3r::sla::DefaultSupportTree::search_pillar_and_connect(), search_widening_path(), and Slic3r::sla::BranchingTreeBuilder::suggest_avoidance().

Here is the caller graph for this function:

halfcone()

indexed_triangle_set Slic3r::sla::halfcone	(	double	baseheight,
		double	r_bottom,
		double	r_top,
		const Vec3d &	pos,
		size_t	steps
	)

{
    assert(steps > 0);
 
    if (baseheight <= 0 || steps <= 0 || (r_bottom <= 0. && r_top <= 0.))
        return {};
 
    indexed_triangle_set base;
 
    double a    = 2 * PI / steps;
    auto   last = int(steps - 1);
    Vec3d  ep{pos.x(), pos.y(), pos.z() + baseheight};
    for (size_t i = 0; i < steps; ++i) {
        double phi = i * a;
        auto x   = float(pos.x() + r_top * std::cos(phi));
        auto y   = float(pos.y() + r_top * std::sin(phi));
        base.vertices.emplace_back(x, y, float(ep.z()));
    }
 
    for (size_t i = 0; i < steps; ++i) {
        double phi = i * a;
        auto x   = float(pos.x() + r_bottom * std::cos(phi));
        auto y   = float(pos.y() + r_bottom * std::sin(phi));
        base.vertices.emplace_back(x, y, float(pos.z()));
    }
 
    base.vertices.emplace_back(pos.cast<float>());
    base.vertices.emplace_back(ep.cast<float>());
 
    auto &indices = base.indices;
    auto  hcenter = int(base.vertices.size() - 1);
    auto  lcenter = int(base.vertices.size() - 2);
    auto  offs    = int(steps);
    for (int i = 0; i < last; ++i) {
        indices.emplace_back(i, i + offs, offs + i + 1);
        indices.emplace_back(i, offs + i + 1, i + 1);
        indices.emplace_back(i, i + 1, hcenter);
        indices.emplace_back(lcenter, offs + i + 1, offs + i);
    }
 
    indices.emplace_back(0, last, offs);
    indices.emplace_back(last, offs + last, offs);
    indices.emplace_back(hcenter, last, 0);
    indices.emplace_back(offs, offs + last, lcenter);
 
    return base;
}

References indexed_triangle_set::indices, PI, pos(), and indexed_triangle_set::vertices.

Referenced by get_mesh(), get_mesh(), and get_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

hollow_mesh() [1/4]

void Slic3r::sla::hollow_mesh	(	indexed_triangle_set &	mesh,
		const HollowingConfig &	cfg,
		int	flags = 0
	)

hollow_mesh() [2/4]

void Slic3r::sla::hollow_mesh	(	indexed_triangle_set &	mesh,
		const Interior &	interior,
		int	flags
	)

{
    if (mesh.empty() || interior.mesh.empty()) return;
 
    if (flags & hfRemoveInsideTriangles && interior.gridptr)
        remove_inside_triangles(mesh, interior);
 
    indexed_triangle_set interi = interior.mesh;
    sla::swap_normals(interi);
 
    its_merge(mesh, interi);
}

References indexed_triangle_set::empty(), Slic3r::sla::Interior::gridptr, hfRemoveInsideTriangles, hollow_mesh(), Slic3r::its_merge(), Slic3r::sla::Interior::mesh, remove_inside_triangles(), and swap_normals().

Here is the call graph for this function:

hollow_mesh() [3/4]

void Slic3r::sla::hollow_mesh	(	TriangleMesh &	mesh,
		const HollowingConfig &	cfg,
		int	flags
	)

{
    InteriorPtr interior = generate_interior(mesh.its, cfg, JobController{});
    if (!interior) return;
 
    hollow_mesh(mesh, *interior, flags);
}

References generate_interior(), hollow_mesh(), and Slic3r::TriangleMesh::its.

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), hollow_mesh(), hollow_mesh(), and hollow_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

hollow_mesh() [4/4]

void Slic3r::sla::hollow_mesh	(	TriangleMesh &	mesh,
		const Interior &	interior,
		int	flags
	)

{
    if (mesh.empty() || interior.mesh.empty()) return;
 
    if (flags & hfRemoveInsideTriangles && interior.gridptr)
        remove_inside_triangles(mesh, interior);
 
    indexed_triangle_set interi = interior.mesh;
    sla::swap_normals(interi);
    TriangleMesh inter{std::move(interi)};
 
    mesh.merge(inter);
}

References indexed_triangle_set::empty(), Slic3r::TriangleMesh::empty(), Slic3r::sla::Interior::gridptr, hfRemoveInsideTriangles, hollow_mesh(), Slic3r::TriangleMesh::merge(), Slic3r::sla::Interior::mesh, remove_inside_triangles(), and swap_normals().

Here is the call graph for this function:

hollow_mesh_and_drill()

int Slic3r::sla::hollow_mesh_and_drill	(	indexed_triangle_set &	hollowed_mesh,
		const Interior &	interior,
		const DrainHoles &	drainholes,
		std::function< void(size_t)>	on_hole_fail
	)

{
    auto tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(
        hollowed_mesh.vertices,
        hollowed_mesh.indices
        );
 
    std::uniform_real_distribution<float> dist(0., float(EPSILON));
    auto holes_mesh_cgal = MeshBoolean::cgal::triangle_mesh_to_cgal({}, {});
    indexed_triangle_set part_to_drill = hollowed_mesh;
 
    std::mt19937 m_rng{std::random_device{}()};
 
    for (size_t i = 0; i < drainholes.size(); ++i) {
        sla::DrainHole holept = drainholes[i];
 
        holept.normal += Vec3f{dist(m_rng), dist(m_rng), dist(m_rng)};
        holept.normal.normalize();
        holept.pos += Vec3f{dist(m_rng), dist(m_rng), dist(m_rng)};
        indexed_triangle_set m = holept.to_mesh();
 
        part_to_drill.indices.clear();
        auto bb = bounding_box(m);
        Eigen::AlignedBox<float, 3> ebb{bb.min.cast<float>(),
                                        bb.max.cast<float>()};
 
        AABBTreeIndirect::traverse(
            tree,
            AABBTreeIndirect::intersecting(ebb),
            [&part_to_drill, &hollowed_mesh](const auto& node)
            {
                part_to_drill.indices.emplace_back(hollowed_mesh.indices[node.idx]);
                // continue traversal
                return true;
            });
 
        auto cgal_meshpart = MeshBoolean::cgal::triangle_mesh_to_cgal(
            remove_unconnected_vertices(part_to_drill));
 
        if (MeshBoolean::cgal::does_self_intersect(*cgal_meshpart)) {
            on_hole_fail(i);
            continue;
        }
 
        auto cgal_hole = MeshBoolean::cgal::triangle_mesh_to_cgal(m);
        MeshBoolean::cgal::plus(*holes_mesh_cgal, *cgal_hole);
    }
 
    auto ret = static_cast<int>(HollowMeshResult::Ok);
 
    if (MeshBoolean::cgal::does_self_intersect(*holes_mesh_cgal)) {
        ret |= static_cast<int>(HollowMeshResult::DrillingFailed);
    }
 
    auto hollowed_mesh_cgal = MeshBoolean::cgal::triangle_mesh_to_cgal(hollowed_mesh);
 
    if (!MeshBoolean::cgal::does_bound_a_volume(*hollowed_mesh_cgal)) {
        ret |= static_cast<int>(HollowMeshResult::FaultyMesh);
    }
 
    if (!MeshBoolean::cgal::empty(*holes_mesh_cgal)
        && !MeshBoolean::cgal::does_bound_a_volume(*holes_mesh_cgal)) {
        ret |= static_cast<int>(HollowMeshResult::FaultyHoles);
    }
 
    // Don't even bother
    if (ret & static_cast<int>(HollowMeshResult::DrillingFailed))
        return ret;
 
    try {
        if (!MeshBoolean::cgal::empty(*holes_mesh_cgal))
            MeshBoolean::cgal::minus(*hollowed_mesh_cgal, *holes_mesh_cgal);
 
        hollowed_mesh =
            MeshBoolean::cgal::cgal_to_indexed_triangle_set(*hollowed_mesh_cgal);
 
        std::vector<bool> exclude_mask =
            create_exclude_mask(hollowed_mesh, interior, drainholes);
 
        sla::remove_inside_triangles(hollowed_mesh, interior, exclude_mask);
    } catch (const Slic3r::RuntimeError &) {
        ret |= static_cast<int>(HollowMeshResult::DrillingFailed);
    }
 
    return ret;
}

References create_exclude_mask(), EPSILON, hollow_mesh_and_drill(), indexed_triangle_set::indices, Eigen::AlignedBox< _Scalar, _AmbientDim >::min(), Slic3r::sla::DrainHole::normal, Slic3r::sla::DrainHole::pos, remove_unconnected_vertices(), Slic3r::sla::DrainHole::to_mesh(), and indexed_triangle_set::vertices.

Referenced by Slic3r::SLAPrint::Steps::generate_preview(), and hollow_mesh_and_drill().

Here is the call graph for this function:

Here is the caller graph for this function:

is_outside_support_cone()

bool Slic3r::sla::is_outside_support_cone ( const Vec3f &  supp, const Vec3f &  pt, float  angle  )

inline

{
    using namespace Slic3r;
 
    Vec3d D = (pt - supp).cast<double>();
    double dot_sq = -D.z() * std::abs(-D.z());
 
    return dot_sq <
           D.squaredNorm() * std::cos(angle) * std::abs(std::cos(angle));
}

References Slic3r::angle(), and is_outside_support_cone().

Referenced by is_outside_support_cone().

Here is the call graph for this function:

Here is the caller graph for this function:

make_layers()

static std::vector< SupportPointGenerator::MyLayer > Slic3r::sla::make_layers ( const std::vector< ExPolygons > &  slices, const std::vector< float > &  heights, std::function< void(void)>  throw_on_cancel  )

static

{
    assert(slices.size() == heights.size());
 
    // Allocate empty layers.
    std::vector<SupportPointGenerator::MyLayer> layers;
    layers.reserve(slices.size());
    for (size_t i = 0; i < slices.size(); ++ i)
        layers.emplace_back(i, heights[i]);
 
    // FIXME: calculate actual pixel area from printer config:
    //const float pixel_area = pow(wxGetApp().preset_bundle->project_config.option<ConfigOptionFloat>("display_width") / wxGetApp().preset_bundle->project_config.option<ConfigOptionInt>("display_pixels_x"), 2.f); //
    const float pixel_area = pow(0.047f, 2.f);
 
    execution::for_each(ex_tbb, size_t(0), layers.size(),
        [&layers, &slices, &heights, pixel_area, throw_on_cancel](size_t layer_id)
    {
        if ((layer_id % 8) == 0)
            // Don't call the following function too often as it flushes
            // CPU write caches due to synchronization primitves.
            throw_on_cancel();
 
        SupportPointGenerator::MyLayer &layer   = layers[layer_id];
        const ExPolygons &              islands = slices[layer_id];
        // FIXME WTF?
        const float height = (layer_id > 2 ?
                                  heights[layer_id - 3] :
                                  heights[0] - (heights[1] - heights[0]));
        layer.islands.reserve(islands.size());
        for (const ExPolygon &island : islands) {
            float area = float(island.area() * SCALING_FACTOR * SCALING_FACTOR);
            if (area >= pixel_area)
                // FIXME this is not a correct centroid of a polygon with holes.
                layer.islands.emplace_back(layer, island, get_extents(island.contour),
                                           unscaled<float>(island.contour.centroid()), area, height);
        }
    }, 32 /*gransize*/);
 
    // Calculate overlap of successive layers. Link overlapping islands.
    execution::for_each(ex_tbb, size_t(1), layers.size(),
                      [&layers, &heights, throw_on_cancel] (size_t layer_id)
    {
      if ((layer_id % 2) == 0)
          // Don't call the following function too often as it flushes CPU write caches due to synchronization primitves.
          throw_on_cancel();
      SupportPointGenerator::MyLayer &layer_above = layers[layer_id];
      SupportPointGenerator::MyLayer &layer_below = layers[layer_id - 1];
      //FIXME WTF?
      const float layer_height = (layer_id!=0 ? heights[layer_id]-heights[layer_id-1] : heights[0]);
      const float safe_angle = 35.f * (float(M_PI)/180.f); // smaller number - less supports
      const float between_layers_offset = scaled<float>(layer_height * std::tan(safe_angle));
      const float slope_angle = 75.f * (float(M_PI)/180.f); // smaller number - less supports
      const float slope_offset = scaled<float>(layer_height * std::tan(slope_angle));
      //FIXME This has a quadratic time complexity, it will be excessively slow for many tiny islands.
      for (SupportPointGenerator::Structure &top : layer_above.islands) {
          for (SupportPointGenerator::Structure &bottom : layer_below.islands) {
              float overlap_area = top.overlap_area(bottom);
              if (overlap_area > 0) {
                  top.islands_below.emplace_back(&bottom, overlap_area);
                  bottom.islands_above.emplace_back(&top, overlap_area);
              }
          }
          if (! top.islands_below.empty()) {
              Polygons bottom_polygons = top.polygons_below();
              top.overhangs = diff_ex(*top.polygon, bottom_polygons);
              if (! top.overhangs.empty()) {
 
                  // Produce 2 bands around the island, a safe band for dangling overhangs
                  // and an unsafe band for sloped overhangs.
                  // These masks include the original island
                  auto dangl_mask = expand(bottom_polygons, between_layers_offset, ClipperLib::jtSquare);
                  auto overh_mask = expand(bottom_polygons, slope_offset, ClipperLib::jtSquare);
 
                  // Absolutely hopeless overhangs are those outside the unsafe band
                  top.overhangs = diff_ex(*top.polygon, overh_mask);
 
                  // Now cut out the supported core from the safe band
                  // and cut the safe band from the unsafe band to get distinct
                  // zones.
                  overh_mask = diff(overh_mask, dangl_mask);
                  dangl_mask = diff(dangl_mask, bottom_polygons);
 
                  top.dangling_areas = intersection_ex(*top.polygon, dangl_mask);
                  top.overhangs_slopes = intersection_ex(*top.polygon, overh_mask);
 
                  top.overhangs_area = 0.f;
                  std::vector<std::pair<ExPolygon*, float>> expolys_with_areas;
                  for (ExPolygon &ex : top.overhangs) {
                      float area = float(ex.area());
                      expolys_with_areas.emplace_back(&ex, area);
                      top.overhangs_area += area;
                  }
                  std::sort(expolys_with_areas.begin(), expolys_with_areas.end(),
                            [](const std::pair<ExPolygon*, float> &p1, const std::pair<ExPolygon*, float> &p2)
                            { return p1.second > p2.second; });
                  ExPolygons overhangs_sorted;
                  for (auto &p : expolys_with_areas)
                      overhangs_sorted.emplace_back(std::move(*p.first));
                  top.overhangs = std::move(overhangs_sorted);
                  top.overhangs_area *= float(SCALING_FACTOR * SCALING_FACTOR);
              }
          }
      }
    }, 8 /* gransize */);
 
    return layers;
}

References Slic3r::ex_tbb, and Slic3r::execution::for_each().

Referenced by Slic3r::sla::SupportPointGenerator::process().

Here is the call graph for this function:

Here is the caller graph for this function:

make_portion()

Portion Slic3r::sla::make_portion ( double  a, double  b  )

inline

{
    return std::make_tuple(a, b);
}

Referenced by get_mesh(), and pinhead().

Here is the caller graph for this function:

min_hit()

template<class It >

Hit Slic3r::sla::min_hit	(	It	from,
		It	to
	)

{
    auto mit = std::min_element(from, to, [](const Hit &h1, const Hit &h2) {
        return h1.distance() < h2.distance();
    });
 
    return *mit;
}

References Slic3r::AABBMesh::hit_result::distance().

Here is the call graph for this function:

non_duplicate_suppt_indices()

template<class PtIndex >

std::vector< size_t > Slic3r::sla::non_duplicate_suppt_indices	(	const PtIndex &	index,
		const SupportPoints &	suppts,
		double	eps
	)

{
    std::vector<bool> to_remove(suppts.size(), false);
 
    for (size_t i = 0; i < suppts.size(); ++i) {
        size_t closest_idx =
            find_closest_point(index, suppts[i].pos,
                               [&i, &to_remove](size_t i_closest) {
                                   return i_closest != i &&
                                          !to_remove[i_closest];
                               });
 
        if (closest_idx < suppts.size() &&
            (suppts[i].pos - suppts[closest_idx].pos).norm() < eps)
            to_remove[i] = true;
    }
 
    auto ret = reserve_vector<size_t>(suppts.size());
    for (size_t i = 0; i < to_remove.size(); i++)
        if (!to_remove[i])
            ret.emplace_back(i);
 
    return ret;
}

References Slic3r::find_closest_point(), non_duplicate_suppt_indices(), and pos().

Referenced by create_branching_tree(), and non_duplicate_suppt_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

offset_waffle_style()

Polygons Slic3r::sla::offset_waffle_style	(	const ConcaveHull &	hull,
		coord_t	delta
	)

{
    auto arc_tolerance = scaled<double>(0.01);
    Polygons res = closing(hull.polygons(), 2 * delta, delta, ClipperLib::jtRound, arc_tolerance);
 
    auto it = std::remove_if(res.begin(), res.end(), [](Polygon &p) { return p.is_clockwise(); });
    res.erase(it, res.end());
 
    return res;
}

References Slic3r::closing(), ClipperLib::jtRound, and Slic3r::sla::ConcaveHull::polygons().

Referenced by offset_waffle_style_ex().

Here is the call graph for this function:

Here is the caller graph for this function:

offset_waffle_style_ex()

ExPolygons Slic3r::sla::offset_waffle_style_ex	(	const ConcaveHull &	hull,
		coord_t	delta
	)

{
    return to_expolygons(offset_waffle_style(hull, delta));
}

References offset_waffle_style(), and Slic3r::to_expolygons().

Referenced by Slic3r::sla::anonymous_namespace{Pad.cpp}::BelowPadSkeleton::BelowPadSkeleton(), and Slic3r::sla::anonymous_namespace{Pad.cpp}::_AroundPadSkeleton< _Intersector >::wafflized_concave_hull().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<()

std::ostream & Slic3r::sla::operator<<	(	std::ostream &	stream,
		const EncodedRaster &	bytes
	)

{
    stream.write(reinterpret_cast<const char *>(bytes.data()),
                 std::streamsize(bytes.size()));
    
    return stream;
}

References Slic3r::sla::EncodedRaster::data(), and Slic3r::sla::EncodedRaster::size().

Here is the call graph for this function:

optimize_anchor_placement()

template<class Ex >

bool Slic3r::sla::optimize_anchor_placement	(	Ex	policy,
		const SupportableMesh &	sm,
		const Junction &	from,
		Anchor &	anchor
	)

{
    Vec3d n = get_normal(sm.emesh, anchor.pos);
 
    auto [polar, azimuth] = dir_to_spheric(n);
 
    // Saturate the polar angle to 3pi/4
    polar = std::min(polar, sm.cfg.bridge_slope);
 
    double lmin = 0;
    double lmax = std::min(sm.cfg.head_width_mm,
                           distance(from.pos, anchor.pos) - 2 * from.r);
 
    double sd = sm.cfg.safety_distance(anchor.r_back_mm);
 
    Optimizer<AlgNLoptGenetic> solver(get_criteria(sm.cfg)
                                          .stop_score(anchor.fullwidth())
                                          .max_iterations(100));
 
    solver.seed(0); // deterministic behavior
 
    auto oresult = solver.to_max().optimize(
        [&sm, &anchor, sd, policy](const opt::Input<3> &input) {
            auto &[plr, azm, l] = input;
 
            auto dir = spheric_to_dir(plr, azm).normalized();
 
            anchor.width_mm = l;
            anchor.dir = dir;
 
            return pinhead_mesh_hit(policy, sm.emesh, anchor, sd)
                .distance();
        },
        initvals({polar, azimuth, (lmin + lmax) / 2.}),
        bounds({{0., sm.cfg.bridge_slope}, // Must not exceed the slope limit
                {-PI, PI}, // azimuth can be a full search
                {lmin, lmax}}));
 
    polar = std::get<0>(oresult.optimum);
    azimuth = std::get<1>(oresult.optimum);
    anchor.dir = spheric_to_dir(polar, azimuth).normalized();
    anchor.width_mm = std::get<2>(oresult.optimum);
 
    if (oresult.score < anchor.fullwidth()) {
        // Unsuccesful search, the anchor does not fit into its intended space.
        return false;
    }
 
    return true;
}

References Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, Slic3r::sla::Head::dir, Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, Slic3r::sla::Head::fullwidth(), get_criteria(), Slic3r::get_normal(), Slic3r::sla::SupportTreeConfig::head_width_mm, input(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::opt::Optimizer< Method, Enable >::optimize(), optimize_anchor_placement(), PI, pinhead_mesh_hit(), Slic3r::sla::Junction::pos, Slic3r::sla::Head::pos, Slic3r::sla::Junction::r, Slic3r::sla::Head::r_back_mm, Slic3r::sla::SupportTreeConfig::safety_distance(), Slic3r::opt::Optimizer< Method, Enable >::seed(), Slic3r::opt::StopCriteria::stop_score(), Slic3r::opt::Optimizer< Method, Enable >::to_max(), and Slic3r::sla::Head::width_mm.

Referenced by calculate_anchor_placement(), and optimize_anchor_placement().

Here is the call graph for this function:

Here is the caller graph for this function:

optimize_pinhead_placement()

template<class Ex >

bool Slic3r::sla::optimize_pinhead_placement	(	Ex	policy,
		const SupportableMesh &	m,
		Head &	head
	)

{
    Vec3d n = get_normal(m.emesh, head.pos);
    assert(std::abs(n.norm() - 1.0) < EPSILON);
 
    // for all normals the spherical coordinates are generated and
    // the polar angle is saturated to 45 degrees from the bottom then
    // converted back to standard coordinates to get the new normal.
    // Then a simple quaternion is created from the two normals
    // (Quaternion::FromTwoVectors) and the rotation is applied to the
    // pinhead.
 
    auto [polar, azimuth] = dir_to_spheric(n);
 
    double back_r = head.r_back_mm;
 
    // skip if the tilt is not sane
    if (polar < PI - m.cfg.normal_cutoff_angle) return false;
 
    // We saturate the polar angle to 3pi/4
    polar = std::max(polar, PI - m.cfg.bridge_slope);
 
    // save the head (pinpoint) position
    Vec3d hp = head.pos;
 
    double lmin = m.cfg.head_width_mm, lmax = lmin;
 
    if (back_r < m.cfg.head_back_radius_mm) {
        lmin = 0., lmax = m.cfg.head_penetration_mm;
    }
 
    // The distance needed for a pinhead to not collide with model.
    double w = lmin + 2 * back_r + 2 * m.cfg.head_front_radius_mm -
               m.cfg.head_penetration_mm;
 
    double pin_r = head.r_pin_mm;
 
    // Reassemble the now corrected normal
    auto nn = spheric_to_dir(polar, azimuth).normalized();
 
    double sd = m.cfg.safety_distance(back_r);
 
    // check available distance
    Hit t = pinhead_mesh_hit(policy, m.emesh, hp, nn, pin_r, back_r, w, sd);
 
    if (t.distance() < w) {
        // Let's try to optimize this angle, there might be a
        // viable normal that doesn't collide with the model
        // geometry and its very close to the default.
 
        Optimizer<opt::AlgNLoptMLSL_Subplx> solver(get_criteria(m.cfg).stop_score(w).max_iterations(100));
        solver.seed(0); // we want deterministic behavior
 
        auto oresult = solver.to_max().optimize(
            [&m, pin_r, back_r, hp, sd, policy](const opt::Input<3> &input) {
                auto &[plr, azm, l] = input;
 
                auto dir = spheric_to_dir(plr, azm).normalized();
 
                return pinhead_mesh_hit(policy, m.emesh, hp, dir, pin_r,
                                              back_r, l, sd).distance();
            },
            initvals({polar, azimuth,
                      (lmin + lmax) / 2.}), // start with what we have
            bounds({{PI - m.cfg.bridge_slope, PI}, // Must not exceed the slope limit
                    {-PI, PI}, // azimuth can be a full search
                    {lmin, lmax}}));
 
        if(oresult.score > w) {
            polar = std::get<0>(oresult.optimum);
            azimuth = std::get<1>(oresult.optimum);
            nn = spheric_to_dir(polar, azimuth).normalized();
            lmin = std::get<2>(oresult.optimum);
            t = AABBMesh::hit_result(oresult.score);
        }
    }
 
    bool ret = false;
    if (t.distance() > w && hp.z() + w * nn.z() >= ground_level(m)) {
        head.dir       = nn;
        head.width_mm  = lmin;
        head.r_back_mm = back_r;
 
        ret = true;
    } else if (back_r > m.cfg.head_fallback_radius_mm) {
        head.r_back_mm = m.cfg.head_fallback_radius_mm;
        ret = optimize_pinhead_placement(policy, m, head);
    }
 
    return ret;
}

References Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, EPSILON, get_criteria(), Slic3r::get_normal(), ground_level(), head(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, Slic3r::sla::SupportTreeConfig::head_fallback_radius_mm, Slic3r::sla::SupportTreeConfig::head_front_radius_mm, Slic3r::sla::SupportTreeConfig::head_penetration_mm, Slic3r::sla::SupportTreeConfig::head_width_mm, input(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::sla::SupportTreeConfig::normal_cutoff_angle, Slic3r::opt::Optimizer< Method, Enable >::optimize(), optimize_pinhead_placement(), PI, pinhead_mesh_hit(), Slic3r::sla::SupportTreeConfig::safety_distance(), Slic3r::opt::Optimizer< Method, Enable >::seed(), Slic3r::opt::StopCriteria::stop_score(), and Slic3r::opt::Optimizer< Method, Enable >::to_max().

Referenced by calculate_pinhead_placement(), and optimize_pinhead_placement().

Here is the call graph for this function:

Here is the caller graph for this function:

pad_blueprint() [1/2]

void Slic3r::sla::pad_blueprint	(	const indexed_triangle_set &	mesh,
		ExPolygons &	output,
		const std::vector< float > &	heights,
		ThrowOnCancel	thrfn
	)

Calculate the polygon representing the silhouette.

{
    if (mesh.empty()) return;
 
    std::vector<ExPolygons> out = slice_mesh_ex(mesh, heights, thrfn);
 
    size_t count = 0;
    for(auto& o : out) count += o.size();
 
    // Unification is expensive, a simplify also speeds up the pad generation
    auto tmp = reserve_vector<ExPolygon>(count);
    for(ExPolygons& o : out)
        for(ExPolygon& e : o) {
            auto&& exss = e.simplify(scaled<double>(0.1));
            for(ExPolygon& ep : exss) tmp.emplace_back(std::move(ep));
        }
 
    ExPolygons utmp = union_ex(tmp);
 
    for(auto& o : utmp) {
        auto&& smp = o.simplify(scaled<double>(0.1));
        output.insert(output.end(), smp.begin(), smp.end());
    }
}

References indexed_triangle_set::empty(), Slic3r::slice_mesh_ex(), and Slic3r::union_ex().

Referenced by create_pad(), and pad_blueprint().

Here is the call graph for this function:

Here is the caller graph for this function:

pad_blueprint() [2/2]

void Slic3r::sla::pad_blueprint	(	const indexed_triangle_set &	mesh,
		ExPolygons &	output,
		float	h,
		float	layerh,
		ThrowOnCancel	thrfn
	)

{
    float gnd = float(bounding_box(mesh).min(Z));
 
    std::vector<float> slicegrid = grid(gnd, gnd + h, layerh);
    pad_blueprint(mesh, output, slicegrid, thrfn);
}

References Slic3r::bounding_box(), Slic3r::grid(), pad_blueprint(), and Slic3r::Z.

Here is the call graph for this function:

pairhash()

template<class I , class DoubleI = IntegerOnly<I>>

IntegerOnly< DoubleI > Slic3r::sla::pairhash	(	I	a,
		I	b
	)

{
    using std::ceil; using std::log2; using std::max; using std::min;
    static const auto constexpr Ibits = int(sizeof(I) * CHAR_BIT);
    static const auto constexpr DoubleIbits = int(sizeof(DoubleI) * CHAR_BIT);
    static const auto constexpr shift = DoubleIbits / 2 < Ibits ? Ibits / 2 : Ibits;
 
    I g = min(a, b), l = max(a, b);
 
       // Assume the hash will fit into the output variable
    assert((g ? (ceil(log2(g))) : 0) <= shift);
    assert((l ? (ceil(log2(l))) : 0) <= shift);
 
    return (DoubleI(g) << shift) + l;
}

References ceil().

Referenced by Slic3r::sla::DefaultSupportTree::interconnect_pillars().

Here is the call graph for this function:

Here is the caller graph for this function:

pinhead()

indexed_triangle_set Slic3r::sla::pinhead	(	double	r_pin,
		double	r_back,
		double	length,
		size_t	steps
	)

{
    assert(steps > 0);
    assert(length >= 0.);
    assert(r_back > 0.);
    assert(r_pin > 0.);
 
    indexed_triangle_set mesh;
 
    // We create two spheres which will be connected with a robe that fits
    // both circles perfectly.
 
    // Set up the model detail level
    const double detail = 2 * PI / steps;
 
    // We don't generate whole circles. Instead, we generate only the
    // portions which are visible (not covered by the robe) To know the
    // exact portion of the bottom and top circles we need to use some
    // rules of tangent circles from which we can derive (using simple
    // triangles the following relations:
 
    // The height of the whole mesh
    const double h   = r_back + r_pin + length;
    double       phi = PI / 2. - std::acos((r_back - r_pin) / h);
 
    if (std::isnan(phi))
        return mesh;
 
    // To generate a whole circle we would pass a portion of (0, Pi)
    // To generate only a half horizontal circle we can pass (0, Pi/2)
    // The calculated phi is an offset to the half circles needed to smooth
    // the transition from the circle to the robe geometry
 
    auto s1 = sphere(r_back, make_portion(0, PI / 2 + phi), detail);
    auto s2 = sphere(r_pin, make_portion(PI / 2 + phi, PI), detail);
 
    for (auto &p : s2.vertices) p.z() += h;
 
    its_merge(mesh, s1);
    its_merge(mesh, s2);
 
    for (size_t idx1 = s1.vertices.size() - steps, idx2 = s1.vertices.size();
         idx1 < s1.vertices.size() - 1; idx1++, idx2++) {
        coord_t i1s1 = coord_t(idx1), i1s2 = coord_t(idx2);
        coord_t i2s1 = i1s1 + 1, i2s2 = i1s2 + 1;
 
        mesh.indices.emplace_back(i1s1, i2s1, i2s2);
        mesh.indices.emplace_back(i1s1, i2s2, i1s2);
    }
 
    auto i1s1 = coord_t(s1.vertices.size()) - coord_t(steps);
    auto i2s1 = coord_t(s1.vertices.size()) - 1;
    auto i1s2 = coord_t(s1.vertices.size());
    auto i2s2 = coord_t(s1.vertices.size()) + coord_t(steps) - 1;
 
    mesh.indices.emplace_back(i2s2, i2s1, i1s1);
    mesh.indices.emplace_back(i1s2, i2s2, i1s1);
 
    return mesh;
}

References indexed_triangle_set::indices, Slic3r::its_merge(), Slic3r::length(), make_portion(), PI, and sphere().

Referenced by get_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

pinhead_mesh_hit() [1/2]

template<class Ex >

Hit Slic3r::sla::pinhead_mesh_hit	(	Ex	ex,
		const AABBMesh &	mesh,
		const Head &	head,
		double	safety_d
	)

{
    return pinhead_mesh_hit(ex, mesh, head.pos, head.dir, head.r_pin_mm,
                            head.r_back_mm, head.width_mm, safety_d);
}

References head(), and pinhead_mesh_hit().

Here is the call graph for this function:

pinhead_mesh_hit() [2/2]

template<class Ex >

Hit Slic3r::sla::pinhead_mesh_hit	(	Ex	ex,
		const AABBMesh &	mesh,
		const Vec3d &	s,
		const Vec3d &	dir,
		double	r_pin,
		double	r_back,
		double	width,
		double	sd
	)

{
    // Support tree generation speed depends heavily on this value. 8 is almost
    // ok, but to prevent rare cases of collision, 16 is necessary, which makes
    // the algorithm run about 60% longer.
    static const size_t SAMPLES = 16;
 
    // Move away slightly from the touching point to avoid raycasting on the
    // inner surface of the mesh.
 
    auto &m         = mesh;
    using HitResult = AABBMesh::hit_result;
 
       // Hit results
    std::array<HitResult, SAMPLES> hits;
 
    struct Rings
    {
        double             rpin;
        double             rback;
        Vec3d              spin;
        Vec3d              sback;
        PointRing<SAMPLES> ring;
 
        Vec3d backring(size_t idx) { return ring.get(idx, sback, rback); }
        Vec3d pinring(size_t idx) { return ring.get(idx, spin, rpin); }
    } rings{r_pin + sd, r_back + sd, s, s + (r_pin + width + r_back) * dir, dir};
 
    // We will shoot multiple rays from the head pinpoint in the direction
    // of the pinhead robe (side) surface. The result will be the smallest
    // hit distance.
 
    execution::for_each(
        ex, size_t(0), hits.size(), [&m, &rings, sd, &hits](size_t i) {
            // Point on the circle on the pin sphere
            Vec3d ps = rings.pinring(i);
            // This is the point on the circle on the back sphere
            Vec3d p = rings.backring(i);
 
            auto &hit = hits[i];
 
               // Point ps is not on mesh but can be inside or
               // outside as well. This would cause many problems
               // with ray-casting. To detect the position we will
               // use the ray-casting result (which has an is_inside
               // predicate).
 
            Vec3d n = (p - ps).normalized();
            auto  q = m.query_ray_hit(ps + sd * n, n);
 
            if (q.is_inside()) { // the hit is inside the model
                if (q.distance() > rings.rpin) {
                    // If we are inside the model and the hit
                    // distance is bigger than our pin circle
                    // diameter, it probably indicates that the
                    // support point was already inside the
                    // model, or there is really no space
                    // around the point. We will assign a zero
                    // hit distance to these cases which will
                    // enforce the function return value to be
                    // an invalid ray with zero hit distance.
                    // (see min_element at the end)
                    hit = HitResult(0.0);
                } else {
                    // re-cast the ray from the outside of the
                    // object. The starting point has an offset
                    // of 2*safety_distance because the
                    // original ray has also had an offset
                    auto q2 = m.query_ray_hit(ps + (q.distance() + 2 * sd) * n, n);
                    hit     = q2;
                }
            } else
                hit = q;
        }, std::min(execution::max_concurrency(ex), SAMPLES));
 
    return min_hit(hits.begin(), hits.end());
}

References Slic3r::execution::for_each(), Slic3r::sla::PointRing< N >::get(), and pinhead_mesh_hit().

Referenced by optimize_anchor_placement(), optimize_pinhead_placement(), pinhead_mesh_hit(), pinhead_mesh_hit(), Slic3r::sla::DefaultSupportTree::pinhead_mesh_intersect(), and search_widening_path().

Here is the call graph for this function:

Here is the caller graph for this function:

poisson_disk_from_samples()

template<typename REFUSE_FUNCTION >

static std::vector< Vec2f > Slic3r::sla::poisson_disk_from_samples ( const std::vector< Vec2f > &  raw_samples, float  radius, REFUSE_FUNCTION  refuse_function  )

inlinestatic

{
    Vec2f corner_min(std::numeric_limits<float>::max(), std::numeric_limits<float>::max());
    for (const Vec2f &pt : raw_samples) {
        corner_min.x() = std::min(corner_min.x(), pt.x());
        corner_min.y() = std::min(corner_min.y(), pt.y());
    }
 
    // Assign the raw samples to grid cells, sort the grid cells lexicographically.
    struct RawSample
    {
        Vec2f coord;
        Vec2i cell_id;
        RawSample(const Vec2f &crd = {}, const Vec2i &id = {}): coord{crd}, cell_id{id} {}
    };
 
    auto raw_samples_sorted = reserve_vector<RawSample>(raw_samples.size());
    for (const Vec2f &pt : raw_samples)
        raw_samples_sorted.emplace_back(pt, ((pt - corner_min) / radius).cast<int>());
 
    std::sort(raw_samples_sorted.begin(), raw_samples_sorted.end(), [](const RawSample &lhs, const RawSample &rhs)
        { return lhs.cell_id.x() < rhs.cell_id.x() || (lhs.cell_id.x() == rhs.cell_id.x() && lhs.cell_id.y() < rhs.cell_id.y()); });
 
    struct PoissonDiskGridEntry {
        // Resulting output sample points for this cell:
        enum {
            max_positions = 4
        };
        Vec2f   poisson_samples[max_positions];
        int     num_poisson_samples = 0;
 
        // Index into raw_samples:
        int     first_sample_idx;
        int     sample_cnt;
    };
 
    struct CellIDHash {
        std::size_t operator()(const Vec2i &cell_id) const {
            return std::hash<int>()(cell_id.x()) ^ std::hash<int>()(cell_id.y() * 593);
        }
    };
 
    // Map from cell IDs to hash_data.  Each hash_data points to the range in raw_samples corresponding to that cell.
    // (We could just store the samples in hash_data.  This implementation is an artifact of the reference paper, which
    // is optimizing for GPU acceleration that we haven't implemented currently.)
    typedef std::unordered_map<Vec2i, PoissonDiskGridEntry, CellIDHash> Cells;
    Cells cells;
    {
        typename Cells::iterator last_cell_id_it;
        Vec2i           last_cell_id(-1, -1);
        for (size_t i = 0; i < raw_samples_sorted.size(); ++ i) {
            const RawSample &sample = raw_samples_sorted[i];
            if (sample.cell_id == last_cell_id) {
                // This sample is in the same cell as the previous, so just increase the count.  Cells are
                // always contiguous, since we've sorted raw_samples_sorted by cell ID.
                ++ last_cell_id_it->second.sample_cnt;
            } else {
                // This is a new cell.
                PoissonDiskGridEntry data;
                data.first_sample_idx = int(i);
                data.sample_cnt       = 1;
                auto result     = cells.insert({sample.cell_id, data});
                last_cell_id    = sample.cell_id;
                last_cell_id_it = result.first;
            }
        }
    }
 
    const int   max_trials = 5;
    const float radius_squared = radius * radius;
    for (int trial = 0; trial < max_trials; ++ trial) {
        // Create sample points for each entry in cells.
        for (auto &it : cells) {
            const Vec2i          &cell_id   = it.first;
            PoissonDiskGridEntry &cell_data = it.second;
            // This cell's raw sample points start at first_sample_idx.  On trial 0, try the first one. On trial 1, try first_sample_idx + 1.
            int next_sample_idx = cell_data.first_sample_idx + trial;
            if (trial >= cell_data.sample_cnt)
                // There are no more points to try for this cell.
                continue;
            const RawSample &candidate = raw_samples_sorted[next_sample_idx];
            // See if this point conflicts with any other points in this cell, or with any points in
            // neighboring cells.  Note that it's possible to have more than one point in the same cell.
            bool conflict = refuse_function(candidate.coord);
            for (int i = -1; i < 2 && ! conflict; ++ i) {
                for (int j = -1; j < 2; ++ j) {
                    const auto &it_neighbor = cells.find(cell_id + Vec2i(i, j));
                    if (it_neighbor != cells.end()) {
                        const PoissonDiskGridEntry &neighbor = it_neighbor->second;
                        for (int i_sample = 0; i_sample < neighbor.num_poisson_samples; ++ i_sample)
                            if ((neighbor.poisson_samples[i_sample] - candidate.coord).squaredNorm() < radius_squared) {
                                conflict = true;
                                break;
                            }
                    }
                }
            }
            if (! conflict) {
                // Store the new sample.
                assert(cell_data.num_poisson_samples < cell_data.max_positions);
                if (cell_data.num_poisson_samples < cell_data.max_positions)
                    cell_data.poisson_samples[cell_data.num_poisson_samples ++] = candidate.coord;
            }
        }
    }
 
    // Copy the results to the output.
    std::vector<Vec2f> out;
    for (const auto& it : cells)
        for (int i = 0; i < it.second.num_poisson_samples; ++ i)
            out.emplace_back(it.second.poisson_samples[i]);
    return out;
}

References poisson_disk_from_samples().

Referenced by poisson_disk_from_samples(), and Slic3r::sla::SupportPointGenerator::uniformly_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

pos() [1/2]

template<class Pt >

Vec3d Slic3r::sla::pos

(

const Pt &

p

)

{ return p.pos.template cast<double>(); }

Referenced by Slic3r::sla::SupportPointGenerator::PointGrid3D::cell_id(), Slic3r::sla::SupportPointGenerator::PointGrid3D::collides_with(), Slic3r::sla::SupportPointGenerator::PointGrid3D::collides_with(), get_mesh(), get_mesh(), halfcone(), Slic3r::sla::SupportPointGenerator::PointGrid3D::insert(), non_duplicate_suppt_indices(), transformed_drainhole_points(), and Slic3r::sla::SupportPointGenerator::uniformly_cover().

Here is the caller graph for this function:

pos() [2/2]

template<class Pt >

void Slic3r::sla::pos	(	Pt &	p,
		const Vec3d &	pp
	)

{ p.pos = pp.cast<float>(); }

raster_to_polygons()

ExPolygons Slic3r::sla::raster_to_polygons	(	const RasterGrayscaleAA &	rst,
		Vec2i	windowsize
	)

{    
    size_t rows = rst.resolution().height_px, cols = rst.resolution().width_px;
    
    if (rows < 2 || cols < 2) return {};
    
    Polygons polys;
    long w_rows = std::max(2l, long(windowsize.y()));
    long w_cols = std::max(2l, long(windowsize.x()));
    
    std::vector<marchsq::Ring> rings =
        marchsq::execute(rst, 128, {w_rows, w_cols});
    
    polys.reserve(rings.size());
    
    auto pxd = rst.pixel_dimensions();
    pxd.w_mm = (rst.resolution().width_px * pxd.w_mm) / (rst.resolution().width_px - 1);
    pxd.h_mm = (rst.resolution().height_px * pxd.h_mm) / (rst.resolution().height_px - 1);
    
    for (const marchsq::Ring &ring : rings) {
        Polygon poly; Points &pts = poly.points;
        pts.reserve(ring.size());
        
        for (const marchsq::Coord &crd : ring)
            pts.emplace_back(scaled(crd.c * pxd.w_mm), scaled(crd.r * pxd.h_mm));
        
        polys.emplace_back(poly);
    }
    
    // reverse the raster transformations
    ExPolygons unioned = union_ex(polys);
    coord_t width = scaled(cols * pxd.h_mm), height = scaled(rows * pxd.w_mm);
    
    auto tr = rst.trafo();
    for (ExPolygon &expoly : unioned) {
        if (tr.mirror_y)
            foreach_vertex(expoly, [height](Point &p) {p.y() = height - p.y(); });
        
        if (tr.mirror_x)
            foreach_vertex(expoly, [width](Point &p) {p.x() = width - p.x(); });
        
        expoly.translate(-tr.center_x, -tr.center_y);
        
        if (tr.flipXY)
            foreach_vertex(expoly, [](Point &p) { std::swap(p.x(), p.y()); });
        
        if ((tr.mirror_x + tr.mirror_y + tr.flipXY) % 2) {
            expoly.contour.reverse();
            for (auto &h : expoly.holes) h.reverse();
        }
    }
    
    return unioned;
}

References foreach_vertex(), Slic3r::sla::Resolution::height_px, Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::pixel_dimensions(), Slic3r::MultiPoint::points, Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::resolution(), Slic3r::scaled(), Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::trafo(), Slic3r::union_ex(), Slic3r::sla::PixelDim::w_mm, and Slic3r::sla::Resolution::width_px.

Here is the call graph for this function:

remove_bottom_points()

void Slic3r::sla::remove_bottom_points	(	std::vector< SupportPoint > &	pts,
		float	lvl
	)

{
    // get iterator to the reorganized vector end
    auto endit = std::remove_if(pts.begin(), pts.end(), [lvl]
                                (const sla::SupportPoint &sp) {
        return sp.pos.z() <= lvl;
    });
 
    // erase all elements after the new end
    pts.erase(endit, pts.end());
}

References remove_bottom_points().

Referenced by remove_bottom_points().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_inside_triangles() [1/2]

void Slic3r::sla::remove_inside_triangles	(	indexed_triangle_set &	mesh,
		const Interior &	interior,
		const std::vector< bool > &	exclude_mask
	)

{
    enum TrPos { posInside, posTouch, posOutside };
 
    auto &faces       = mesh.indices;
    auto &vertices    = mesh.vertices;
    auto bb           = bounding_box(mesh); //mesh.bounding_box();
 
    bool use_exclude_mask = faces.size() == exclude_mask.size();
    auto is_excluded = [&exclude_mask, use_exclude_mask](size_t face_id) {
        return use_exclude_mask && exclude_mask[face_id];
    };
 
    // TODO: Parallel mode not working yet
    constexpr auto &exec_policy = ex_seq;
 
    // Info about the needed modifications on the input mesh.
    struct MeshMods {
 
        // Just a thread safe wrapper for a vector of triangles.
        struct {
            std::vector<std::array<Vec3f, 3>> data;
            execution::SpinningMutex<decltype(exec_policy)> mutex;
 
            void emplace_back(const std::array<Vec3f, 3> &pts)
            {
                std::lock_guard lk{mutex};
                data.emplace_back(pts);
            }
 
            size_t size() const { return data.size(); }
            const std::array<Vec3f, 3>& operator[](size_t idx) const
            {
                return data[idx];
            }
 
        } new_triangles;
 
        // A vector of bool for all faces signaling if it needs to be removed
        // or not.
        std::vector<bool> to_remove;
 
        MeshMods(const indexed_triangle_set &mesh):
            to_remove(mesh.indices.size(), false) {}
 
        // Number of triangles that need to be removed.
        size_t to_remove_cnt() const
        {
            return std::accumulate(to_remove.begin(), to_remove.end(), size_t(0));
        }
 
    } mesh_mods{mesh};
 
    // Must return true if further division of the face is needed.
    auto divfn = [&interior, bb, &mesh_mods](const DivFace &f) {
        BoundingBoxf3 facebb { f.verts.begin(), f.verts.end() };
 
        // Face is certainly outside the cavity
        if (! facebb.intersects(bb) && f.faceid != NEW_FACE) {
            return false;
        }
 
        TriangleBubble bubble{facebb.center().cast<float>(), facebb.radius()};
 
        double D = get_distance(bubble, interior);
        double R = bubble.R;
 
        if (std::isnan(D)) // The distance cannot be measured, triangle too big
            return true;
 
        // Distance of the bubble wall to the interior wall. Negative if the
        // bubble is overlapping with the interior
        double bubble_distance = D - R;
 
        // The face is crossing the interior or inside, it must be removed and
        // parts of it re-added, that are outside the interior
        if (bubble_distance < 0.) {
            if (f.faceid != NEW_FACE)
                mesh_mods.to_remove[f.faceid] = true;
 
            if (f.parent != NEW_FACE) // Top parent needs to be removed as well
                mesh_mods.to_remove[f.parent] = true;
 
            // If the outside part is between the interior and the exterior
            // (inside the wall being invisible), no further division is needed.
            if ((R + D) < interior.thickness)
                return false;
 
            return true;
        } else if (f.faceid == NEW_FACE) {
            // New face completely outside needs to be re-added.
            mesh_mods.new_triangles.emplace_back(f.verts);
        }
 
        return false;
    };
 
    interior.reset_accessor();
 
    execution::for_each(
        exec_policy, size_t(0), faces.size(),
        [&](size_t face_idx) {
            const Vec3i &face = faces[face_idx];
 
            // If the triangle is excluded, we need to keep it.
            if (is_excluded(face_idx))
                return;
 
            std::array<Vec3f, 3> pts = {vertices[face(0)], vertices[face(1)],
                                        vertices[face(2)]};
 
            BoundingBoxf3 facebb{pts.begin(), pts.end()};
 
            // Face is certainly outside the cavity
            if (!facebb.intersects(bb))
                return;
 
            DivFace df{face, pts, long(face_idx)};
 
            if (divfn(df)) divide_triangle(df, divfn);
        },
        execution::max_concurrency(exec_policy)
    );
 
    auto new_faces = reserve_vector<Vec3i>(faces.size() +
                                           mesh_mods.new_triangles.size());
 
    for (size_t face_idx = 0; face_idx < faces.size(); ++face_idx) {
        if (!mesh_mods.to_remove[face_idx])
            new_faces.emplace_back(faces[face_idx]);
    }
 
    for(size_t i = 0; i < mesh_mods.new_triangles.size(); ++i) {
        size_t o = vertices.size();
        vertices.emplace_back(mesh_mods.new_triangles[i][0]);
        vertices.emplace_back(mesh_mods.new_triangles[i][1]);
        vertices.emplace_back(mesh_mods.new_triangles[i][2]);
        new_faces.emplace_back(int(o), int(o + 1), int(o + 2));
    }
 
    BOOST_LOG_TRIVIAL(info)
            << "Trimming: " << mesh_mods.to_remove_cnt() << " triangles removed";
    BOOST_LOG_TRIVIAL(info)
            << "Trimming: " << mesh_mods.new_triangles.size() << " triangles added";
 
    faces.swap(new_faces);
    new_faces = {};
 
//    mesh = TriangleMesh{mesh.its};
    //FIXME do we want to repair the mesh? Are there duplicate vertices or flipped triangles?
}

References Slic3r::bounding_box(), Slic3r::sla::TriangleBubble::center, divide_triangle(), Slic3r::ex_seq, Slic3r::f(), Slic3r::execution::for_each(), get_distance(), indexed_triangle_set::indices, long, NEW_FACE, remove_inside_triangles(), Slic3r::sla::Interior::reset_accessor(), Slic3r::sla::Interior::thickness, and indexed_triangle_set::vertices.

Referenced by hollow_mesh(), hollow_mesh(), remove_inside_triangles(), and remove_inside_triangles().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_inside_triangles() [2/2]

void Slic3r::sla::remove_inside_triangles	(	TriangleMesh &	mesh,
		const Interior &	interior,
		const std::vector< bool > &	exclude_mask
	)

{
    remove_inside_triangles(mesh.its, interior, exclude_mask);
}

References Slic3r::TriangleMesh::its, and remove_inside_triangles().

Here is the call graph for this function:

remove_unconnected_vertices()

static indexed_triangle_set Slic3r::sla::remove_unconnected_vertices ( const indexed_triangle_set &  its )

static

{
    if (its.indices.empty()) {};
 
    indexed_triangle_set M;
 
    std::vector<int> vtransl(its.vertices.size(), -1);
    int vcnt = 0;
    for (auto &f : its.indices) {
 
        for (int i = 0; i < 3; ++i)
            if (vtransl[size_t(f(i))] < 0) {
 
                M.vertices.emplace_back(its.vertices[size_t(f(i))]);
                vtransl[size_t(f(i))] = vcnt++;
            }
 
        std::array<int, 3> new_f = {
            vtransl[size_t(f(0))],
            vtransl[size_t(f(1))],
            vtransl[size_t(f(2))]
        };
 
        M.indices.emplace_back(new_f[0], new_f[1], new_f[2]);
    }
 
    return M;
}

References indexed_triangle_set::indices, remove_unconnected_vertices(), and indexed_triangle_set::vertices.

Referenced by hollow_mesh_and_drill(), and remove_unconnected_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

reproject_points_and_holes()

void Slic3r::sla::reproject_points_and_holes ( ModelObject *  object )

inline

{
    bool has_sppoints = !object->sla_support_points.empty();
    bool has_holes    = !object->sla_drain_holes.empty();
 
    if (!object || (!has_holes && !has_sppoints)) return;
 
    TriangleMesh rmsh = object->raw_mesh();
    AABBMesh emesh{rmsh};
 
    if (has_sppoints)
        reproject_support_points(emesh, object->sla_support_points);
 
    if (has_holes)
        reproject_support_points(emesh, object->sla_drain_holes);
}

References reproject_support_points(), Slic3r::ModelObject::sla_drain_holes, and Slic3r::ModelObject::sla_support_points.

Referenced by Slic3r::GUI::Plater::changed_mesh(), Slic3r::GUI::Plater::priv::reload_from_disk(), and Slic3r::GUI::Plater::priv::replace_volume_with_stl().

Here is the call graph for this function:

Here is the caller graph for this function:

reproject_support_points()

template<class PointType >

void Slic3r::sla::reproject_support_points	(	const AABBMesh &	mesh,
		std::vector< PointType > &	pts
	)

{
    tbb::parallel_for(size_t(0), pts.size(), [&mesh, &pts](size_t idx) {
        int junk;
        Vec3d new_pos;
        mesh.squared_distance(pos(pts[idx]), junk, new_pos);
        pos(pts[idx], new_pos);
    });
}

Referenced by reproject_points_and_holes().

Here is the caller graph for this function:

sample_expolygon() [1/2]

std::vector< Vec2f > Slic3r::sla::sample_expolygon	(	const ExPolygon &	expoly,
		float	samples_per_mm2,
		std::mt19937 &	rng
	)

{
    // Triangulate the polygon with holes into triplets of 3D points.
    std::vector<Vec2f> triangles = Slic3r::triangulate_expolygon_2f(expoly);
 
    std::vector<Vec2f> out;
    if (! triangles.empty())
    {
        // Calculate area of each triangle.
        auto   areas = reserve_vector<float>(triangles.size() / 3);
        double aback = 0.;
        for (size_t i = 0; i < triangles.size(); ) {
            const Vec2f &a  = triangles[i ++];
            const Vec2f  v1 = triangles[i ++] - a;
            const Vec2f  v2 = triangles[i ++] - a;
 
            // Prefix sum of the areas.
            areas.emplace_back(aback + 0.5f * std::abs(cross2(v1, v2)));
            aback = areas.back();
        }
 
        size_t num_samples = size_t(ceil(areas.back() * samples_per_mm2));
        std::uniform_real_distribution<> random_triangle(0., double(areas.back()));
        std::uniform_real_distribution<> random_float(0., 1.);
        for (size_t i = 0; i < num_samples; ++ i) {
            double r = random_triangle(rng);
            size_t idx_triangle = std::min<size_t>(std::upper_bound(areas.begin(), areas.end(), (float)r) - areas.begin(), areas.size() - 1) * 3;
            // Select a random point on the triangle.
            const Vec2f &a = triangles[idx_triangle ++];
            const Vec2f &b = triangles[idx_triangle++];
            const Vec2f &c = triangles[idx_triangle];
#if 1
            // https://www.cs.princeton.edu/~funk/tog02.pdf
            // page 814, formula 1.
            double u = float(std::sqrt(random_float(rng)));
            double v = float(random_float(rng));
            out.emplace_back(a * (1.f - u) + b * (u * (1.f - v)) + c * (v * u));
#else
            // Greg Turk, Graphics Gems
            // https://devsplorer.wordpress.com/2019/08/07/find-a-random-point-on-a-plane-using-barycentric-coordinates-in-unity/
            double u = float(random_float(rng));
            double v = float(random_float(rng));
            if (u + v >= 1.f) {
              u = 1.f - u;
              v = 1.f - v;
            }
            out.emplace_back(a + u * (b - a) + v * (c - a));
#endif
        }
    }
    return out;
}

References ceil(), Slic3r::cross2(), sample_expolygon(), and Slic3r::triangulate_expolygon_2f().

Referenced by sample_expolygon(), sample_expolygon(), sample_expolygon_with_boundary(), and Slic3r::sla::SupportPointGenerator::uniformly_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_expolygon() [2/2]

std::vector< Vec2f > Slic3r::sla::sample_expolygon	(	const ExPolygons &	expolys,
		float	samples_per_mm2,
		std::mt19937 &	rng
	)

{
    std::vector<Vec2f> out;
    for (const ExPolygon &expoly : expolys)
        append(out, sample_expolygon(expoly, samples_per_mm2, rng));
 
    return out;
}

References sample_expolygon().

Here is the call graph for this function:

sample_expolygon_boundary()

void Slic3r::sla::sample_expolygon_boundary	(	const ExPolygon &	expoly,
		float	samples_per_mm,
		std::vector< Vec2f > &	out,
		std::mt19937 &
	)

{
    double  point_stepping_scaled = scale_(1.f) / samples_per_mm;
    for (size_t i_contour = 0; i_contour <= expoly.holes.size(); ++ i_contour) {
        const Polygon &contour = (i_contour == 0) ? expoly.contour :
                                                    expoly.holes[i_contour - 1];
 
        const Points pts = contour.equally_spaced_points(point_stepping_scaled);
        for (size_t i = 0; i < pts.size(); ++ i)
            out.emplace_back(unscale<float>(pts[i].x()),
                             unscale<float>(pts[i].y()));
    }
}

References Slic3r::ExPolygon::contour, Slic3r::Polygon::equally_spaced_points(), Slic3r::ExPolygon::holes, sample_expolygon_boundary(), and scale_.

Referenced by sample_expolygon_boundary(), and sample_expolygon_with_boundary().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_expolygon_with_boundary() [1/2]

std::vector< Vec2f > Slic3r::sla::sample_expolygon_with_boundary	(	const ExPolygon &	expoly,
		float	samples_per_mm2,
		float	samples_per_mm_boundary,
		std::mt19937 &	rng
	)

{
    std::vector<Vec2f> out = sample_expolygon(expoly, samples_per_mm2, rng);
    sample_expolygon_boundary(expoly, samples_per_mm_boundary, out, rng);
    return out;
}

References sample_expolygon(), sample_expolygon_boundary(), and sample_expolygon_with_boundary().

Referenced by sample_expolygon_with_boundary(), sample_expolygon_with_boundary(), and Slic3r::sla::SupportPointGenerator::uniformly_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

sample_expolygon_with_boundary() [2/2]

std::vector< Vec2f > Slic3r::sla::sample_expolygon_with_boundary	(	const ExPolygons &	expolys,
		float	samples_per_mm2,
		float	samples_per_mm_boundary,
		std::mt19937 &	rng
	)

{
    std::vector<Vec2f> out;
    for (const ExPolygon &expoly : expolys)
        append(out, sample_expolygon_with_boundary(expoly, samples_per_mm2, samples_per_mm_boundary, rng));
    return out;
}

References sample_expolygon_with_boundary().

Here is the call graph for this function:

search_ground_route()

template<class Ex >

std::pair< bool, long > Slic3r::sla::search_ground_route	(	Ex	policy,
		SupportTreeBuilder &	builder,
		const SupportableMesh &	sm,
		const Junction &	j,
		double	end_radius,
		const Vec3d &	init_dir = DOWN
	)

{
    double downdst = j.pos.z() - ground_level(sm);
 
    auto res = connect_to_ground(policy, builder, sm, j, init_dir, end_radius);
    if (res.first)
        return res;
 
         // Optimize bridge direction:
         // Straight path failed so we will try to search for a suitable
         // direction out of the cavity.
    auto [polar, azimuth] = dir_to_spheric(init_dir);
 
    Optimizer<AlgNLoptGenetic> solver(get_criteria(sm.cfg).stop_score(1e6));
    solver.seed(0); // we want deterministic behavior
 
    auto   sd  = j.r * sm.cfg.safety_distance_mm / sm.cfg.head_back_radius_mm;
    auto oresult = solver.to_max().optimize(
        [&j, sd, &policy, &sm, &downdst, &end_radius](const opt::Input<2> &input) {
            auto &[plr, azm] = input;
            Vec3d n = spheric_to_dir(plr, azm).normalized();
            Beam beam{Ball{j.pos, j.r}, Ball{j.pos + downdst * n, end_radius}};
            return beam_mesh_hit(policy, sm.emesh, beam, sd).distance();
        },
        initvals({polar, azimuth}),  // let's start with what we have
        bounds({ {PI - sm.cfg.bridge_slope, PI}, {-PI, PI} })
        );
 
    Vec3d bridgedir = spheric_to_dir(oresult.optimum).normalized();
 
    return connect_to_ground(policy, builder, sm, j, bridgedir, end_radius);
}

References beam_mesh_hit(), Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, connect_to_ground(), Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, get_criteria(), ground_level(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, input(), Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, Slic3r::sla::Junction::pos, Slic3r::sla::Junction::r, Slic3r::sla::SupportTreeConfig::safety_distance_mm, Slic3r::opt::Optimizer< Method, Enable >::seed(), Slic3r::opt::StopCriteria::stop_score(), and Slic3r::opt::Optimizer< Method, Enable >::to_max().

Referenced by Slic3r::sla::DefaultSupportTree::connect_to_ground().

Here is the call graph for this function:

Here is the caller graph for this function:

search_widening_path()

template<class Ex >

std::optional< DiffBridge > Slic3r::sla::search_widening_path	(	Ex	policy,
		const SupportableMesh &	sm,
		const Vec3d &	jp,
		const Vec3d &	dir,
		double	radius,
		double	new_radius
	)

{
    double w = radius + 2 * sm.cfg.head_back_radius_mm;
    double stopval = w + jp.z() - ground_level(sm);
    Optimizer<AlgNLoptSubplex> solver(get_criteria(sm.cfg).stop_score(stopval));
 
    auto [polar, azimuth] = dir_to_spheric(dir);
 
    double fallback_ratio = radius / sm.cfg.head_back_radius_mm;
 
    auto oresult = solver.to_max().optimize(
        [&policy, &sm, jp, radius, new_radius](const opt::Input<3> &input) {
            auto &[plr, azm, t] = input;
 
            auto d = spheric_to_dir(plr, azm).normalized();
 
            auto sd = sm.cfg.safety_distance(new_radius);
 
            double ret = pinhead_mesh_hit(policy, sm.emesh, jp, d, radius,
                                          new_radius, t, sd)
                             .distance();
 
            Beam beam{jp + t * d, d, new_radius};
            double down = beam_mesh_hit(policy, sm.emesh, beam, sd).distance();
 
            if (ret > t && std::isinf(down))
                ret += jp.z() - ground_level(sm);
 
            return ret;
        },
        initvals({polar, azimuth, w}), // start with what we have
        bounds({
            {PI - sm.cfg.bridge_slope, PI}, // Must not exceed the slope limit
            {-PI, PI}, // azimuth can be a full search
            {radius + sm.cfg.head_back_radius_mm,
             fallback_ratio * sm.cfg.max_bridge_length_mm}
        }));
 
    if (oresult.score >= stopval) {
        polar       = std::get<0>(oresult.optimum);
        azimuth     = std::get<1>(oresult.optimum);
        double t    = std::get<2>(oresult.optimum);
        Vec3d  endp = jp + t * spheric_to_dir(polar, azimuth);
 
        return DiffBridge(jp, endp, radius, sm.cfg.head_back_radius_mm);
    }
 
    return {};
}

References beam_mesh_hit(), Slic3r::sla::SupportTreeConfig::bridge_slope, Slic3r::sla::SupportableMesh::cfg, Slic3r::AABBMesh::hit_result::distance(), Slic3r::sla::SupportableMesh::emesh, get_criteria(), ground_level(), Slic3r::sla::SupportTreeConfig::head_back_radius_mm, input(), Slic3r::sla::SupportTreeConfig::max_bridge_length_mm, Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, pinhead_mesh_hit(), Slic3r::sla::SupportTreeConfig::safety_distance(), Slic3r::opt::StopCriteria::stop_score(), and Slic3r::opt::Optimizer< Method, Enable >::to_max().

Referenced by create_ground_pillar(), and Slic3r::sla::DefaultSupportTree::search_widening_path().

Here is the call graph for this function:

Here is the caller graph for this function:

slice()

std::vector< ExPolygons > Slic3r::sla::slice	(	const indexed_triangle_set &	sup_mesh,
		const indexed_triangle_set &	pad_mesh,
		const std::vector< float > &	grid,
		float	cr,
		const JobController &	ctl
	)

{
    using Slices = std::vector<ExPolygons>;
 
    auto slices = reserve_vector<Slices>(2);
 
    if (!sup_mesh.empty()) {
        slices.emplace_back();
        slices.back() = slice_mesh_ex(sup_mesh, grid, cr, ctl.cancelfn);
    }
 
    if (!pad_mesh.empty()) {
        slices.emplace_back();
 
        auto bb     = bounding_box(pad_mesh);
        auto maxzit = std::upper_bound(grid.begin(), grid.end(), bb.max.z());
 
        auto cap     = grid.end() - maxzit;
        auto padgrid = reserve_vector<float>(size_t(cap > 0 ? cap : 0));
        std::copy(grid.begin(), maxzit, std::back_inserter(padgrid));
 
        slices.back() = slice_mesh_ex(pad_mesh, padgrid, cr, ctl.cancelfn);
    }
 
    size_t len = grid.size();
    for (const Slices &slv : slices)
        len = std::min(len, slv.size());
 
    // Either the support or the pad or both has to be non empty
    if (slices.empty()) return {};
 
    Slices &mrg = slices.front();
 
    for (auto it = std::next(slices.begin()); it != slices.end(); ++it) {
        for (size_t i = 0; i < len; ++i) {
            Slices &slv = *it;
            std::copy(slv[i].begin(), slv[i].end(), std::back_inserter(mrg[i]));
            slv[i] = {}; // clear and delete
        }
    }
 
    return mrg;
}

References Slic3r::bounding_box(), Slic3r::sla::JobController::cancelfn, indexed_triangle_set::empty(), Slic3r::grid(), and Slic3r::slice_mesh_ex().

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

Here is the call graph for this function:

Here is the caller graph for this function:

sphere()

indexed_triangle_set Slic3r::sla::sphere	(	double	rho,
		Portion	portion,
		double	fa
	)

                                                                    {
 
    indexed_triangle_set ret;
 
    // prohibit close to zero radius
    if(rho <= 1e-6 && rho >= -1e-6) return ret;
 
    auto& vertices = ret.vertices;
    auto& facets = ret.indices;
 
    // Algorithm:
    // Add points one-by-one to the sphere grid and form facets using relative
    // coordinates. Sphere is composed effectively of a mesh of stacked circles.
 
    // adjust via rounding to get an even multiple for any provided angle.
    double angle = (2 * PI / floor(2*PI / fa) );
 
    // Ring to be scaled to generate the steps of the sphere
    std::vector<double> ring;
 
    for (double i = 0; i < 2*PI; i+=angle) ring.emplace_back(i);
 
    const auto sbegin = size_t(2*std::get<0>(portion)/angle);
    const auto send = size_t(2*std::get<1>(portion)/angle);
 
    const size_t steps = ring.size();
    const double increment = 1.0 / double(steps);
 
    // special case: first ring connects to 0,0,0
    // insert and form facets.
    if (sbegin == 0)
        vertices.emplace_back(
            Vec3f(0.f, 0.f, float(-rho + increment * sbegin * 2. * rho)));
 
    auto id = coord_t(vertices.size());
    for (size_t i = 0; i < ring.size(); i++) {
        // Fixed scaling
        const double z = -rho + increment*rho*2.0 * (sbegin + 1.0);
        // radius of the circle for this step.
        const double r = std::sqrt(std::abs(rho*rho - z*z));
        Vec2d b = Eigen::Rotation2Dd(ring[i]) * Eigen::Vector2d(0, r);
        vertices.emplace_back(Vec3d(b(0), b(1), z).cast<float>());
 
        if (sbegin == 0)
            (i == 0) ? facets.emplace_back(coord_t(ring.size()), 0, 1) :
                       facets.emplace_back(id - 1, 0, id);
        ++id;
    }
 
    // General case: insert and form facets for each step,
    // joining it to the ring below it.
    for (size_t s = sbegin + 2; s < send - 1; s++) {
        const double z = -rho + increment * double(s * 2. * rho);
        const double r = std::sqrt(std::abs(rho*rho - z*z));
 
        for (size_t i = 0; i < ring.size(); i++) {
            Vec2d b = Eigen::Rotation2Dd(ring[i]) * Eigen::Vector2d(0, r);
            vertices.emplace_back(Vec3d(b(0), b(1), z).cast<float>());
            auto id_ringsize = coord_t(id - int(ring.size()));
            if (i == 0) {
                // wrap around
                facets.emplace_back(id - 1, id, id + coord_t(ring.size() - 1) );
                facets.emplace_back(id - 1, id_ringsize, id);
            } else {
                facets.emplace_back(id_ringsize - 1, id_ringsize, id);
                facets.emplace_back(id - 1, id_ringsize - 1, id);
            }
            id++;
        }
    }
 
    // special case: last ring connects to 0,0,rho*2.0
    // only form facets.
    if(send >= size_t(2*PI / angle)) {
        vertices.emplace_back(0.f, 0.f, float(-rho + increment*send*2.0*rho));
        for (size_t i = 0; i < ring.size(); i++) {
            auto id_ringsize = coord_t(id - int(ring.size()));
            if (i == 0) {
                // third vertex is on the other side of the ring.
                facets.emplace_back(id - 1, id_ringsize, id);
            } else {
                auto ci = coord_t(id_ringsize + coord_t(i));
                facets.emplace_back(ci - 1, ci, id);
            }
        }
    }
    id++;
 
    return ret;
}

References Slic3r::angle(), floor(), indexed_triangle_set::indices, PI, and indexed_triangle_set::vertices.

Referenced by get_mesh(), and pinhead().

Here is the call graph for this function:

Here is the caller graph for this function:

swap_normals()

void Slic3r::sla::swap_normals ( indexed_triangle_set &  its )

inline

{
    for (auto &face : its.indices)
        std::swap(face(0), face(2));
}

References indexed_triangle_set::indices.

Referenced by hollow_mesh(), and hollow_mesh().

Here is the caller graph for this function:

to_vec2()

Vec2crd Slic3r::sla::to_vec2 ( const Vec3d &  v3 )

inline

{ return {coord_t(v3(X)), coord_t(v3(Y))}; }

References Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::sla::ConcaveHull::add_connector_rectangles().

Here is the caller graph for this function:

to_vec3()

Vec3d Slic3r::sla::to_vec3 ( const Vec2crd &  v2 )

inline

{ return {double(v2(X)), double(v2(Y)), 0.}; }

References Slic3r::X, and Slic3r::Y.

Referenced by Slic3r::sla::ConcaveHull::add_connector_rectangles().

Here is the caller graph for this function:

transformed_drainhole_points()

sla::DrainHoles Slic3r::sla::transformed_drainhole_points	(	const ModelObject &	mo,
		const Transform3d &	trafo
	)

vol_trafo

{
    auto pts = mo.sla_drain_holes;
//    const Transform3d& vol_trafo = mo.volumes.front()->get_transformation().get_matrix();
    const Geometry::Transformation trans(trafo );
    const Transform3d& tr = trans.get_matrix();
    for (sla::DrainHole &hl : pts) {
        Vec3d pos = hl.pos.cast<double>();
        Vec3d nrm = hl.normal.cast<double>();
 
        pos = tr * pos;
        nrm = tr * nrm - tr.translation();
 
        // Now shift the hole a bit above the object and make it deeper to
        // compensate for it. This is to avoid problems when the hole is placed
        // on (nearly) flat surface.
        pos -= nrm.normalized() * sla::HoleStickOutLength;
 
        hl.pos = pos.cast<float>();
        hl.normal = nrm.cast<float>();
        hl.height += sla::HoleStickOutLength;
    }
 
    return pts;
}

References Slic3r::Geometry::Transformation::get_matrix(), pos(), Slic3r::ModelObject::sla_drain_holes, transformed_drainhole_points(), and Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::translation().

Referenced by Slic3r::SLAPrintObject::transformed_drainhole_points(), and transformed_drainhole_points().

Here is the call graph for this function:

Here is the caller graph for this function:

transformed_support_points()

SupportPoints Slic3r::sla::transformed_support_points	(	const ModelObject &	mo,
		const Transform3d &	trafo
	)

{
    auto spts = mo.sla_support_points;
    Transform3f tr = trafo.cast<float>();
    for (sla::SupportPoint& suppt : spts) {
        suppt.pos = tr * suppt.pos;
    }
 
    return spts;
}

References Eigen::Transform< _Scalar, _Dim, _Mode, _Options >::cast(), Slic3r::ModelObject::sla_support_points, and transformed_support_points().

Referenced by Slic3r::SLAPrintObject::transformed_support_points(), and transformed_support_points().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

beam_ex_policy

constexpr const auto& Slic3r::sla::beam_ex_policy = ex_tbb

inlineconstexpr

Referenced by Slic3r::sla::BranchingTreeBuilder::add_bridge(), Slic3r::sla::BranchingTreeBuilder::add_ground_bridge(), Slic3r::sla::BranchingTreeBuilder::add_merger(), Slic3r::sla::BranchingTreeBuilder::add_mesh_bridge(), and Slic3r::sla::BranchingTreeBuilder::suggest_avoidance().

BeamSamplesV

template<class WFn >

constexpr size_t Slic3r::sla::BeamSamplesV = BeamSamples<remove_cvref_t<WFn>>::Value

constexpr

DOWN

const Vec3d Slic3r::sla::DOWN = {0.0, 0.0, -1.0}

Referenced by Slic3r::sla::DefaultSupportTree::classify(), Slic3r::sla::DefaultSupportTree::connect_to_model_body(), Slic3r::sla::DefaultSupportTree::connect_to_nearpillar(), find_min_z_height_rotation(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_chull_rotations(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_supportedness_score(), and Slic3r::sla::BranchingTreeBuilder::suggest_avoidance().

HoleStickOutLength

constexpr float Slic3r::sla::HoleStickOutLength = 1.f

constexpr

Referenced by Slic3r::GUI::GLGizmoHollow::render_points(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

IsWideningFn

template<class Fn >

constexpr bool Slic3r::sla::IsWideningFn

constexpr

Initial value:

= std::is_invocable_r_v< double,
                                                    Fn,
                                                    Ball ,
                                                    Vec3d ,
                                                    double >

Referenced by deepsearch_ground_connection().

suptree_ex_policy

constexpr const auto& Slic3r::sla::suptree_ex_policy = ex_tbb

inlineconstexpr

Referenced by Slic3r::sla::DefaultSupportTree::add_pinheads(), Slic3r::sla::DefaultSupportTree::bridge_mesh_intersect(), Slic3r::sla::DefaultSupportTree::connect_to_ground(), Slic3r::sla::DefaultSupportTree::create_ground_pillar(), Slic3r::sla::DefaultSupportTree::pinhead_mesh_intersect(), Slic3r::sla::DefaultSupportTree::routing_to_model(), and Slic3r::sla::DefaultSupportTree::search_widening_path().