Slic3r::sla Namespace Reference

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

Classes
struct	Colors
class	AGGRaster
class	RasterGrayscaleAA
class	RasterGrayscaleAAGammaPower
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...
struct	_ccr
struct	_ccr< true >
struct	_ccr< false >
struct	Interior
struct	TriangleBubble
struct	DivFace
struct	HollowingConfig
struct	InteriorDeleter
struct	DrainHole
class	IndexedMesh
	An index-triangle structure for libIGL functions. Also serves as an alternative (raw) input format for the SLASupportTree. More...
struct	JobController
	A Control structure for the support calculation. Consists of the status indicator callback and the stop condition predicate. More...
struct	PadConfig
class	EncodedRaster
struct	Resolution
	Type that represents a resolution in pixels. More...
struct	PixelDim
	Types that represents the dimension of a pixel in millimeters. More...
class	RasterBase
struct	PNGRasterEncoder
struct	PPMRasterEncoder
struct	RotfinderBoilerplate
class	RotOptimizeParams
class	PointIndex
class	BoxIndex
struct	SupportPoint
class	SupportPointGenerator
struct	SupportTreeConfig
struct	SupportableMesh
class	SupportTree
	The class containing mesh data for the generated supports. More...
struct	SupportTreeNode
struct	Head
struct	Junction
struct	Pillar
struct	Pedestal
struct	Anchor
struct	Bridge
struct	DiffBridge
struct	Pad
class	SupportTreeBuilder
class	PointRing
class	PillarIndex
class	SupportTreeBuildsteps
class	StopCriteria
class	Optimizer

Typedefs
using	_RasterGrayscaleAA
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	ccr = _ccr<USE_FULL_CONCURRENCY>
using	ccr_seq = _ccr<false>
using	ccr_par = _ccr<true>
using	InteriorPtr = std::unique_ptr<Interior, InteriorDeleter>
using	DrainHoles = std::vector<DrainHole>
using	PointSet = Eigen::MatrixXd
using	RasterEncoder
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	AlgNLoptSubplex
using	AlgNLoptGenetic

Enumerations
enum	{ NEW_FACE = -1 }
enum	HollowingFlags { hfRemoveInsideTriangles = 0x1 }
enum class	PointsStatus { NoPoints , Generating , AutoGenerated , UserModified }
enum class	PillarConnectionMode { zigzag , cross , dynamic }
enum class	MeshType { Support , Pad }
enum	{ X , Y , Z }

Functions
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)
Vec3d	to_vec3 (const Vec2d &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)
indexed_triangle_set &	get_mesh (Interior &interior)
const indexed_triangle_set &	get_mesh (const Interior &interior)
static InteriorPtr	generate_interior_verbose (const TriangleMesh &mesh, const JobController &ctl, double min_thickness, double voxel_scale, double closing_dist)
InteriorPtr	generate_interior (const TriangleMesh &mesh, 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)
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 Fn>
void	divide_triangle (const DivFace &face, Fn &&visitor)
void	remove_inside_triangles (TriangleMesh &mesh, const Interior &interior, const std::vector< bool > &exclude_mask)
template<class T>
FloatingOnly< T >	get_distance (const Vec< 3, T > &p, const Interior &interior)
void	swap_normals (indexed_triangle_set &its)
static bool	point_on_edge (const Vec3d &p, const Vec3d &e1, const Vec3d &e2, double eps=0.05)
PointSet	normals (const PointSet &points, const IndexedMesh &mesh, double eps, std::function< void()> thr, const std::vector< unsigned > &pt_indices)
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, Vec2i32 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 IndexedMesh &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)
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)
template<class Vec>
double	distance (const Vec &p)
template<class Vec>
double	distance (const Vec &pp1, const Vec &pp2)
StopCriteria	get_criteria (const SupportTreeConfig &cfg)
template<class C, class Hit = IndexedMesh::hit_result>
static Hit	min_hit (const C &hits)
std::pair< double, double >	dir_to_spheric (const Vec3d &n, double norm=1.)
Vec3d	spheric_to_dir (double polar, double azimuth)
Vec3d	spheric_to_dir (const std::tuple< double, double > &v)
Vec3d	spheric_to_dir (const std::pair< double, double > &v)
Vec3d	spheric_to_dir (const std::array< double, 2 > &v)
Vec3d	dirv (const Vec3d &startp, const Vec3d &endp)
template<class I, class DoubleI = IntegerOnly<I>>
IntegerOnly< DoubleI >	pairhash (I a, I b)
indexed_triangle_set	sphere (double rho, Portion portion, double fa)
indexed_triangle_set	cylinder (double r, double h, size_t ssteps, const Vec3d &sp)
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)
Portion	make_portion (double a, double b)
indexed_triangle_set	get_mesh (const Head &h, size_t steps)
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)
indexed_triangle_set	get_mesh (const Bridge &br, size_t steps)
indexed_triangle_set	get_mesh (const DiffBridge &br, size_t steps)
template<size_t N>
Input< N >	initvals (const double(&a)[N])
template<size_t N>
Bounds< N >	bounds (const Bound(&b)[N])

