Slic3r::GUI::MeshClipper Class Reference

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

Collaboration diagram for Slic3r::GUI::MeshClipper:

Classes
struct	CutIsland
struct	ClipResult

Public Member Functions
void	set_behaviour (bool fill_cut, double contour_width)
void	set_plane (const ClippingPlane &plane)
void	set_limiting_plane (const ClippingPlane &plane)
void	set_mesh (const indexed_triangle_set &mesh)
void	set_mesh (AnyPtr< const indexed_triangle_set > &&ptr)
void	set_negative_mesh (const indexed_triangle_set &mesh)
void	set_negative_mesh (AnyPtr< const indexed_triangle_set > &&ptr)
template<class It>
void	set_mesh (const Range< It > &csgrange, bool copy_meshes=false)
void	set_transformation (const Geometry::Transformation &trafo)
void	render_cut (const ColorRGBA &color, const std::vector< size_t > *ignore_idxs=nullptr)
void	render_contour (const ColorRGBA &color, const std::vector< size_t > *ignore_idxs=nullptr)
int	is_projection_inside_cut (const Vec3d &point) const
bool	has_valid_contour () const
int	get_number_of_contours () const
std::vector< Vec3d >	point_per_contour () const

Private Member Functions
void	recalculate_triangles ()

Private Attributes
Geometry::Transformation	m_trafo
AnyPtr< const indexed_triangle_set >	m_mesh
AnyPtr< const indexed_triangle_set >	m_negative_mesh
std::vector< csg::CSGPart >	m_csgmesh
ClippingPlane	m_plane
ClippingPlane	m_limiting_plane = ClippingPlane::ClipsNothing()
std::optional< ClipResult >	m_result
bool	m_fill_cut = true
double	m_contour_width = 0.

Detailed Description

---

Class Documentation

Slic3r::GUI::MeshClipper::CutIsland

struct Slic3r::GUI::MeshClipper::CutIsland

Collaboration diagram for Slic3r::GUI::MeshClipper::CutIsland:

Class Members
bool	disabled = false
ExPolygon	expoly
BoundingBox	expoly_bb
size_t	hash
GLModel	model
GLModel	model_expanded

Slic3r::GUI::MeshClipper::ClipResult

struct Slic3r::GUI::MeshClipper::ClipResult

Collaboration diagram for Slic3r::GUI::MeshClipper::ClipResult:

Class Members
vector< CutIsland >	cut_islands
Transform3d	trafo

Member Function Documentation

get_number_of_contours()

int Slic3r::GUI::MeshClipper::get_number_of_contours ( ) const

inline

{ return m_result ? m_result->cut_islands.size() : 0; }

References m_result.

has_valid_contour()

bool Slic3r::GUI::MeshClipper::has_valid_contour

(

)

const

{
    return m_result && std::any_of(m_result->cut_islands.begin(), m_result->cut_islands.end(), [](const CutIsland& isl) { return !isl.expoly.empty(); });
}

References m_result.

is_projection_inside_cut()

int Slic3r::GUI::MeshClipper::is_projection_inside_cut

(

const Vec3d &

point

)

const

{
    if (!m_result || m_result->cut_islands.empty())
        return -1;
    Vec3d point = m_result->trafo.inverse() * point_in;
    Point pt_2d = Point::new_scale(Vec2d(point.x(), point.y()));
 
    for (int i=0; i<int(m_result->cut_islands.size()); ++i) {
        const CutIsland& isl = m_result->cut_islands[i];
        if (isl.expoly_bb.contains(pt_2d) && isl.expoly.contains(pt_2d))
            return i; // TODO: handle intersecting contours
    }
    return -1;
}

References Slic3r::BoundingBoxBase< PointType, APointsType >::contains(), Slic3r::ExPolygon::contains(), Slic3r::GUI::MeshClipper::CutIsland::expoly, Slic3r::GUI::MeshClipper::CutIsland::expoly_bb, m_result, and Slic3r::Point::new_scale().

Here is the call graph for this function:

point_per_contour()

std::vector< Vec3d > Slic3r::GUI::MeshClipper::point_per_contour

(

)

