Slic3r::GUI::MeshRaycaster Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MeshUtils.hpp>

Collaboration diagram for Slic3r::GUI::MeshRaycaster:

Public Member Functions
	MeshRaycaster (std::shared_ptr< const TriangleMesh > mesh)
	MeshRaycaster (const TriangleMesh &mesh)
bool	unproject_on_mesh (const Vec2d &mouse_pos, const Transform3d &trafo, const Camera &camera, Vec3f &position, Vec3f &normal, const ClippingPlane *clipping_plane=nullptr, size_t *facet_idx=nullptr, bool sinking_limit=true) const
const AABBMesh &	get_aabb_mesh () const
bool	intersects_line (Vec3d point, Vec3d direction, const Transform3d &trafo) const
std::vector< unsigned >	get_unobscured_idxs (const Geometry::Transformation &trafo, const Camera &camera, const std::vector< Vec3f > &points, const ClippingPlane *clipping_plane=nullptr) const
bool	closest_hit (const Vec2d &mouse_pos, const Transform3d &trafo, const Camera &camera, Vec3f &position, Vec3f &normal, const ClippingPlane *clipping_plane=nullptr, size_t *facet_idx=nullptr) const
Vec3f	get_closest_point (const Vec3f &point, Vec3f *normal=nullptr) const
int	get_closest_facet (const Vec3f &point) const
Vec3f	get_triangle_normal (size_t facet_idx) const

Static Public Member Functions
static void	line_from_mouse_pos (const Vec2d &mouse_pos, const Transform3d &trafo, const Camera &camera, Vec3d &point, Vec3d &direction)

Private Attributes
std::shared_ptr< const TriangleMesh >	m_mesh
AABBMesh	m_emesh
std::vector< stl_normal >	m_normals

Detailed Description

Constructor & Destructor Documentation

MeshRaycaster() [1/2]

Slic3r::GUI::MeshRaycaster::MeshRaycaster ( std::shared_ptr< const TriangleMesh > mesh )

inlineexplicit

        : m_mesh(std::move(mesh))
        , m_emesh(*m_mesh, true) // calculate epsilon for triangle-ray intersection from an average edge length
        , m_normals(its_face_normals(m_mesh->its))
    {
        assert(m_mesh);
    }

References Slic3r::its_face_normals(), m_emesh, m_mesh, and m_normals.

Referenced by MeshRaycaster().

Here is the call graph for this function:

Here is the caller graph for this function:

MeshRaycaster() [2/2]

Slic3r::GUI::MeshRaycaster::MeshRaycaster ( const TriangleMesh & mesh )

inlineexplicit

        : MeshRaycaster(std::make_unique<TriangleMesh>(mesh))
    {}

References MeshRaycaster(), and Slic3r::make_unique().

Here is the call graph for this function:

Member Function Documentation

closest_hit()

bool Slic3r::GUI::MeshRaycaster::closest_hit	(	const Vec2d &	mouse_pos,
		const Transform3d &	trafo,
		const Camera &	camera,
		Vec3f &	position,
		Vec3f &	normal,
		const ClippingPlane *	clipping_plane = nullptr,
		size_t *	facet_idx = nullptr ) const

{
    Vec3d point;
    Vec3d direction;
    line_from_mouse_pos(mouse_pos, trafo, camera, point, direction);
 
    const std::vector<AABBMesh::hit_result> hits = m_emesh.query_ray_hits(point, direction.normalized());
 
    if (hits.empty())
        return false; // no intersection found
 
    size_t hit_id = 0;
    if (clipping_plane != nullptr) {
        while (hit_id < hits.size() && clipping_plane->is_point_clipped(trafo * hits[hit_id].position())) {
            ++hit_id;
        }
    }
 
    if (hit_id == hits.size())
        return false; // all points are obscured or cut by the clipping plane.
 
    const AABBMesh::hit_result& hit = hits[hit_id];
 
    position = hit.position().cast<float>();
    normal = hit.normal().cast<float>();
 
    if (facet_idx != nullptr)
        *facet_idx = hit.face();
 
    return true;
}

References Slic3r::AABBMesh::hit_result::face(), Slic3r::GUI::ClippingPlane::is_point_clipped(), line_from_mouse_pos(), m_emesh, Slic3r::AABBMesh::hit_result::normal(), Slic3r::normal(), and Slic3r::AABBMesh::hit_result::position().