Variables
template<class Color>
const Color	Colors< Color >::White = Color{255}
template<class Color>
const Color	Colors< Color >::Black = Color{0}
const constexpr bool	USE_FULL_CONCURRENCY = true
constexpr float	HoleStickOutLength = 1.f
const Vec3d	DOWN = {0.0, 0.0, -1.0}
const double	D_SP = 0.1

---

Class Documentation

Slic3r::sla::_ccr

struct Slic3r::sla::_ccr

template<bool>
struct Slic3r::sla::_ccr< bool >

Inheritance diagram for Slic3r::sla::_ccr< bool >:

Slic3r::sla::TriangleBubble

struct Slic3r::sla::TriangleBubble

Class Members
Vec3f	center
double	R

Slic3r::sla::DivFace

struct Slic3r::sla::DivFace

Collaboration diagram for Slic3r::sla::DivFace:

Class Members
long	faceid = NEW_FACE
Vec3i32	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 std::function<void(void)>
typedef function< void(unsigned, const string &)>	StatusFn std::function<void(unsigned, const std::string&)>
typedef function< bool(void)>	StopCond std::function<bool(void)>

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

Typedef Documentation

_RasterGrayscaleAA

using Slic3r::sla::_RasterGrayscaleAA

Initial value:

 
    AGGRaster<agg::pixfmt_gray8, agg::renderer_scanline_aa_solid>

AlgNLoptGenetic

using Slic3r::opt::AlgNLoptGenetic

AlgNLoptSubplex

using Slic3r::opt::AlgNLoptSubplex

BoxIndexEl

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

ccr

using Slic3r::sla::ccr = _ccr<USE_FULL_CONCURRENCY>

ccr_par

using Slic3r::sla::ccr_par = _ccr<true>

ccr_seq

using Slic3r::sla::ccr_seq = _ccr<false>

ClusteredPoints

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

ClusterEl

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

DrainHoles

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

Index3D

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

InteriorPtr

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

PointIndexEl

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

PointSet

using Slic3r::sla::PointSet = Eigen::MatrixXd

Portion

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

RasterEncoder

using Slic3r::sla::RasterEncoder

Initial value:

 
    std::function<EncodedRaster(const void *ptr, size_t w, size_t h, size_t num_components)>

RotOptimizeStatusCB

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

SupportPoints

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

ThrowOnCancel

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

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};

anonymous enum

anonymous enum

Enumerator
X
Y
Z

     { // For indexing Eigen vectors as v(X), v(Y), v(Z) instead of numbers
    X, Y, Z
};

HollowingFlags

enum Slic3r::sla::HollowingFlags

Enumerator
hfRemoveInsideTriangles

{ hfRemoveInsideTriangles = 0x1 };

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.
};

Function Documentation

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>()};
}

Referenced by find_min_z_height_rotation().

Here is the caller graph for this function:

bounds()

template<size_t N>

Bounds< N > Slic3r::opt::bounds

(

const Bound(&)

b[N]

)

{ return detail::to_arr(b); }

Referenced by Slic3r::sla::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::filter(), find_best_misalignment_rotation(), find_least_supports_rotation(), and Slic3r::sla::SupportTreeBuildsteps::search_widening_path().

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(), and Slic3r::Geometry::dist().

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(), and Slic3r::Geometry::dist().

Referenced by Slic3r::sla::SupportTreeBuildsteps::classify(), cluster(), cluster(), cluster(), and Slic3r::sla::SupportTreeBuildsteps::filter().

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());
}

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

Here is the caller graph for this function:

create_pad()

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::sla::Pad::Pad().

Here is the call graph for this function:

Here is the caller 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::SL1Archive::create_raster(), Slic3r::GUI::CreateFontImageJob::process(), and Slic3r::GUI::Emboss::CreateFontStyleImagesJob::process().

Here is the caller 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::diff_ex(), Slic3r::TriangleMesh::empty(), Slic3r::holes(), Slic3r::TriangleMesh::its, Slic3r::TriangleMesh::merge(), and Slic3r::slice_mesh_ex().

Here is the call graph for this function:

cylinder()

indexed_triangle_set Slic3r::sla::cylinder	(	double	r,
		double	h,
		size_t	ssteps,
		const Vec3d &	sp )

{
    assert(ssteps > 0);
 
    indexed_triangle_set ret;
 
    auto steps = int(ssteps);
    auto& points = ret.vertices;
    auto& indices = ret.indices;
    points.reserve(2*ssteps);
    double a = 2*PI/steps;
 
    Vec3d jp = sp;
    Vec3d endp = {sp(X), sp(Y), sp(Z) + h};
 
    // Upper circle points
    for(int i = 0; i < steps; ++i) {
        double phi = i*a;
        auto ex = float(endp(X) + r*std::cos(phi));
        auto ey = float(endp(Y) + r*std::sin(phi));
        points.emplace_back(ex, ey, float(endp(Z)));
    }
 
    // Lower circle points
    for(int i = 0; i < steps; ++i) {
        double phi = i*a;
        auto x = float(jp(X) + r*std::cos(phi));
        auto y = float(jp(Y) + r*std::sin(phi));
        points.emplace_back(x, y, float(jp(Z)));
    }
 
    // Now create long triangles connecting upper and lower circles
    indices.reserve(2*ssteps);
    auto offs = steps;
    for(int i = 0; i < steps - 1; ++i) {
        indices.emplace_back(i, i + offs, offs + i + 1);
        indices.emplace_back(i, offs + i + 1, i + 1);
    }
 
    // Last triangle connecting the first and last vertices
    auto last = steps - 1;
    indices.emplace_back(0, last, offs);
    indices.emplace_back(last, offs + last, offs);
 
    // According to the slicing algorithms, we need to aid them with generating
    // a watertight body. So we create a triangle fan for the upper and lower
    // ending of the cylinder to close the geometry.
    points.emplace_back(jp.cast<float>()); int ci = int(points.size() - 1);
    for(int i = 0; i < steps - 1; ++i)
        indices.emplace_back(i + offs + 1, i + offs, ci);
 
    indices.emplace_back(offs, steps + offs - 1, ci);
 
    points.emplace_back(endp.cast<float>()); ci = int(points.size() - 1);
    for(int i = 0; i < steps - 1; ++i)
        indices.emplace_back(ci, i, i + 1);
 
    indices.emplace_back(steps - 1, 0, ci);
 
    return ret;
}

References PI, X, Y, and Z.

Referenced by get_mesh(), get_mesh(), and Slic3r::sla::DrainHole::to_mesh().

Here is the caller graph for this function:

dir_to_spheric()

std::pair< double, double > Slic3r::sla::dir_to_spheric ( const Vec3d & n, double norm = 1. )

inline

{
    double z       = n.z();
    double r       = norm;
    double polar   = std::acos(z / r);
    double azimuth = std::atan2(n(1), n(0));
    return {polar, azimuth};
}

Referenced by Slic3r::sla::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::create_ground_pillar(), Slic3r::sla::SupportTreeBuildsteps::filter(), and Slic3r::sla::SupportTreeBuildsteps::search_widening_path().

Here is the caller graph for this function:

dirv()

Vec3d Slic3r::sla::dirv ( const Vec3d & startp, const Vec3d & endp )

inline

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

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

Here is the caller graph for this function:

distance() [1/2]

template<class Vec>

double Slic3r::sla::distance

(

const Vec &

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 std::sqrt(p.transpose() * p);
}

Referenced by Slic3r::sla::SupportTreeBuildsteps::classify(), Slic3r::sla::SupportTreeBuildsteps::connect_to_nearpillar(), distance(), Slic3r::sla::SupportTreeBuildsteps::interconnect(), Slic3r::sla::SupportTreeBuildsteps::interconnect_pillars(), and Slic3r::sla::SupportTreeBuildsteps::routing_to_ground().

Here is the caller graph for this function:

distance() [2/2]

template<class Vec>

double Slic3r::sla::distance	(	const Vec &	pp1,
		const Vec &	pp2 )

                                                                    {
    auto p = pp2 - pp1;
    return distance(p);
}

References distance().

Here is the call graph for this function:

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:

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(), bounds(), Slic3r::opt::initvals(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::max_tries, Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::mesh, Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::statusfn(), 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(), bounds(), Slic3r::ModelObject::config, Slic3r::ModelConfig::get(), Slic3r::opt::initvals(), Slic3r::opt::StopCriteria::max_iterations(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::max_tries, Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::mesh, Slic3r::opt::Optimizer< Method, Enable >::optimize(), PI, Slic3r::sla::RotOptimizeParams::print_config(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::statusfn(), Slic3r::opt::StopCriteria::stop_condition(), and Slic3r::opt::Optimizer< Method, Enable >::to_min().

Here is the call 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, Slic3r::TriangleMesh::its, Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::max_tries, Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::mesh, Slic3r::reserve_vector(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::sla::RotfinderBoilerplate< MAX_ITER >::statusfn(), X, and 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);
}

Referenced by raster_to_polygons().

Here is the caller graph for this function:

generate_interior()

InteriorPtr Slic3r::sla::generate_interior	(	const TriangleMesh &	mesh,
		const HollowingConfig &	hc,
		const JobController &	ctl )

{
    static const double MIN_OVERSAMPL = 3.5;
    static const double MAX_OVERSAMPL = 8.;
 
    // 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.
    //
    // max 8x upscale, min is native voxel size
    auto voxel_scale = MIN_OVERSAMPL + (MAX_OVERSAMPL - MIN_OVERSAMPL) * hc.quality;
 
    InteriorPtr interior =
        generate_interior_verbose(mesh, ctl, hc.min_thickness, voxel_scale,
                                  hc.closing_distance);
 
    if (interior && !interior->mesh.empty()) {
 
        // flip normals back...
        swap_normals(interior->mesh);
 
        // simplify mesh lossless
        float loss_less_max_error = 2*std::numeric_limits<float>::epsilon();
        its_quadric_edge_collapse(interior->mesh, 0U, &loss_less_max_error);
 
        its_compactify_vertices(interior->mesh);
        its_merge_vertices(interior->mesh);
 
        // flip normals back...
        swap_normals(interior->mesh);
    }
 
    return interior;
}

References Slic3r::sla::HollowingConfig::closing_distance, generate_interior_verbose(), Slic3r::its_compactify_vertices(), Slic3r::its_merge_vertices(), Slic3r::its_quadric_edge_collapse(), Slic3r::sla::Interior::mesh, Slic3r::sla::HollowingConfig::min_thickness, Slic3r::sla::HollowingConfig::quality, and swap_normals().

Referenced by hollow_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_interior_verbose()

InteriorPtr Slic3r::sla::generate_interior_verbose ( const TriangleMesh & mesh, const JobController & ctl, double min_thickness, double voxel_scale, double closing_dist )

static

{
    double offset = voxel_scale * min_thickness;
    double D = voxel_scale * closing_dist;
    float  out_range = 0.1f * float(offset);
    float  in_range = 1.1f * float(offset + D);
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(0, L("Hollowing"));
 
    auto gridptr = mesh_to_grid(mesh.its, {}, voxel_scale, out_range, in_range);
 
    assert(gridptr);
 
    if (!gridptr) {
        BOOST_LOG_TRIVIAL(error) << "Returned OpenVDB grid is NULL";
        return {};
    }
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(30, L("Hollowing"));
 
    double iso_surface = D;
    auto   narrowb = double(in_range);
    gridptr = redistance_grid(*gridptr, -(offset + D), narrowb, narrowb);
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(70, L("Hollowing"));
 
    double adaptivity = 0.;
    InteriorPtr interior = InteriorPtr{new Interior{}};
 
    interior->mesh = grid_to_mesh(*gridptr, iso_surface, adaptivity);
    interior->gridptr = gridptr;
 
    if (ctl.stopcondition()) return {};
    else ctl.statuscb(100, L("Hollowing"));
 
    interior->closing_distance = D;
    interior->thickness = offset;
    interior->voxel_scale = voxel_scale;
    interior->nb_in = narrowb;
    interior->nb_out = narrowb;
 
    return interior;
}

References Slic3r::sla::Interior::closing_distance, Slic3r::grid_to_mesh(), Slic3r::sla::Interior::gridptr, Slic3r::TriangleMesh::its, L, Slic3r::sla::Interior::mesh, Slic3r::mesh_to_grid(), Slic3r::sla::Interior::nb_in, Slic3r::sla::Interior::nb_out, Slic3r::offset(), Slic3r::redistance_grid(), Slic3r::sla::JobController::statuscb, Slic3r::sla::JobController::stopcondition, Slic3r::sla::Interior::thickness, and Slic3r::sla::Interior::voxel_scale.

Referenced by generate_interior().

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

)

{
    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::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::filter(), and Slic3r::sla::SupportTreeBuildsteps::search_widening_path().

Here is the call graph for this function:

Here is the caller graph for this function:

get_distance() [1/3]

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

static

{
    double R = b.R * interior.voxel_scale;
    double D = get_distance_raw(b.center, interior);
 
    return (D > 0. && R >= interior.nb_out) ||
           (D < 0. && R >= interior.nb_in)  ||
           ((D - R) < 0. && 2 * R > interior.thickness) ?
                std::nan("") :
                // FIXME: Adding interior.voxel_scale is a compromise supposed
                // to prevent the deletion of the triangles forming the interior
                // itself. This has a side effect that a small portion of the
                // bad triangles will still be visible.
                D - interior.closing_distance /*+ 2 * interior.voxel_scale*/;
}

References Slic3r::sla::TriangleBubble::center, Slic3r::sla::Interior::closing_distance, get_distance_raw(), Slic3r::sla::Interior::nb_in, Slic3r::sla::Interior::nb_out, Slic3r::sla::TriangleBubble::R, Slic3r::sla::Interior::thickness, and Slic3r::sla::Interior::voxel_scale.

Referenced by Slic3r::create_exclude_mask(), 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 )

{
    double d = get_distance_raw(p, interior) - interior.closing_distance;
    return d / interior.voxel_scale;
}

References Slic3r::sla::Interior::closing_distance, get_distance_raw(), and Slic3r::sla::Interior::voxel_scale.

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 Slic3r::cast(), and get_distance().

Here is the call graph for this function:

get_distance_raw()

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

static

{
    assert(interior.gridptr);
 
    if (!interior.accessor) interior.reset_accessor();
 
    auto v       = (p * interior.voxel_scale).cast<double>();
    auto grididx = interior.gridptr->transform().worldToIndexCellCentered(
        {v.x(), v.y(), v.z()});
 
    return interior.accessor->getValue(grididx) ;
}

References Slic3r::sla::Interior::accessor, Slic3r::cast(), Slic3r::sla::Interior::gridptr, Slic3r::sla::Interior::reset_accessor(), and Slic3r::sla::Interior::voxel_scale.

Referenced by get_distance(), and get_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

get_mesh() [1/8]

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

inline

{
    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, and Slic3r::sla::Bridge::startp.

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 )

inline

{
    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::cast(), Slic3r::sla::DiffBridge::end_r, Slic3r::sla::Bridge::get_dir(), Slic3r::sla::Bridge::get_length(), halfcone(), Slic3r::sla::Bridge::r, and Slic3r::sla::Bridge::startp.

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 )

inline

{
    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(), Slic3r::sla::Head::pos, pos(), Slic3r::sla::Head::r_back_mm, Slic3r::sla::Head::r_pin_mm, 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, Slic3r::sla::Junction::pos, pos(), Slic3r::sla::Junction::r, and sphere().

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, p.height, steps, p.endpoint());
    }
 
    return {};
}

