Slic3r::BuildVolume Class Reference

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

Collaboration diagram for Slic3r::BuildVolume:

Classes
struct	BuildExtruderVolume
struct	BuildSharedVolume

Public Types
enum class	ObjectState : unsigned char {   Inside , Colliding , Outside , Below ,   Limited }

Public Member Functions
	BuildVolume ()
	BuildVolume (const std::vector< Vec2d > &printable_area, const double printable_height, const std::vector< std::vector< Vec2d > > &extruder_areas, const std::vector< double > &extruder_printable_heights)
const std::vector< Vec2d > &	printable_area () const
double	printable_height () const
const std::vector< std::vector< Vec2d > > &	extruder_areas () const
const std::vector< double > &	extruder_heights () const
const BuildSharedVolume &	get_shared_volume () const
BuildVolume_Type	type () const
std::string_view	type_name () const
bool	valid () const
const Polygon &	polygon () const
const BoundingBox &	bounding_box () const
const BoundingBoxf3 &	bounding_volume () const
BoundingBoxf	bounding_volume2d () const
indexed_triangle_set	bounding_mesh (bool scale=true) const
Vec2d	bed_center () const
const Polygon &	convex_hull () const
const Geometry::Circled &	circle () const
ObjectState	object_state (const indexed_triangle_set &its, const Transform3f &trafo, bool may_be_below_bed, bool ignore_bottom=true) const
ObjectState	volume_state_bbox (const BoundingBoxf3 &volume_bbox, bool ignore_bottom=true) const
bool	all_paths_inside (const GCodeProcessorResult &paths, const BoundingBoxf3 &paths_bbox, bool ignore_bottom=true) const
int	get_extruder_area_count () const
const BuildExtruderVolume &	get_extruder_area_volume (int index) const
ObjectState	check_object_state_with_extruder_area (const indexed_triangle_set &its, const Transform3f &trafo, int index) const
ObjectState	check_object_state_with_extruder_areas (const indexed_triangle_set &its, const Transform3f &trafo, std::vector< bool > &inside_extruders) const
ObjectState	check_volume_bbox_state_with_extruder_area (const BoundingBoxf3 &volume_bbox, int index) const
ObjectState	check_volume_bbox_state_with_extruder_areas (const BoundingBoxf3 &volume_bbox, std::vector< bool > &inside_extruders) const
const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > &	top_bottom_convex_hull_decomposition_scene () const
const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > &	top_bottom_convex_hull_decomposition_bed () const

Static Public Member Functions
static std::string_view	type_name (BuildVolume_Type type)

Static Public Attributes
static constexpr const double	SceneEpsilon = EPSILON
static constexpr const double	BedEpsilon = 3. * EPSILON

Private Attributes
std::vector< Vec2d >	m_bed_shape
std::vector< std::vector< Vec2d > >	m_extruder_shapes
std::vector< BuildExtruderVolume >	m_extruder_volumes
BuildSharedVolume	m_shared_volume
double	m_max_print_height { 0.f }
std::vector< double >	m_extruder_printable_height
BuildVolume_Type	m_type { BuildVolume_Type::Invalid }
Polygon	m_polygon
BoundingBox	m_bbox
BoundingBoxf3	m_bboxf
double	m_area { 0. }
Polygon	m_convex_hull
std::pair< std::vector< Vec2d >, std::vector< Vec2d > >	m_top_bottom_convex_hull_decomposition_scene
std::pair< std::vector< Vec2d >, std::vector< Vec2d > >	m_top_bottom_convex_hull_decomposition_bed
Geometry::Circled	m_circle { Vec2d::Zero(), 0 }

Detailed Description

---

Class Documentation

Slic3r::BuildVolume::BuildExtruderVolume

struct Slic3r::BuildVolume::BuildExtruderVolume

Collaboration diagram for Slic3r::BuildVolume::BuildExtruderVolume:

Class Members
BoundingBox	bbox
BoundingBoxf3	bboxf
Circled	circle
bool	same_with_bed {false}
BuildVolume_Type	type {BuildVolume_Type::Invalid}

Slic3r::BuildVolume::BuildSharedVolume

struct Slic3r::BuildVolume::BuildSharedVolume

Collaboration diagram for Slic3r::BuildVolume::BuildSharedVolume:

Class Members
array< float, 4 >	data
int	type { 0 }
array< float, 2 >	zs

Member Enumeration Documentation

ObjectState

enum class Slic3r::BuildVolume::ObjectState : unsigned char

strong

Enumerator
Inside
Colliding
Outside
Below
Limited

    {
        // Inside the build volume, thus printable.
        Inside,
        // Colliding with the build volume boundary, thus not printable and error is shown.
        Colliding,
        // Outside of the build volume means the object is ignored: Not printed and no error is shown.
        Outside,
        // Completely below the print bed. The same as Outside, but an object with one printable part below the print bed
        // and at least one part above the print bed is still printable.
        Below,
        //in Limited area
        Limited
    };

Constructor & Destructor Documentation

BuildVolume() [1/2]

Slic3r::BuildVolume::BuildVolume ( )

inline

{}

BuildVolume() [2/2]

