Slic3r::GUI::GLGizmoCut3D::PartSelection Class Reference

Collaboration diagram for Slic3r::GUI::GLGizmoCut3D::PartSelection:

Classes
struct	Part

Public Member Functions
	PartSelection ()=default
	PartSelection (const ModelObject *mo, const Transform3d &cut_matrix, int instance_idx, const Vec3d &center, const Vec3d &normal, const CommonGizmosDataObjects::ObjectClipper &oc)
	PartSelection (const ModelObject *mo, int instance_idx_in)
	~PartSelection ()
void	render (const Vec3d *normal, GLModel &sphere_model)
void	toggle_selection (const Vec2d &mouse_pos)
void	turn_over_selection ()
ModelObject *	model_object ()
bool	valid () const
bool	is_one_object () const
const std::vector< Part > &	parts () const
const std::vector< size_t > *	get_ignored_contours_ptr () const
std::vector< Cut::Part >	get_cut_parts ()

Private Member Functions
void	add_object (const ModelObject *object)

Private Attributes
Model	m_model
int	m_instance_idx
std::vector< Part >	m_parts
bool	m_valid = false
std::vector< std::pair< std::vector< size_t >, std::vector< size_t > > >	m_contour_to_parts
std::vector< size_t >	m_ignored_contours
std::vector< Vec3d >	m_contour_points
std::vector< std::vector< Vec3d > >	m_debug_pts

Detailed Description

---

Class Documentation

Slic3r::GUI::GLGizmoCut3D::PartSelection::Part

struct Slic3r::GUI::GLGizmoCut3D::PartSelection::Part

Collaboration diagram for Slic3r::GUI::GLGizmoCut3D::PartSelection::Part:

Class Members
GLModel	glmodel
bool	is_modifier
MeshRaycaster	raycaster
bool	selected

Constructor & Destructor Documentation

PartSelection() [1/3]

Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection ( )

default

References Slic3r::center(), and Slic3r::normal().

Here is the call graph for this function:

PartSelection() [2/3]

Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection	(	const ModelObject *	mo,
		const Transform3d &	cut_matrix,
		int	instance_idx,
		const Vec3d &	center,
		const Vec3d &	normal,
		const CommonGizmosDataObjects::ObjectClipper &	oc )

    : m_instance_idx(instance_idx_in)
{
    Cut cut(mo, instance_idx_in, cut_matrix);
    add_object(cut.perform_with_plane().front());
 
    const ModelVolumePtrs& volumes = model_object()->volumes;
 
    // split to parts
    for (int id = int(volumes.size())-1; id >= 0; id--)
        if (volumes[id]->is_splittable())
            volumes[id]->split(1, false); // No need to remap paint here, we do it later in perform_by_contour
 
    m_parts.clear();
    for (const ModelVolume* volume : volumes) {
        assert(volume != nullptr);
        m_parts.emplace_back(Part{GLModel(), MeshRaycaster(volume->mesh()), true, !volume->is_model_part()});
        m_parts.back().glmodel.set_color({ 0.f, 0.f, 1.f, 1.f });
        m_parts.back().glmodel.init_from(volume->mesh());
 
        // Now check whether this part is below or above the plane.
        Transform3d tr = (model_object()->instances[m_instance_idx]->get_matrix() * volume->get_matrix()).inverse();
        Vec3f pos = (tr * center).cast<float>();
        Vec3f norm = (tr.linear().inverse().transpose() * normal).cast<float>();
        for (const Vec3f& v : volume->mesh().its.vertices) {
            double p = (v - pos).dot(norm);
            if (std::abs(p) > EPSILON) {
                m_parts.back().selected = p > 0.;
                break;
            }
        }
    }
 
    // Now go through the contours and create a map from contours to parts.
    m_contour_points.clear();
    m_contour_to_parts.clear();
    m_debug_pts = std::vector<std::vector<Vec3d>>(m_parts.size(), std::vector<Vec3d>());
    if (std::vector<Vec3d> pts = oc.point_per_contour();! pts.empty()) {
        
        m_contour_to_parts.resize(pts.size());
 
        for (size_t pt_idx=0; pt_idx<pts.size(); ++pt_idx) {
            const Vec3d& pt = pts[pt_idx];
            const Vec3d dir = (center-pt).dot(normal) * normal;
            m_contour_points.emplace_back(dir + pt); // the result is in world coordinates.
            
            // Now, cast a ray from every contour point and see which volumes of the ones above
            // the plane are hit from the inside.
            for (size_t part_id=0; part_id<m_parts.size(); ++part_id) {
                const AABBMesh& aabb = m_parts[part_id].raycaster.get_aabb_mesh();
                const Transform3d& tr = (translation_transform(model_object()->instances[m_instance_idx]->get_offset()) * translation_transform(model_object()->volumes[part_id]->get_offset())).inverse();
                for (double d : {-1., 1.}) {
                    const Vec3d dir_mesh = d * tr.linear().inverse().transpose() * normal;
                    const Vec3d src = tr * (m_contour_points[pt_idx] + d*0.01 * normal);
                    AABBMesh::hit_result hit = aabb.query_ray_hit(src, dir_mesh);
 
                    m_debug_pts[part_id].emplace_back(src);
 
                    if (hit.is_inside()) {
                        // This part belongs to this point.
                        if (d == 1.)
                            m_contour_to_parts[pt_idx].first.emplace_back(part_id);
                        else
                            m_contour_to_parts[pt_idx].second.emplace_back(part_id);
                    }
                }
            }
        }
 
    }
 
    
    m_valid = true;
}

