Slic3r::BoundingBoxf3 Class Reference

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

Inheritance diagram for Slic3r::BoundingBoxf3:

Collaboration diagram for Slic3r::BoundingBoxf3:

Public Types
using	PointsType

Public Member Functions
BoundingBoxf3	transformed (const Transform3d &matrix) const
	BoundingBox3Base ()
	BoundingBox3Base (const PointType &pmin, const PointType &pmax)
	BoundingBox3Base (const PointType &p1, const PointType &p2, const PointType &p3)
template<class It, class = IteratorOnly<It>>
	BoundingBox3Base (It from, It to)
	BoundingBox3Base (const PointsType &points)
Polygon	polygon (bool is_scaled=false) const
void	merge (const Vec3d &point)
Vec3d	size () const
double	radius () const
void	translate (coordf_t x, coordf_t y, coordf_t z)
void	translate (coordf_t x, coordf_t y)
void	offset (coordf_t delta)
BoundingBox3Base< Vec3d >	inflated (coordf_t delta) const throw ()
Vec3d	center () const
coordf_t	max_size () const
bool	contains (const Vec3d &point) const
bool	intersects (const BoundingBox3Base< Vec3d > &other) const
void	reset ()
void	scale (double factor)
double	area () const
bool	overlap (const BoundingBoxBase< Vec3d, PointsType > &other) const
Vec3d	operator[] (size_t idx) const
bool	operator== (const BoundingBoxBase< Vec3d, PointsType > &rhs)
bool	operator!= (const BoundingBoxBase< Vec3d, PointsType > &rhs)

Public Attributes
Vec3d	min
Vec3d	max
bool	defined

Static Private Member Functions
static void	construct (BoundingBoxType &out, It from, It to)

Detailed Description

Member Typedef Documentation

PointsType

using Slic3r::BoundingBox3Base< Vec3d >::PointsType

inherited

Member Function Documentation

area()

double Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::area ( ) const

inlineinherited

{ return double(this->max(0) - this->min(0)) * (this->max(1) - this->min(1));    } // BBS

BoundingBox3Base() [1/5]

Slic3r::BoundingBox3Base< PointType >::BoundingBox3Base ( )

inline

: BoundingBoxBase<PointType>() {}

BoundingBox3Base() [2/5]

Slic3r::BoundingBox3Base< PointType >::BoundingBox3Base ( const PointsType & points )

inline

        : BoundingBox3Base(points.begin(), points.end())
    {}

BoundingBox3Base() [3/5]

Slic3r::BoundingBox3Base< PointType >::BoundingBox3Base ( const PointType & p1, const PointType & p2, const PointType & p3 )

inline

                                                                                    :
        BoundingBoxBase<PointType>(p1, p1) { merge(p2); merge(p3); }

BoundingBox3Base() [4/5]

Slic3r::BoundingBox3Base< PointType >::BoundingBox3Base ( const PointType & pmin, const PointType & pmax )

inline

                                                                   : 
        BoundingBoxBase<PointType>(pmin, pmax) 
        { if (pmin.z() >= pmax.z()) BoundingBoxBase<PointType>::defined = false; }

BoundingBox3Base() [5/5]

template<class It, class = IteratorOnly<It>>

Slic3r::BoundingBox3Base< PointType >::BoundingBox3Base ( It from, It to )

inline

    {
        if (from == to)
            throw Slic3r::InvalidArgument("Empty point set supplied to BoundingBox3Base constructor.");
 
        auto it = from;
        this->min = it->template cast<typename PointType::Scalar>();
        this->max = this->min;
        for (++ it; it != to; ++ it) {
            auto vec = it->template cast<typename PointType::Scalar>();
            this->min = this->min.cwiseMin(vec);
            this->max = this->max.cwiseMax(vec);
        }
        this->defined = (this->min.x() < this->max.x()) && (this->min.y() < this->max.y()) && (this->min.z() < this->max.z());
    }

center()

template Vec3d Slic3r::BoundingBox3Base< Vec3d >::center ( ) const

inherited

{
    return (this->min + this->max) / 2;
}

construct()

