Slic3r::sla::DrainHole Struct Reference

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

Public Member Functions
	DrainHole ()
	DrainHole (Vec3f p, Vec3f n, float r, float h, bool fl=false)
bool	operator== (const DrainHole &sp) const
bool	operator!= (const DrainHole &sp) const
bool	is_inside (const Vec3f &pt) const
bool	get_intersections (const Vec3f &s, const Vec3f &dir, std::array< std::pair< float, Vec3d >, 2 > &out) const
indexed_triangle_set	to_mesh () const
template<class Archive>
void	serialize (Archive &ar)

Public Attributes
Vec3f	pos
Vec3f	normal
float	radius
float	height
bool	failed = false

Static Public Attributes
static constexpr size_t	steps = 32

Detailed Description

Constructor & Destructor Documentation

DrainHole() [1/2]

Slic3r::sla::DrainHole::DrainHole ( )

inline

        : pos(Vec3f::Zero()), normal(Vec3f::UnitZ()), radius(5.f), height(10.f)
    {}

References height, normal, pos, and radius.

Referenced by operator!=(), and operator==().

Here is the caller graph for this function:

DrainHole() [2/2]

Slic3r::sla::DrainHole::DrainHole ( Vec3f p, Vec3f n, float r, float h, bool fl = false )

inline

        : pos(p), normal(n), radius(r), height(h), failed(fl)
    {}

References failed, height, normal, pos, and radius.

Member Function Documentation

get_intersections()

bool Slic3r::sla::DrainHole::get_intersections	(	const Vec3f &	s,
		const Vec3f &	dir,
		std::array< std::pair< float, Vec3d >, 2 > &	out ) const

{
    assert(is_approx(normal.norm(), 1.f));
    const Eigen::ParametrizedLine<float, 3> ray(s, dir.normalized());
 
    for (size_t i=0; i<2; ++i)
        out[i] = std::make_pair(sla::IndexedMesh::hit_result::infty(), Vec3d::Zero());
 
    const float sqr_radius = pow(radius, 2.f);
 
    // first check a bounding sphere of the hole:
    Vec3f center = pos+normal*height/2.f;
    float sqr_dist_limit = pow(height/2.f, 2.f) + sqr_radius ;
    if (ray.squaredDistance(center) > sqr_dist_limit)
        return false;
 
    // The line intersects the bounding sphere, look for intersections with
    // bases of the cylinder.
 
    size_t found = 0; // counts how many intersections were found
    Eigen::Hyperplane<float, 3> base;
    if (! is_approx(ray.direction().dot(normal), 0.f)) {
        for (size_t i=1; i<=1; --i) {
            Vec3f cylinder_center = pos+i*height*normal;
            if (i == 0) {
                // The hole base can be identical to mesh surface if it is flat
                // let's better move the base outward a bit
                cylinder_center -= EPSILON*normal;
            }
            base = Eigen::Hyperplane<float, 3>(normal, cylinder_center);
            Vec3f intersection = ray.intersectionPoint(base);
            // Only accept the point if it is inside the cylinder base.
            if ((cylinder_center-intersection).squaredNorm() < sqr_radius) {
                out[found].first = ray.intersectionParameter(base);
                out[found].second = (i==0 ? 1. : -1.) * normal.cast<double>();
                ++found;
            }
        }
    }
    else
    {
        // In case the line was perpendicular to the cylinder axis, previous
        // block was skipped, but base will later be assumed to be valid.
        base = Eigen::Hyperplane<float, 3>(normal, pos-EPSILON*normal);
    }
 
    // In case there is still an intersection to be found, check the wall
    if (found != 2 && ! is_approx(std::abs(ray.direction().dot(normal)), 1.f)) {
        // Project the ray onto the base plane
        Vec3f proj_origin = base.projection(ray.origin());
        Vec3f proj_dir = base.projection(ray.origin()+ray.direction())-proj_origin;
        // save how the parameter scales and normalize the projected direction
        float par_scale = proj_dir.norm();
        proj_dir = proj_dir/par_scale;
        Eigen::ParametrizedLine<float, 3> projected_ray(proj_origin, proj_dir);
        // Calculate point on the secant that's closest to the center
        // and its distance to the circle along the projected line
        Vec3f closest = projected_ray.projection(pos);
        float dist = sqrt((sqr_radius - (closest-pos).squaredNorm()));
        // Unproject both intersections on the original line and check
        // they are on the cylinder and not past it:
        for (int i=-1; i<=1 && found !=2; i+=2) {
            Vec3f isect = closest + i*dist * projected_ray.direction();
            Vec3f to_isect = isect-proj_origin;
            float par = to_isect.norm() / par_scale;
            if (to_isect.normalized().dot(proj_dir.normalized()) < 0.f)
                par *= -1.f;
            Vec3d hit_normal = (pos-isect).normalized().cast<double>();
            isect = ray.pointAt(par);
            // check that the intersection is between the base planes:
            float vert_dist = base.signedDistance(isect);
            if (vert_dist > 0.f && vert_dist < height) {
                out[found].first = par;
                out[found].second = hit_normal;
                ++found;
            }
        }
    }
 
    // If only one intersection was found, it is some corner case,
    // no intersection will be returned:
    if (found != 2)
        return false;
 
    // Sort the intersections:
    if (out[0].first > out[1].first)
        std::swap(out[0], out[1]);
 
    return true;
}

