Slic3r::GUI::RaycastManager Class Reference

Cast rays from camera to scene Used for find hit point on model volume under mouse cursor. More...

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/RaycastManager.hpp>

Collaboration diagram for Slic3r::GUI::RaycastManager:

Classes
class	ISkip
	Interface for identify allowed volumes to cast rays. More...
struct	SurfacePoint
struct	Hit
struct	ClosePoint
class	SkipVolume
class	AllowVolumes

Public Types
using	Mesh = std::pair<size_t, std::unique_ptr<AABBMesh> >
using	Meshes = std::vector<Mesh>
using	TrKey = std::pair<size_t, size_t>
using	TrItem = std::pair<TrKey, Transform3d>
using	TrItems = std::vector<TrItem>

Public Member Functions
void	actualize (const ModelObject &object, const ISkip *skip=nullptr, Meshes *meshes=nullptr)
	Actualize raycasters + transformation Detection of removed object Detection of removed instance Detection of removed volume.
void	actualize (const ModelInstance &instance, const ISkip *skip=nullptr, Meshes *meshes=nullptr)
std::optional< Hit >	first_hit (const Vec3d &point, const Vec3d &direction, const ISkip *skip=nullptr) const
	Unproject on mesh and return closest hit to point in given direction.
std::optional< Hit >	closest_hit (const Vec3d &point, const Vec3d &direction, const ISkip *skip=nullptr) const
	Unproject Ray(point direction) on mesh to find closest hit of surface in given direction NOTE: It inspect also oposit direction of ray !!
std::optional< ClosePoint >	closest (const Vec3d &point, const ISkip *skip=nullptr) const
	Search of closest point.
Transform3d	get_transformation (const TrKey &tr_key) const
	Getter on transformation from hitted volume to world.

Private Attributes
Meshes	m_meshes
TrItems	m_transformations

Detailed Description

Cast rays from camera to scene Used for find hit point on model volume under mouse cursor.

---

Class Documentation

Slic3r::GUI::RaycastManager::SurfacePoint

struct Slic3r::GUI::RaycastManager::SurfacePoint

template<typename T>
struct Slic3r::GUI::RaycastManager::SurfacePoint< T >

Inheritance diagram for Slic3r::GUI::RaycastManager::SurfacePoint< T >:

Class Members
typedef Matrix< T, 3, 1, DontAlign >	Vec3 Eigen::Matrix<T, 3, 1, Eigen::DontAlign>

Class Members
Vec3	normal = Vec3::UnitZ()
Vec3	position = Vec3::Zero()

Slic3r::GUI::RaycastManager::ClosePoint

struct Slic3r::GUI::RaycastManager::ClosePoint

Collaboration diagram for Slic3r::GUI::RaycastManager::ClosePoint:

Class Members
Vec3d	point
double	squared_distance
TrKey	tr_key

Member Typedef Documentation

Mesh

using Slic3r::GUI::RaycastManager::Mesh = std::pair<size_t, std::unique_ptr<AABBMesh> >

Meshes

using Slic3r::GUI::RaycastManager::Meshes = std::vector<Mesh>

TrItem

using Slic3r::GUI::RaycastManager::TrItem = std::pair<TrKey, Transform3d>

TrItems

using Slic3r::GUI::RaycastManager::TrItems = std::vector<TrItem>

TrKey

using Slic3r::GUI::RaycastManager::TrKey = std::pair<size_t, size_t>

Member Function Documentation

actualize() [1/2]

void RaycastManager::actualize	(	const ModelInstance &	instance,
		const ISkip *	skip = nullptr,
		Meshes *	meshes = nullptr )

{
    const ModelVolumePtrs &volumes = instance.get_object()->volumes;
 
    // actualize MeshRaycaster
    ::actualize(m_meshes, volumes, skip, meshes);
 
    // check if inscance was removed
    std::vector<bool> removed_transf(m_transformations.size(), {true});
 
    bool need_sort = false;
    // actualize transformation matrices
    for (const ModelVolume *volume : volumes) {
        if (skip != nullptr && skip->skip(volume->id().id))
            continue;
        const Transform3d &volume_tr = volume->get_matrix();
        const Transform3d &instrance_tr   = instance.get_matrix();
        Transform3d        transformation = instrance_tr * volume_tr;
        TrKey key = ::create_key(*volume, instance);
        auto item = ::find(m_transformations, key);
        if (item != m_transformations.end()) {
            // actualize transformation all the time
            item->second          = transformation;
            size_t index          = item - m_transformations.begin();
            removed_transf[index] = false;
        } else {
            // add new transformation
            m_transformations.emplace_back(key, transformation);
            need_sort = true;
        }        
    }
 
    // clean other transformation
    ::erase(m_transformations, removed_transf);
 
    if (need_sort)
        std::sort(m_transformations.begin(), m_transformations.end(), ::is_lower);
}

