Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache Class Reference

Collaboration diagram for Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache:

Public Member Functions
	RadiusLayerPolygonCache ()=default
	RadiusLayerPolygonCache (RadiusLayerPolygonCache &&rhs)
RadiusLayerPolygonCache &	operator= (RadiusLayerPolygonCache &&rhs)
	RadiusLayerPolygonCache (const RadiusLayerPolygonCache &)=delete
RadiusLayerPolygonCache &	operator= (const RadiusLayerPolygonCache &)=delete
void	insert (std::vector< std::pair< RadiusLayerPair, Polygons > > &&in)
void	insert (std::vector< std::pair< coord_t, Polygons > > &&in, coord_t radius)
void	insert (std::vector< Polygons > &&in, coord_t first_layer_idx, coord_t radius)
void	insert (LayerPolygonCache &&in, coord_t radius)
std::optional< std::reference_wrapper< const Polygons > >	getArea (const TreeModelVolumes::RadiusLayerPair &key) const
	Checks a cache for a given RadiusLayerPair and returns it if it is found.
std::optional< std::pair< coord_t, std::reference_wrapper< const Polygons > > >	get_lower_bound_area (const TreeModelVolumes::RadiusLayerPair &key) const
LayerIndex	getMaxCalculatedLayer (coord_t radius) const
	Get the highest already calculated layer in the cache.
std::vector< std::pair< RadiusLayerPair, std::reference_wrapper< const Polygons > > >	sorted () const
void	clear ()
void	clear_all_but_radius0 ()

Private Types
using	LayerData = std::map<coord_t, Polygons>
using	Layers = std::vector<LayerData>

Private Member Functions
LayerData &	get_allocate_layer_data (LayerIndex layer_idx)
void	allocate_layers (size_t num_layers)

Private Attributes
Layers	m_data
std::mutex	m_mutex

Detailed Description

Member Typedef Documentation

LayerData

using Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::LayerData = std::map<coord_t, Polygons>

private

Layers

using Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::Layers = std::vector<LayerData>

private

Constructor & Destructor Documentation

RadiusLayerPolygonCache() [1/3]

Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::RadiusLayerPolygonCache ( )

default

Referenced by RadiusLayerPolygonCache(), RadiusLayerPolygonCache(), operator=(), and operator=().

Here is the caller graph for this function:

RadiusLayerPolygonCache() [2/3]

Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::RadiusLayerPolygonCache ( RadiusLayerPolygonCache && rhs )

inline

: m_data(std::move(rhs.m_data)) {}

References RadiusLayerPolygonCache(), and m_data.

Here is the call graph for this function:

RadiusLayerPolygonCache() [3/3]

Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::RadiusLayerPolygonCache ( const RadiusLayerPolygonCache & )

delete

References RadiusLayerPolygonCache().

Here is the call graph for this function:

Member Function Documentation

allocate_layers()

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::allocate_layers ( size_t num_layers )

private

{
    if (num_layers > m_data.size()) {
        if (num_layers > m_data.capacity())
            reserve_power_of_2(m_data, num_layers);
        m_data.resize(num_layers, {});
    }
}

References allocate_layers(), m_data, and Slic3r::reserve_power_of_2().

Referenced by allocate_layers(), get_allocate_layer_data(), insert(), and insert().

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::clear ( )

inline

{ m_data.clear(); }

References m_data.

clear_all_but_radius0()

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::clear_all_but_radius0 ( )

inline

                                     { 
            for (LayerData &l : m_data) {
                auto begin = l.begin();
                auto end = l.end();
                if (begin != end && ++ begin != end)
                    l.erase(begin, end);
            }
        }

References m_data.

get_allocate_layer_data()

LayerData & Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::get_allocate_layer_data ( LayerIndex layer_idx )

inlineprivate

                                                                          {
            allocate_layers(layer_idx + 1);
            return m_data[layer_idx];
        }

References allocate_layers(), and m_data.

Referenced by insert(), and insert().

Here is the call graph for this function:

Here is the caller graph for this function:

get_lower_bound_area()

std::optional< std::pair< coord_t, std::reference_wrapper< const Polygons > > > Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::get_lower_bound_area ( const TreeModelVolumes::RadiusLayerPair & key ) const

inline

                                                                                                                                                   {
            std::lock_guard<std::mutex> guard(m_mutex);
            if (key.second >= LayerIndex(m_data.size()))
                return {};
            const auto &layer = m_data[key.second];
            if (layer.empty())
                return {};
            auto it = layer.lower_bound(key.first);
            if (it == layer.end() || it->first != key.first) {
                if (it == layer.begin())
                    return {};
                -- it;
            }
            return std::make_pair(it->first, std::reference_wrapper<const Polygons>(it->second));
        }

References m_data, and m_mutex.

getArea()

std::optional< std::reference_wrapper< const Polygons > > Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::getArea ( const TreeModelVolumes::RadiusLayerPair & key ) const

inline

Checks a cache for a given RadiusLayerPair and returns it if it is found.

Parameters

key	RadiusLayerPair of the requested areas. The radius will be calculated up to the provided layer.

Returns