References Slic3r::center(), Slic3r::Geometry::dist(), EPSILON, height, Slic3r::sla::IndexedMesh::hit_result::infty(), Slic3r::intersection(), Slic3r::is_approx(), normal, pos, and radius.

Here is the call graph for this function:

is_inside()

bool Slic3r::sla::DrainHole::is_inside

(

const Vec3f &

pt

)

const

{
    Eigen::Hyperplane<float, 3> plane(normal, pos);
    float dist = plane.signedDistance(pt);
    if (dist < float(EPSILON) || dist > height)
        return false;
 
    Eigen::ParametrizedLine<float, 3> axis(pos, normal);
    if ( axis.squaredDistance(pt) < pow(radius, 2.f))
        return true;
 
    return false;
}

References Slic3r::Geometry::dist(), EPSILON, height, normal, pos, and radius.

Here is the call graph for this function:

operator!=()

bool Slic3r::sla::DrainHole::operator!= ( const DrainHole & sp ) const

inline

{ return !(sp == (*this)); }

References DrainHole().

Here is the call graph for this function:

operator==()

bool Slic3r::sla::DrainHole::operator==

(

const DrainHole &

sp

)

const

{
    return (pos == sp.pos) && (normal == sp.normal) &&
            is_approx(radius, sp.radius) &&
            is_approx(height, sp.height);
}

References DrainHole(), height, Slic3r::is_approx(), normal, pos, and radius.

Here is the call graph for this function:

serialize()

template<class Archive>

void Slic3r::sla::DrainHole::serialize ( Archive & ar )

inline

    {
        ar(pos, normal, radius, height, failed);
    }

References failed, height, normal, pos, and radius.

to_mesh()

indexed_triangle_set Slic3r::sla::DrainHole::to_mesh

(

)

const

{
    auto r = double(radius);
    auto h = double(height);
    indexed_triangle_set hole = sla::cylinder(r, h, steps);
    Eigen::Quaternionf q;
    q.setFromTwoVectors(Vec3f{0.f, 0.f, 1.f}, normal);
    for(auto& p : hole.vertices) p = q * p + pos;
    
    return hole;
}

References Slic3r::sla::cylinder(), height, normal, pos, radius, and steps.

Here is the call graph for this function:

Member Data Documentation

failed

bool Slic3r::sla::DrainHole::failed = false

Referenced by DrainHole(), and serialize().

height

float Slic3r::sla::DrainHole::height

Referenced by DrainHole(), DrainHole(), get_intersections(), is_inside(), operator==(), serialize(), and to_mesh().

normal

Vec3f Slic3r::sla::DrainHole::normal

Referenced by DrainHole(), DrainHole(), get_intersections(), is_inside(), operator==(), serialize(), and to_mesh().

pos

Vec3f Slic3r::sla::DrainHole::pos

Referenced by DrainHole(), DrainHole(), get_intersections(), is_inside(), operator==(), serialize(), and to_mesh().

radius

float Slic3r::sla::DrainHole::radius

Referenced by DrainHole(), DrainHole(), get_intersections(), is_inside(), operator==(), serialize(), and to_mesh().

steps

size_t Slic3r::sla::DrainHole::steps = 32

staticconstexpr

Referenced by Slic3r::create_exclude_mask(), and to_mesh().

---

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

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