Here is the call graph for this function:

get_aabb_mesh()

const AABBMesh & Slic3r::GUI::MeshRaycaster::get_aabb_mesh ( ) const

inline

{ return m_emesh; }

References m_emesh.

get_closest_facet()

int Slic3r::GUI::MeshRaycaster::get_closest_facet

(

const Vec3f &

point

)

const

{
    int   facet_idx = 0;
    Vec3d closest_point;
    m_emesh.squared_distance(point.cast<double>(), facet_idx, closest_point);
    return facet_idx;
}

References m_emesh.

get_closest_point()

Vec3f Slic3r::GUI::MeshRaycaster::get_closest_point	(	const Vec3f &	point,
		Vec3f *	normal = nullptr ) const

{
    int idx = 0;
    Vec3d closest_point;
    Vec3d pointd = point.cast<double>();
    m_emesh.squared_distance(pointd, idx, closest_point);
    if (normal)
        // TODO: consider: get_normal(m_emesh, pointd).cast<float>();
        *normal = m_normals[idx];
 
    return closest_point.cast<float>();
}

References m_emesh, m_normals, and Slic3r::normal().

Here is the call graph for this function:

get_triangle_normal()

Vec3f Slic3r::GUI::MeshRaycaster::get_triangle_normal

(

size_t

facet_idx

)

const

{
    return m_normals[facet_idx];
}

References m_normals.

get_unobscured_idxs()

std::vector< unsigned > Slic3r::GUI::MeshRaycaster::get_unobscured_idxs	(	const Geometry::Transformation &	trafo,
		const Camera &	camera,
		const std::vector< Vec3f > &	points,
		const ClippingPlane *	clipping_plane = nullptr ) const

{
    std::vector<unsigned> out;
 
    const Transform3d instance_matrix_no_translation_no_scaling = trafo.get_rotation_matrix();
    Vec3d direction_to_camera = -camera.get_dir_forward();
    Vec3d direction_to_camera_mesh = (instance_matrix_no_translation_no_scaling.inverse() * direction_to_camera).normalized().eval();
    direction_to_camera_mesh = direction_to_camera_mesh.cwiseProduct(trafo.get_scaling_factor());
    const Transform3d inverse_trafo = trafo.get_matrix().inverse();
 
    for (size_t i=0; i<points.size(); ++i) {
        const Vec3f& pt = points[i];
        if (clipping_plane && clipping_plane->is_point_clipped(pt.cast<double>()))
            continue;
 
        bool is_obscured = false;
        // Cast a ray in the direction of the camera and look for intersection with the mesh:
        std::vector<AABBMesh::hit_result> hits;
        // Offset the start of the ray by EPSILON to account for numerical inaccuracies.
        hits = m_emesh.query_ray_hits((inverse_trafo * pt.cast<double>() + direction_to_camera_mesh * EPSILON),
                                      direction_to_camera_mesh);
 
        if (! hits.empty()) {
            // If the closest hit facet normal points in the same direction as the ray,
            // we are looking through the mesh and should therefore discard the point:
            if (hits.front().normal().dot(direction_to_camera_mesh.cast<double>()) > 0)
                is_obscured = true;
 
            // Eradicate all hits that the caller wants to ignore
            for (unsigned j=0; j<hits.size(); ++j) {
                if (clipping_plane && clipping_plane->is_point_clipped(trafo.get_matrix() * hits[j].position())) {
                    hits.erase(hits.begin()+j);
                    --j;
                }
            }
 
            // FIXME: the intersection could in theory be behind the camera, but as of now we only have camera direction.
            // Also, the threshold is in mesh coordinates, not in actual dimensions.
            if (! hits.empty())
                is_obscured = true;
        }
        if (! is_obscured)
            out.push_back(i);
    }
    return out;
}