template void Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::construct< 1, BoundingBox, Points::const_iterator > ( BoundingBoxType & out, It from, It to )

inlinestaticprivateinherited

    {
        if (from != to) {
            auto it = from;
            out.min = it->template cast<typename PointType::Scalar>();
            out.max = out.min;
            for (++ it; it != to; ++ it) {
                auto vec = it->template cast<typename PointType::Scalar>();
                out.min = out.min.cwiseMin(vec);
                out.max = out.max.cwiseMax(vec);
            }
            out.defined = IncludeBoundary || (out.min.x() < out.max.x() && out.min.y() < out.max.y());
        }
    }

contains()

bool Slic3r::BoundingBox3Base< Vec3d >::contains ( const Vec3d & point ) const

inlineinherited

                                                {
        return BoundingBoxBase<PointType>::contains(point) && point.z() >= this->min.z() && point.z() <= this->max.z();
    }

inflated()

BoundingBox3Base< Vec3d > Slic3r::BoundingBox3Base< Vec3d >::inflated ( coordf_t delta ) const throw (  )

inlineinherited

{ BoundingBox3Base<PointType> out(*this); out.offset(delta); return out; }

intersects()

bool Slic3r::BoundingBox3Base< Vec3d >::intersects ( const BoundingBox3Base< Vec3d > & other ) const

inlineinherited

                                                                    {
        return this->min.x() < other.max.x() && this->max.x() > other.min.x() && this->min.y() < other.max.y() && this->max.y() > other.min.y() && 
            this->min.z() < other.max.z() && this->max.z() > other.min.z();
    }

max_size()

template coordf_t Slic3r::BoundingBox3Base< Vec3d >::max_size ( ) const

inherited

{
    PointType s = size();
    return std::max(s.x(), std::max(s.y(), s.z()));
}

merge()

void Slic3r::BoundingBox3Base< Vec3d >::merge ( const Vec3d & point )

inherited

{
    if (this->defined) {
        this->min = this->min.cwiseMin(point);
        this->max = this->max.cwiseMax(point);
    } else {
        this->min = point;
        this->max = point;
        this->defined = true;
    }
}

offset()

template void Slic3r::BoundingBox3Base< Vec3d >::offset ( coordf_t delta )

inherited

{
    PointType v(delta, delta, delta);
    this->min -= v;
    this->max += v;
}

operator!=()

bool Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::operator!= ( const BoundingBoxBase< Vec3d, PointsType > & rhs )

inlineinherited

{ return ! (*this == rhs); }

operator==()

bool Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::operator== ( const BoundingBoxBase< Vec3d, PointsType > & rhs )

inlineinherited

{ return this->min == rhs.min && this->max == rhs.max; }

operator[]()

Vec3d Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::operator[] ( size_t idx ) const

inlineinherited

                                           {
        switch (idx) {
        case 0:
            return min;
            break;
        case 1:
            return PointType(max(0), min(1));
            break;
        case 2:
            return max;
            break;
        case 3:
            return PointType(min(0), max(1));
            break;
        default:
            return PointType();
            break;
        }
        return PointType();
    }

overlap()

bool Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::overlap ( const BoundingBoxBase< Vec3d, PointsType > & other ) const

inlineinherited

                                                                            {
        return ! (this->max.x() < other.min.x() || this->min.x() > other.max.x() ||
                  this->max.y() < other.min.y() || this->min.y() > other.max.y());
    }

polygon()

template Polygon Slic3r::BoundingBox3Base< Vec3d >::polygon ( bool is_scaled = false ) const

inherited

{
    Polygon polygon;
    polygon.points.clear();
    polygon.points.resize(4);
    double scale_factor = 1 / (is_scaled ? SCALING_FACTOR : 1);
    polygon.points[0](0) = this->min(0) * scale_factor;
    polygon.points[0](1) = this->min(1) * scale_factor;
    polygon.points[1](0) = this->max(0) * scale_factor;
    polygon.points[1](1) = this->min(1) * scale_factor;
    polygon.points[2](0) = this->max(0) * scale_factor;
    polygon.points[2](1) = this->max(1) * scale_factor;
    polygon.points[3](0) = this->min(0) * scale_factor;
    polygon.points[3](1) = this->max(1) * scale_factor;
    return polygon;
}

