anonymous_namespace{RaycastManager.cpp} Namespace Reference

Functions
void	actualize (RaycastManager::Meshes &meshes, const ModelVolumePtrs &volumes, const RaycastManager::ISkip *skip, RaycastManager::Meshes *input=nullptr)
const AABBMesh *	get_mesh (const RaycastManager::Meshes &meshes, size_t volume_id)
RaycastManager::TrKey	create_key (const ModelVolume &volume, const ModelInstance &instance)
RaycastManager::TrItems::iterator	find (RaycastManager::TrItems &items, const RaycastManager::TrKey &key)
RaycastManager::TrItems::const_iterator	find (const RaycastManager::TrItems &items, const RaycastManager::TrKey &key)
bool	is_lower_key (const RaycastManager::TrKey &k1, const RaycastManager::TrKey &k2)
bool	is_lower (const RaycastManager::TrItem &i1, const RaycastManager::TrItem &i2)
template<typename VecType >
void	erase (std::vector< VecType > &vec, const std::vector< bool > &flags)

Function Documentation

actualize()

void anonymous_namespace{RaycastManager.cpp}::actualize	(	RaycastManager::Meshes &	meshes,
		const ModelVolumePtrs &	volumes,
		const RaycastManager::ISkip *	skip,
		RaycastManager::Meshes *	input = nullptr
	)

{
    // check if volume was removed
    std::vector<bool> removed_meshes(meshes.size(), {true});
    bool need_sort = false;
    // actualize MeshRaycaster
    for (const ModelVolume *volume : volumes) {
        size_t oid = volume->id().id;
        if (skip != nullptr && skip->skip(oid))
            continue;
        auto is_oid = [oid](const RaycastManager::Mesh &it) { return oid == it.first; };        
        if (auto item = std::find_if(meshes.begin(), meshes.end(), is_oid);
            item != meshes.end()) {
            size_t index = item - meshes.begin();
            removed_meshes[index] = false;
            continue;
        }
 
        // exist AABB in inputs ?
        if (inputs != nullptr) {
            auto input = std::find_if(inputs->begin(), inputs->end(), is_oid);
            if (input != inputs->end()) {
                meshes.emplace_back(std::move(*input));
                need_sort = true;    
                continue;
            }
        }
 
        // add new raycaster
        bool calculate_epsilon = true;
        auto mesh = std::make_unique<AABBMesh>(volume->mesh(), calculate_epsilon);
        meshes.emplace_back(std::make_pair(oid, std::move(mesh)));
        need_sort = true;        
    }
 
    // clean other raycasters
    erase(meshes, removed_meshes);
 
    // All the time meshes must be sorted by volume id - for faster search
    if (need_sort) {
        auto is_lower = [](const RaycastManager::Mesh &m1, const RaycastManager::Mesh &m2) { return m1.first < m2.first; };
        std::sort(meshes.begin(), meshes.end(), is_lower);
    }
}

References actualize(), erase(), input(), is_lower(), and Slic3r::GUI::RaycastManager::ISkip::skip().

Referenced by actualize().

Here is the call graph for this function:

Here is the caller graph for this function:

create_key()

RaycastManager::TrKey anonymous_namespace{RaycastManager.cpp}::create_key	(	const ModelVolume &	volume,
		const ModelInstance &	instance
	)

                                                                                        { 
    return std::make_pair(instance.id().id, volume.id().id); }

References Slic3r::ObjectID::id, and Slic3r::ObjectBase::id().

Here is the call graph for this function:

erase()

template<typename VecType >

void anonymous_namespace{RaycastManager.cpp}::erase ( std::vector< VecType > &  vec, const std::vector< bool > &  flags  )

inline

{
    if (vec.size() < flags.size() || flags.empty())
        return;
 
    // reverse iteration over flags to erase indices from back to front.
    for (int i = static_cast<int>(flags.size()) - 1; i >= 0; --i)
        if (flags[i])
            vec.erase(vec.begin() + i);
}

References erase().

Referenced by actualize(), and erase().

Here is the call graph for this function:

Here is the caller graph for this function:

find() [1/2]

RaycastManager::TrItems::const_iterator anonymous_namespace{RaycastManager.cpp}::find	(	const RaycastManager::TrItems &	items,
		const RaycastManager::TrKey &	key
	)

{
    auto fnc = [](const RaycastManager::TrItem &it, const RaycastManager::TrKey &l_key) { return is_lower_key(it.first, l_key); };
    auto it  = std::lower_bound(items.begin(), items.end(), key, fnc);
    if (it != items.end() && it->first != key)
        return items.end();
    return it;
}

References is_lower_key().

Here is the call graph for this function:

find() [2/2]

RaycastManager::TrItems::iterator anonymous_namespace{RaycastManager.cpp}::find	(	RaycastManager::TrItems &	items,
		const RaycastManager::TrKey &	key
	)

                                                                                                 {
    auto fnc = [](const RaycastManager::TrItem &it, const RaycastManager::TrKey &l_key) { return is_lower_key(it.first, l_key); };
    auto it = std::lower_bound(items.begin(), items.end(), key, fnc);
    if (it != items.end() && it->first != key)
        return items.end();
    return it;
}

References is_lower_key().

Here is the call graph for this function:

get_mesh()

const Slic3r::AABBMesh * anonymous_namespace{RaycastManager.cpp}::get_mesh	(	const RaycastManager::Meshes &	meshes,
		size_t	volume_id
	)

{
    auto is_lower_index = [](const RaycastManager::Mesh &m, size_t i) { return m.first < i; };
    auto it = std::lower_bound(meshes.begin(), meshes.end(), volume_id, is_lower_index);
    if (it == meshes.end() || it->first != volume_id)
        return nullptr;
    return &(*(it->second));
}

is_lower()

bool anonymous_namespace{RaycastManager.cpp}::is_lower	(	const RaycastManager::TrItem &	i1,
		const RaycastManager::TrItem &	i2
	)

                                                                              {
    return is_lower_key(i1.first, i2.first); };

References is_lower_key().

Referenced by actualize().

Here is the call graph for this function:

Here is the caller graph for this function:

is_lower_key()

bool anonymous_namespace{RaycastManager.cpp}::is_lower_key	(	const RaycastManager::TrKey &	k1,
		const RaycastManager::TrKey &	k2
	)

                                                                                {
    return k1.first < k2.first || (k1.first == k2.first && k1.second < k2.second); }

Referenced by find(), find(), and is_lower().

Here is the caller graph for this function: