Slic3r::BuildVolume Class Reference

#include <src/libslic3r/BuildVolume.hpp>

Collaboration diagram for Slic3r::BuildVolume:

Public Types
enum class	Type : unsigned char {   Invalid , Rectangle , Circle , Convex ,   Custom }
enum class	ObjectState : unsigned char { Inside , Colliding , Outside , Below }

Public Member Functions
	BuildVolume ()
	BuildVolume (const std::vector< Vec2d > &bed_shape, const double max_print_height)
const std::vector< Vec2d > &	bed_shape () const
double	max_print_height () const
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
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
bool	all_paths_inside_vertices_and_normals_interleaved (const std::vector< float > &paths, const Eigen::AlignedBox< float, 3 > &bbox, bool ignore_bottom=true) 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 (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
double	m_max_print_height
Type	m_type { 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

Member Enumeration Documentation

ObjectState

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

strong

Enumerator
Inside
Colliding
Outside
Below

    {
        // 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,
    };

Type

enum class Slic3r::BuildVolume::Type : unsigned char

strong

Enumerator
Invalid
Rectangle
Circle
Convex
Custom

    {
        // Not set yet or undefined.
        Invalid,
        // Rectangular print bed. Most common, cheap to work with.
        Rectangle,
        // Circular print bed. Common on detals, cheap to work with.
        Circle,
        // Convex print bed. Complex to process.
        Convex,
        // Some non convex shape.
        Custom
    };

Constructor & Destructor Documentation

BuildVolume() [1/2]

Slic3r::BuildVolume::BuildVolume ( )

inline

{}

BuildVolume() [2/2]

Slic3r::BuildVolume::BuildVolume	(	const std::vector< Vec2d > &	bed_shape,
		const double	max_print_height
	)

                                                                                         : m_bed_shape(bed_shape), m_max_print_height(max_print_height)
{
    assert(max_print_height >= 0);
 
    m_polygon     = Polygon::new_scale(bed_shape);
 
    // 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(bed_shape);
    m_bboxf = BoundingBoxf3{ to_3d(bboxf.min, 0.), to_3d(bboxf.max, max_print_height) };
 
    if (bed_shape.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 = 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 (bed_shape.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(bed_shape);
        m_circle = Geometry::circle_ransac(bed_shape);
        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 = bed_shape.back();
        for (const Vec2d &p : bed_shape) {
#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 = Type::Circle;
            m_circle.center = scaled<double>(m_circle.center);
            m_circle.radius = scaled<double>(m_circle.radius);
        }
    }
 
    if (bed_shape.size() >= 3 && m_type == 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) ? Type::Convex : 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);
    }
 
    BOOST_LOG_TRIVIAL(debug) << "BuildVolume bed_shape clasified as: " << this->type_name();
}

References Slic3r::Polygon::area(), bed_shape(), BedEpsilon, Slic3r::Geometry::Circle< Vector >::center, Circle, Slic3r::Geometry::circle_ransac(), Convex, Slic3r::Geometry::convex_hull(), Custom, Slic3r::Geometry::decompose_convex_polygon_top_bottom(), Slic3r::expand(), Slic3r::get_extents(), Invalid, m_area, m_bbox, m_bboxf, m_circle, m_convex_hull, m_polygon, m_top_bottom_convex_hull_decomposition_bed, m_top_bottom_convex_hull_decomposition_scene, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, max_print_height(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Polygon::new_scale(), Slic3r::MultiPoint::points, Slic3r::Geometry::Circle< Vector >::radius, Rectangle, SCALED_EPSILON, SceneEpsilon, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), Slic3r::MultiPoint::size(), Slic3r::Geometry::smallest_enclosing_circle_welzl(), Slic3r::sqr(), Slic3r::to_3d(), and type_name().

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 != GCodeExtrusionRole::Custom && move.width != 0.f && move.height != 0.f;
    };
    static constexpr const double epsilon = BedEpsilon;
 
    switch (m_type) {
    case 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();
        return build_volume.contains(paths_bbox);
    }
    case 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 Type::Convex:
    //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case 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::Geometry::Circle< Vector >::center, Circle, Slic3r::BoundingBox3Base< PointType >::contains(), Convex, Custom, Slic3r::Custom, Slic3r::Extrude, Slic3r::BoundingBox3Base< PointType >::inflated(), m_circle, m_max_print_height, m_type, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::GCodeProcessorResult::moves, Slic3r::Geometry::Circle< Vector >::radius, Rectangle, and Slic3r::sqr().

Here is the call graph for this function:

all_paths_inside_vertices_and_normals_interleaved()

bool Slic3r::BuildVolume::all_paths_inside_vertices_and_normals_interleaved	(	const std::vector< float > &	paths,
		const Eigen::AlignedBox< float, 3 > &	bbox,
		bool	ignore_bottom = true
	)		const

{
    assert(paths.size() % 6 == 0);
    static constexpr const double epsilon = BedEpsilon;
    switch (m_type) {
    case 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();
        return build_volume.contains(paths_bbox.min().cast<double>()) && build_volume.contains(paths_bbox.max().cast<double>());
    }
    case Type::Circle:
    {
        const Vec2f c = unscaled<float>(m_circle.center);
        const float r = unscaled<double>(m_circle.radius) + float(epsilon);
        const float r2 = sqr(r);
        return m_max_print_height == 0.0 ?
            all_inside_vertices_normals_interleaved(paths, [c, r2](Vec3f p) { return (to_2d(p) - c).squaredNorm() <= r2; }) :
            all_inside_vertices_normals_interleaved(paths, [c, r2, z = m_max_print_height + epsilon](Vec3f p) { return (to_2d(p) - c).squaredNorm() <= r2 && p.z() <= z; });
    }
    case Type::Convex:
        //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case Type::Custom:
        return m_max_print_height == 0.0 ?
            all_inside_vertices_normals_interleaved(paths, [this](Vec3f p) { return Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_bed, to_2d(p).cast<double>()); }) :
            all_inside_vertices_normals_interleaved(paths, [this, z = m_max_print_height + epsilon](Vec3f p) { return Geometry::inside_convex_polygon(m_top_bottom_convex_hull_decomposition_bed, to_2d(p).cast<double>()) && p.z() <= z; });
    default:
        return true;
    }
}

References Slic3r::all_inside_vertices_normals_interleaved(), BedEpsilon, bounding_volume(), Slic3r::Geometry::Circle< Vector >::center, Circle, Slic3r::BoundingBox3Base< PointType >::contains(), Convex, Custom, Slic3r::BoundingBox3Base< PointType >::inflated(), Slic3r::Geometry::inside_convex_polygon(), m_circle, m_max_print_height, m_top_bottom_convex_hull_decomposition_bed, m_type, Eigen::AlignedBox< _Scalar, _AmbientDim >::max(), Slic3r::BoundingBoxBase< PointType, APointsType >::max, Eigen::AlignedBox< _Scalar, _AmbientDim >::min(), Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::Geometry::Circle< Vector >::radius, Rectangle, Slic3r::sqr(), and Slic3r::to_2d().

Here is the call graph for this function:

bed_center()

Vec2d Slic3r::BuildVolume::bed_center ( ) const

inline

{ return to_2d(m_bboxf.center()); }

References Slic3r::BoundingBox3Base< PointType >::center(), m_bboxf, and Slic3r::to_2d().

Here is the call graph for this function:

bed_shape()

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

inline

{ return m_bed_shape; }

References m_bed_shape.

Referenced by BuildVolume(), Slic3r::GUI::Bed3D::set_shape(), and priv::start_create_object_job().

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_volume()

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

inline

{ return m_bboxf; }

References m_bboxf.

Referenced by Slic3r::GUI::GLCanvas3D::_max_bounding_box(), all_paths_inside(), all_paths_inside_vertices_and_normals_interleaved(), Slic3r::GUI::BedShape::apply_optgroup_values(), Slic3r::GUI::bed_stride(), Slic3r::GUI::Bed3D::calc_extended_bounding_box(), Slic3r::GUI::BedShape::get_full_name_with_params(), object_state(), Slic3r::GUI::Bed3D::set_shape(), volume_state_bbox(), and Slic3r::GUI::GLCanvas3D::zoom_to_bed().

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, Slic3r::BoundingBoxBase< PointType, APointsType >::max, Slic3r::BoundingBoxBase< PointType, APointsType >::min, and Slic3r::to_2d().

