Slic3r::sla::anonymous_namespace{Clustering.cpp} Namespace Reference

Functions
bool	cmp_ptidx_elements (const PointIndexEl &e1, const PointIndexEl &e2)
ClusteredPoints	cluster (Index3D &sindex, unsigned max_points, std::function< std::vector< PointIndexEl >(const Index3D &, const PointIndexEl &)> qfn)
std::vector< PointIndexEl >	distance_queryfn (const Index3D &sindex, const PointIndexEl &p, double dist, unsigned max_points)

Function Documentation

cluster()

ClusteredPoints Slic3r::sla::anonymous_namespace{Clustering.cpp}::cluster	(	Index3D &	sindex,
		unsigned	max_points,
		std::function< std::vector< PointIndexEl >(const Index3D &, const PointIndexEl &)>	qfn )

{
    using Elems = std::vector<PointIndexEl>;
 
    // Recursive function for visiting all the points in a given distance to
    // each other
    std::function<void(Elems&, Elems&)> group =
        [&sindex, &group, max_points, qfn](Elems& pts, Elems& cluster)
    {
        for(auto& p : pts) {
            std::vector<PointIndexEl> tmp = qfn(sindex, p);
 
            std::sort(tmp.begin(), tmp.end(), cmp_ptidx_elements);
 
            Elems newpts;
            std::set_difference(tmp.begin(), tmp.end(),
                                cluster.begin(), cluster.end(),
                                std::back_inserter(newpts), cmp_ptidx_elements);
 
            int c = max_points && newpts.size() + cluster.size() > max_points?
                        int(max_points - cluster.size()) : int(newpts.size());
 
            cluster.insert(cluster.end(), newpts.begin(), newpts.begin() + c);
            std::sort(cluster.begin(), cluster.end(), cmp_ptidx_elements);
 
            if(!newpts.empty() && (!max_points || cluster.size() < max_points))
                group(newpts, cluster);
        }
    };
 
    std::vector<Elems> clusters;
    for(auto it = sindex.begin(); it != sindex.end();) {
        Elems cluster = {};
        Elems pts = {*it};
        group(pts, cluster);
 
        for(auto& c : cluster) sindex.remove(c);
        it = sindex.begin();
 
        clusters.emplace_back(cluster);
    }
 
    ClusteredPoints result;
    for(auto& cluster : clusters) {
        result.emplace_back();
        for(auto c : cluster) result.back().emplace_back(c.second);
    }
 
    return result;
}

References cluster(), and cmp_ptidx_elements().

Referenced by cluster().

Here is the call graph for this function:

Here is the caller graph for this function:

cmp_ptidx_elements()

bool Slic3r::sla::anonymous_namespace{Clustering.cpp}::cmp_ptidx_elements	(	const PointIndexEl &	e1,
		const PointIndexEl &	e2 )

{
    return e1.second < e2.second;
};

References cmp_ptidx_elements().

Referenced by cluster(), and cmp_ptidx_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

distance_queryfn()

std::vector< PointIndexEl > Slic3r::sla::anonymous_namespace{Clustering.cpp}::distance_queryfn	(	const Index3D &	sindex,
		const PointIndexEl &	p,
		double	dist,
		unsigned	max_points )

{
    std::vector<PointIndexEl> tmp; tmp.reserve(max_points);
    sindex.query(
        bgi::nearest(p.first, max_points),
        std::back_inserter(tmp)
        );
 
    for(auto it = tmp.begin(); it < tmp.end(); ++it)
        if((p.first - it->first).norm() > dist) it = tmp.erase(it);
 
    return tmp;
}

References Slic3r::Geometry::dist(), and distance_queryfn().

Referenced by distance_queryfn().

Here is the call graph for this function:

Here is the caller graph for this function: