Slic3r::MutablePolygon Class Reference

#include <src/libslic3r/MutablePolygon.hpp>

Collaboration diagram for Slic3r::MutablePolygon:

Classes
class	const_iterator
class	iterator
struct	LinkedPoint
class	range

Public Types
using	IndexType = int32_t
using	PointType = Point

Public Member Functions
	MutablePolygon ()=default
	MutablePolygon (const Polygon &rhs, size_t reserve=0)
	MutablePolygon (std::initializer_list< Point > rhs, size_t reserve=0)
template<typename IT >
	MutablePolygon (IT begin, IT end, size_t reserve=0)
template<typename IT >
void	assign (IT begin, IT end, size_t reserve=0)
void	assign (const Polygon &rhs, size_t reserve=0)
void	polygon (Polygon &out) const
Polygon	polygon () const
bool	empty () const
size_t	size () const
size_t	capacity () const
bool	valid () const
void	clear ()
iterator	begin ()
const_iterator	cbegin () const
const_iterator	begin () const
iterator	end ()
const_iterator	cend () const
const_iterator	end () const
iterator	remove (const iterator it)
iterator	insert (const iterator it, const PointType pt)

Private Member Functions
LinkedPoint &	at (IndexType i)
const LinkedPoint &	at (IndexType i) const
template<typename IT >
void	assign_inner (IT begin, IT end, size_t reserve)
IndexType	remove (const IndexType i)
IndexType	insert (const IndexType i, const Point pt)

Private Attributes
std::vector< LinkedPoint >	m_data
IndexType	m_size { 0 }
IndexType	m_head { IndexType(-1) }
IndexType	m_head_free { IndexType(-1) }

Detailed Description

---

Class Documentation

Slic3r::MutablePolygon::LinkedPoint

struct Slic3r::MutablePolygon::LinkedPoint

Collaboration diagram for Slic3r::MutablePolygon::LinkedPoint:

Class Members
IndexType	next
PointType	point
IndexType	prev

Member Typedef Documentation

IndexType

using Slic3r::MutablePolygon::IndexType = int32_t

PointType

using Slic3r::MutablePolygon::PointType = Point

Constructor & Destructor Documentation

MutablePolygon() [1/4]

Slic3r::MutablePolygon::MutablePolygon ( )

default

MutablePolygon() [2/4]

Slic3r::MutablePolygon::MutablePolygon ( const Polygon &  rhs, size_t  reserve = 0  )

inline

: MutablePolygon(rhs.points.begin(), rhs.points.end(), reserve) {}

MutablePolygon() [3/4]

Slic3r::MutablePolygon::MutablePolygon ( std::initializer_list< Point >  rhs, size_t  reserve = 0  )

inline

: MutablePolygon(rhs.begin(), rhs.end(), reserve) {}

MutablePolygon() [4/4]

template<typename IT >

Slic3r::MutablePolygon::MutablePolygon ( IT  begin, IT  end, size_t  reserve = 0  )

inline

                                                         {
        this->assign_inner(begin, end, reserve);
    };

References assign_inner(), and end().

Here is the call graph for this function:

Member Function Documentation

assign() [1/2]

void Slic3r::MutablePolygon::assign ( const Polygon &  rhs, size_t  reserve = 0  )

inline

                                                        {
        assign(rhs.points.begin(), rhs.points.end(), reserve);
    }

References assign(), and Slic3r::MultiPoint::points.

Here is the call graph for this function:

assign() [2/2]

template<typename IT >

void Slic3r::MutablePolygon::assign ( IT  begin, IT  end, size_t  reserve = 0  )

inline

                                                      {
        m_data.clear();
        m_head      = IndexType(-1);
        m_head_free = { IndexType(-1) };
        this->assign_inner(begin, end, reserve);  
    };

References assign_inner(), end(), m_data, m_head, and m_head_free.

Referenced by assign(), Slic3r::remove_duplicates(), Slic3r::smooth_outward(), and Slic3r::smooth_outward().

Here is the call graph for this function:

Here is the caller graph for this function:

assign_inner()

template<typename IT >

void Slic3r::MutablePolygon::assign_inner ( IT  begin, IT  end, size_t  reserve  )

inlineprivate

                                                        {
        m_size = IndexType(end - begin);
        if (m_size > 0) {
            m_head = 0;
            m_data.reserve(std::max<size_t>(m_size, reserve));
            auto i = IndexType(-1);
            auto j = IndexType(1);
            for (auto it = begin; it != end; ++ it)
                m_data.push_back({ *it, i ++, j ++ });
            m_data.front().prev = m_size - 1;
            m_data.back ().next = 0;
        }
    };