References cylinder(), Slic3r::sla::Pillar::endpoint(), EPSILON, Slic3r::sla::Pillar::height, and Slic3r::sla::Pillar::r.

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::create_exclude_mask(), Slic3r::SLAPrint::Steps::hollow_model(), Slic3r::SLAPrintObject::hollowed_interior_mesh(), Slic3r::sla::SupportTreeBuilder::merged_mesh(), and Slic3r::SLAPrint::Steps::slice_model().

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) 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 PI, and pos().

Referenced by get_mesh(), and get_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

hollow_mesh() [1/2]

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

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

References generate_interior(), and hollow_mesh().

Referenced by hollow_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

hollow_mesh() [2/2]

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);
 
    mesh.merge(TriangleMesh{interior.mesh});
}

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

Here is the call graph for this function:

initvals()

template<size_t N>

Input< N > Slic3r::opt::initvals

(

const double(&)

a[N]

)

{ return detail::to_arr(a); }

Referenced by Slic3r::sla::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::filter(), and Slic3r::sla::SupportTreeBuildsteps::search_widening_path().

Here is the caller graph for this function:

make_layers()

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);
 
    ccr_par::for_each(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.
    ccr_par::for_each(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, jtSquare);
                  auto overh_mask = expand(bottom_polygons, slope_offset, 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::sla::_ccr< true >::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 C, class Hit = IndexedMesh::hit_result>

Hit Slic3r::sla::min_hit ( const C & hits )

static

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

normals()

PointSet Slic3r::sla::normals	(	const PointSet &	points,
		const IndexedMesh &	mesh,
		double	eps,
		std::function< void()>	thr,
		const std::vector< unsigned > &	pt_indices )

{
    if (points.rows() == 0 || mesh.vertices().empty() || mesh.indices().empty())
        return {};
 
    std::vector<unsigned> range = pt_indices;
    if (range.empty()) {
        range.resize(size_t(points.rows()), 0);
        std::iota(range.begin(), range.end(), 0);
    }
 
    PointSet ret(range.size(), 3);
 
    //    for (size_t ridx = 0; ridx < range.size(); ++ridx)
    ccr::for_each(size_t(0), range.size(),
        [&ret, &mesh, &points, thr, eps, &range](size_t ridx) {
            thr();
            unsigned el = range[ridx];
            auto  eidx   = Eigen::Index(el);
            int   faceid = 0;
            Vec3d p;
 
            mesh.squared_distance(points.row(eidx), faceid, p);
 
            auto trindex = mesh.indices(faceid);
 
            const Vec3d &p1 = mesh.vertices(trindex(0)).cast<double>();
            const Vec3d &p2 = mesh.vertices(trindex(1)).cast<double>();
            const Vec3d &p3 = mesh.vertices(trindex(2)).cast<double>();
 
            // We should check if the point lies on an edge of the hosting
            // triangle. If it does then all the other triangles using the
            // same two points have to be searched and the final normal should
            // be some kind of aggregation of the participating triangle
            // normals. We should also consider the cases where the support
            // point lies right on a vertex of its triangle. The procedure is
            // the same, get the neighbor triangles and calculate an average
            // normal.
 
            // mark the vertex indices of the edge. ia and ib marks and edge
            // ic will mark a single vertex.
            int ia = -1, ib = -1, ic = -1;
 
            if (std::abs((p - p1).norm()) < eps) {
                ic = trindex(0);
            } else if (std::abs((p - p2).norm()) < eps) {
                ic = trindex(1);
            } else if (std::abs((p - p3).norm()) < eps) {
                ic = trindex(2);
            } else if (point_on_edge(p, p1, p2, eps)) {
                ia = trindex(0);
                ib = trindex(1);
            } else if (point_on_edge(p, p2, p3, eps)) {
                ia = trindex(1);
                ib = trindex(2);
            } else if (point_on_edge(p, p1, p3, eps)) {
                ia = trindex(0);
                ib = trindex(2);
            }
 
            // vector for the neigboring triangles including the detected one.
            std::vector<size_t> neigh;
            if (ic >= 0) { // The point is right on a vertex of the triangle
                for (size_t n = 0; n < mesh.indices().size(); ++n) {
                    thr();
                    Vec3i32 ni = mesh.indices(n);
                    if ((ni(X) == ic || ni(Y) == ic || ni(Z) == ic))
                        neigh.emplace_back(n);
                }
            } else if (ia >= 0 && ib >= 0) { // the point is on and edge
                // now get all the neigboring triangles
                for (size_t n = 0; n < mesh.indices().size(); ++n) {
                    thr();
                    Vec3i32 ni = mesh.indices(n);
                    if ((ni(X) == ia || ni(Y) == ia || ni(Z) == ia) &&
                        (ni(X) == ib || ni(Y) == ib || ni(Z) == ib))
                        neigh.emplace_back(n);
                }
            }
 
            // Calculate the normals for the neighboring triangles
            std::vector<Vec3d> neighnorms;
            neighnorms.reserve(neigh.size());
            for (size_t &tri_id : neigh)
                neighnorms.emplace_back(mesh.normal_by_face_id(tri_id));
 
            // Throw out duplicates. They would cause trouble with summing. We
            // will use std::unique which works on sorted ranges. We will sort
            // by the coefficient-wise sum of the normals. It should force the
            // same elements to be consecutive.
            std::sort(neighnorms.begin(), neighnorms.end(),
                      [](const Vec3d &v1, const Vec3d &v2) {
                          return v1.sum() < v2.sum();
                      });
 
            auto lend = std::unique(neighnorms.begin(), neighnorms.end(),
                                    [](const Vec3d &n1, const Vec3d &n2) {
                                        // Compare normals for equivalence.
                                        // This is controvers stuff.
                                        auto deq = [](double a, double b) {
                                            return std::abs(a - b) < 1e-3;
                                        };
                                        return deq(n1(X), n2(X)) &&
                                               deq(n1(Y), n2(Y)) &&
                                               deq(n1(Z), n2(Z));
                                    });
 
            if (!neighnorms.empty()) { // there were neighbors to count with
                // sum up the normals and then normalize the result again.
                // This unification seems to be enough.
                Vec3d sumnorm(0, 0, 0);
                sumnorm = std::accumulate(neighnorms.begin(), lend, sumnorm);
                sumnorm.normalize();
                ret.row(long(ridx)) = sumnorm;
            } else { // point lies safely within its triangle
                Eigen::Vector3d U   = p2 - p1;
                Eigen::Vector3d V   = p3 - p1;
                ret.row(long(ridx)) = U.cross(V).normalized();
            }
        });
 
    return ret;
}

References Slic3r::sla::IndexedMesh::indices(), Slic3r::sla::IndexedMesh::normal_by_face_id(), point_on_edge(), Slic3r::range(), Slic3r::sla::IndexedMesh::vertices(), X, Y, and Z.

Referenced by Slic3r::sla::SupportTreeBuildsteps::filter().

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, 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(), Slic3r::jtRound, Slic3r::sla::ConcaveHull::polygons(), and Slic3r::scaled().

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:

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 count, Slic3r::reserve_vector(), Slic3r::scaled(), Slic3r::slice_mesh_ex(), and Slic3r::union_ex().

Referenced by Slic3r::sla::Pad::Pad(), Slic3r::SLAPrint::Steps::generate_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 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 Slic3r::I.

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

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);
 
    // 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 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:

point_on_edge()

bool Slic3r::sla::point_on_edge ( const Vec3d & p, const Vec3d & e1, const Vec3d & e2, double eps = 0.05 )

static

{
    using Line3D = Eigen::ParametrizedLine<double, 3>;
 
    auto line = Line3D::Through(e1, e2);
    double d = line.distance(p);
    return std::abs(d) < eps;
}

Referenced by normals().

Here is the caller graph for this function:

poisson_disk_from_samples()

template<typename REFUSE_FUNCTION>

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;
        Vec2i32 cell_id;
        RawSample(const Vec2f &crd = {}, const Vec2i32 &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 Vec2i32 &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<Vec2i32, PoissonDiskGridEntry, CellIDHash> Cells;
    Cells cells;
    {
        typename Cells::iterator last_cell_id_it;
        Vec2i32           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 Vec2i32          &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 + Vec2i32(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 Slic3r::cast(), poisson_disk_from_samples(), and Slic3r::reserve_vector().

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>(); }

References Slic3r::cast().

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(), and Slic3r::sla::SupportPointGenerator::uniformly_cover().

Here is the call graph for this function:

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,
		Vec2i32	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(1l, long(windowsize.y()));
    long w_cols = std::max(1l, 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();
 
    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 marchsq::execute(), foreach_vertex(), Slic3r::sla::Resolution::height_px, Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::pixel_dimensions(), Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::resolution(), Slic3r::scaled(), Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::trafo(), Slic3r::union_ex(), 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()

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

{
    enum TrPos { posInside, posTouch, posOutside };
 
    auto &faces       = mesh.its.indices;
    auto &vertices    = mesh.its.vertices;
    auto bb           = 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
    using exec_policy = ccr_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;
            exec_policy::SpinningMutex        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 TriangleMesh &mesh):
            to_remove(mesh.its.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 * interior.voxel_scale;
 
        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 end 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();
 
    exec_policy::for_each(size_t(0), faces.size(), [&] (size_t face_idx) {
        const Vec3i32 &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);
 
    }, exec_policy::max_concurreny());
 
    auto new_faces = reserve_vector<Vec3i32>(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::TriangleMesh::bounding_box(), Slic3r::BoundingBox3Base< PointType >::center(), divide_triangle(), Slic3r::f(), get_distance(), Slic3r::BoundingBox3Base< PointType >::intersects(), Slic3r::TriangleMesh::its, NEW_FACE, Slic3r::sla::TriangleBubble::R, Slic3r::BoundingBox3Base< PointType >::radius(), Slic3r::sla::Interior::reset_accessor(), Slic3r::BoundingBox3Base< PointType >::size(), Slic3r::sla::Interior::thickness, and Slic3r::sla::Interior::voxel_scale.

Referenced by hollow_mesh().

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();
    IndexedMesh 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(), Slic3r::GUI::Plater::priv::replace_volume_with_stl(), and Slic3r::GUI::Emboss::UpdateJob::update_volume().

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 IndexedMesh &	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 Slic3r::cross2(), Slic3r::reserve_vector(), 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 Slic3r::append(), and 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::contour(), Slic3r::ExPolygon::contour, Slic3r::ExPolygon::holes, sample_expolygon_boundary(), scale_, and Slic3r::unscale().

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 Slic3r::append(), and sample_expolygon_with_boundary().

Here is the call 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(), Slic3r::cast(), and PI.

Referenced by get_mesh(), and pinhead().

Here is the call graph for this function:

Here is the caller graph for this function:

spheric_to_dir() [1/4]

Vec3d Slic3r::sla::spheric_to_dir ( const std::array< double, 2 > & v )

inline

{
    return spheric_to_dir(v[0], v[1]);
}

References spheric_to_dir().

Here is the call graph for this function:

spheric_to_dir() [2/4]

Vec3d Slic3r::sla::spheric_to_dir ( const std::pair< double, double > & v )

inline

{
    return spheric_to_dir(v.first, v.second);
}

References spheric_to_dir().

Here is the call graph for this function:

spheric_to_dir() [3/4]

Vec3d Slic3r::sla::spheric_to_dir ( const std::tuple< double, double > & v )

inline

{
    auto [plr, azm] = v;
    return spheric_to_dir(plr, azm);
}

References spheric_to_dir().

Here is the call graph for this function:

spheric_to_dir() [4/4]

Vec3d Slic3r::sla::spheric_to_dir ( double polar, double azimuth )

inline

{
    return {std::cos(azimuth) * std::sin(polar),
            std::sin(azimuth) * std::sin(polar), std::cos(polar)};
}

Referenced by Slic3r::sla::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::create_ground_pillar(), Slic3r::sla::SupportTreeBuildsteps::filter(), Slic3r::sla::SupportTreeBuildsteps::search_widening_path(), spheric_to_dir(), spheric_to_dir(), and spheric_to_dir().

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));
}

Referenced by generate_interior(), and Slic3r::SLAPrint::Steps::slice_model().

Here is the caller graph for this function:

to_vec2()

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

inline

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

References X, and Y.

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

Here is the caller graph for this function:

to_vec3() [1/2]

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

inline

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

References X, and Y.

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

Here is the caller graph for this function:

to_vec3() [2/2]

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

inline

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

References X, and Y.

Variable Documentation

Colors< Color >::Black

template<class Color>

const Color Slic3r::sla::Colors< Color >::Black = Color{0}

{0};

Referenced by Slic3r::sla::RasterGrayscaleAA::RasterGrayscaleAA().

Colors< Color >::White

template<class Color>

const Color Slic3r::sla::Colors< Color >::White = Color{255}

{255};

Referenced by Slic3r::sla::RasterGrayscaleAA::RasterGrayscaleAA().

D_SP

const double Slic3r::sla::D_SP = 0.1

Referenced by Slic3r::sla::SupportTreeBuildsteps::filter().

DOWN

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

{0.0, 0.0, -1.0};

Referenced by Slic3r::sla::SupportTreeBuildsteps::classify(), Slic3r::sla::SupportTreeBuildsteps::connect_to_ground(), Slic3r::sla::SupportTreeBuildsteps::connect_to_model_body(), Slic3r::sla::SupportTreeBuildsteps::connect_to_nearpillar(), Slic3r::sla::SupportTreeBuildsteps::create_ground_pillar(), find_min_z_height_rotation(), and Slic3r::sla::SupportTreeBuildsteps::interconnect_pillars().

HoleStickOutLength

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

constexpr

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

USE_FULL_CONCURRENCY

const constexpr bool Slic3r::sla::USE_FULL_CONCURRENCY = true

constexpr