References EPSILON, Slic3r::GUI::Camera::get_dir_forward(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::Geometry::Transformation::get_rotation_matrix(), Slic3r::Geometry::Transformation::get_scaling_factor(), Slic3r::GUI::ClippingPlane::is_point_clipped(), and m_emesh.

Here is the call graph for this function:

intersects_line()

bool Slic3r::GUI::MeshRaycaster::intersects_line	(	Vec3d	point,
		Vec3d	direction,
		const Transform3d &	trafo ) const

{
    Transform3d trafo_inv = trafo.inverse();
    Vec3d to = trafo_inv * (point + direction);
    point = trafo_inv * point;
    direction = (to-point).normalized();
 
    std::vector<AABBMesh::hit_result> hits      = m_emesh.query_ray_hits(point, direction);
    std::vector<AABBMesh::hit_result> neg_hits  = m_emesh.query_ray_hits(point, -direction);
 
    return !hits.empty() || !neg_hits.empty();
}

References m_emesh.

line_from_mouse_pos()

void Slic3r::GUI::MeshRaycaster::line_from_mouse_pos ( const Vec2d & mouse_pos, const Transform3d & trafo, const Camera & camera, Vec3d & point, Vec3d & direction )

static

{
    CameraUtils::ray_from_screen_pos(camera, mouse_pos, point, direction);
    Transform3d inv = trafo.inverse();
    point     = inv*point;
    direction = inv.linear()*direction;
}

References Slic3r::GUI::CameraUtils::ray_from_screen_pos().

Referenced by closest_hit(), Slic3r::GUI::GLGizmoCut3D::process_cut_line(), and Slic3r::GUI::GLGizmoCut3D::unproject_on_cut_plane().

Here is the call graph for this function:

Here is the caller graph for this function:

unproject_on_mesh()

bool Slic3r::GUI::MeshRaycaster::unproject_on_mesh	(	const Vec2d &	mouse_pos,
		const Transform3d &	trafo,
		const Camera &	camera,
		Vec3f &	position,
		Vec3f &	normal,
		const ClippingPlane *	clipping_plane = nullptr,
		size_t *	facet_idx = nullptr,
		bool	sinking_limit = true ) const

{
    Vec3d point;
    Vec3d direction;
    CameraUtils::ray_from_screen_pos(camera, mouse_pos, point, direction);
    Transform3d inv = trafo.inverse();
    point     = inv*point;
    direction = inv.linear()*direction;
 
    std::vector<AABBMesh::hit_result> hits = m_emesh.query_ray_hits(point, direction);
 
    if (hits.empty())
        return false; // no intersection found
 
    unsigned i = 0;
 
    // Remove points that are obscured or cut by the clipping plane.
    // Also, remove anything below the bed (sinking objects).
    for (i=0; i<hits.size(); ++i) {
        Vec3d transformed_hit = trafo * hits[i].position();
        if (transformed_hit.z() >= (sinking_limit ? SINKING_Z_THRESHOLD : -std::numeric_limits<double>::max()) &&
            (!clipping_plane || !clipping_plane->is_point_clipped(transformed_hit)))
            break;
    }
 
    if (i==hits.size() || (hits.size()-i) % 2 != 0) {
        // All hits are either clipped, or there is an odd number of unclipped
        // hits - meaning the nearest must be from inside the mesh.
        return false;
    }
 
    // Now stuff the points in the provided vector and calculate normals if asked about them:
    position = hits[i].position().cast<float>();
    normal = hits[i].normal().cast<float>();
 
    if (facet_idx)
        *facet_idx = hits[i].face();
 
    return true;
}

References Slic3r::GUI::ClippingPlane::is_point_clipped(), m_emesh, Slic3r::normal(), Slic3r::GUI::CameraUtils::ray_from_screen_pos(), and Slic3r::SINKING_Z_THRESHOLD.

Here is the call graph for this function:

Member Data Documentation

m_emesh

AABBMesh Slic3r::GUI::MeshRaycaster::m_emesh

private

Referenced by MeshRaycaster(), closest_hit(), get_aabb_mesh(), get_closest_facet(), get_closest_point(), get_unobscured_idxs(), intersects_line(), and unproject_on_mesh().

m_mesh

std::shared_ptr<const TriangleMesh> Slic3r::GUI::MeshRaycaster::m_mesh

private

Referenced by MeshRaycaster().

m_normals

std::vector<stl_normal> Slic3r::GUI::MeshRaycaster::m_normals

private

Referenced by MeshRaycaster(), get_closest_point(), and get_triangle_normal().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MeshUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/MeshUtils.cpp