A wrapped optional reference of the requested area (if it was found, an empty optional if nothing was found)

                                                                                                                    {
            std::lock_guard<std::mutex> guard(m_mutex);
            if (key.second >= LayerIndex(m_data.size()))
                return std::optional<std::reference_wrapper<const Polygons>>{};
            const auto &layer = m_data[key.second];
            auto it = layer.find(key.first);
            return it == layer.end() ? 
                std::optional<std::reference_wrapper<const Polygons>>{} : std::optional<std::reference_wrapper<const Polygons>>{ it->second };
        }

References m_data, and m_mutex.

getMaxCalculatedLayer()

LayerIndex Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::getMaxCalculatedLayer ( coord_t radius ) const

inline

Get the highest already calculated layer in the cache.

Parameters

radius	The radius for which the highest already calculated layer has to be found.
map	The cache in which the lookup is performed.

Returns

A wrapped optional reference of the requested area (if it was found, an empty optional if nothing was found)

                                                               {
            std::lock_guard<std::mutex> guard(m_mutex);
            auto layer_idx = LayerIndex(m_data.size()) - 1;
            for (; layer_idx > 0; -- layer_idx)
                if (const auto &layer = m_data[layer_idx]; layer.find(radius) != layer.end())
                    break;
            // The placeable on model areas do not exist on layer 0, as there can not be model below it. As such it may be possible that layer 1 is available, but layer 0 does not exist.
            return layer_idx == 0 ? -1 : layer_idx;
        }

References m_data, and m_mutex.

insert() [1/4]

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::insert ( LayerPolygonCache && in, coord_t radius )

inline

                                                            {
            std::lock_guard<std::mutex> guard(m_mutex);
            LayerIndex i = in.begin();
            allocate_layers(i + LayerIndex(in.size()));
            for (auto &d : in.polygons_mutable())
                m_data[i ++].emplace(radius, std::move(d));
        }

References allocate_layers(), m_data, and m_mutex.

Here is the call graph for this function:

insert() [2/4]

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::insert ( std::vector< Polygons > && in, coord_t first_layer_idx, coord_t radius )

inline

                                                                                       {
            std::lock_guard<std::mutex> guard(m_mutex);
            allocate_layers(first_layer_idx + in.size());
            for (auto &d : in)
                m_data[first_layer_idx ++].emplace(radius, std::move(d));
        }

References allocate_layers(), m_data, and m_mutex.

Here is the call graph for this function:

insert() [3/4]

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::insert ( std::vector< std::pair< coord_t, Polygons > > && in, coord_t radius )

inline

                                                                                {
            std::lock_guard<std::mutex> guard(m_mutex);
            for (auto &d : in)
                this->get_allocate_layer_data(d.first).emplace(radius, std::move(d.second));
        }

References get_allocate_layer_data(), and m_mutex.

Here is the call graph for this function:

insert() [4/4]

void Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::insert ( std::vector< std::pair< RadiusLayerPair, Polygons > > && in )

inline

                                                                        {
            std::lock_guard<std::mutex> guard(m_mutex);
            for (auto &d : in)
                this->get_allocate_layer_data(d.first.second).emplace(d.first.first, std::move(d.second));
        }

References get_allocate_layer_data(), and m_mutex.

Here is the call graph for this function:

operator=() [1/2]

RadiusLayerPolygonCache & Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::operator= ( const RadiusLayerPolygonCache & )

delete

References RadiusLayerPolygonCache().

Here is the call graph for this function:

operator=() [2/2]

RadiusLayerPolygonCache & Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::operator= ( RadiusLayerPolygonCache && rhs )

inline

{ m_data = std::move(rhs.m_data); return *this; }

References RadiusLayerPolygonCache(), and m_data.

Here is the call graph for this function:

sorted()

std::vector< std::pair< TreeModelVolumes::RadiusLayerPair, std::reference_wrapper< const Polygons > > > Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::sorted ( ) const

nodiscard

{
    std::vector<std::pair<RadiusLayerPair, std::reference_wrapper<const Polygons>>> out;
    for (auto &layer : m_data) {
        auto layer_idx = LayerIndex(&layer - m_data.data());
        for (auto &radius_polygons : layer)
            out.emplace_back(std::make_pair(radius_polygons.first, layer_idx), radius_polygons.second);
    }
    assert(std::is_sorted(out.begin(), out.end(), [](auto &l, auto &r){ return l.first.second < r.first.second || (l.first.second == r.first.second) && l.first.first < r.first.first; }));
    return out;
}

References m_data, and sorted().

Referenced by Slic3r::TreeSupport3D::TreeModelVolumes::precalculate(), and sorted().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_data

Layers Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::m_data

private

Referenced by RadiusLayerPolygonCache(), allocate_layers(), clear(), clear_all_but_radius0(), get_allocate_layer_data(), get_lower_bound_area(), getArea(), getMaxCalculatedLayer(), insert(), insert(), operator=(), and sorted().

m_mutex

std::mutex Slic3r::TreeSupport3D::TreeModelVolumes::RadiusLayerPolygonCache::m_mutex

mutableprivate

Referenced by get_lower_bound_area(), getArea(), getMaxCalculatedLayer(), insert(), insert(), insert(), and insert().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Support/TreeModelVolumes.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/Support/TreeModelVolumes.cpp