Slic3r::BoundingBoxf Class Reference

#include <src/libslic3r/BoundingBox.hpp>

Inheritance diagram for Slic3r::BoundingBoxf:

Collaboration diagram for Slic3r::BoundingBoxf:

Public Types
using	PointsType = std::vector< Vec2d >

Public Member Functions
	BoundingBoxf ()
	BoundingBoxf (const Vec2d &pmin, const Vec2d &pmax)
	BoundingBoxf (const std::vector< Vec2d > &points)
void	reset ()
void	merge (const Vec2d &point)
void	merge (const PointsType &points)
void	merge (const BoundingBoxBase< Vec2d, PointsType > &bb)
void	scale (double factor)
Vec2d	size () const
double	radius () const
void	translate (coordf_t x, coordf_t y)
void	translate (const Vec2d &v)
void	offset (coordf_t delta)
BoundingBoxBase< Vec2d, PointsType >	inflated (coordf_t delta) const throw ()
Vec2d	center () const
bool	contains (const Vec2d &point) const
bool	contains (const BoundingBoxBase< Vec2d, PointsType > &other) const
bool	overlap (const BoundingBoxBase< Vec2d, PointsType > &other) const
bool	operator== (const BoundingBoxBase< Vec2d, PointsType > &rhs)
bool	operator!= (const BoundingBoxBase< Vec2d, PointsType > &rhs)

Public Attributes
Vec2d	min
Vec2d	max
bool	defined

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

Detailed Description

Member Typedef Documentation

PointsType

using Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::PointsType = std::vector<Vec2d >

inherited

Constructor & Destructor Documentation

BoundingBoxf() [1/3]

Slic3r::BoundingBoxf::BoundingBoxf ( )

inline

: BoundingBoxBase<Vec2d>() {}

BoundingBoxf() [2/3]

Slic3r::BoundingBoxf::BoundingBoxf ( const Vec2d &  pmin, const Vec2d &  pmax  )

inline

: BoundingBoxBase<Vec2d>(pmin, pmax) {}

BoundingBoxf() [3/3]

Slic3r::BoundingBoxf::BoundingBoxf ( const std::vector< Vec2d > &  points )

inline

: BoundingBoxBase<Vec2d>(points) {}

Member Function Documentation

center()

template Vec2d Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::center

inherited

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

construct()

static void Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::construct ( 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() [1/2]

bool Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::contains ( const BoundingBoxBase< Vec2d , PointsType > &  other ) const

inlineinherited

                                                                             {
        return contains(other.min) && contains(other.max);
    }

contains() [2/2]

bool Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::contains ( const Vec2d &  point ) const

inlineinherited

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

inflated()

BoundingBoxBase< Vec2d , PointsType > Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::inflated ( coordf_t  delta ) const throw ( )

inlineinherited

{ BoundingBoxBase<PointType, PointsType> out(*this); out.offset(delta); return out; }

merge() [1/3]

void Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::merge ( const BoundingBoxBase< Vec2d , PointsType > &  bb )

inherited

{
    assert(bb.defined || bb.min.x() >= bb.max.x() || bb.min.y() >= bb.max.y());
    if (bb.defined) {
        if (this->defined) {
            this->min = this->min.cwiseMin(bb.min);
            this->max = this->max.cwiseMax(bb.max);
        } else {
            this->min = bb.min;
            this->max = bb.max;
            this->defined = true;
        }
    }
}

merge() [2/3]

void Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::merge ( const PointsType &  points )

inherited

{
    this->merge(BoundingBoxBase(points));
}

merge() [3/3]

void Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::merge ( const Vec2d &  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::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::offset ( coordf_t  delta )

inherited

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

operator!=()

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

inlineinherited

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

operator==()

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

inlineinherited

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

overlap()

bool Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::overlap ( const BoundingBoxBase< Vec2d , 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());
    }

radius()

template double Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::radius

inherited

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

reset()

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

inlineinherited

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

scale()

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

inherited

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

size()

template Vec2d Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::size

inherited

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

translate() [1/2]

void Slic3r::BoundingBoxBase< Vec2d , std::vector<Vec2d > >::translate ( const Vec2d &  v )

inlineinherited

{ this->min += v; this->max += v; }

translate() [2/2]

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

inlineinherited

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

Member Data Documentation

defined

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

inherited

max

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

inherited

min

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

inherited

---

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

• src/libslic3r/BoundingBox.hpp