подсчитайте частоту групп в векторе, используя rtree (или любой другой алгоритм)

R-деревья — одна из самых полезных структур данных пространственного индексирования, но они доказали свою полезность для определенных областей и задач. Тем не менее, это не причина воздерживаться от дидактичности (в конце концов, то, что спрашивали, может быть упрощением реальной проблемы).

Если вы решите использовать R-деревья, вы выполняете декомпозицию домена. Подобно кривым заполнения пространства, вы можете иметь упорядоченное пространство под рукой, но элементы узла сохраняют пространственную близость (чем дальше вы удаляетесь от корня).

Идеальным решением было бы построить ваши R-деревья таким образом, чтобы формировались radius=5 регионы, но это потребовало бы пользовательской структуры данных и настройки алгоритмов STR или массовой загрузки и было бы похоже на алгоритм кластеризации. .

Имея boost::index, вы можете идентифицировать все районы, я попробуйте уточнить код:

Обязательно включает

#include <vector>
#include <iostream>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point.hpp>
#include <boost/geometry/geometries/box.hpp>
#include <boost/geometry/index/rtree.hpp>

Определения

namespace bg  = boost::geometry;
namespace bgi = boost::geometry::index;   
using  point  = bg::model::point < float, 2, bg::cs::cartesian > ;

Вспомогательные

Boost R-деревья имеют метод query. Хотя он предназначен для выполнения типичных запросов, таких как kNN или перекрывающихся, вы можете передать ему пользовательские предикаты. Здесь мы разрабатываем вариант, который возвращает true, если точка, которую мы запрашиваем, находится на расстоянии до max_dist от точки base (обе переменные указываются при построении).

struct distance_pred
{
    point const& _base; 
    double       _threshold; 

    distance_pred(point const& base, double max_dist)
        : _base(base)
        , _threshold(max_dist)
    {
    }
    bool operator()(point const& p) const
    {
        auto d = boost::geometry::distance(_base, p); 
        return d && d < _threshold; 
    }
};

// just for output
std::ostream& operator<<(std::ostream &os, point const& p)
{
    os << "{ " << p.get<0>() << ", " << p.get<1>() << " }"; 
    return os; 
}

Исполнение

Для каждой точки мы запрашиваем те, которые находятся на расстоянии не более distance=5 друг от друга.

int main()
{
    std::vector<point> cloud {
        point(100, 150), point(101, 152), point(102, 151), 
        point(105, 155), point( 50,  50), point( 51,  55), 
        point( 55,  55), point(150, 250), point(190, 260) 
    }; 

    bgi::rtree<point, bgi::quadratic<16>> rtree(cloud.begin(), cloud.end());

    std::vector<point> hood;
    for (auto &&p : cloud)
    {
        hood.clear(); 
        std::cout << "neighborhood of point " << p << "\n-----------------\n\n";

        rtree.query(bgi::satisfies(distance_pred(p, 5)), std::back_inserter(hood)); 

        // Output the results -----------------------------------------
        if (!hood.empty())
        {
            for (auto &&pt : hood) std::cout << '\t' << pt << std::endl;
        }
        else
        {
            std::cout << "\t... is empty\n"; 
        }

        std::cout << std::endl; 
    }
}

Расширения

Если вы хотите что-то исключить, я считаю, что алгоритм кластеризации будет более подходящим, а это выходит за рамки RTrees. Например, что, если точки, которые вы исключили из-за того, что они расположены близко к point1, оказались ближе к point2?

Тем не менее, если вы действительно хотите это сделать, это просто вопрос бухгалтерского учета. Определите точку так

using  pointI  = std::pair<point, std::size_t>; // remember : geometric info first

и преобразовать вас для цикла в

for (std::size_t i(0), i < cloud.size(); ++i)
{
    if (cloud.end() != std::find(rec.begin(), rec.end(), i))
    { // you'll only be building neighorhoods for points that are not touched
        // queries and recording performed on point2 types  
    }
}

Полный код демонстрирует проблемы в этой логике: множество кварталы остаются пустыми.

То же самое, что и выше, может быть достигнуто с гораздо меньшим количеством кода, но значительно более сложным (в основном мы помещаем запрос в лямбда-функцию и используем итераторы запросов для циклического просмотра результатов) Демо

R-tree — это просто структура данных, но не алгоритм, и мне он кажется довольно сложным . Если вам действительно не нужно иметь дело с эффективностью mirco, я бы использовал простые стандартные алгоритмы и вектор точек. std::count_if было бы моим первым предположением.