Slic3r::sla::anonymous_namespace{Rotfinder.cpp} Namespace Reference

Classes
struct	Facestats

Typedefs
using	XYRotation = std::array<double, 2>

Functions
std::array< Vec3f, 3 >	get_triangle_vertices (const TriangleMesh &mesh, size_t faceidx)
std::array< Vec3f, 3 >	get_transformed_triangle (const TriangleMesh &mesh, const Transform3f &tr, size_t faceidx)
template<class T>
Vec< 3, T >	normal (const std::array< Vec< 3, T >, 3 > &tri)
template<class T, class AccessFn>
T	sum_score (AccessFn &&accessfn, size_t facecount, size_t Nthreads)
double	get_misalginment_score (const TriangleMesh &mesh, const Transform3f &tr)
double	get_supportedness_score (const Facestats &fc)
double	get_supportedness_score (const TriangleMesh &mesh, const Transform3f &tr)
float	find_ground_level (const TriangleMesh &mesh, const Transform3f &tr, size_t threads)
float	get_supportedness_onfloor_score (const TriangleMesh &mesh, const Transform3f &tr)
Transform3f	to_transform3f (const XYRotation &rot)
XYRotation	from_transform3f (const Transform3f &tr)
bool	is_on_floor (const SLAPrintObjectConfig &cfg)
std::vector< XYRotation >	get_chull_rotations (const TriangleMesh &mesh, size_t max_count)
template<size_t N, class Fn, class It, class StopCond>
std::array< double, N >	find_min_score (Fn &&fn, It from, It to, StopCond &&stopfn)

Variables
const Vec3f	DOWN = {0.f, 0.f, -1.f}
constexpr double	POINTS_PER_UNIT_AREA = 1.f

Typedef Documentation

XYRotation

using Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::XYRotation = std::array<double, 2>

Function Documentation

find_ground_level()

float Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_ground_level	(	const TriangleMesh &	mesh,
		const Transform3f &	tr,
		size_t	threads )

{
    size_t vsize = mesh.its.vertices.size();
 
    auto minfn = [](float a, float b) { return std::min(a, b); };
 
    auto accessfn = [&mesh, &tr] (size_t vi) {
        return (tr * mesh.its.vertices[vi]).z();
    };
 
    auto zmin = std::numeric_limits<float>::max();
    size_t granularity = vsize / threads;
    return execution::reduce(ex_tbb, size_t(0), vsize, zmin, minfn, accessfn, granularity);
}

References Slic3r::ex_tbb, find_ground_level(), Slic3r::TriangleMesh::its, and Slic3r::execution::reduce().

Referenced by find_ground_level(), and get_supportedness_onfloor_score().

Here is the call graph for this function:

Here is the caller graph for this function:

find_min_score()

template<size_t N, class Fn, class It, class StopCond>

std::array< double, N > Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::find_min_score	(	Fn &&	fn,
		It	from,
		It	to,
		StopCond &&	stopfn )

{
    std::array<double, N> ret = {};
 
    double score = std::numeric_limits<double>::max();
 
    size_t Nthreads = std::thread::hardware_concurrency();
    size_t dist = std::distance(from, to);
    std::vector<double> scores(dist, score);
 
    execution::for_each(
        ex_tbb, size_t(0), dist, [&stopfn, &scores, &fn, &from](size_t i) {
            if (stopfn()) return;
 
            scores[i] = fn(*(from + i));
        },
        dist / Nthreads);
 
    auto it = std::min_element(scores.begin(), scores.end());
 
    if (it != scores.end())
        ret = *(from + std::distance(scores.begin(), it));
 
    return ret;
}

References Slic3r::Geometry::dist(), Slic3r::ex_tbb, find_min_score(), and Slic3r::execution::for_each().

Referenced by find_min_score().

Here is the call graph for this function:

Here is the caller graph for this function:

from_transform3f()

XYRotation Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::from_transform3f

(

const Transform3f &

tr

)

{
    Vec3d rot3 = Geometry::Transformation{tr.cast<double>()}.get_rotation();
    return {rot3.x(), rot3.y()};
}

References from_transform3f(), and Slic3r::Geometry::Transformation::get_rotation().

Referenced by from_transform3f(), and get_chull_rotations().

Here is the call graph for this function:

Here is the caller graph for this function:

get_chull_rotations()

std::vector< XYRotation > Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_chull_rotations	(	const TriangleMesh &	mesh,
		size_t	max_count )

{
    TriangleMesh chull = mesh.convex_hull_3d();
    double chull2d_area = chull.convex_hull().area();
    double area_threshold = chull2d_area / (scaled<double>(1e3) * scaled(1.));
 
    size_t facecount = chull.its.indices.size();
 
    struct RotArea { XYRotation rot; double area; };
 
    auto inputs = reserve_vector<RotArea>(facecount);
 
    auto rotcmp = [](const RotArea &r1, const RotArea &r2) {
        double xdiff = r1.rot[X] - r2.rot[X], ydiff = r1.rot[Y] - r2.rot[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 < facecount; ++fi) {
        Facestats fc{get_triangle_vertices(chull, fi)};
 
        if (fc.area > area_threshold)  {
            auto q = Eigen::Quaternionf{}.FromTwoVectors(fc.normal, DOWN);
            XYRotation rot = from_transform3f(Transform3f::Identity() * q);
            RotArea ra = {rot, fc.area};
 
            auto it = std::lower_bound(inputs.begin(), inputs.end(), ra, rotcmp);
 
            if (it == inputs.end() || !eqcmp(it->rot, rot))
                inputs.insert(it, ra);
        }
    }
 
    inputs.shrink_to_fit();
    if (!max_count) max_count = inputs.size();
    std::sort(inputs.begin(), inputs.end(),
              [](const RotArea &ra, const RotArea &rb) {
                  return ra.area > rb.area;
              });
 
    auto ret = reserve_vector<XYRotation>(std::min(max_count, inputs.size()));
    for (const RotArea &ra : inputs) ret.emplace_back(ra.rot);
 
    return ret;
}

References Slic3r::area(), Slic3r::Polygon::area(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::area, Slic3r::TriangleMesh::convex_hull(), Slic3r::TriangleMesh::convex_hull_3d(), DOWN, EPSILON, from_transform3f(), get_chull_rotations(), get_triangle_vertices(), Slic3r::TriangleMesh::its, Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::normal, Slic3r::reserve_vector(), Slic3r::scaled(), Slic3r::sla::X, and Slic3r::sla::Y.

Referenced by get_chull_rotations().

Here is the call graph for this function:

Here is the caller graph for this function:

get_misalginment_score()

double Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_misalginment_score	(	const TriangleMesh &	mesh,
		const Transform3f &	tr )

{
    if (mesh.its.vertices.empty()) return std::nan("");
 
    auto accessfn = [&mesh, &tr](size_t fi) {
        Facestats fc{get_transformed_triangle(mesh, tr, fi)};
 
        float score = fc.area
                      * (std::abs(fc.normal.dot(Vec3f::UnitX()))
                         + std::abs(fc.normal.dot(Vec3f::UnitY()))
                         + std::abs(fc.normal.dot(Vec3f::UnitZ())));
 
        // We should score against the alignment with the reference planes
        return scaled<int_fast64_t>(score);
    };
 
    size_t facecount = mesh.its.indices.size();
    size_t Nthreads  = std::thread::hardware_concurrency();
    double S = unscaled(sum_score<int_fast64_t>(accessfn, facecount, Nthreads));
 
    return S / facecount;
}

References Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::area, get_misalginment_score(), get_transformed_triangle(), Slic3r::TriangleMesh::its, Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::normal, Slic3r::scaled(), sum_score(), and Slic3r::unscaled().

Referenced by get_misalginment_score().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedness_onfloor_score()

float Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_supportedness_onfloor_score	(	const TriangleMesh &	mesh,
		const Transform3f &	tr )

{
    if (mesh.its.vertices.empty()) return std::nan("");
 
    size_t Nthreads = std::thread::hardware_concurrency();
 
    float zmin = find_ground_level(mesh, tr, Nthreads);
    float zlvl = zmin + 0.1f; // Set up a slight tolerance from z level
 
    auto accessfn = [&mesh, &tr, zlvl](size_t fi) {
        std::array<Vec3f, 3> tri = get_transformed_triangle(mesh, tr, fi);
        Facestats fc{tri};
 
        if (tri[0].z() <= zlvl && tri[1].z() <= zlvl && tri[2].z() <= zlvl)
            return -2 * fc.area * POINTS_PER_UNIT_AREA;
 
        return get_supportedness_score(fc);
    };
 
    size_t facecount = mesh.its.indices.size();
    double S = unscaled(sum_score<int_fast64_t>(accessfn, facecount, Nthreads));
 
    return S / facecount;
}

References Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::area, find_ground_level(), get_supportedness_onfloor_score(), get_supportedness_score(), get_transformed_triangle(), Slic3r::TriangleMesh::its, POINTS_PER_UNIT_AREA, sum_score(), and Slic3r::unscaled().

Referenced by get_supportedness_onfloor_score().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedness_score() [1/2]

double Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_supportedness_score ( const Facestats & fc )

inline

{
    // Simply get the angle (acos of dot product) between the face normal and
    // the DOWN vector.
    float cosphi = fc.normal.dot(DOWN);
    float phi = 1.f - std::acos(cosphi) / float(PI);
 
    // Make the huge slopes more significant than the smaller slopes
    phi = phi * phi * phi;
 
    // Multiply with the square root of face area of the current face,
    // the area is less important as it grows.
    // This makes many smaller overhangs a bigger impact.
    return std::sqrt(fc.area) * POINTS_PER_UNIT_AREA * phi;
}

References Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::area, DOWN, get_supportedness_score(), Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::Facestats::normal, PI, and POINTS_PER_UNIT_AREA.

Referenced by get_supportedness_onfloor_score(), get_supportedness_score(), and get_supportedness_score().

Here is the call graph for this function:

Here is the caller graph for this function:

get_supportedness_score() [2/2]

double Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_supportedness_score	(	const TriangleMesh &	mesh,
		const Transform3f &	tr )

{
    if (mesh.its.vertices.empty()) return std::nan("");
 
    auto accessfn = [&mesh, &tr](size_t fi) {
        Facestats fc{get_transformed_triangle(mesh, tr, fi)};
        return scaled<int_fast64_t>(get_supportedness_score(fc));
    };
 
    size_t facecount = mesh.its.indices.size();
    size_t Nthreads  = std::thread::hardware_concurrency();
    double S = unscaled(sum_score<int_fast64_t>(accessfn, facecount, Nthreads));
 
    return S / facecount;
}

References get_supportedness_score(), get_transformed_triangle(), Slic3r::TriangleMesh::its, Slic3r::scaled(), sum_score(), and Slic3r::unscaled().

Here is the call graph for this function:

get_transformed_triangle()

std::array< Vec3f, 3 > Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_transformed_triangle	(	const TriangleMesh &	mesh,
		const Transform3f &	tr,
		size_t	faceidx )

{
    const auto &tri = get_triangle_vertices(mesh, faceidx);
    return {tr * tri[0], tr * tri[1], tr * tri[2]};
}

References get_transformed_triangle(), and get_triangle_vertices().

Referenced by get_misalginment_score(), get_supportedness_onfloor_score(), get_supportedness_score(), and get_transformed_triangle().

Here is the call graph for this function:

Here is the caller graph for this function:

get_triangle_vertices()

std::array< Vec3f, 3 > Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::get_triangle_vertices	(	const TriangleMesh &	mesh,
		size_t	faceidx )

{
    const auto &face = mesh.its.indices[faceidx];
    return {mesh.its.vertices[face(0)],
            mesh.its.vertices[face(1)],
            mesh.its.vertices[face(2)]};
}

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

Referenced by get_chull_rotations(), get_transformed_triangle(), and get_triangle_vertices().

Here is the call graph for this function:

Here is the caller graph for this function:

is_on_floor()

bool Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::is_on_floor ( const SLAPrintObjectConfig & cfg )

inline

{
    auto opt_elevation = cfg.support_object_elevation.getFloat();
    auto opt_padaround = cfg.pad_around_object.getBool();
 
    return opt_elevation < EPSILON || opt_padaround;
}

References EPSILON, and is_on_floor().

Referenced by is_on_floor().

Here is the call graph for this function:

Here is the caller graph for this function:

normal()

template<class T>

Vec< 3, T > Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::normal

(

const std::array< Vec< 3, T >, 3 > &

tri

)

{
    Vec<3, T> U = tri[1] - tri[0];
    Vec<3, T> V = tri[2] - tri[0];
    return U.cross(V).normalized();
}

sum_score()

template<class T, class AccessFn>

T Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::sum_score	(	AccessFn &&	accessfn,
		size_t	facecount,
		size_t	Nthreads )

{
    T  initv         = 0.;
    auto   mergefn   = [](T a, T b) { return a + b; };
    size_t grainsize = facecount / Nthreads;
    size_t from = 0, to = facecount;
 
    return execution::reduce(ex_tbb, from, to, initv, mergefn, accessfn, grainsize);
}

References Slic3r::ex_tbb, Slic3r::execution::reduce(), and sum_score().

Referenced by get_misalginment_score(), get_supportedness_onfloor_score(), get_supportedness_score(), and sum_score().

Here is the call graph for this function:

Here is the caller graph for this function:

to_transform3f()

Transform3f Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::to_transform3f

(

const XYRotation &

rot

)

{
    Transform3f rt = Transform3f::Identity();
    rt.rotate(Eigen::AngleAxisf(float(rot[1]), Vec3f::UnitY()));
    rt.rotate(Eigen::AngleAxisf(float(rot[0]), Vec3f::UnitX()));
 
    return rt;
}

References to_transform3f().

Referenced by to_transform3f().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

DOWN

const Vec3f Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::DOWN = {0.f, 0.f, -1.f}

inline

{0.f, 0.f, -1.f};

Referenced by get_chull_rotations(), and get_supportedness_score().

POINTS_PER_UNIT_AREA

double Slic3r::sla::anonymous_namespace{Rotfinder.cpp}::POINTS_PER_UNIT_AREA = 1.f

constexpr

Referenced by get_supportedness_onfloor_score(), and get_supportedness_score().