Slic3r::sla::DrainHole Struct Reference

#include <src/libslic3r/SLA/Hollowing.hpp>

Collaboration diagram for Slic3r::sla::DrainHole:

Public Member Functions
	DrainHole ()
	DrainHole (Vec3f p, Vec3f n, float r, float h, bool fl=false)
	DrainHole (const DrainHole &rhs)
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/3]

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

inline

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

DrainHole() [2/3]

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

DrainHole() [3/3]

Slic3r::sla::DrainHole::DrainHole ( const DrainHole &  rhs )

inline

                                    :
        DrainHole(rhs.pos, rhs.normal, rhs.radius, rhs.height, rhs.failed) {}

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(AABBMesh::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 Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::direction(), EPSILON, height, Slic3r::AABBMesh::hit_result::infty(), Slic3r::intersection(), Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::intersectionParameter(), Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::intersectionPoint(), Slic3r::is_approx(), normal, Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::origin(), Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::pointAt(), pos, Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::projection(), Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::projection(), radius, Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::signedDistance(), sqrt(), and Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::squaredDistance().

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 EPSILON, height, normal, pos, radius, Eigen::Hyperplane< _Scalar, _AmbientDim, _Options >::signedDistance(), and Eigen::ParametrizedLine< _Scalar, _AmbientDim, _Options >::squaredDistance().

Here is the call graph for this function:

operator!=()

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

inline

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

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 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 = its_make_cylinder(r, h); //sla::cylinder(r, h, steps);
    Eigen::Quaternionf q;
    q.setFromTwoVectors(Vec3f::UnitZ(), normal);
    for(auto& p : hole.vertices) p = q * p + pos;
    
    return hole;
}

References height, Slic3r::its_make_cylinder(), normal, pos, radius, and Eigen::QuaternionBase< Derived >::setFromTwoVectors().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

failed

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

Referenced by serialize().

height

float Slic3r::sla::DrainHole::height

Referenced by get_intersections(), is_inside(), operator==(), Slic3r::GUI::GLGizmoHollow::render_points(), serialize(), to_mesh(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

normal

Vec3f Slic3r::sla::DrainHole::normal

Referenced by get_intersections(), Slic3r::sla::hollow_mesh_and_drill(), is_inside(), operator==(), Slic3r::GUI::GLGizmoHollow::render_points(), serialize(), to_mesh(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

pos

Vec3f Slic3r::sla::DrainHole::pos

Referenced by get_intersections(), Slic3r::sla::hollow_mesh_and_drill(), is_inside(), operator==(), Slic3r::GUI::GLGizmoHollow::render_points(), serialize(), to_mesh(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

radius

float Slic3r::sla::DrainHole::radius

Referenced by get_intersections(), is_inside(), operator==(), Slic3r::GUI::GLGizmoHollow::render_points(), serialize(), to_mesh(), and Slic3r::GUI::GLGizmoHollow::update_hole_raycasters_for_picking_transform().

steps

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

staticconstexpr

---

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

• src/libslic3r/SLA/Hollowing.hpp
• src/libslic3r/SLA/Hollowing.cpp