Slic3r::BuildVolume::BuildVolume	(	const std::vector< Vec2d > &	printable_area,
		const double	printable_height,
		const std::vector< std::vector< Vec2d > > &	extruder_areas,
		const std::vector< double > &	extruder_printable_heights )

    : m_bed_shape(printable_area), m_max_print_height(printable_height), m_extruder_shapes(extruder_areas), m_extruder_printable_height(extruder_printable_heights)
{
    assert(printable_height >= 0);
 
    m_polygon     = Polygon::new_scale(printable_area);
    assert(m_polygon.is_counter_clockwise());
 
    // Calcuate various metrics of the input polygon.
    m_convex_hull = Geometry::convex_hull(m_polygon.points);
    m_bbox        = get_extents(m_convex_hull);
    m_area        = m_polygon.area();
 
    BoundingBoxf bboxf = get_extents(printable_area);
    m_bboxf = BoundingBoxf3{ to_3d(bboxf.min, 0.), to_3d(bboxf.max, printable_height) };
 
    if (printable_area.size() >= 4 && std::abs((m_area - double(m_bbox.size().x()) * double(m_bbox.size().y()))) < sqr(SCALED_EPSILON)) {
        // Square print bed, use the bounding box for collision detection.
        m_type = BuildVolume_Type::Rectangle;
        m_circle.center = 0.5 * (m_bbox.min.cast<double>() + m_bbox.max.cast<double>());
        m_circle.radius = 0.5 * m_bbox.size().cast<double>().norm();
    } else if (printable_area.size() > 3) {
        // Circle was discretized, formatted into text with limited accuracy, thus the circle was deformed.
        // RANSAC is slightly more accurate than the iterative Taubin / Newton method with such an input.
//        m_circle = Geometry::circle_taubin_newton(printable_area);
        m_circle = Geometry::circle_ransac(printable_area);
        bool is_circle = true;
#ifndef NDEBUG
        // Measuring maximum absolute error of interpolating an input polygon with circle.
        double max_error = 0;
#endif // NDEBUG
        Vec2d prev = printable_area.back();
        for (const Vec2d &p : printable_area) {
#ifndef NDEBUG
            max_error = std::max(max_error, std::abs((p - m_circle.center).norm() - m_circle.radius));
#endif // NDEBUG
            if (// Polygon vertices must lie very close the circle.
                std::abs((p - m_circle.center).norm() - m_circle.radius) > 0.005 ||
                // Midpoints of polygon edges must not undercat more than 3mm. This corresponds to 72 edges per circle generated by BedShapePanel::update_shape().
                m_circle.radius - (0.5 * (prev + p) - m_circle.center).norm() > 3.) {
                is_circle = false;
                break;
            }
            prev = p;
        }
        if (is_circle) {
            m_type = BuildVolume_Type::Circle;
            m_circle.center = scaled<double>(m_circle.center);
            m_circle.radius = scaled<double>(m_circle.radius);
        }
    }
 
    if (printable_area.size() >= 3 && m_type == BuildVolume_Type::Invalid) {
        // Circle check is not used for Convex / Custom shapes, fill it with something reasonable.
        m_circle = Geometry::smallest_enclosing_circle_welzl(m_convex_hull.points);
        m_type   = (m_convex_hull.area() - m_area) < sqr(SCALED_EPSILON) ? BuildVolume_Type::Convex : BuildVolume_Type::Custom;
        // Initialize the top / bottom decomposition for inside convex polygon check. Do it with two different epsilons applied.
        auto convex_decomposition = [](const Polygon &in, double epsilon) {
            Polygon src = expand(in, float(epsilon)).front();
            std::vector<Vec2d> pts;
            pts.reserve(src.size());
            for (const Point &pt : src.points)
                pts.emplace_back(unscaled<double>(pt.cast<double>().eval()));
            return Geometry::decompose_convex_polygon_top_bottom(pts);
        };
        m_top_bottom_convex_hull_decomposition_scene = convex_decomposition(m_convex_hull, SceneEpsilon);
        m_top_bottom_convex_hull_decomposition_bed   = convex_decomposition(m_convex_hull, BedEpsilon);
    }
 
    if (m_extruder_shapes.size() > 0)
    {
        m_shared_volume.data[0] = m_bboxf.min.x();
        m_shared_volume.data[1] = m_bboxf.min.y();
        m_shared_volume.data[2] = m_bboxf.max.x();
        m_shared_volume.data[3] = m_bboxf.max.y();
        m_shared_volume.zs[1] = m_bboxf.max.z();
        if (extruder_printable_heights.size() < m_extruder_shapes.size())
            BOOST_LOG_TRIVIAL(warning) << boost::format("extruder_printable_height has only %1% entries but extruder_printable_area has %2%, falling back to the bed printable_height for the missing ones")
                    % extruder_printable_heights.size() % m_extruder_shapes.size();
        for (unsigned int index = 0; index < m_extruder_shapes.size(); index++)
        {
            std::vector<Vec2d>& extruder_shape = m_extruder_shapes[index];
            BuildExtruderVolume extruder_volume;
 
            if (extruder_shape.empty())
            {
                //should not happen
                BOOST_LOG_TRIVIAL(warning) << boost::format("Found invalid extruder_printable_area of index %1%")%index;
                assert(false);
                m_extruder_shapes.clear();
                return;
            }
 
            const double extruder_height = index < extruder_printable_heights.size() ? extruder_printable_heights[index] : printable_height;
 
            if ((extruder_shape == printable_area)&&(extruder_height == printable_height)) {
                extruder_volume.same_with_bed = true;
                extruder_volume.type = m_type;
                extruder_volume.bbox = m_bbox;
                extruder_volume.bboxf = m_bboxf;
                extruder_volume.circle = m_circle;
            }
            else {
                Polygon poly             = Polygon::new_scale(extruder_shape);
 
                double poly_area         = poly.area();
                extruder_volume.bbox = get_extents(poly);
                BoundingBoxf temp_bboxf = get_extents(extruder_shape);
                extruder_volume.bboxf = BoundingBoxf3{ to_3d(temp_bboxf.min, 0.), to_3d(temp_bboxf.max, extruder_height) };
 
                if (extruder_shape.size() >= 4 && std::abs((poly_area - double(extruder_volume.bbox.size().x()) * double(extruder_volume.bbox.size().y()))) < sqr(SCALED_EPSILON))
                {
                    extruder_volume.type = BuildVolume_Type::Rectangle;
                    extruder_volume.circle.center = 0.5 * (extruder_volume.bbox.min.cast<double>() + extruder_volume.bbox.max.cast<double>());
                    extruder_volume.circle.radius = 0.5 * extruder_volume.bbox.size().cast<double>().norm();
                }
                else if (extruder_shape.size() > 3) {
                    extruder_volume.circle = Geometry::circle_ransac(extruder_shape);
                    bool is_circle = true;
 
                    Vec2d prev = extruder_shape.back();
                    for (const Vec2d &p : extruder_shape) {
                        if (// Polygon vertices must lie very close the circle.
                            std::abs((p - extruder_volume.circle.center).norm() - extruder_volume.circle.radius) > 0.005 ||
                            // Midpoints of polygon edges must not undercat more than 3mm. This corresponds to 72 edges per circle generated by BedShapePanel::update_shape().
                            extruder_volume.circle.radius - (0.5 * (prev + p) -extruder_volume.circle.center).norm() > 3.) {
                            is_circle = false;
                            break;
                        }
                        prev = p;
                    }
                    if (is_circle) {
                        extruder_volume.type = BuildVolume_Type::Circle;
                        extruder_volume.circle.center = scaled<double>(extruder_volume.circle.center);
                        extruder_volume.circle.radius = scaled<double>(extruder_volume.circle.radius);
                    }
                }
 
                if (m_type == BuildVolume_Type::Invalid) {
                    //not supported currently, use the same as bed
                    extruder_volume.same_with_bed = true;
                    extruder_volume.type = m_type;
                    extruder_volume.bbox = m_bbox;
                    extruder_volume.bboxf = m_bboxf;
                    extruder_volume.circle = m_circle;
                }
                //always ignore z
                extruder_volume.bboxf.min.z() = -std::numeric_limits<double>::max();
            }
            m_extruder_volumes.push_back(std::move(extruder_volume));
 
            if (m_shared_volume.data[0] < extruder_volume.bboxf.min.x())
                m_shared_volume.data[0] = extruder_volume.bboxf.min.x();
            if (m_shared_volume.data[1] < extruder_volume.bboxf.min.y())
                m_shared_volume.data[1] = extruder_volume.bboxf.min.y();
            if (m_shared_volume.data[2] > extruder_volume.bboxf.max.x())
                m_shared_volume.data[2] = extruder_volume.bboxf.max.x();
            if (m_shared_volume.data[3] > extruder_volume.bboxf.max.y())
                m_shared_volume.data[3] = extruder_volume.bboxf.max.y();
            if (m_shared_volume.zs[1] > extruder_volume.bboxf.max.z())
                m_shared_volume.zs[1] = extruder_volume.bboxf.max.z();
        }
 
        m_shared_volume.type = static_cast<int>(m_type);
        m_shared_volume.zs[0] = 0.f;
        //m_shared_volume.zs[1] = printable_height;
    }
 
    BOOST_LOG_TRIVIAL(debug) << "BuildVolume printable_area clasified as: " << this->type_name();
}

