Slic3r::Cut Class Reference

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

Collaboration diagram for Slic3r::Cut:

Classes
struct	Groove
struct	Part

Public Member Functions
	Cut (const ModelObject *object, int instance, const Transform3d &cut_matrix, ModelObjectCutAttributes attributes=ModelObjectCutAttribute::KeepUpper|ModelObjectCutAttribute::KeepLower|ModelObjectCutAttribute::KeepAsParts)
	~Cut ()
const ModelObjectPtrs &	perform_with_plane ()
const ModelObjectPtrs &	perform_by_contour (const ModelObject *src_object, std::vector< Part > parts, int dowels_count)
const ModelObjectPtrs &	perform_with_groove (const Groove &groove, const Transform3d &rotation_m, const int groove_count, const float groove_gap, const float m_radius, bool keep_as_parts=false)

Static Public Member Functions
static float	calculate_groove_width (const Cut::Groove &groove, const float m_radius)

Private Member Functions
void	post_process (ModelObject *object, ModelObjectPtrs &objects, bool keep, bool place_on_cut, bool flip)
void	post_process (ModelObject *upper_object, ModelObject *lower_object, ModelObjectPtrs &objects)
void	finalize (const ModelObjectPtrs &objects, const std::vector< std::optional< TriangleSelector::SavedPainting > > &saved_paintings)

Private Attributes
Model	m_model
int	m_instance
const Transform3d	m_cut_matrix
ModelObjectCutAttributes	m_attributes

Detailed Description

---

Class Documentation

Slic3r::Cut::Groove

struct Slic3r::Cut::Groove

Class Members
float	angle { 0.f }
float	angle_init { 0.f }
float	depth { 0.f }
float	depth_init { 0.f }
float	depth_tolerance { 0.1f }
float	flaps_angle { 0.f }
float	flaps_angle_init { 0.f }
float	width { 0.f }
float	width_init { 0.f }
float	width_tolerance { 0.1f }

Slic3r::Cut::Part

struct Slic3r::Cut::Part

Class Members
bool	is_modifier
bool	selected

Constructor & Destructor Documentation

Cut()

Slic3r::Cut::Cut	(	const ModelObject *	object,
		int	instance,
		const Transform3d &	cut_matrix,
		ModelObjectCutAttributes	attributes = ModelObjectCutAttribute::KeepUpper | ModelObjectCutAttribute::KeepLower | ModelObjectCutAttribute::KeepAsParts )

    : m_instance(instance), m_cut_matrix(cut_matrix), m_attributes(attributes)
{
    m_model = Model();
    if (object)
        m_model.add_object(*object);
}

References m_attributes, m_cut_matrix, m_instance, and m_model.

Referenced by perform_by_contour(), and perform_with_groove().

Here is the caller graph for this function:

~Cut()

Slic3r::Cut::~Cut ( )

inline

{ m_model.clear_objects(); }

References m_model.

Member Function Documentation

calculate_groove_width()

float Slic3r::Cut::calculate_groove_width ( const Cut::Groove & groove, const float m_radius )

static

{
    // Compute same slot outer width used in preview plane
    const double flap_width             = is_approx(groove.flaps_angle, 0.f) ? groove.depth : groove.depth / sin(groove.flaps_angle);
    const double total_flap_width       = 2.0 * flap_width * cos(groove.flaps_angle);
    const double slot_neck_half_width   = 0.5f * (groove.width);
    const double slot_mouth_half_width  = 0.5 * (groove.width + total_flap_width);
    const double plane_half_height      = 0.5f* (1.5f * (1.5f *m_radius));
    const double flap_taper_offset      = plane_half_height * tan(groove.angle);
    const double slot_outer_x_max       = std::max(slot_mouth_half_width + flap_taper_offset, slot_neck_half_width + flap_taper_offset);
 
    return float(2.0 * slot_outer_x_max);
}

References Slic3r::Cut::Groove::angle, Slic3r::Cut::Groove::depth, Slic3r::Cut::Groove::flaps_angle, Slic3r::is_approx(), and Slic3r::Cut::Groove::width.

Referenced by perform_with_groove(), and Slic3r::GUI::GLGizmoCut3D::render_cut_plane_input_window().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