References add_object(), Slic3r::cast(), Slic3r::center(), Slic3r::dot(), EPSILON, Slic3r::ModelObject::instances, m_contour_points, m_contour_to_parts, m_debug_pts, m_instance_idx, m_parts, m_valid, model_object(), Slic3r::normal(), Slic3r::Cut::perform_with_plane(), Slic3r::GUI::CommonGizmosDataObjects::ObjectClipper::point_per_contour(), Slic3r::AABBMesh::query_ray_hit(), Slic3r::Geometry::translation_transform(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

PartSelection() [3/3]

Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection	(	const ModelObject *	mo,
		int	instance_idx_in )

    : m_instance_idx (instance_idx_in)
{
    add_object(object);
 
    m_parts.clear();
 
    for (const ModelVolume* volume : object->volumes) {
        assert(volume != nullptr);
        m_parts.emplace_back(Part{ GLModel(), MeshRaycaster(volume->mesh()), true, !volume->is_model_part() });
        m_parts.back().glmodel.init_from(volume->mesh());
 
        // Now check whether this part is below or above the plane.
        m_parts.back().selected = volume->is_from_upper();
    }
    
    m_valid = true;
}

References add_object(), Slic3r::ModelVolume::is_from_upper(), Slic3r::ModelVolume::is_model_part(), m_instance_idx, m_parts, m_valid, Slic3r::ModelVolume::mesh(), and Slic3r::ModelObject::volumes.

Here is the call graph for this function:

~PartSelection()

Slic3r::GUI::GLGizmoCut3D::PartSelection::~PartSelection ( )

inline

{ m_model.clear_objects(); }

References m_model.

Member Function Documentation

add_object()

void Slic3r::GUI::GLGizmoCut3D::PartSelection::add_object ( const ModelObject * object )

private

{
    m_model = Model();
    m_model.add_object(*object);
 
    const double sla_shift_z = wxGetApp().plater()->canvas3D()->get_selection().get_first_volume()->get_sla_shift_z();
    if (!is_approx(sla_shift_z, 0.)) {
        Vec3d inst_offset = model_object()->instances[m_instance_idx]->get_offset();
        inst_offset[Z] += sla_shift_z;
        model_object()->instances[m_instance_idx]->set_offset(inst_offset);
    }
}

References Slic3r::ModelObject::instances, Slic3r::is_approx(), m_instance_idx, m_model, model_object(), and Slic3r::GUI::GLGizmoCut3D::Z.

Referenced by PartSelection(), and PartSelection().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cut_parts()

std::vector< Cut::Part > Slic3r::GUI::GLGizmoCut3D::PartSelection::get_cut_parts

(

)

{
    std::vector<Cut::Part> parts;
 
    for (const auto& part : m_parts)
        parts.push_back({part.selected, part.is_modifier});
 
    return parts;
}

References m_parts, and parts().

Here is the call graph for this function:

get_ignored_contours_ptr()

const std::vector< size_t > * Slic3r::GUI::GLGizmoCut3D::PartSelection::get_ignored_contours_ptr ( ) const

inline

{ return (valid() ? &m_ignored_contours : nullptr); }

References m_ignored_contours, and valid().

Here is the call graph for this function:

is_one_object()

bool Slic3r::GUI::GLGizmoCut3D::PartSelection::is_one_object

(

)

const

{
    // In theory, the implementation could be just this:
    // return m_contour_to_parts.size() == m_ignored_contours.size();
    // However, this would require that the part-contour correspondence works
    // flawlessly. Because it is currently not always so for self-intersecting
    // objects, let's better check the parts itself:
    if (m_parts.size() < 2)
        return true;
    return std::all_of(m_parts.begin(), m_parts.end(), [this](const Part& part) {
        return part.is_modifier || part.selected == m_parts.front().selected;
    });
}

References m_parts.

model_object()

ModelObject * Slic3r::GUI::GLGizmoCut3D::PartSelection::model_object ( )

inline

{ return m_model.objects.front(); }

References m_model.

Referenced by PartSelection(), add_object(), render(), and toggle_selection().

Here is the caller graph for this function:

parts()

const std::vector< Part > & Slic3r::GUI::GLGizmoCut3D::PartSelection::parts ( ) const

inline

{ return m_parts; }

References m_parts.

Referenced by get_cut_parts().

Here is the caller graph for this function:

render()

void Slic3r::GUI::GLGizmoCut3D::PartSelection::render	(	const Vec3d *	normal,
		GLModel &	sphere_model )

{
    if (! valid())
        return;
 
    const Camera&       camera          = wxGetApp().plater()->get_camera();
 
    if (GLShaderProgram* shader = wxGetApp().get_shader("gouraud_light")) {
        shader->start_using();
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
        shader->set_uniform("emission_factor", 0.f);
 
        // FIXME: Cache the transforms.
 
        const Vec3d         inst_offset     = model_object()->instances[m_instance_idx]->get_offset();
        const Transform3d   view_inst_matrix= camera.get_view_matrix() * translation_transform(inst_offset);
 
        const bool is_looking_forward = normal && camera.get_dir_forward().dot(*normal) < 0.05;
 
        for (size_t id=0; id<m_parts.size(); ++id) {
            if (!m_parts[id].is_modifier && normal && ((is_looking_forward && m_parts[id].selected) ||
                                                      (!is_looking_forward && !m_parts[id].selected)   ) )
                continue;
            shader->set_uniform("view_model_matrix", view_inst_matrix * model_object()->volumes[id]->get_matrix());
            if (m_parts[id].is_modifier) {
                glsafe(::glEnable(GL_BLEND));
                glsafe(::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
            }
            m_parts[id].glmodel.set_color(m_parts[id].is_modifier ? MODIFIER_COLOR : (m_parts[id].selected ? UPPER_PART_COLOR : LOWER_PART_COLOR));
            m_parts[id].glmodel.render();
            if (m_parts[id].is_modifier)
                glsafe(::glDisable(GL_BLEND));
        }
 
        shader->stop_using();
    }
 
 
 
    // { // Debugging render:
 
    //     static int idx = -1;
    //     ImGui::Begin("DEBUG");
    //     for (int i=0; i<m_parts.size(); ++i)
    //         if (ImGui::Button(std::to_string(i).c_str()))
    //             idx = i;
    //     if (idx >= m_parts.size())
    //         idx = -1;
    //     ImGui::End();
 
    //     ::glDisable(GL_DEPTH_TEST);
    //     if (valid()) {
    //         for (size_t i=0; i<m_contour_points.size(); ++i) {
    //             const Vec3d& pt = m_contour_points[i];
    //             ColorRGBA col = ColorRGBA::GREEN();
            
    //             bool red = false;
    //             bool yellow = false;
    //             for (size_t j=0; j<m_contour_to_parts[i].first.size(); ++j) {
    //                 red |= m_parts[m_contour_to_parts[i].first[j]].selected;
    //                 yellow |= m_parts[m_contour_to_parts[i].second[j]].selected;
    //             }
    //             if (red)
    //                 col = ColorRGBA::RED();
    //             if (yellow)
    //                 col = ColorRGBA::YELLOW();
                    
    //             GLGizmoCut3D::render_model(sphere_model, col, camera.get_view_matrix() * translation_transform(pt));
    //         }
    //     }
        
    //     if (idx != -1) {
    //         render_model(m_parts[idx].glmodel, ColorRGBA::RED(), camera.get_view_matrix());
    //         for (const Vec3d& pt : m_debug_pts[idx]) {
    //             render_model(sphere_model, ColorRGBA::GREEN(), camera.get_view_matrix() * translation_transform(pt));
    //         }
    //     }
    //     ::glEnable(GL_DEPTH_TEST);
    // }
}

References Slic3r::GUI::Camera::get_dir_forward(), Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), GL_BLEND, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, glBlendFunc, glDisable, glEnable, glsafe, Slic3r::GUI::GLGizmoCut3D::is_looking_forward(), Slic3r::GUI::LOWER_PART_COLOR, m_instance_idx, m_parts, model_object(), Slic3r::GUI::MODIFIER_COLOR, Slic3r::normal(), Slic3r::Geometry::translation_transform(), Slic3r::GUI::UPPER_PART_COLOR, and valid().

Here is the call graph for this function:

toggle_selection()

void Slic3r::GUI::GLGizmoCut3D::PartSelection::toggle_selection

(

const Vec2d &

mouse_pos

)

{
    // FIXME: Cache the transforms.
    const Camera& camera     = wxGetApp().plater()->get_camera();
    const Vec3d&  camera_pos = camera.get_position();
 
    Vec3f pos;
    Vec3f normal;
 
    std::vector<std::pair<size_t, double>> hits_id_and_sqdist;
 
    for (size_t id=0; id<m_parts.size(); ++id) {
//        const Vec3d volume_offset = model_object()->volumes[id]->get_offset();
        Transform3d tr = translation_transform(model_object()->instances[m_instance_idx]->get_offset()) * translation_transform(model_object()->volumes[id]->get_offset());
        if (m_parts[id].raycaster.unproject_on_mesh(mouse_pos, tr, camera, pos, normal)) {
            hits_id_and_sqdist.emplace_back(id, (camera_pos - tr*(pos.cast<double>())).squaredNorm());
        }
    }
    if (! hits_id_and_sqdist.empty()) {
        size_t id = std::min_element(hits_id_and_sqdist.begin(), hits_id_and_sqdist.end(),
            [](const std::pair<size_t, double>& a, const std::pair<size_t, double>& b) { return a.second < b.second; })->first;
        m_parts[id].selected = ! m_parts[id].selected;
 
        // And now recalculate the contours which should be ignored.
        m_ignored_contours.clear();
        size_t cont_id = 0;
        for (const auto& [parts_above, parts_below] : m_contour_to_parts) {
            for (size_t upper : parts_above) {
                bool upper_sel = m_parts[upper].selected;
                if (std::find_if(parts_below.begin(), parts_below.end(), [this, &upper_sel](const size_t& i) { return m_parts[i].selected == upper_sel; }) != parts_below.end()) {
                    m_ignored_contours.emplace_back(cont_id);
                    break;
                }
            }
            ++cont_id;
        }
    }
}

References Slic3r::GUI::Camera::get_position(), m_contour_to_parts, m_ignored_contours, m_instance_idx, m_parts, model_object(), Slic3r::normal(), and Slic3r::Geometry::translation_transform().

Here is the call graph for this function:

turn_over_selection()

void Slic3r::GUI::GLGizmoCut3D::PartSelection::turn_over_selection

(

)

{
    for (Part& part : m_parts)
        part.selected = !part.selected;
}

References m_parts.

valid()

bool Slic3r::GUI::GLGizmoCut3D::PartSelection::valid ( ) const

inline

{ return m_valid; }

References m_valid.

Referenced by get_ignored_contours_ptr(), and render().

Here is the caller graph for this function:

Member Data Documentation

m_contour_points

std::vector<Vec3d> Slic3r::GUI::GLGizmoCut3D::PartSelection::m_contour_points

private

Referenced by PartSelection().

m_contour_to_parts

std::vector<std::pair<std::vector<size_t>, std::vector<size_t> > > Slic3r::GUI::GLGizmoCut3D::PartSelection::m_contour_to_parts

private

Referenced by PartSelection(), and toggle_selection().

m_debug_pts

std::vector<std::vector<Vec3d> > Slic3r::GUI::GLGizmoCut3D::PartSelection::m_debug_pts

private

Referenced by PartSelection().

m_ignored_contours

std::vector<size_t> Slic3r::GUI::GLGizmoCut3D::PartSelection::m_ignored_contours

private

Referenced by get_ignored_contours_ptr(), and toggle_selection().

m_instance_idx

int Slic3r::GUI::GLGizmoCut3D::PartSelection::m_instance_idx

private

Referenced by PartSelection(), PartSelection(), add_object(), render(), and toggle_selection().

m_model

Model Slic3r::GUI::GLGizmoCut3D::PartSelection::m_model

private

Referenced by ~PartSelection(), add_object(), and model_object().

m_parts

std::vector<Part> Slic3r::GUI::GLGizmoCut3D::PartSelection::m_parts

private

Referenced by PartSelection(), PartSelection(), get_cut_parts(), is_one_object(), parts(), render(), toggle_selection(), and turn_over_selection().

m_valid

bool Slic3r::GUI::GLGizmoCut3D::PartSelection::m_valid = false

private

Referenced by PartSelection(), PartSelection(), and valid().

---

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

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