References Slic3r::BuildVolume::BuildExtruderVolume::bbox, Slic3r::BuildVolume::BuildExtruderVolume::bboxf, BedEpsilon, Slic3r::Geometry::Circle< Vector >::center, Slic3r::Circle, Slic3r::BuildVolume::BuildExtruderVolume::circle, Slic3r::Geometry::circle_ransac(), Slic3r::Convex, Slic3r::Geometry::convex_hull(), Slic3r::Custom, Slic3r::Geometry::decompose_convex_polygon_top_bottom(), Slic3r::expand(), extruder_areas(), Slic3r::get_extents(), Slic3r::Invalid, m_area, m_bbox, m_bboxf, m_bed_shape, m_circle, m_convex_hull, m_extruder_printable_height, m_extruder_shapes, m_extruder_volumes, m_max_print_height, m_polygon, m_shared_volume, m_top_bottom_convex_hull_decomposition_bed, m_top_bottom_convex_hull_decomposition_scene, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::Polygon::new_scale(), Slic3r::MultiPoint::points, printable_area(), printable_height(), Slic3r::Geometry::Circle< Vector >::radius, Slic3r::Rectangle, Slic3r::BuildVolume::BuildExtruderVolume::same_with_bed, Slic3r::scaled(), SCALED_EPSILON, SceneEpsilon, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::MultiPoint::size(), Slic3r::Geometry::smallest_enclosing_circle_welzl(), Slic3r::sqr(), Slic3r::to_3d(), Slic3r::BuildVolume::BuildExtruderVolume::type, type_name(), and Slic3r::unscaled().