References begin(), end(), m_data, m_head, and m_size.

Referenced by MutablePolygon(), and assign().

Here is the call graph for this function:

Here is the caller graph for this function:

at() [1/2]

LinkedPoint & Slic3r::MutablePolygon::at ( IndexType  i )

inlineprivate

{ return m_data[i]; }

References m_data.

Referenced by cend(), end(), insert(), Slic3r::MutablePolygon::const_iterator::next(), Slic3r::MutablePolygon::iterator::next(), Slic3r::MutablePolygon::const_iterator::operator*(), Slic3r::MutablePolygon::iterator::operator*(), Slic3r::MutablePolygon::const_iterator::operator++(), Slic3r::MutablePolygon::iterator::operator++(), Slic3r::MutablePolygon::const_iterator::operator--(), Slic3r::MutablePolygon::iterator::operator--(), Slic3r::MutablePolygon::const_iterator::operator->(), Slic3r::MutablePolygon::iterator::operator->(), Slic3r::MutablePolygon::const_iterator::prev(), Slic3r::MutablePolygon::iterator::prev(), and remove().

Here is the caller graph for this function:

at() [2/2]

const LinkedPoint & Slic3r::MutablePolygon::at ( IndexType  i ) const

inlineprivate

{ return m_data[i]; }

References m_data.

begin() [1/2]

iterator Slic3r::MutablePolygon::begin ( )

inline

{ return { this, m_head }; }

References m_head.

Referenced by assign_inner(), Slic3r::remove_duplicates(), Slic3r::remove_duplicates(), Slic3r::remove_duplicates(), and Slic3r::smooth_outward().

Here is the caller graph for this function:

begin() [2/2]

const_iterator Slic3r::MutablePolygon::begin ( ) const

inline

{ return this->cbegin(); }

References cbegin().

Here is the call graph for this function:

capacity()

size_t Slic3r::MutablePolygon::capacity ( ) const

inline

{ return m_data.capacity(); }

References m_data.

cbegin()

const_iterator Slic3r::MutablePolygon::cbegin ( ) const

inline

{ return { this, m_head }; }

References m_head.

Referenced by begin(), Slic3r::operator==(), and polygon().

Here is the caller graph for this function:

cend()

const_iterator Slic3r::MutablePolygon::cend ( ) const

inline

{ return { this, this->empty() ? -1 : this->at(m_head).prev }; }

References at(), empty(), m_head, and Slic3r::MutablePolygon::LinkedPoint::prev.

Referenced by end().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::MutablePolygon::clear ( )

inline

{ m_data.clear(); m_size = 0; m_head = IndexType(-1); m_head_free = IndexType(-1); }

References m_data, m_head, m_head_free, and m_size.

Referenced by Slic3r::clip_narrow_corner(), Slic3r::remove_duplicates(), and Slic3r::smooth_outward().

Here is the caller graph for this function:

empty()

bool Slic3r::MutablePolygon::empty ( ) const

inline

{ return m_size == 0; }

References m_size.

Referenced by cend(), end(), Slic3r::operator==(), remove(), Slic3r::remove_duplicates(), and Slic3r::remove_duplicates().

Here is the caller graph for this function:

end() [1/2]

iterator Slic3r::MutablePolygon::end ( )

inline

{ return { this, this->empty() ? -1 : this->at(m_head).prev }; }

References at(), empty(), m_head, and Slic3r::MutablePolygon::LinkedPoint::prev.

Referenced by MutablePolygon(), assign(), and assign_inner().

Here is the call graph for this function:

Here is the caller graph for this function:

end() [2/2]

const_iterator Slic3r::MutablePolygon::end ( ) const

inline

{ return this->cend(); }

References cend().

Here is the call graph for this function:

insert() [1/2]

IndexType Slic3r::MutablePolygon::insert ( const IndexType  i, const Point  pt  )

inlineprivate

                                                        {
        assert(i >= 0);
        IndexType n;
        IndexType j = this->at(i).prev;
        if (m_head_free == -1) {
            // Allocate a new item.
            n = IndexType(m_data.size());
            m_data.push_back({ pt, j, i });
        } else {
            n = m_head_free;
            LinkedPoint &nlp = this->at(n);
            m_head_free = nlp.next;
            nlp = { pt, j, i };
        }
        this->at(j).next = n;
        this->at(i).prev = n;
        ++ m_size;
        return n;
    }