const

                                                      {
    std::vector<Vec3d> out;
    if (m_result == std::nullopt) {
        return out;
    }
    assert(m_result);
    for (const auto& isl : m_result->cut_islands) {
        assert(isl.expoly.contour.size() > 2);
        // Now return a point lying inside the contour but not in a hole.
        // We do this by taking a point lying close to the edge, repeating
        // this several times for different edges and distances from them.
        // (We prefer point not extremely close to the border.
        bool done = false;
        Vec2d p;
        size_t i = 1;
        while (i < isl.expoly.contour.size()) {
            const Vec2d& a = unscale(isl.expoly.contour.points[i-1]);
            const Vec2d& b = unscale(isl.expoly.contour.points[i]);
            Vec2d n = (b-a).normalized();
            std::swap(n.x(), n.y());
            n.x() = -1 * n.x();
            double f = 10.;
            while (f > 0.05) {
                p = (0.5*(b+a)) + f * n;
                if (isl.expoly.contains(Point::new_scale(p))) {
                    done = true;
                    break;
                }
                f = f/10.;
            }
            if (done)
                break;
            i += std::max(size_t(2), isl.expoly.contour.size() / 5);
        }
        // If the above failed, just return the centroid, regardless of whether
        // it is inside the contour or in a hole (we must return something).
        Vec2d c = done ? p : unscale(isl.expoly.contour.centroid());
        out.emplace_back(m_result->trafo * Vec3d(c.x(), c.y(), 0.));
    }
    return out;
}

References Slic3r::f(), m_result, Slic3r::Point::new_scale(), and Slic3r::unscale().

Here is the call graph for this function:

recalculate_triangles()

void Slic3r::GUI::MeshClipper::recalculate_triangles ( )

private