Here is the call graph for this function:

Member Function Documentation

all_paths_inside()

bool Slic3r::BuildVolume::all_paths_inside	(	const GCodeProcessorResult &	paths,
		const BoundingBoxf3 &	paths_bbox,
		bool	ignore_bottom = true ) const

{
    auto move_valid = [](const GCodeProcessorResult::MoveVertex &move) {
        return move.type == EMoveType::Extrude && move.extrusion_role != erCustom && move.width != 0.f && move.height != 0.f;
    };
    static constexpr const double epsilon = BedEpsilon;
 
    switch (m_type) {
    case BuildVolume_Type::Rectangle:
    {
        BoundingBox3Base<Vec3d> build_volume = this->bounding_volume().inflated(epsilon);
        if (m_max_print_height == 0.0)
            build_volume.max.z() = std::numeric_limits<double>::max();
        if (ignore_bottom)
            build_volume.min.z() = -std::numeric_limits<double>::max();
        // BBox-only callers may provide no moves. Validate bbox corners regardless of paths_bbox.defined.
        if (paths.moves.empty())
            return build_volume.contains(paths_bbox.min) && build_volume.contains(paths_bbox.max);
        if (paths_bbox.defined && build_volume.contains(paths_bbox))
            return true;
 
        // Fallback: validate only relevant extrusion moves.
        const BoundingBox3Base<Vec3f> build_volumef(build_volume.min.cast<float>(), build_volume.max.cast<float>());
        return std::all_of(paths.moves.begin(), paths.moves.end(), [move_valid, build_volumef](const GCodeProcessorResult::MoveVertex &move)
            { return !move_valid(move) || build_volumef.contains(move.position); });
    }
    case BuildVolume_Type::Circle:
    {
        const Vec2f c = unscaled<float>(m_circle.center);
        const float r = unscaled<double>(m_circle.radius) + epsilon;
        const float r2 = sqr(r);
        return m_max_print_height == 0.0 ?
            std::all_of(paths.moves.begin(), paths.moves.end(), [move_valid, c, r2](const GCodeProcessorResult::MoveVertex &move)
                { return ! move_valid(move) || (to_2d(move.position) - c).squaredNorm() <= r2; }) :
            std::all_of(paths.moves.begin(), paths.moves.end(), [move_valid, c, r2, z = m_max_print_height + epsilon](const GCodeProcessorResult::MoveVertex& move)
                { return ! move_valid(move) || ((to_2d(move.position) - c).squaredNorm() <= r2 && move.position.z() <= z); });
    }
    case BuildVolume_Type::Convex:
    //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case BuildVolume_Type::Custom:
        return m_max_print_height == 0.0 ?
            std::all_of(paths.moves.begin(), paths.moves.end(), [move_valid, this](const GCodeProcessorResult::MoveVertex &move)
                { return ! move_valid(move) || Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_bed, to_2d(move.position).cast<double>()); }) :
            std::all_of(paths.moves.begin(), paths.moves.end(), [move_valid, this, z = m_max_print_height + epsilon](const GCodeProcessorResult::MoveVertex &move)
                { return ! move_valid(move) || (Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_bed, to_2d(move.position).cast<double>()) && move.position.z() <= z); });
    default:
        return true;
    }
}

References BedEpsilon, bounding_volume(), Slic3r::Circle, Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::Convex, Slic3r::Custom, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::defined, Slic3r::erCustom, Slic3r::Extrude, Slic3r::BoundingBox3Base< PointType >::inflated(), m_circle, m_max_print_height, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::BoundingBoxBase< PointType, std::vector< PointType > >::min, Slic3r::GCodeProcessorResult::moves, Slic3r::Rectangle, Slic3r::sqr(), and Slic3r::unscaled().

Here is the call graph for this function:

bed_center()

Vec2d Slic3r::BuildVolume::bed_center ( ) const

inline

{ return get_extents(m_bed_shape).center(); }

References Slic3r::BoundingBoxBase< PointType, APointsType >::center(), Slic3r::get_extents(), and m_bed_shape.