Referenced by Slic3r::GUI::GLCanvas3D::get_size_proportional_to_max_bed_size(), and Slic3r::GUI::Bed3D::render_model().

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 Slic3r::GUI::BedShape::apply_optgroup_values(), Slic3r::GUI::BedShape::get_full_name_with_params(), 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.

max_print_height()

double Slic3r::BuildVolume::max_print_height ( ) const

inline

{ return m_max_print_height; }

References m_max_print_height.

Referenced by BuildVolume(), Slic3r::GUI::GLCanvas3D::scene_bounding_box(), and Slic3r::GUI::Bed3D::set_shape().

Here is the caller graph for this function:

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 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, [build_volumef](const Vec3f &pt) { return build_volumef.contains(pt); });
    }
    case 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, [circle](const Vec3f &pt) { return circle.contains(to_2d(pt)); }) :
            object_state_templ(its, trafo, may_be_below_bed, [circle, z = m_max_print_height + SceneEpsilon](const Vec3f &pt) { return pt.z() < z && circle.contains(to_2d(pt)); });
    }
    case Type::Convex:
    //FIXME doing test on convex hull until we learn to do test on non-convex polygons efficiently.
    case Type::Custom:
        return m_max_print_height == 0.0 ? 
            object_state_templ(its, trafo, may_be_below_bed, [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, [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 Type::Invalid:
    default:
        return ObjectState::Inside;
    }
}

References bounding_volume(), Slic3r::Geometry::Circle< Vector >::center, Circle, circle(), Slic3r::BoundingBox3Base< PointType >::contains(), Slic3r::Geometry::Circle< Vector >::contains(), Convex, Custom, Slic3r::BoundingBox3Base< PointType >::inflated(), Inside, Slic3r::Geometry::inside_convex_polygon(), 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::Geometry::Circle< Vector >::radius, Rectangle, SceneEpsilon, and Slic3r::to_2d().

Referenced by Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), and Slic3r::ModelObject::update_instances_print_volume_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.

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()

Type Slic3r::BuildVolume::type ( ) const

inline

{ return m_type; }

References m_type.

Referenced by Slic3r::GUI::BedShape::apply_optgroup_values(), Slic3r::GUI::GLCanvas3D::check_volumes_outside_state(), Slic3r::GUI::BedShape::get_full_name_with_params(), Slic3r::GUI::BedShape::get_page_type(), Slic3r::GUI::BedShape::is_custom(), 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 ( Type  type )

static

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

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

Here is the call graph for this function:

valid()

bool Slic3r::BuildVolume::valid ( ) const

inline

{ return m_type != Type::Invalid; }

References Invalid, and m_type.

Referenced by Slic3r::GUI::GLCanvas3D::_render_objects(), Slic3r::GUI::GLCanvas3D::render(), and Slic3r::GUI::Bed3D::render_axes().

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 == 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, Rectangle, and SceneEpsilon.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BedEpsilon

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

staticconstexpr

Referenced by BuildVolume(), all_paths_inside(), all_paths_inside_vertices_and_normals_interleaved(), Slic3r::GUI::contains(), and Slic3r::Print::sequential_print_horizontal_clearance_valid().

m_area

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

private

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(), bed_center(), bounding_volume(), and bounding_volume2d().

m_bed_shape

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

private

Referenced by bed_shape().

m_circle

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

private

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

m_convex_hull

Polygon Slic3r::BuildVolume::m_convex_hull

private

Referenced by BuildVolume(), and convex_hull().

m_max_print_height

double Slic3r::BuildVolume::m_max_print_height

private

Referenced by all_paths_inside(), all_paths_inside_vertices_and_normals_interleaved(), max_print_height(), object_state(), and volume_state_bbox().

m_polygon

Polygon Slic3r::BuildVolume::m_polygon

private

Referenced by BuildVolume(), and polygon().

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(), all_paths_inside_vertices_and_normals_interleaved(), 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

Type Slic3r::BuildVolume::m_type { Type::Invalid }

private

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

SceneEpsilon

constexpr const double Slic3r::BuildVolume::SceneEpsilon = EPSILON

staticconstexpr

Referenced by BuildVolume(), Slic3r::GUI::GLCanvas3D::_render_objects(), object_state(), Slic3r::object_state_templ(), and volume_state_bbox().

---

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

• src/libslic3r/BuildVolume.hpp
• src/libslic3r/BuildVolume.cpp