{
    m_result = ClipResult();
 
    auto plane_mesh = Eigen::Hyperplane<double, 3>(m_plane.get_normal(), -m_plane.distance(Vec3d::Zero())).transform(m_trafo.get_matrix().inverse());
    const Vec3d up = plane_mesh.normal();
    const float height_mesh = -plane_mesh.offset();
 
    // Now do the cutting
    MeshSlicingParams slicing_params;
    slicing_params.trafo.rotate(Eigen::Quaternion<double, Eigen::DontAlign>::FromTwoVectors(up, Vec3d::UnitZ()));
 
    ExPolygons expolys;
 
    if (m_csgmesh.empty()) {
        if (m_mesh)
            expolys = union_ex(slice_mesh(*m_mesh, height_mesh, slicing_params));
 
        if (m_negative_mesh && !m_negative_mesh->empty()) {
            const ExPolygons neg_expolys = union_ex(slice_mesh(*m_negative_mesh, height_mesh, slicing_params));
            expolys = diff_ex(expolys, neg_expolys);
        }
    } else {
        expolys = std::move(csg::slice_csgmesh_ex(range(m_csgmesh), {height_mesh}, MeshSlicingParamsEx{slicing_params}).front());
    }
 
 
    // Triangulate and rotate the cut into world coords:
    Eigen::Quaterniond q;
    q.setFromTwoVectors(Vec3d::UnitZ(), up);
    Transform3d tr = Transform3d::Identity();
    tr.rotate(q);
    tr = m_trafo.get_matrix() * tr;
 
    m_result->trafo = tr;
 
    if (m_limiting_plane != ClippingPlane::ClipsNothing())
    {
        // Now remove whatever ended up below the limiting plane (e.g. sinking objects).
        // First transform the limiting plane from world to mesh coords.
        // Note that inverse of tr transforms the plane from world to horizontal.
        const Vec3d normal_old = m_limiting_plane.get_normal().normalized();
        const Vec3d normal_new = (tr.matrix().block<3,3>(0,0).transpose() * normal_old).normalized();
 
        // normal_new should now be the plane normal in mesh coords. To find the offset,
        // transform a point and set offset so it belongs to the transformed plane.
        Vec3d pt = Vec3d::Zero();
        const double plane_offset = m_limiting_plane.get_data()[3];
        if (std::abs(normal_old.z()) > 0.5) // normal is normalized, at least one of the coords if larger than sqrt(3)/3 = 0.57
            pt.z() = - plane_offset / normal_old.z();
        else if (std::abs(normal_old.y()) > 0.5)
            pt.y() = - plane_offset / normal_old.y();
        else
            pt.x() = - plane_offset / normal_old.x();
        pt = tr.inverse() * pt;
        const double offset = -(normal_new.dot(pt));
 
        if (std::abs(normal_old.dot(m_plane.get_normal().normalized())) > 0.99) {
            // The cuts are parallel, show all or nothing.
            if (normal_old.dot(m_plane.get_normal().normalized()) < 0.0 && offset < height_mesh)
                expolys.clear();
        } else {
            // The cut is a horizontal plane defined by z=height_mesh.
            // ax+by+e=0 is the line of intersection with the limiting plane.
            // Normalized so a^2 + b^2 = 1.
            const double len = std::hypot(normal_new.x(), normal_new.y());
            if (len == 0.)
                return;
            const double a = normal_new.x() / len;
            const double b = normal_new.y() / len;
            const double e = (normal_new.z() * height_mesh + offset) / len;
 
            // We need a half-plane to limit the cut. Get angle of the intersecting line.
            double angle = (b != 0.0) ? std::atan(-a / b) : ((a < 0.0) ? -0.5 * M_PI : 0.5 * M_PI);
            if (b > 0) // select correct half-plane
                angle += M_PI;
 
            // We'll take a big rectangle above x-axis and rotate and translate
            // it so it lies on our line. This will be the figure to subtract
            // from the cut. The coordinates must not overflow after the transform,
            // make the rectangle a bit smaller.
            const coord_t size = (double(std::numeric_limits<coord_t>::max()/2) - scale_(std::max(std::abs(e * a), std::abs(e * b)))) / 4;
            Polygons ep {Polygon({Point(-size, 0), Point(size, 0), Point(size, 2*size), Point(-size, 2*size)})};
            ep.front().rotate(angle);
            ep.front().translate(scale_(-e * a), scale_(-e * b));
            expolys = diff_ex(expolys, ep);
        }
    }
 
    tr.pretranslate(0.001 * m_plane.get_normal().normalized()); // to avoid z-fighting
    Transform3d tr2 = tr;
    tr2.pretranslate(0.002 * m_plane.get_normal().normalized());
 
 
    std::vector<Vec2f> triangles2d;
 
    for (const ExPolygon& exp : expolys) {
        triangles2d.clear();
 
        m_result->cut_islands.push_back(CutIsland());
        CutIsland& isl = m_result->cut_islands.back();
 
        if (m_fill_cut) {
            triangles2d = triangulate_expolygon_2f(exp, m_trafo.get_matrix().matrix().determinant() < 0.);
            GLModel::Geometry init_data;
            init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
            init_data.reserve_vertices(triangles2d.size());
            init_data.reserve_indices(triangles2d.size());
 
            // vertices + indices
            for (auto it = triangles2d.cbegin(); it != triangles2d.cend(); it = it + 3) {
                init_data.add_vertex((Vec3f)(tr * Vec3d((*(it + 0)).x(), (*(it + 0)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                init_data.add_vertex((Vec3f)(tr * Vec3d((*(it + 1)).x(), (*(it + 1)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                init_data.add_vertex((Vec3f)(tr * Vec3d((*(it + 2)).x(), (*(it + 2)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                const size_t idx = it - triangles2d.cbegin();
                init_data.add_triangle((unsigned int)idx, (unsigned int)idx + 1, (unsigned int)idx + 2);
            }
 
            if (!init_data.is_empty())
                isl.model.init_from(std::move(init_data));
        }
 
        if (m_contour_width != 0. && ! exp.contour.empty()) {
            triangles2d.clear();
 
            // The contours must not scale with the object. Check the scale factor
            // in the respective directions, create a scaled copy of the ExPolygon
            // offset it and then unscale the result again.
 
            Transform3d t = tr;
            t.translation() = Vec3d::Zero();
            double scale_x = (t * Vec3d::UnitX()).norm();
            double scale_y = (t * Vec3d::UnitY()).norm();
 
            // To prevent overflow after scaling, downscale the input if needed:
            double extra_scale = 1.;
            coord_t limit = coord_t(std::min(double(std::numeric_limits<coord_t>::max()) / (2. * std::max(1., scale_x)), double(std::numeric_limits<coord_t>::max()) / (2. * std::max(1., scale_y))));
            coord_t max_coord = 0;
            for (const Point& pt : exp.contour)
                max_coord = std::max(max_coord, std::max(std::abs(pt.x()), std::abs(pt.y())));
            if (max_coord + m_contour_width >= limit)
                extra_scale = 0.9 * double(limit) / max_coord;
 
            ExPolygon exp_copy = exp;
            if (extra_scale != 1.)
                exp_copy.scale(extra_scale);
            exp_copy.scale(scale_x, scale_y);
 
            ExPolygons expolys_exp = offset_ex(exp_copy, scale_(m_contour_width));
            expolys_exp = diff_ex(expolys_exp, ExPolygons({exp_copy}));
 
            for (ExPolygon& e : expolys_exp) {
                e.scale(1./scale_x, 1./scale_y);
                if (extra_scale != 1.)
                    e.scale(1./extra_scale);
            }
 
 
            triangles2d = triangulate_expolygons_2f(expolys_exp, m_trafo.get_matrix().matrix().determinant() < 0.);
            GLModel::Geometry init_data = GLModel::Geometry();
            init_data.format = { GLModel::Geometry::EPrimitiveType::Triangles, GLModel::Geometry::EVertexLayout::P3N3 };
            init_data.reserve_vertices(triangles2d.size());
            init_data.reserve_indices(triangles2d.size());
 
            // vertices + indices
            for (auto it = triangles2d.cbegin(); it != triangles2d.cend(); it = it + 3) {
                init_data.add_vertex((Vec3f)(tr2 * Vec3d((*(it + 0)).x(), (*(it + 0)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                init_data.add_vertex((Vec3f)(tr2 * Vec3d((*(it + 1)).x(), (*(it + 1)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                init_data.add_vertex((Vec3f)(tr2 * Vec3d((*(it + 2)).x(), (*(it + 2)).y(), height_mesh)).cast<float>(), (Vec3f)up.cast<float>());
                const size_t idx = it - triangles2d.cbegin();
                init_data.add_triangle((unsigned short)idx, (unsigned short)idx + 1, (unsigned short)idx + 2);
            }
 
            if (!init_data.is_empty())
                isl.model_expanded.init_from(std::move(init_data));
        }
 
        isl.expoly = std::move(exp);
        isl.expoly_bb = get_extents(isl.expoly);
 
        Point centroid_scaled = isl.expoly.contour.centroid();
        Vec3d centroid_world = m_result->trafo * Vec3d(unscale(centroid_scaled).x(), unscale(centroid_scaled).y(), 0.);
        isl.hash = isl.expoly.contour.size() + size_t(std::abs(100.*centroid_world.x())) + size_t(std::abs(100.*centroid_world.y())) + size_t(std::abs(100.*centroid_world.z()));
    }
 
    // Now sort the islands so they are in defined order. This is a hack needed by cut gizmo, which sometimes
    // flips the normal of the cut, in which case the contours stay the same but their order may change.
    std::sort(m_result->cut_islands.begin(), m_result->cut_islands.end(), [](const CutIsland& a, const CutIsland& b) {
        return a.hash < b.hash;
    });
}

References Slic3r::GUI::GLModel::Geometry::add_triangle(), Slic3r::GUI::GLModel::Geometry::add_vertex(), Slic3r::angle(), Slic3r::cast(), Slic3r::Polygon::centroid(), Slic3r::GUI::ClippingPlane::ClipsNothing(), Slic3r::ExPolygon::contour, Slic3r::diff_ex(), Slic3r::GUI::MeshClipper::CutIsland::expoly, Slic3r::GUI::MeshClipper::CutIsland::expoly_bb, Slic3r::GUI::GLModel::Geometry::format, Slic3r::get_extents(), Slic3r::GUI::MeshClipper::CutIsland::hash, Slic3r::GUI::GLModel::init_from(), Slic3r::GUI::GLModel::Geometry::is_empty(), m_contour_width, m_csgmesh, m_fill_cut, m_limiting_plane, m_mesh, m_negative_mesh, M_PI, m_plane, m_result, m_trafo, Slic3r::GUI::MeshClipper::CutIsland::model, Slic3r::GUI::MeshClipper::CutIsland::model_expanded, Slic3r::offset(), Slic3r::offset_ex(), Slic3r::GUI::GLModel::Geometry::P3N3, Slic3r::range(), Slic3r::GUI::GLModel::Geometry::reserve_indices(), Slic3r::GUI::GLModel::Geometry::reserve_vertices(), Slic3r::ExPolygon::scale(), scale_, Slic3r::MultiPoint::size(), Slic3r::csg::slice_csgmesh_ex(), Slic3r::slice_mesh(), Slic3r::MeshSlicingParams::trafo, Slic3r::GUI::GLModel::Geometry::Triangles, Slic3r::triangulate_expolygon_2f(), Slic3r::triangulate_expolygons_2f(), Slic3r::union_ex(), and Slic3r::unscale().

Referenced by render_contour(), and render_cut().

Here is the call graph for this function:

Here is the caller graph for this function:

render_contour()

void Slic3r::GUI::MeshClipper::render_contour	(	const ColorRGBA &	color,
		const std::vector< size_t > *	ignore_idxs = nullptr )

{
    if (! m_result)
        recalculate_triangles();
 
    GLShaderProgram* curr_shader = wxGetApp().get_current_shader();
    if (curr_shader != nullptr)
        curr_shader->stop_using();
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader != nullptr) {
        shader->start_using();
        const Camera& camera = wxGetApp().plater()->get_camera();
        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
        for (size_t i=0; i<m_result->cut_islands.size(); ++i) {
            if (ignore_idxs && std::binary_search(ignore_idxs->begin(), ignore_idxs->end(), i))
                continue;
            CutIsland& isl = m_result->cut_islands[i];
            isl.model_expanded.set_color(isl.disabled ? ColorRGBA(1.f, 0.f, 0.f, 1.f) : color);
            isl.model_expanded.render();
        }
        shader->stop_using();
    }
 
    if (curr_shader != nullptr)
        curr_shader->start_using();
}

References Slic3r::GUI::MeshClipper::CutIsland::disabled, Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_result, Slic3r::GUI::MeshClipper::CutIsland::model_expanded, recalculate_triangles(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Here is the call graph for this function:

render_cut()

void Slic3r::GUI::MeshClipper::render_cut	(	const ColorRGBA &	color,
		const std::vector< size_t > *	ignore_idxs = nullptr )

{
    if (! m_result)
        recalculate_triangles();
    GLShaderProgram* curr_shader = wxGetApp().get_current_shader();
    if (curr_shader != nullptr)
        curr_shader->stop_using();
 
    GLShaderProgram* shader = wxGetApp().get_shader("flat");
    if (shader != nullptr) {
        shader->start_using();
        const Camera& camera = wxGetApp().plater()->get_camera();
        shader->set_uniform("view_model_matrix", camera.get_view_matrix());
        shader->set_uniform("projection_matrix", camera.get_projection_matrix());
        for (size_t i=0; i<m_result->cut_islands.size(); ++i) {
            if (ignore_idxs && std::binary_search(ignore_idxs->begin(), ignore_idxs->end(), i))
                continue;
            CutIsland& isl = m_result->cut_islands[i];
            isl.model.set_color(isl.disabled ? ColorRGBA(0.5f, 0.5f, 0.5f, 1.f) : color);
            isl.model.render();
        }
        shader->stop_using();
    }
 
    if (curr_shader != nullptr)
        curr_shader->start_using();
}

References Slic3r::GUI::MeshClipper::CutIsland::disabled, Slic3r::GUI::Camera::get_projection_matrix(), Slic3r::GUI::Camera::get_view_matrix(), m_result, Slic3r::GUI::MeshClipper::CutIsland::model, recalculate_triangles(), Slic3r::GUI::GLModel::render(), Slic3r::GUI::GLModel::set_color(), Slic3r::GLShaderProgram::set_uniform(), Slic3r::GLShaderProgram::start_using(), and Slic3r::GLShaderProgram::stop_using().

Referenced by Slic3r::GUI::GLCanvas3D::_render_section_view_caps().

Here is the call graph for this function:

Here is the caller graph for this function:

set_behaviour()

void Slic3r::GUI::MeshClipper::set_behaviour	(	bool	fill_cut,
		double	contour_width )

{
    if (fill_cut != m_fill_cut || ! is_approx(contour_width, m_contour_width))
        m_result.reset();
    m_fill_cut = fill_cut;
    m_contour_width = contour_width;
}

References Slic3r::is_approx(), m_contour_width, m_fill_cut, and m_result.

Here is the call graph for this function:

set_limiting_plane()

void Slic3r::GUI::MeshClipper::set_limiting_plane

(

const ClippingPlane &

plane

)

{
    if (m_limiting_plane != plane) {
        m_limiting_plane = plane;
        m_result.reset();
    }
}

References m_limiting_plane, and m_result.

Referenced by Slic3r::GUI::GLCanvas3D::_render_section_view_caps().

Here is the caller graph for this function:

set_mesh() [1/3]

void Slic3r::GUI::MeshClipper::set_mesh

(

AnyPtr< const indexed_triangle_set > &&

ptr

)

{
    if (m_mesh.get() != ptr.get()) {
        m_mesh = std::move(ptr);
        m_result.reset();
    }
}

References m_mesh, and m_result.

set_mesh() [2/3]

void Slic3r::GUI::MeshClipper::set_mesh

(

const indexed_triangle_set &

mesh

)

{
    if (m_mesh.get() != &mesh) {
        m_mesh = &mesh;
        m_result.reset();
    }
}

References m_mesh, and m_result.

Referenced by Slic3r::GUI::GLCanvas3D::_render_section_view_caps().

Here is the caller graph for this function:

set_mesh() [3/3]

template<class It>

void Slic3r::GUI::MeshClipper::set_mesh ( const Range< It > & csgrange, bool copy_meshes = false )

inline

    {
        if (! csg::is_same(range(m_csgmesh), csgrange)) {
            m_csgmesh.clear();
            if (copy_meshes)
                csg::copy_csgrange_deep(csgrange, std::back_inserter(m_csgmesh));
            else
                csg::copy_csgrange_shallow(csgrange, std::back_inserter(m_csgmesh));
 
            m_result.reset();
        }
    }

References Slic3r::csg::copy_csgrange_deep(), Slic3r::csg::copy_csgrange_shallow(), Slic3r::csg::is_same(), m_csgmesh, m_result, and Slic3r::range().

Here is the call graph for this function:

set_negative_mesh() [1/2]

void Slic3r::GUI::MeshClipper::set_negative_mesh

(

AnyPtr< const indexed_triangle_set > &&

ptr

)

{
    if (m_negative_mesh.get() != ptr.get()) {
        m_negative_mesh = std::move(ptr);
        m_result.reset();
    }
}

References m_negative_mesh, and m_result.

set_negative_mesh() [2/2]

void Slic3r::GUI::MeshClipper::set_negative_mesh

(

const indexed_triangle_set &

mesh

)

{
    if (m_negative_mesh.get() != &mesh) {
        m_negative_mesh = &mesh;
        m_result.reset();
    }
}

References m_negative_mesh, and m_result.

set_plane()

void Slic3r::GUI::MeshClipper::set_plane

(

const ClippingPlane &

plane

)

{
    if (m_plane != plane) {
        m_plane = plane;
        m_result.reset();
    }
}

References m_plane, and m_result.

Referenced by Slic3r::GUI::GLCanvas3D::_render_section_view_caps().

Here is the caller graph for this function:

set_transformation()

void Slic3r::GUI::MeshClipper::set_transformation

(

const Geometry::Transformation &

trafo

)

{
    if (! m_trafo.get_matrix().isApprox(trafo.get_matrix())) {
        m_trafo = trafo;
        m_result.reset();
    }
}

References Slic3r::Geometry::Transformation::get_matrix(), m_result, and m_trafo.

Referenced by Slic3r::GUI::GLCanvas3D::_render_section_view_caps().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_contour_width

double Slic3r::GUI::MeshClipper::m_contour_width = 0.

private

Referenced by recalculate_triangles(), and set_behaviour().

m_csgmesh

std::vector<csg::CSGPart> Slic3r::GUI::MeshClipper::m_csgmesh

private

Referenced by recalculate_triangles(), and set_mesh().

m_fill_cut

bool Slic3r::GUI::MeshClipper::m_fill_cut = true

private

Referenced by recalculate_triangles(), and set_behaviour().

m_limiting_plane

ClippingPlane Slic3r::GUI::MeshClipper::m_limiting_plane = ClippingPlane::ClipsNothing()

private

Referenced by recalculate_triangles(), and set_limiting_plane().

m_mesh

AnyPtr<const indexed_triangle_set> Slic3r::GUI::MeshClipper::m_mesh

private

Referenced by recalculate_triangles(), set_mesh(), and set_mesh().

m_negative_mesh

AnyPtr<const indexed_triangle_set> Slic3r::GUI::MeshClipper::m_negative_mesh

private

Referenced by recalculate_triangles(), set_negative_mesh(), and set_negative_mesh().

m_plane

ClippingPlane Slic3r::GUI::MeshClipper::m_plane

private

Referenced by recalculate_triangles(), and set_plane().

m_result

std::optional<ClipResult> Slic3r::GUI::MeshClipper::m_result

private

Referenced by get_number_of_contours(), has_valid_contour(), is_projection_inside_cut(), point_per_contour(), recalculate_triangles(), render_contour(), render_cut(), set_behaviour(), set_limiting_plane(), set_mesh(), set_mesh(), set_mesh(), set_negative_mesh(), set_negative_mesh(), set_plane(), and set_transformation().

m_trafo

Geometry::Transformation Slic3r::GUI::MeshClipper::m_trafo

private

Referenced by recalculate_triangles(), and set_transformation().

---

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