Referenced by Slic3r::GUI::GLCanvas3D::_render_cad_grid(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::Plater::priv::load_model_objects(), Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume(), and Slic3r::GUI::Plater::priv::update().

Here is the call graph for this function:

Here is the caller graph for this function:

bounding_box()

const BoundingBox & Slic3r::BuildVolume::bounding_box ( ) const

inline

{ return m_bbox; }

References m_bbox.

bounding_mesh()

indexed_triangle_set Slic3r::BuildVolume::bounding_mesh

(

bool

scale = true

)

const

{
    auto max_pt3 = m_bboxf.max;
    if (scale) {
        return its_make_cube(scale_(max_pt3.x()), scale_(max_pt3.y()), scale_(max_pt3.z()));
    }
    else {
        return its_make_cube(max_pt3.x(), max_pt3.y(), max_pt3.z());
    }
}

References Slic3r::its_make_cube(), m_bboxf, scale(), and scale_.

Here is the call graph for this function:

bounding_volume()

const BoundingBoxf3 & Slic3r::BuildVolume::bounding_volume ( ) const

inline

{ return m_bboxf; }

References m_bboxf.

Referenced by all_paths_inside(), Slic3r::GUI::contains(), object_state(), Slic3r::GUI::Plater::priv::scale_selection_to_fit_print_volume(), Slic3r::Model::update_print_volume_state(), and volume_state_bbox().

Here is the caller graph for this function:

bounding_volume2d()

BoundingBoxf Slic3r::BuildVolume::bounding_volume2d ( ) const

inline

{ return { to_2d(m_bboxf.min), to_2d(m_bboxf.max) }; }

References m_bboxf, and Slic3r::to_2d().

Referenced by Slic3r::GUI::GLCanvas3D::_current_plate_box(), Slic3r::GUI::GLCanvas3D::_render_cad_grid(), Slic3r::ModelInstance::calc_print_volume_state(), and Slic3r::GUI::Plater::priv::load_model_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

check_object_state_with_extruder_area()

BuildVolume::ObjectState Slic3r::BuildVolume::check_object_state_with_extruder_area	(	const indexed_triangle_set &	its,
		const Transform3f &	trafo,
		int	index ) const

{
    const BuildExtruderVolume& extruder_volume = get_extruder_area_volume(index);
    ObjectState return_state = ObjectState::Inside;
 
    if (!extruder_volume.same_with_bed) {
         switch (extruder_volume.type) {
            case BuildVolume_Type::Rectangle:
            {
                BoundingBox3Base<Vec3d> build_volume = extruder_volume.bboxf.inflated(SceneEpsilon);
                if (m_max_print_height == 0.0)
                    build_volume.max.z() = std::numeric_limits<double>::max();
                BoundingBox3Base<Vec3f> build_volumef(build_volume.min.cast<float>(), build_volume.max.cast<float>());
 
                return_state = object_state_templ(its, trafo, false, true, [build_volumef](const Vec3f &pt) { return build_volumef.contains(pt); });
                break;
            }
            case BuildVolume_Type::Circle:
            {
                Geometry::Circlef circle { unscaled<float>(extruder_volume.circle.center), unscaled<float>(extruder_volume.circle.radius + SceneEpsilon) };
                return_state = (m_max_print_height == 0.0) ?
                        object_state_templ(its, trafo, false, true, [circle](const Vec3f &pt) { return circle.contains(to_2d(pt)); }) :
                        object_state_templ(its, trafo, false, true, [circle, z = m_max_print_height + SceneEpsilon](const Vec3f &pt) { return pt.z() < z && circle.contains(to_2d(pt)); });
                break;
            }
            case BuildVolume_Type::Invalid:
            default:
                break;
        }
    }
 
    if (return_state != ObjectState::Inside)
        return_state = ObjectState::Limited;
 
    return return_state;
}

References Slic3r::BuildVolume::BuildExtruderVolume::bboxf, Slic3r::Geometry::Circle< Vector >::center, Slic3r::Circle, Slic3r::BuildVolume::BuildExtruderVolume::circle, circle(), Slic3r::BoundingBox3Base< PointType >::contains(), get_extruder_area_volume(), Slic3r::BoundingBox3Base< PointType >::inflated(), Inside, Slic3r::Invalid, Limited, m_max_print_height, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::object_state_templ(), Slic3r::Geometry::Circle< Vector >::radius, Slic3r::Rectangle, Slic3r::BuildVolume::BuildExtruderVolume::same_with_bed, SceneEpsilon, Slic3r::to_2d(), Slic3r::BuildVolume::BuildExtruderVolume::type, and Slic3r::unscaled().

Referenced by check_object_state_with_extruder_areas().

Here is the call graph for this function:

Here is the caller graph for this function:

check_object_state_with_extruder_areas()

BuildVolume::ObjectState Slic3r::BuildVolume::check_object_state_with_extruder_areas	(	const indexed_triangle_set &	its,
		const Transform3f &	trafo,
		std::vector< bool > &	inside_extruders ) const

{
    ObjectState result = ObjectState::Inside;
    int extruder_area_count = get_extruder_area_count();
    inside_extruders.resize(extruder_area_count, true);
    for (int index = 0; index < extruder_area_count; index++)
    {
        ObjectState state = check_object_state_with_extruder_area(its, trafo, index);
 
        if (state == ObjectState::Limited) {
            inside_extruders[index] = false;
            result = ObjectState::Limited;
        }
    }
 
    return result;
}

References check_object_state_with_extruder_area(), get_extruder_area_count(), Inside, and Limited.

Referenced by Slic3r::GLVolumeCollection::check_outside_state().

Here is the call graph for this function:

Here is the caller graph for this function:

check_volume_bbox_state_with_extruder_area()

BuildVolume::ObjectState Slic3r::BuildVolume::check_volume_bbox_state_with_extruder_area	(	const BoundingBoxf3 &	volume_bbox,
		int	index ) const

{
    const BuildExtruderVolume& extruder_volume = get_extruder_area_volume(index);
    BoundingBox3Base<Vec3d> extruder_bbox = extruder_volume.bboxf.inflated(SceneEpsilon);
    if (extruder_volume.same_with_bed || extruder_bbox.contains(volume_bbox))
        return ObjectState::Inside;
    else
        return ObjectState::Limited;
}

References Slic3r::BuildVolume::BuildExtruderVolume::bboxf, Slic3r::BoundingBox3Base< PointType >::contains(), get_extruder_area_volume(), Slic3r::BoundingBox3Base< PointType >::inflated(), Inside, Limited, Slic3r::BuildVolume::BuildExtruderVolume::same_with_bed, and SceneEpsilon.

Referenced by check_volume_bbox_state_with_extruder_areas().

Here is the call graph for this function:

Here is the caller graph for this function:

check_volume_bbox_state_with_extruder_areas()

BuildVolume::ObjectState Slic3r::BuildVolume::check_volume_bbox_state_with_extruder_areas	(	const BoundingBoxf3 &	volume_bbox,
		std::vector< bool > &	inside_extruders ) const

{
    ObjectState result = ObjectState::Inside;
    int extruder_area_count = get_extruder_area_count();
    inside_extruders.resize(extruder_area_count, true);
    for (int index = 0; index < extruder_area_count; index++)
    {
        ObjectState state = check_volume_bbox_state_with_extruder_area(volume_bbox, index);
 
        if (state == ObjectState::Limited) {
            inside_extruders[index] = false;
            result = ObjectState::Limited;
        }
    }
 
    return result;
}

References check_volume_bbox_state_with_extruder_area(), get_extruder_area_count(), Inside, and Limited.

Referenced by Slic3r::GLVolumeCollection::check_outside_state(), and Slic3r::CLI::run().

Here is the call graph for this function:

Here is the caller graph for this function:

circle()

const Geometry::Circled & Slic3r::BuildVolume::circle ( ) const

inline

{ return m_circle; }

References m_circle.

Referenced by check_object_state_with_extruder_area(), Slic3r::GUI::contains(), and object_state().

Here is the caller graph for this function:

convex_hull()

const Polygon & Slic3r::BuildVolume::convex_hull ( ) const

inline

{ return m_convex_hull; }

References m_convex_hull.

extruder_areas()

const std::vector< std::vector< Vec2d > > & Slic3r::BuildVolume::extruder_areas ( ) const

inline

{ return m_extruder_shapes; }

References m_extruder_shapes.

Referenced by BuildVolume(), Slic3r::GLVolumeCollection::check_outside_state(), and Slic3r::GLVolumeCollection::check_wipe_tower_outside_state().

Here is the caller graph for this function:

extruder_heights()

const std::vector< double > & Slic3r::BuildVolume::extruder_heights ( ) const

inline

{ return m_extruder_printable_height; }

References m_extruder_printable_height.

Referenced by Slic3r::GLVolumeCollection::check_outside_state().

Here is the caller graph for this function:

get_extruder_area_count()

int Slic3r::BuildVolume::get_extruder_area_count ( ) const

inline

{ return m_extruder_volumes.size(); }

References m_extruder_volumes.

Referenced by check_object_state_with_extruder_areas(), Slic3r::GLVolumeCollection::check_outside_state(), and check_volume_bbox_state_with_extruder_areas().

Here is the caller graph for this function:

get_extruder_area_volume()

const BuildVolume::BuildExtruderVolume & Slic3r::BuildVolume::get_extruder_area_volume

(

int

index

)

const

{
    assert(index >= 0 && index < m_extruder_volumes.size());
    return m_extruder_volumes[index];
}

References m_extruder_volumes.

Referenced by check_object_state_with_extruder_area(), and check_volume_bbox_state_with_extruder_area().

Here is the caller graph for this function:

get_shared_volume()

const BuildSharedVolume & Slic3r::BuildVolume::get_shared_volume ( ) const

inline

{ return m_shared_volume; }

References m_shared_volume.

object_state()

BuildVolume::ObjectState Slic3r::BuildVolume::object_state	(	const indexed_triangle_set &	its,
		const Transform3f &	trafo,
		bool	may_be_below_bed,
		bool	ignore_bottom = true ) const

{
    switch (m_type) {
    case BuildVolume_Type::Rectangle:
    {
        BoundingBox3Base<Vec3d> build_volume = this->bounding_volume().inflated(SceneEpsilon);
        if (m_max_print_height == 0.0)
            build_volume.max.z() = std::numeric_limits<double>::max();
        if (ignore_bottom)
            build_volume.min.z() = -std::numeric_limits<double>::max();
        BoundingBox3Base<Vec3f> build_volumef(build_volume.min.cast<float>(), build_volume.max.cast<float>());
        // The following test correctly interprets intersection of a non-convex object with a rectangular build volume.
        //return rectangle_test(its, trafo, to_2d(build_volume.min), to_2d(build_volume.max), build_volume.max.z());
        //FIXME This test does NOT correctly interprets intersection of a non-convex object with a rectangular build volume.
        return object_state_templ(its, trafo, may_be_below_bed, true, [build_volumef](const Vec3f &pt) { return build_volumef.contains(pt); });
    }
    case BuildVolume_Type::Circle:
    {
        Geometry::Circlef circle { unscaled<float>(m_circle.center), unscaled<float>(m_circle.radius + SceneEpsilon) };
        return m_max_print_height == 0.0 ?
            object_state_templ(its, trafo, may_be_below_bed, true, [circle](const Vec3f& pt) { return circle.contains(to_2d(pt)); }) :
            object_state_templ(its, trafo, may_be_below_bed, true, [circle, z = m_max_print_height + SceneEpsilon](const Vec3f &pt) { return pt.z() < z && circle.contains(to_2d(pt)); });
    }
    case BuildVolume_Type::Convex:
    //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case BuildVolume_Type::Custom:
        return m_max_print_height == 0.0 ?
            object_state_templ(its, trafo, may_be_below_bed, m_type == BuildVolume_Type::Convex, [this](const Vec3f &pt) { return Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_scene, to_2d(pt).cast<double>()); }) :
            object_state_templ(its, trafo, may_be_below_bed, m_type == BuildVolume_Type::Convex, [this, z = m_max_print_height + SceneEpsilon](const Vec3f &pt) { return pt.z() < z && Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_scene, to_2d(pt).cast<double>()); });
    case BuildVolume_Type::Invalid:
    default:
        return ObjectState::Inside;
    }
}