radius()

template double Slic3r::BoundingBox3Base< Vec3d >::radius ( ) const

inherited

{
    return 0.5 * (this->max - this->min).template cast<double>().norm();
}

reset()

void Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::reset ( )

inlineinherited

{ this->defined = false; this->min = PointType::Zero(); this->max = PointType::Zero(); }

scale()

template void Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::scale ( double factor )

inherited

{
    this->min *= factor;
    this->max *= factor;
}

size()

template Vec3d Slic3r::BoundingBox3Base< Vec3d >::size ( ) const

inherited

{
    return this->max - this->min;
}

transformed()

BoundingBoxf3 Slic3r::BoundingBoxf3::transformed

(

const Transform3d &

matrix

)

const

{
    typedef Eigen::Matrix<double, 3, 8, Eigen::DontAlign> Vertices;
 
    Vertices src_vertices;
    src_vertices(0, 0) = min.x(); src_vertices(1, 0) = min.y(); src_vertices(2, 0) = min.z();
    src_vertices(0, 1) = max.x(); src_vertices(1, 1) = min.y(); src_vertices(2, 1) = min.z();
    src_vertices(0, 2) = max.x(); src_vertices(1, 2) = max.y(); src_vertices(2, 2) = min.z();
    src_vertices(0, 3) = min.x(); src_vertices(1, 3) = max.y(); src_vertices(2, 3) = min.z();
    src_vertices(0, 4) = min.x(); src_vertices(1, 4) = min.y(); src_vertices(2, 4) = max.z();
    src_vertices(0, 5) = max.x(); src_vertices(1, 5) = min.y(); src_vertices(2, 5) = max.z();
    src_vertices(0, 6) = max.x(); src_vertices(1, 6) = max.y(); src_vertices(2, 6) = max.z();
    src_vertices(0, 7) = min.x(); src_vertices(1, 7) = max.y(); src_vertices(2, 7) = max.z();
 
    Vertices dst_vertices = matrix * src_vertices.colwise().homogeneous();
 
    Vec3d v_min(dst_vertices(0, 0), dst_vertices(1, 0), dst_vertices(2, 0));
    Vec3d v_max = v_min;
 
    for (int i = 1; i < 8; ++i)
    {
        for (int j = 0; j < 3; ++j)
        {
            v_min(j) = std::min(v_min(j), dst_vertices(j, i));
            v_max(j) = std::max(v_max(j), dst_vertices(j, i));
        }
    }
 
    return BoundingBoxf3(v_min, v_max);
}

References Slic3r::BoundingBox3Base< Vec3d >::max, and Slic3r::BoundingBox3Base< Vec3d >::min.

Referenced by Slic3r::PrintObject::PrintObject(), Slic3r::GUI::Camera::calc_tight_frustrum_zs_around(), anonymous_namespace{EmbossJob.cpp}::cut_surface_to_its(), Slic3r::GUI::Selection::paste_volumes_from_clipboard(), Slic3r::ModelInstance::transform_bounding_box(), Slic3r::GLVolume::transformed_bounding_box(), and Slic3r::GLVolume::transformed_convex_hull_bounding_box().

Here is the caller graph for this function:

translate() [1/2]

void Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::translate ( coordf_t x, coordf_t y )

inlineinherited

{ assert(this->defined); PointType v(x, y); this->min += v; this->max += v; }

translate() [2/2]

void Slic3r::BoundingBox3Base< Vec3d >::translate ( coordf_t x, coordf_t y, coordf_t z )

inlineinherited

{ assert(this->defined); PointType v(x, y, z); this->min += v; this->max += v; }

Member Data Documentation

defined

bool Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::defined

inherited

max

Vec3d Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::max

inherited

Referenced by Slic3r::BoundingBoxf3::transformed().

min

Vec3d Slic3r::BoundingBoxBase< Vec3d, std::vector< Vec3d > >::min

inherited

Referenced by Slic3r::BoundingBoxf3::transformed().

---

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

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