void Slic3r::Cut::finalize ( const ModelObjectPtrs & objects, const std::vector< std::optional< TriangleSelector::SavedPainting > > & saved_paintings )

private

{
    // Paint volumes
    for (const auto& saved_painting : saved_paintings) {
        if (saved_painting) {
            for (const auto object : objects) {
                for (const auto volume : object->volumes) {
                    if (volume->is_model_part() && !volume->is_cut_connector()) {
                    volume->restore_painting(saved_painting, true);
                    }
                }
            }
        }
    }
 
    //clear model from temporary objects
    m_model.clear_objects();
 
    // add to model result objects
    m_model.objects = objects;
}

References m_model, and Slic3r::ModelObject::volumes.

Referenced by perform_by_contour(), perform_with_groove(), and perform_with_plane().

Here is the caller graph for this function:

perform_by_contour()

const ModelObjectPtrs & Slic3r::Cut::perform_by_contour	(	const ModelObject *	src_object,
		std::vector< Part >	parts,
		int	dowels_count )

{
    ModelObject* cut_mo = m_model.objects.front();
 
    // Clone the object to duplicate instances, materials etc.
    ModelObject* upper{ nullptr };
    if (m_attributes.has(ModelObjectCutAttribute::KeepUpper)) cut_mo->clone_for_cut(&upper);
    ModelObject* lower{ nullptr };
    if (m_attributes.has(ModelObjectCutAttribute::KeepLower)) cut_mo->clone_for_cut(&lower);
 
    if (upper && lower) {
        upper->name = upper->name + "_A";
        lower->name = lower->name + "_B";
    }
 
    // Save painting data so we later can remap it.
    std::vector<std::optional<TriangleSelector::SavedPainting>> saved_paintings;
    if (m_attributes.has(ModelObjectCutAttribute::KeepPaint)) {
        const auto instance_matrix = src_object->instances[m_instance]->get_transformation().get_matrix_no_offset();
        for (const auto volume : src_object->volumes) {
            saved_paintings.emplace_back(volume->save_painting());
            if (saved_paintings.back()) {
                // Transform mesh to cut space (same transform as process_volume_cut applies)
                saved_paintings.back()->mesh.transform(instance_matrix * volume->get_matrix(), true);
            }
        }
    }
 
    const size_t cut_parts_cnt = parts.size();
    bool has_modifiers = false;
 
    // Distribute SolidParts to the Upper/Lower object
    for (size_t id = 0; id < cut_parts_cnt; ++id) {
        if (parts[id].is_modifier)
            has_modifiers = true; // modifiers will be added later to the related parts
        else if (ModelObject* obj = (parts[id].selected ? upper : lower))
            obj->add_volume(*(cut_mo->volumes[id]));
    }
 
    if (has_modifiers) {
        // Distribute Modifiers to the Upper/Lower object
        distribute_modifiers_from_object(cut_mo, m_instance, upper, lower);
    }
 
    ModelObjectPtrs cut_object_ptrs;
 
    ModelVolumePtrs& volumes = cut_mo->volumes;
    if (volumes.size() == cut_parts_cnt) {
        // Means that object is cut without connectors
 
        // Just add Upper and Lower objects to cut_object_ptrs
        post_process(upper, lower, cut_object_ptrs);
 
        // Now merge all model parts together:
        merge_solid_parts_inside_object(cut_object_ptrs);
 
        // replace initial objects in model with cut object 
        finalize(cut_object_ptrs, saved_paintings);
    }
    else if (volumes.size() > cut_parts_cnt) {
        // Means that object is cut with connectors
 
        // All volumes are distributed to Upper / Lower object,
        // So we don’t need them anymore
        for (size_t id = 0; id < cut_parts_cnt; id++)
            delete* (volumes.begin() + id);
        volumes.erase(volumes.begin(), volumes.begin() + cut_parts_cnt);
 
        // Perform cut just to get connectors
        Cut cut(cut_mo, m_instance, m_cut_matrix, m_attributes);
        const ModelObjectPtrs& cut_connectors_obj = cut.perform_with_plane();
        assert(dowels_count > 0 ? cut_connectors_obj.size() >= 3 : cut_connectors_obj.size() == 2);
 
        // Connectors from upper object
        for (const ModelVolume* volume : cut_connectors_obj[0]->volumes)
            upper->add_volume(*volume, volume->type());
 
        // Connectors from lower object
        for (const ModelVolume* volume : cut_connectors_obj[1]->volumes)
            lower->add_volume(*volume, volume->type());
 
        // Add Upper and Lower objects to cut_object_ptrs
        post_process(upper, lower, cut_object_ptrs);
 
        // Now merge all model parts together:
        merge_solid_parts_inside_object(cut_object_ptrs);
 
        // replace initial objects in model with cut object
        finalize(cut_object_ptrs, saved_paintings);
 
        // Add Dowel-connectors as separate objects to model
        if (cut_connectors_obj.size() >= 3)
            for (size_t id = 2; id < cut_connectors_obj.size(); id++)
                m_model.add_object(*cut_connectors_obj[id]);
    }
 
    return m_model.objects;
}