References bounding_volume(), Slic3r::cast(), Slic3r::Circle, circle(), Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::Convex, Slic3r::Custom, Slic3r::BoundingBox3Base< PointType >::inflated(), Inside, Slic3r::Geometry::inside_convex_polygon(), Slic3r::Invalid, m_circle, m_max_print_height, m_top_bottom_convex_hull_decomposition_scene, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::object_state_templ(), Slic3r::Rectangle, SceneEpsilon, Slic3r::to_2d(), and Slic3r::unscaled().

Referenced by Slic3r::ModelInstance::calc_print_volume_state(), and Slic3r::GLVolumeCollection::check_outside_state().

Here is the call graph for this function:

Here is the caller graph for this function:

polygon()

const Polygon & Slic3r::BuildVolume::polygon ( ) const

inline

{ return m_polygon; }

References m_polygon.

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::TreeModelVolumes().

Here is the caller graph for this function:

printable_area()

const std::vector< Vec2d > & Slic3r::BuildVolume::printable_area ( ) const

inline

{ return m_bed_shape; }

References m_bed_shape.

Referenced by BuildVolume(), Slic3r::GLVolumeCollection::check_wipe_tower_outside_state(), and anonymous_namespace{EmbossJob.cpp}::start_create_object_job().

Here is the caller graph for this function:

printable_height()

double Slic3r::BuildVolume::printable_height ( ) const

inline

{ return m_max_print_height; }

References m_max_print_height.

Referenced by BuildVolume(), Slic3r::GLVolumeCollection::check_outside_state(), and Slic3r::GUI::contains().

Here is the caller graph for this function:

top_bottom_convex_hull_decomposition_bed()

const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > & Slic3r::BuildVolume::top_bottom_convex_hull_decomposition_bed ( ) const

inline

{ return m_top_bottom_convex_hull_decomposition_bed; }

References m_top_bottom_convex_hull_decomposition_bed.

top_bottom_convex_hull_decomposition_scene()

const std::pair< std::vector< Vec2d >, std::vector< Vec2d > > & Slic3r::BuildVolume::top_bottom_convex_hull_decomposition_scene ( ) const

inline

{ return m_top_bottom_convex_hull_decomposition_scene; }

References m_top_bottom_convex_hull_decomposition_scene.

type()

BuildVolume_Type Slic3r::BuildVolume::type ( ) const

inline

{ return m_type; }

References m_type.

Referenced by Slic3r::ModelInstance::calc_print_volume_state(), Slic3r::GLVolumeCollection::check_outside_state(), Slic3r::GUI::contains(), and type_name().

Here is the caller graph for this function:

type_name() [1/2]

std::string_view Slic3r::BuildVolume::type_name ( ) const

inline

{ return type_name(m_type); }

References m_type, and type_name().

Referenced by BuildVolume(), and type_name().

Here is the call graph for this function:

Here is the caller graph for this function:

type_name() [2/2]

std::string_view Slic3r::BuildVolume::type_name ( BuildVolume_Type type )

static

{
    using namespace std::literals;
    switch (type) {
    case BuildVolume_Type::Invalid:   return "Invalid"sv;
    case BuildVolume_Type::Rectangle: return "Rectangle"sv;
    case BuildVolume_Type::Circle:    return "Circle"sv;
    case BuildVolume_Type::Convex:    return "Convex"sv;
    case BuildVolume_Type::Custom:    return "Custom"sv;
    }
    // make visual studio happy
    assert(false);
    return {};
}

References Slic3r::Circle, Slic3r::Convex, Slic3r::Custom, Slic3r::Invalid, Slic3r::Rectangle, and type().

Here is the call graph for this function:

valid()

bool Slic3r::BuildVolume::valid ( ) const

inline

{ return m_type != BuildVolume_Type::Invalid; }

References Slic3r::Invalid, and m_type.

Referenced by Slic3r::GUI::GLCanvas3D::_current_plate_box(), and Slic3r::GUI::GLCanvas3D::_render_cad_grid().

Here is the caller graph for this function:

volume_state_bbox()