References actualize(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelInstance::get_object(), m_meshes, m_transformations, Slic3r::GUI::RaycastManager::ISkip::skip(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

actualize() [2/2]

void RaycastManager::actualize	(	const ModelObject &	object,
		const ISkip *	skip = nullptr,
		Meshes *	meshes = nullptr )

Actualize raycasters + transformation Detection of removed object Detection of removed instance Detection of removed volume.

Parameters

object	Model representation
skip	Condifiton for skip actualization
meshes	Speed up for already created AABBtrees

{
    // actualize MeshRaycaster
    ::actualize(m_meshes, object.volumes, skip, meshes);
 
    // check if inscance was removed
    std::vector<bool> removed_transf(m_transformations.size(), {true});
 
    bool need_sort = false;
    // actualize transformation matrices
    for (const ModelVolume *volume : object.volumes) {
        if (skip != nullptr && skip->skip(volume->id().id)) continue;
        const Transform3d &volume_tr = volume->get_matrix();
        for (const ModelInstance *instance : object.instances) {
            const Transform3d &instrance_tr = instance->get_matrix();
            Transform3d transformation = instrance_tr * volume_tr;
            TrKey key = ::create_key(*volume, *instance);
            auto item = ::find(m_transformations, key);
            if (item != m_transformations.end()) {
                // actualize transformation all the time
                item->second = transformation;
                size_t index = item - m_transformations.begin();
                removed_transf[index] = false;
            } else {
                // add new transformation
                m_transformations.emplace_back(key, transformation);
                need_sort = true;
            }
        }
    }
 
    // clean other transformation
    ::erase(m_transformations, removed_transf);
 
    if (need_sort)
        std::sort(m_transformations.begin(), m_transformations.end(), ::is_lower);
}

References actualize(), m_meshes, m_transformations, and Slic3r::GUI::RaycastManager::ISkip::skip().

Referenced by actualize(), actualize(), Slic3r::GUI::calc_distance(), Slic3r::GUI::calc_surface_offset(), anonymous_namespace{EmbossJob.cpp}::start_create_volume_on_surface_job(), and anonymous_namespace{SurfaceDrag.cpp}::start_dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

closest()

std::optional< RaycastManager::ClosePoint > RaycastManager::closest	(	const Vec3d &	point,
		const ISkip *	skip = nullptr ) const

Search of closest point.

Parameters

point	Point
skip	Define which caster will be skipped, null mean no skip

Returns

{
    std::optional<ClosePoint> closest;
    for (const auto &[key, transformation] : m_transformations) {
        size_t       volume_id = key.second;
        if (skip != nullptr && skip->skip(volume_id))
            continue;
        const AABBMesh *mesh = ::get_mesh(m_meshes, volume_id);
        if (mesh == nullptr) continue;
        Transform3d tr_inv = transformation.inverse();
        Vec3d mesh_point = tr_inv * point;
                
        int   face_idx = 0;
        Vec3d closest_point;
        Vec3d pointd = point.cast<double>();
        mesh->squared_distance(pointd, face_idx, closest_point);
 
        double squared_distance = (mesh_point - closest_point).squaredNorm();
        if (closest.has_value() && closest->squared_distance < squared_distance)
            continue;
 
        closest = ClosePoint{key, closest_point, squared_distance};
    }
    return closest;
}

References closest(), m_meshes, m_transformations, Slic3r::GUI::RaycastManager::ISkip::skip(), and Slic3r::AABBMesh::squared_distance().

Referenced by Slic3r::GUI::calc_surface_offset(), closest(), and closest_hit().

Here is the call graph for this function:

Here is the caller graph for this function:

closest_hit()

std::optional< RaycastManager::Hit > RaycastManager::closest_hit	(	const Vec3d &	point,
		const Vec3d &	direction,
		const ISkip *	skip = nullptr ) const

Unproject Ray(point direction) on mesh to find closest hit of surface in given direction NOTE: It inspect also oposit direction of ray !!

Parameters

point	Start point for ray
direction	Direction of ray, orientation doesn't matter, both are used
skip	Define which caster will be skipped, null mean no skip

Returns

Position on surface, normal direction and transformation key, which define hitted object instance

{
    std::optional<Hit> closest;
    for (const auto &[key, transformation] : m_transformations) {
        size_t volume_id = key.second;
        if (skip != nullptr && skip->skip(volume_id)) continue;
        const AABBMesh *mesh = ::get_mesh(m_meshes, volume_id);
        if (mesh == nullptr) continue;
        Transform3d tr_inv = transformation.inverse();
        Vec3d mesh_point = tr_inv * point;
        Vec3d mesh_direction = tr_inv.linear() * direction;
 
        // Need for detect that actual point position is on correct place
        Vec3d point_positive = mesh_point - mesh_direction;
        Vec3d point_negative = mesh_point + mesh_direction;
 
        // Throw ray to both directions of ray
        std::vector<AABBMesh::hit_result> hits = mesh->query_ray_hits(point_positive, mesh_direction);
        std::vector<AABBMesh::hit_result> hits_neg = mesh->query_ray_hits(point_negative, -mesh_direction);
        hits.insert(hits.end(), std::make_move_iterator(hits_neg.begin()), std::make_move_iterator(hits_neg.end()));
        for (const AABBMesh::hit_result &hit : hits) { 
            Vec3d diff = mesh_point - hit.position();
            double squared_distance = diff.squaredNorm();
            if (closest.has_value() &&
                closest->squared_distance < squared_distance)
                continue;
            closest = Hit{{hit.position(), hit.normal()}, key, squared_distance};
        }
    }
    return closest;
}

References closest(), Slic3r::diff(), m_meshes, m_transformations, Slic3r::AABBMesh::query_ray_hits(), and Slic3r::GUI::RaycastManager::ISkip::skip().

Referenced by Slic3r::GUI::calc_distance(), and Slic3r::GUI::calc_surface_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

first_hit()

std::optional< RaycastManager::Hit > RaycastManager::first_hit	(	const Vec3d &	point,
		const Vec3d &	direction,
		const ISkip *	skip = nullptr ) const

Unproject on mesh and return closest hit to point in given direction.

Parameters

point	Position in space
direction	Casted ray direction
skip	Define which caster will be skipped, null mean no skip

Returns

Position on surface, normal direction in world coorinate

• key, to know hitted instance and volume

{
    // Improve: it is not neccessaru to use AABBMesh and calc normal for every hit
    
    // Results
    const AABBMesh *hit_mesh = nullptr;
    double hit_squared_distance = 0.;
    int hit_face = -1;
    Vec3d hit_world { Vec3d::Zero() };
    const Transform3d *hit_tramsformation = nullptr;
    const TrKey *hit_key = nullptr;
 
    for (const auto &[key, transformation]: m_transformations) {
        size_t volume_id = key.second;
        if (skip != nullptr && skip->skip(volume_id)) continue;
        const AABBMesh *mesh = ::get_mesh(m_meshes, volume_id);
        if (mesh == nullptr) continue;
        Transform3d inv = transformation.inverse();
 
        // transform input into mesh world
        Vec3d point_    = inv * point;
        Vec3d direction_= inv.linear() * direction;
 
        std::vector<AABBMesh::hit_result> hits = mesh->query_ray_hits(point_, direction_);
        if (hits.empty()) continue; // no intersection found
 
        const AABBMesh::hit_result &hit = hits.front();
 
        // convert to world
        Vec3d world = transformation * hit.position();
        double squared_distance = (point - world).squaredNorm();
        if (hit_mesh != nullptr &&
            hit_squared_distance < squared_distance)
            continue; // exist closer one
 
        hit_mesh = mesh;
        hit_squared_distance = squared_distance;
        hit_face = hit.face();
        hit_world = world;
        hit_tramsformation = &transformation;
        hit_key = &key;
    }
 
    if (hit_mesh == nullptr)
        return {};
 
    // Calculate normal from transformed triangle
    // NOTE: Anisotropic transformation of normal is not perpendiculat to triangle
    const Vec3i32 tri = hit_mesh->indices(hit_face);
    std::array<Vec3d,3> pts;
    auto tr = hit_tramsformation->linear().eval();
    for (int i = 0; i < 3; ++i)
        pts[i] = tr * hit_mesh->vertices(tri[i]).cast<double>();
    Vec3d normal_world = (pts[1] - pts[0]).cross(pts[2] - pts[1]);
    if (has_reflection(*hit_tramsformation))
        normal_world *= -1;
    normal_world.normalize();
 
    SurfacePoint<double> point_world{hit_world, normal_world};
    return RaycastManager::Hit{point_world, *hit_key, hit_squared_distance};
}

References Slic3r::cross(), Slic3r::AABBMesh::hit_result::face(), Slic3r::has_reflection(), Slic3r::AABBMesh::indices(), m_meshes, m_transformations, Slic3r::AABBMesh::hit_result::position(), Slic3r::AABBMesh::query_ray_hits(), Slic3r::GUI::RaycastManager::ISkip::skip(), and Slic3r::AABBMesh::vertices().

Referenced by Slic3r::GUI::ray_from_camera().

Here is the call graph for this function:

Here is the caller graph for this function:

get_transformation()

Slic3r::Transform3d RaycastManager::get_transformation

(

const TrKey &

tr_key

)

const

Getter on transformation from hitted volume to world.

Parameters

tr_key

Define transformation

Returns

Transformation for key

                                                                              {
    auto tr = ::find(m_transformations, tr_key);
    if (tr == m_transformations.end())
        return Transform3d::Identity();
    return tr->second;
}

References m_transformations.

Referenced by Slic3r::GUI::calc_distance(), and Slic3r::GUI::calc_surface_offset().

Here is the caller graph for this function:

Member Data Documentation

m_meshes

Meshes Slic3r::GUI::RaycastManager::m_meshes

private

Referenced by actualize(), actualize(), closest(), closest_hit(), and first_hit().

m_transformations

TrItems Slic3r::GUI::RaycastManager::m_transformations

private

Referenced by actualize(), actualize(), closest(), closest_hit(), first_hit(), and get_transformation().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/RaycastManager.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/Utils/RaycastManager.cpp