References Cut(), Slic3r::ModelObject::add_volume(), Slic3r::ModelObject::clone_for_cut(), Slic3r::distribute_modifiers_from_object(), finalize(), Slic3r::ModelObject::instances, Slic3r::KeepLower, Slic3r::KeepPaint, Slic3r::KeepUpper, m_attributes, m_cut_matrix, m_instance, m_model, Slic3r::merge_solid_parts_inside_object(), Slic3r::ModelObject::name, perform_with_plane(), post_process(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_with_groove()

const ModelObjectPtrs & Slic3r::Cut::perform_with_groove	(	const Groove &	groove,
		const Transform3d &	rotation_m,
		const int	groove_count,
		const float	groove_gap,
		const float	m_radius,
		bool	keep_as_parts = false )

{
    ModelObject* cut_mo = m_model.objects.front();
 
    // Clone the object to duplicate instances, materials etc.
    ModelObject* upper{ nullptr };
    cut_mo->clone_for_cut(&upper);
    ModelObject* lower{ nullptr };
    cut_mo->clone_for_cut(&lower);
 
    if (upper && lower) {
        upper->name = upper->name + "_A";
        lower->name = lower->name + "_B";
    }
 
    // Save painting data so we later can remap it.
    std::vector<std::optional<TriangleSelector::SavedPainting>> saved_paintings;
    if (m_attributes.has(ModelObjectCutAttribute::KeepPaint)) {
        const auto instance_matrix = cut_mo->instances[m_instance]->get_transformation().get_matrix_no_offset();
        for (const auto volume : cut_mo->volumes) {
            saved_paintings.emplace_back(volume->save_painting());
            if (saved_paintings.back()) {
                // Transform mesh to cut space (same transform as process_volume_cut applies)
                saved_paintings.back()->mesh.transform(instance_matrix * volume->get_matrix(), true);
            }
        }
    }
 
    const double groove_half_depth = 0.5 * double(groove.depth);
 
    Model tmp_model_for_cut = Model();
 
    Model tmp_model = Model();
    tmp_model.add_object(*cut_mo);
    ModelObject* tmp_object = tmp_model.objects.front();
 
    auto add_volumes_from_cut = [](ModelObject* object, const ModelObjectCutAttribute attribute, const Model& tmp_model_for_cut) {
        const auto& volumes = tmp_model_for_cut.objects.front()->volumes;
        for (const ModelVolume* volume : volumes)
            if (volume->is_model_part()) {
                if ((attribute == ModelObjectCutAttribute::KeepUpper && volume->is_from_upper()) ||
                    (attribute != ModelObjectCutAttribute::KeepUpper && !volume->is_from_upper())) {
                    ModelVolume* new_vol = object->add_volume(*volume);
                    new_vol->reset_from_upper();
                }
            }
    };
 
    auto cut = [this, add_volumes_from_cut]
                (ModelObject* object, const Transform3d& cut_matrix, const ModelObjectCutAttribute add_volumes_attribute, Model& tmp_model_for_cut) {
        Cut cut(object, m_instance, cut_matrix);
 
        tmp_model_for_cut = Model();
        tmp_model_for_cut.add_object(*cut.perform_with_plane().front());
        assert(!tmp_model_for_cut.objects.empty());
 
        object->clear_volumes();
        add_volumes_from_cut(object, add_volumes_attribute, tmp_model_for_cut);
        reset_instance_transformation(object, m_instance);
    };
 
    // cut by upper plane (+Z)
    {
        const Transform3d cut_matrix_upper = translation_transform(rotation_m * (groove_half_depth * Vec3d::UnitZ())) * m_cut_matrix;
 
        cut(tmp_object, cut_matrix_upper, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
        add_volumes_from_cut(upper, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
    }
 
    // cut by lower plane (-Z)
    {
        const Transform3d cut_matrix_lower = translation_transform(rotation_m * (-groove_half_depth * Vec3d::UnitZ())) * m_cut_matrix;
 
        cut(tmp_object, cut_matrix_lower, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
        add_volumes_from_cut(lower, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
    }
 
    // Compute same slot outer width used in preview plane
    const float  groove_width     = calculate_groove_width(groove, m_radius);
 
    ModelObject* groove_object{nullptr};
 
    // multiple cuts
    for (int i = 0; i < groove_count; i++) {
        bool is_first_groove = i == 0; 
        bool is_last_groove = i == groove_count - 1; 
 
        // Calculate the x-axis offset for this dovetail
        float groove_offset_factor_start = -.5 * ((groove_count - 1));
        float groove_offset_factor       = groove_offset_factor_start + i;
 
        float offset_x = groove_offset_factor * (groove_gap + groove_width);
 
 
        tmp_object->clone_for_cut(&groove_object);
        for (ModelVolume* volume : tmp_object->volumes) {
            ModelVolume* new_vol = groove_object->add_volume(*volume);
            new_vol->reset_from_upper();
        }
 
        // isolate area of current groove
        if (!is_first_groove) {
            float left_cut_position = (-groove_gap / 2.f) - (groove_width / 2.f) + offset_x;
 
            const Transform3d cut_matrix_left = translation_transform(rotation_m * (left_cut_position * Vec3d::UnitX())) *
                                                m_cut_matrix * rotation_transform(Vec3d(0, M_PI / 2.0, 0));
 
            cut(groove_object, cut_matrix_left, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
        }
        if (!is_last_groove) {
            float right_cut_position = (groove_gap / 2.f) + (groove_width / 2.f) + offset_x;
 
            const Transform3d cut_matrix_right = translation_transform(rotation_m * (right_cut_position * Vec3d::UnitX())) *
                                                 m_cut_matrix * rotation_transform(Vec3d(0, M_PI / 2.0, 0));
            cut(groove_object, cut_matrix_right, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
        }
 
        const Transform3d groove_translation = translation_transform(rotation_m * (offset_x * Vec3d::UnitX()));
        // cut middle part with 2 angles and add parts to related upper/lower objects
        const double h_side_shift = 0.5 * double(groove.width + groove.depth / tan(groove.flaps_angle));
 
        // cut by angle1 plane
        {
            const Transform3d cut_matrix_angle1 = groove_translation * translation_transform(rotation_m * (-h_side_shift * Vec3d::UnitX())) *
                                                  m_cut_matrix * rotation_transform(Vec3d(0, -groove.flaps_angle, -groove.angle));
 
            cut(groove_object, cut_matrix_angle1, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
            add_volumes_from_cut(lower, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
        }
 
        // cut by angle2 plane
        {
            const Transform3d cut_matrix_angle2 = groove_translation * translation_transform(rotation_m * (h_side_shift * Vec3d::UnitX())) *
                                                  m_cut_matrix * rotation_transform(Vec3d(0, groove.flaps_angle, groove.angle));
 
            cut(groove_object, cut_matrix_angle2, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
            add_volumes_from_cut(lower, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
        }
 
        // apply tolerance to the middle part
        {
            const double h_groove_shift_tolerance = groove_half_depth - (double)groove.depth_tolerance;
 
            const Transform3d cut_matrix_lower_tolerance = groove_translation * translation_transform(rotation_m * (-h_groove_shift_tolerance * Vec3d::UnitZ())) *
                                                           m_cut_matrix;
            cut(groove_object, cut_matrix_lower_tolerance, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
 
            const double h_side_shift_tolerance = h_side_shift - 0.5 * double(groove.width_tolerance);
 
            const Transform3d cut_matrix_angle1_tolerance = groove_translation * translation_transform(rotation_m * (-h_side_shift_tolerance * Vec3d::UnitX())) *
                                                            m_cut_matrix * rotation_transform(Vec3d(0, -groove.flaps_angle, -groove.angle));
            cut(groove_object, cut_matrix_angle1_tolerance, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
 
            const Transform3d cut_matrix_angle2_tolerance = groove_translation * translation_transform(rotation_m * (h_side_shift_tolerance * Vec3d::UnitX())) *
                                                            m_cut_matrix * rotation_transform(Vec3d(0, groove.flaps_angle, groove.angle));
            cut(groove_object, cut_matrix_angle2_tolerance, ModelObjectCutAttribute::KeepUpper, tmp_model_for_cut);
        }
 
        add_volumes_from_cut(upper, ModelObjectCutAttribute::KeepLower, tmp_model_for_cut);
 
        groove_object->clear_volumes();
    }
 
    ModelObjectPtrs cut_object_ptrs;
 
    if (keep_as_parts) {
        // add volumes from lower object to the upper, but mark them as a lower
        const auto& volumes = lower->volumes;
        for (const ModelVolume* volume : volumes) {
            ModelVolume* new_vol = upper->add_volume(*volume);
            new_vol->cut_info.is_from_upper = false;
        }
 
        // add modifiers
        for (const ModelVolume* volume : cut_mo->volumes)
            if (!volume->is_model_part())
                upper->add_volume(*volume);
 
        cut_object_ptrs.push_back(upper);
 
        // add lower object to the cut_object_ptrs just to correct delete it from the Model destructor and avoid memory leaks
        cut_object_ptrs.push_back(lower);
    }
    else {
        // add modifiers if object has any
        for (const ModelVolume* volume : cut_mo->volumes)
            if (!volume->is_model_part()) {
                distribute_modifiers_from_object(cut_mo, m_instance, upper, lower);
                break;
            }
 
        assert(!upper->volumes.empty() && !lower->volumes.empty());
 
        // Add Upper and Lower parts to cut_object_ptrs
 
        post_process(upper, lower, cut_object_ptrs);
 
        // Now merge all model parts together:
        merge_solid_parts_inside_object(cut_object_ptrs);
    }
 
    finalize(cut_object_ptrs, saved_paintings);
 
    return m_model.objects;
}

References Cut(), Slic3r::Model::add_object(), Slic3r::ModelObject::add_volume(), Slic3r::Cut::Groove::angle, calculate_groove_width(), Slic3r::ModelObject::clear_volumes(), Slic3r::ModelObject::clone_for_cut(), Slic3r::ModelVolume::cut_info, Slic3r::Cut::Groove::depth, Slic3r::Cut::Groove::depth_tolerance, Slic3r::distribute_modifiers_from_object(), finalize(), Slic3r::Cut::Groove::flaps_angle, Slic3r::ModelObject::instances, Slic3r::ModelVolume::CutInfo::is_from_upper, Slic3r::ModelVolume::is_model_part(), Slic3r::KeepLower, Slic3r::KeepPaint, Slic3r::KeepUpper, m_attributes, m_cut_matrix, m_instance, m_model, M_PI, Slic3r::merge_solid_parts_inside_object(), Slic3r::ModelObject::name, Slic3r::Model::objects, perform_with_plane(), post_process(), Slic3r::ModelVolume::reset_from_upper(), Slic3r::reset_instance_transformation(), Slic3r::Geometry::rotation_transform(), Slic3r::Geometry::translation_transform(), Slic3r::ModelObject::volumes, Slic3r::Cut::Groove::width, and Slic3r::Cut::Groove::width_tolerance.

Referenced by Slic3r::GUI::GLGizmoCut3D::perform_cut(), and Slic3r::GUI::GLGizmoCut3D::process_contours().

Here is the call graph for this function:

Here is the caller graph for this function:

perform_with_plane()

const ModelObjectPtrs & Slic3r::Cut::perform_with_plane

(

)

{
    if (!m_attributes.has(ModelObjectCutAttribute::KeepUpper) && !m_attributes.has(ModelObjectCutAttribute::KeepLower)) {
        m_model.clear_objects();
        return m_model.objects;
    }
 
    ModelObject* mo = m_model.objects.front();
 
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::cut - start";
 
    // Clone the object to duplicate instances, materials etc.
    ModelObject* upper{ nullptr };
    if (m_attributes.has(ModelObjectCutAttribute::KeepUpper))
        mo->clone_for_cut(&upper);
 
    ModelObject* lower{ nullptr };
    if (m_attributes.has(ModelObjectCutAttribute::KeepLower) && !m_attributes.has(ModelObjectCutAttribute::KeepAsParts))
        mo->clone_for_cut(&lower);
 
    std::vector<ModelObject*> dowels;
 
    // Because transformations are going to be applied to meshes directly,
    // we reset transformation of all instances and volumes,
    // except for translation and Z-rotation on instances, which are preserved
    // in the transformation matrix and not applied to the mesh transform.
 
    const auto              instance_matrix = mo->instances[m_instance]->get_transformation().get_matrix_no_offset();
    const Transformation    cut_transformation = Transformation(m_cut_matrix);
    const Transform3d       inverse_cut_matrix = cut_transformation.get_rotation_matrix().inverse() * translation_transform(-1. * cut_transformation.get_offset());
 
    std::vector<std::optional<TriangleSelector::SavedPainting>> saved_paintings;
    for (ModelVolume* volume : mo->volumes) {
        // Save painting data before reset_extra_facets() discards it.
        if (m_attributes.has(ModelObjectCutAttribute::KeepPaint)) {
            saved_paintings.emplace_back(volume->save_painting());
            if (saved_paintings.back()) {
                // Transform mesh to cut space (same transform as process_volume_cut applies)
                saved_paintings.back()->mesh.transform(instance_matrix * volume->get_matrix(), true);
            }
        }
 
        volume->reset_extra_facets();
 
        if (!volume->is_model_part()) {
            if (volume->cut_info.is_processed)
                process_modifier_cut(volume, instance_matrix, inverse_cut_matrix, m_attributes, upper, lower);
            else
                process_connector_cut(volume, instance_matrix, m_cut_matrix, m_attributes, upper, lower, dowels);
        }
        else if (!volume->mesh().empty())
            process_solid_part_cut(volume, instance_matrix, m_cut_matrix, m_attributes, upper, lower);
    }
 
    // Post-process cut parts
 
    if (m_attributes.has(ModelObjectCutAttribute::KeepAsParts) && upper->volumes.empty()) {
        m_model = Model();
        m_model.objects.push_back(upper);
        return m_model.objects;
    }
 
    ModelObjectPtrs cut_object_ptrs;
 
    if (m_attributes.has(ModelObjectCutAttribute::KeepAsParts) && !upper->volumes.empty()) {
        reset_instance_transformation(upper, m_instance, m_cut_matrix);
        cut_object_ptrs.push_back(upper);
    }
    else {
        // Delete all modifiers which are not intersecting with solid parts bounding box
        auto delete_extra_modifiers = [this](ModelObject* mo) {
            if (!mo) return;
            const BoundingBoxf3 obj_bb = mo->instance_bounding_box(m_instance);
            const Transform3d inst_matrix = mo->instances[m_instance]->get_transformation().get_matrix();
 
            for (int i = int(mo->volumes.size()) - 1; i >= 0; --i)
                if (const ModelVolume* vol = mo->volumes[i];
                    !vol->is_model_part() && !vol->is_cut_connector()) {
                    auto bb = vol->mesh().transformed_bounding_box(inst_matrix * vol->get_matrix());
                    if (!obj_bb.intersects(bb))
                        mo->delete_volume(i);
                }
        };
 
        post_process(upper, lower, cut_object_ptrs);
        delete_extra_modifiers(upper);
        delete_extra_modifiers(lower);
 
        if (m_attributes.has(ModelObjectCutAttribute::CreateDowels) && !dowels.empty()) {
            for (auto dowel : dowels) {
                reset_instance_transformation(dowel, m_instance);
                dowel->name += "-Dowel-" + dowel->volumes[0]->name;
                cut_object_ptrs.push_back(dowel);
            }
        }
    }
 
    finalize(cut_object_ptrs, saved_paintings);
 
    BOOST_LOG_TRIVIAL(trace) << "ModelObject::cut - end";
 
    return m_model.objects;
}

References Slic3r::ModelObject::clone_for_cut(), Slic3r::CreateDowels, Slic3r::ModelVolume::cut_info, Slic3r::ModelObject::delete_volume(), Slic3r::TriangleMesh::empty(), finalize(), Slic3r::ModelVolume::get_matrix(), Slic3r::Geometry::Transformation::get_offset(), Slic3r::Geometry::Transformation::get_rotation_matrix(), Slic3r::ModelObject::instance_bounding_box(), Slic3r::ModelObject::instances, Slic3r::BoundingBox3Base< PointType >::intersects(), Slic3r::ModelVolume::is_model_part(), Slic3r::ModelVolume::CutInfo::is_processed, Slic3r::KeepAsParts, Slic3r::KeepLower, Slic3r::KeepPaint, Slic3r::KeepUpper, m_attributes, m_cut_matrix, m_instance, m_model, Slic3r::ModelVolume::mesh(), post_process(), Slic3r::process_connector_cut(), Slic3r::process_modifier_cut(), Slic3r::process_solid_part_cut(), Slic3r::ModelVolume::reset_extra_facets(), Slic3r::reset_instance_transformation(), Slic3r::ModelVolume::save_painting(), Slic3r::trace(), Slic3r::Geometry::translation_transform(), and Slic3r::ModelObject::volumes.

Referenced by Slic3r::GUI::GLGizmoCut3D::PartSelection::PartSelection(), Slic3r::GUI::cut_model(), perform_by_contour(), Slic3r::GUI::GLGizmoCut3D::perform_cut(), and perform_with_groove().

Here is the call graph for this function:

Here is the caller graph for this function:

post_process() [1/2]

void Slic3r::Cut::post_process ( ModelObject * object, ModelObjectPtrs & objects, bool keep, bool place_on_cut, bool flip )

private

{
    if (!object) return;
 
    if (keep && !object->volumes.empty()) {
        reset_instance_transformation(object, m_instance, m_cut_matrix, place_on_cut, flip);
        cut_object_ptrs.push_back(object);
    }
    else
        m_model.objects.push_back(object); // will be deleted in m_model.clear_objects();
}

References m_cut_matrix, m_instance, m_model, Slic3r::reset_instance_transformation(), and Slic3r::ModelObject::volumes.

Referenced by perform_by_contour(), perform_with_groove(), perform_with_plane(), and post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

post_process() [2/2]

void Slic3r::Cut::post_process ( ModelObject * upper_object, ModelObject * lower_object, ModelObjectPtrs & objects )

private

{
    post_process(upper, cut_object_ptrs,
        m_attributes.has(ModelObjectCutAttribute::KeepUpper),
        m_attributes.has(ModelObjectCutAttribute::PlaceOnCutUpper),
        m_attributes.has(ModelObjectCutAttribute::FlipUpper));
 
    post_process(lower, cut_object_ptrs,
        m_attributes.has(ModelObjectCutAttribute::KeepLower),
        m_attributes.has(ModelObjectCutAttribute::PlaceOnCutLower),
        m_attributes.has(ModelObjectCutAttribute::PlaceOnCutLower) || m_attributes.has(ModelObjectCutAttribute::FlipLower));
}

References Slic3r::FlipLower, Slic3r::FlipUpper, Slic3r::KeepLower, Slic3r::KeepUpper, m_attributes, Slic3r::PlaceOnCutLower, Slic3r::PlaceOnCutUpper, and post_process().

Here is the call graph for this function:

Member Data Documentation

m_attributes

ModelObjectCutAttributes Slic3r::Cut::m_attributes

private

Referenced by Cut(), perform_by_contour(), perform_with_groove(), perform_with_plane(), and post_process().

m_cut_matrix

const Transform3d Slic3r::Cut::m_cut_matrix

private

Referenced by Cut(), perform_by_contour(), perform_with_groove(), perform_with_plane(), and post_process().

m_instance

int Slic3r::Cut::m_instance

private

Referenced by Cut(), perform_by_contour(), perform_with_groove(), perform_with_plane(), and post_process().

m_model

Model Slic3r::Cut::m_model

private

Referenced by Cut(), ~Cut(), finalize(), perform_by_contour(), perform_with_groove(), perform_with_plane(), and post_process().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/CutUtils.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/CutUtils.cpp