BuildVolume::ObjectState Slic3r::BuildVolume::volume_state_bbox	(	const BoundingBoxf3 &	volume_bbox,
		bool	ignore_bottom = true ) const

{
    assert(m_type == BuildVolume_Type::Rectangle);
    BoundingBox3Base<Vec3d> build_volume = this->bounding_volume().inflated(SceneEpsilon);
    if (m_max_print_height == 0.0)
        build_volume.max.z() = std::numeric_limits<double>::max();
    if (ignore_bottom)
        build_volume.min.z() = -std::numeric_limits<double>::max();
    return build_volume.max.z() <= - SceneEpsilon ? ObjectState::Below :
           build_volume.contains(volume_bbox) ? ObjectState::Inside :
           build_volume.intersects(volume_bbox) ? ObjectState::Colliding : ObjectState::Outside;
}

References Below, bounding_volume(), Colliding, Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::BoundingBox3Base< PointType >::inflated(), Inside, Slic3r::BoundingBox3Base< PointType >::intersects(), m_max_print_height, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Outside, Slic3r::Rectangle, and SceneEpsilon.

Referenced by Slic3r::ModelInstance::calc_print_volume_state(), and Slic3r::GLVolumeCollection::check_outside_state().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BedEpsilon

const double Slic3r::BuildVolume::BedEpsilon = 3. * EPSILON

staticconstexpr

Referenced by BuildVolume(), Slic3r::GUI::GLCanvas3D::_get_current_partplate_print_volume(), all_paths_inside(), Slic3r::GUI::contains(), Slic3r::GUI::PartPlate::contains(), and Slic3r::GUI::PartPlate::intersects().

m_area

double Slic3r::BuildVolume::m_area { 0. }

private

{ 0. };

Referenced by BuildVolume().

m_bbox

BoundingBox Slic3r::BuildVolume::m_bbox

private

Referenced by BuildVolume(), and bounding_box().

m_bboxf

BoundingBoxf3 Slic3r::BuildVolume::m_bboxf

private

Referenced by BuildVolume(), bounding_mesh(), bounding_volume(), and bounding_volume2d().

m_bed_shape

std::vector<Vec2d> Slic3r::BuildVolume::m_bed_shape

private

Referenced by BuildVolume(), bed_center(), and printable_area().

m_circle

Geometry::Circled Slic3r::BuildVolume::m_circle { Vec2d::Zero(), 0 }

private

{ Vec2d::Zero(), 0 };

Referenced by BuildVolume(), all_paths_inside(), circle(), and object_state().

m_convex_hull

Polygon Slic3r::BuildVolume::m_convex_hull

private

Referenced by BuildVolume(), and convex_hull().

m_extruder_printable_height

std::vector<double> Slic3r::BuildVolume::m_extruder_printable_height

private

Referenced by BuildVolume(), and extruder_heights().

m_extruder_shapes

std::vector<std::vector<Vec2d> > Slic3r::BuildVolume::m_extruder_shapes

private

Referenced by BuildVolume(), and extruder_areas().

m_extruder_volumes

std::vector<BuildExtruderVolume> Slic3r::BuildVolume::m_extruder_volumes

private

Referenced by BuildVolume(), get_extruder_area_count(), and get_extruder_area_volume().

m_max_print_height

double Slic3r::BuildVolume::m_max_print_height { 0.f }

private

{ 0.f };

Referenced by BuildVolume(), all_paths_inside(), check_object_state_with_extruder_area(), object_state(), printable_height(), and volume_state_bbox().

m_polygon

Polygon Slic3r::BuildVolume::m_polygon

private

Referenced by BuildVolume(), and polygon().

m_shared_volume

BuildSharedVolume Slic3r::BuildVolume::m_shared_volume

private

Referenced by BuildVolume(), and get_shared_volume().

m_top_bottom_convex_hull_decomposition_bed

std::pair<std::vector<Vec2d>, std::vector<Vec2d> > Slic3r::BuildVolume::m_top_bottom_convex_hull_decomposition_bed

private

Referenced by BuildVolume(), and top_bottom_convex_hull_decomposition_bed().

m_top_bottom_convex_hull_decomposition_scene

std::pair<std::vector<Vec2d>, std::vector<Vec2d> > Slic3r::BuildVolume::m_top_bottom_convex_hull_decomposition_scene

private

Referenced by BuildVolume(), object_state(), and top_bottom_convex_hull_decomposition_scene().

m_type

BuildVolume_Type Slic3r::BuildVolume::m_type { BuildVolume_Type::Invalid }

private

{ BuildVolume_Type::Invalid };

Referenced by BuildVolume(), all_paths_inside(), object_state(), type(), type_name(), valid(), and volume_state_bbox().

SceneEpsilon

const double Slic3r::BuildVolume::SceneEpsilon = EPSILON

staticconstexpr

Referenced by BuildVolume(), Slic3r::GUI::GLCanvas3D::_render_objects(), Slic3r::ModelInstance::calc_print_volume_state(), check_object_state_with_extruder_area(), check_volume_bbox_state_with_extruder_area(), Slic3r::GUI::free_print_volumes(), Slic3r::GUI::PartPlate::get_build_volume(), object_state(), Slic3r::object_state_templ(), Slic3r::GUI::GLCanvas3D::render_thumbnail_internal(), and volume_state_bbox().

---

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

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