References at(), m_data, m_head_free, m_size, Slic3r::MutablePolygon::LinkedPoint::next, and Slic3r::MutablePolygon::LinkedPoint::prev.

Here is the call graph for this function:

insert() [2/2]

iterator Slic3r::MutablePolygon::insert ( const iterator  it, const PointType  pt  )

inline

{ assert(it.m_data == this); return { this, this->insert(it.m_idx, pt) }; }

References insert(), Slic3r::MutablePolygon::iterator::m_data, and Slic3r::MutablePolygon::iterator::m_idx.

Referenced by insert(), and Slic3r::MutablePolygon::iterator::insert().

Here is the call graph for this function:

Here is the caller graph for this function:

polygon() [1/2]

Polygon Slic3r::MutablePolygon::polygon ( ) const

inline

                            {
        Polygon out;
        this->polygon(out);
        return out;
    };

References polygon().

Referenced by polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

polygon() [2/2]

void Slic3r::MutablePolygon::polygon ( Polygon &  out ) const

inline

                                     {
        out.points.clear();
        if (this->valid()) {
            out.points.reserve(this->size());
            auto it = this->cbegin();
            out.points.emplace_back(*it);
            for (++ it; it != this->cbegin(); ++ it)
                out.points.emplace_back(*it);
        }
    };

References cbegin(), Slic3r::MultiPoint::points, size(), and valid().

Referenced by Slic3r::remove_duplicates(), Slic3r::smooth_outward(), Slic3r::smooth_outward(), and Slic3r::smooth_outward().

Here is the call graph for this function:

Here is the caller graph for this function:

remove() [1/2]

IndexType Slic3r::MutablePolygon::remove ( const IndexType  i )

inlineprivate

                                        {
        assert(i >= 0);
        assert(m_size > 0);
        assert(m_head != -1);
        LinkedPoint &lp = this->at(i);
        IndexType prev = lp.prev;
        IndexType next = lp.next;
        lp.next = m_head_free;
        m_head_free = i;
        if (-- m_size == 0)
            m_head = -1;
        else if (m_head == i)
            m_head = next;
        assert(! this->empty() || (prev == i && next == i));
        if (this->empty())
            return IndexType(-1);
        this->at(prev).next = next;
        this->at(next).prev = prev;
        return next;
    }

References at(), empty(), m_head, m_head_free, m_size, Slic3r::MutablePolygon::LinkedPoint::next, and Slic3r::MutablePolygon::LinkedPoint::prev.

Here is the call graph for this function:

remove() [2/2]

iterator Slic3r::MutablePolygon::remove ( const iterator  it )

inline

{ assert(it.m_data == this); return { this, this->remove(it.m_idx) }; }

References Slic3r::MutablePolygon::iterator::m_data, Slic3r::MutablePolygon::iterator::m_idx, and remove().

Referenced by Slic3r::MutablePolygon::iterator::remove(), and remove().

Here is the call graph for this function:

Here is the caller graph for this function:

size()

size_t Slic3r::MutablePolygon::size ( ) const

inline

{ return m_size; }

References m_size.

Referenced by Slic3r::clip_narrow_corner(), Slic3r::operator==(), polygon(), Slic3r::remove_duplicates(), Slic3r::MutablePolygon::const_iterator::size(), Slic3r::MutablePolygon::iterator::size(), and Slic3r::smooth_outward().

Here is the caller graph for this function:

valid()

bool Slic3r::MutablePolygon::valid ( ) const

inline

{ return m_size >= 3; }

References m_size.

Referenced by polygon().

Here is the caller graph for this function:

Member Data Documentation

m_data

std::vector<LinkedPoint> Slic3r::MutablePolygon::m_data

private

Referenced by assign(), assign_inner(), at(), at(), capacity(), clear(), and insert().

m_head

IndexType Slic3r::MutablePolygon::m_head { IndexType(-1) }

private

Referenced by assign(), assign_inner(), begin(), cbegin(), cend(), clear(), end(), and remove().

m_head_free

IndexType Slic3r::MutablePolygon::m_head_free { IndexType(-1) }

private

Referenced by assign(), clear(), insert(), and remove().

m_size

IndexType Slic3r::MutablePolygon::m_size { 0 }

private

Referenced by assign_inner(), clear(), empty(), insert(), remove(), size(), and valid().

---

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

• src/libslic3r/MutablePolygon.hpp