boostr树节点删除

我要删除最近的点节点。这应该满足距离的限制。 但我认为我的代码效率不高。 我如何修改这个

    for (int j = 0; j < 3; j++) {
    bgi::rtree< value, bgi::quadratic<16> > nextRT;

    // search for nearest neighbours
    std::vector<value> matchPoints;
    vector<pair<float, float>> pointList;

    for (unsigned i = 0; i < keypoints[j + 1].size(); ++i) {
        point p = point(keypoints[j + 1][i].pt.x, keypoints[j + 1][i].pt.y);
        nextRT.insert(std::make_pair(p, i));
        RT.query(bgi::nearest(p, 1), std::back_inserter(matchPoints));

        if (bg::distance(p, matchPoints.back().first) > 3) matchPoints.pop_back();
        else {
            pointList.push_back(make_pair(keypoints[j + 1][i].pt.x, keypoints[j + 1][i].pt.y));
            RT.remove(matchPoints.back());
        }
    }

for（int j=0；j<3；j++）{
bgi:：rtreenextRT；
//寻找最近的邻居
向量匹配点；
向量点列表；
对于（无符号i=0；i3）matchPoints.pop_back（）；
否则{
pointList.push_back（创建_对（关键点[j+1][i].pt.x，关键点[j+1][i].pt.y））；
RT.remove（matchPoints.back（））；
}
}

我也很好奇匹配点的结果。 查询函数工作后，匹配点中存在值。 第一个是点，第二个看起来像索引编号。 我不知道第二个是什么意思

Q.我也对匹配点的结果很好奇。查询功能运行后，匹配点中有值。第一个是点，第二个看起来像某个索引编号。我不知道第二个是什么意思

好的，那必须是

值

类型中的数据成员。其中的内容完全取决于插入到

rtree

中的内容。如果它是一个描述几何体的ID，我也不会感到惊讶

由于您甚至没有显示

RT

的类型，我们只能假设它与

nextRT

相同。如果是这样，我们可以假设

value

很可能是类似

pair

的一对（因为您插入了什么）。因此，请查看为

RT

中该对的

无符号

值插入了什么

Q.

简化代码！提取需求：

在我看来，对于4组“关键点”，您希望创建4个RTree，其中包含所有这些关键点，ID依次递增

同样，对于这4组“关键点”，您希望创建一个关键点列表，可以找到半径为

3

的几何体

作为一种副作用，从原始rtree

RT

中删除那些紧密匹配的几何体

决策：因为这些任务是独立的，所以让我们分开执行：

具有讽刺意味的是，从

RT

中删除匹配的几何体成了一个小问题：您可以通过迭代器或通过一个值来删除。在这种情况下，我们使用了接受

值的重载

总结
很难理解代码以了解它的功能。我已经演示了如何清理代码并使其工作。也许这些不是您需要的东西，但希望使用更好的分离代码，您应该能够取得更大的进步

请注意，这些算法有副作用。这使得我们很难理解到底会发生什么。例如：


从原始RT中删除点会影响后续关键点（甚至是从后续集合（next
j
）中）可以匹配的内容
如果多次使用同一关键点，它们可能会匹配多个源RT点（因为删除第一个匹配后，半径3内可能会有第二个匹配）
严格按顺序检查关键点。这意味着，如果第一个关键点与点X大致匹配，这可能会导致后面的关键点无法匹配，即使点X可能更接近该关键点


我建议您在实现带有这些副作用的东西之前认真考虑需求。**。如果所有这些副作用都是您想要的，请确保使用更好的命名和适当的注释来描述代码的作用

现场演示

#include <boost/geometry.hpp>
#include <boost/geometry/io/io.hpp>
#include <boost/geometry/index/rtree.hpp>
#include <iostream>

namespace bg  = boost::geometry;
namespace bgi = bg::index;

typedef bg::model::point<float, 2, bg::cs::cartesian> point;

typedef std::pair<point, unsigned> pvalue;
typedef pvalue value;

int main() {
    bgi::rtree< value, bgi::quadratic<16> > RT;

    {
        int i = 0;
        for (auto p : { point(2.0f, 2.0f), point(2.5f, 2.5f) })
            RT.insert(std::make_pair(p, i++));
    }

    struct keypoint_t { point pt; };
    using keypoints_t = std::vector<keypoint_t>;

    keypoints_t const keypoints[] = {
        keypoints_t{ keypoint_t { point(-2, 2)  } },  // should not match anything
        keypoints_t{ keypoint_t { point(-1, 2)  } },  // should match (2,2)
        keypoints_t{ keypoint_t { point(2.0, 2.0) },  // matches (2.5,2.5)
                                { point(2.5, 2.5) },  // nothing anymore...
                   },
    };

    for (auto const& current_key_set : keypoints) {
        bgi::rtree< pvalue, bgi::quadratic<16> > nextRT; // use a better name...

        int i = 0;
        for (auto const& kpd : current_key_set)
            nextRT.insert(std::make_pair(kpd.pt, i++));
    }

    for (auto const& current_key_set : keypoints) {
        std::cout << "-----------\n";
        std::vector<point> matched_key_points;

        for (auto const& kpd : current_key_set) {
            point p = kpd.pt;
            std::cout << "Key: " << bg::wkt(p) << "\n";

            value match;
            if (!RT.query(bgi::nearest(p, 1), &match))
                continue;

            if (bg::distance(p, match.first) <= 3) {
                matched_key_points.push_back(p);
                std::cout << "\tRemoving close point: " << bg::wkt(match.first) << "\n";
                RT.remove(match);
            }
        }

        std::cout << "\nMatched keys: ";
        for (auto& p : matched_key_points)
            std::cout << bg::wkt(p) << " ";
        std::cout << "\n\tElements remaining: " << RT.size() << "\n";
    }

}

// making up types that match the usage in your code:
struct keypoint_t { point pt; };
std::array<std::vector<keypoint_t>, 4> keypoints;

for (auto const& current_key_set : keypoints) {
    bgi::rtree< value, bgi::quadratic<16> > nextRT; // use a better name...

    int i = 0;
    for (auto const& kpd : current_key_set)
        nextRT.insert(std::make_pair(kpd.pt, i++));
}

for (auto const& current_key_set : keypoints) {
    std::vector<point> matched_key_points;

    for (auto const& kpd : current_key_set) {
        point p = kpd.pt;

        value match;
        if (!RT.query(bgi::nearest(p, 1), &match))
            continue;

        if (bg::distance(p, match.first) <= 3) {
            matched_key_points.push_back(p);
            RT.remove(match);
        }
    }
}

#include <boost/geometry.hpp>
#include <boost/geometry/io/io.hpp>
#include <boost/geometry/index/rtree.hpp>
#include <iostream>

namespace bg  = boost::geometry;
namespace bgi = bg::index;

typedef bg::model::point<float, 2, bg::cs::cartesian> point;

typedef std::pair<point, unsigned> pvalue;
typedef pvalue value;

int main() {
    bgi::rtree< value, bgi::quadratic<16> > RT;

    {
        int i = 0;
        for (auto p : { point(2.0f, 2.0f), point(2.5f, 2.5f) })
            RT.insert(std::make_pair(p, i++));
    }

    struct keypoint_t { point pt; };
    using keypoints_t = std::vector<keypoint_t>;

    keypoints_t const keypoints[] = {
        keypoints_t{ keypoint_t { point(-2, 2)  } },  // should not match anything
        keypoints_t{ keypoint_t { point(-1, 2)  } },  // should match (2,2)
        keypoints_t{ keypoint_t { point(2.0, 2.0) },  // matches (2.5,2.5)
                                { point(2.5, 2.5) },  // nothing anymore...
                   },
    };

    for (auto const& current_key_set : keypoints) {
        bgi::rtree< pvalue, bgi::quadratic<16> > nextRT; // use a better name...

        int i = 0;
        for (auto const& kpd : current_key_set)
            nextRT.insert(std::make_pair(kpd.pt, i++));
    }

    for (auto const& current_key_set : keypoints) {
        std::cout << "-----------\n";
        std::vector<point> matched_key_points;

        for (auto const& kpd : current_key_set) {
            point p = kpd.pt;
            std::cout << "Key: " << bg::wkt(p) << "\n";

            value match;
            if (!RT.query(bgi::nearest(p, 1), &match))
                continue;

            if (bg::distance(p, match.first) <= 3) {
                matched_key_points.push_back(p);
                std::cout << "\tRemoving close point: " << bg::wkt(match.first) << "\n";
                RT.remove(match);
            }
        }

        std::cout << "\nMatched keys: ";
        for (auto& p : matched_key_points)
            std::cout << bg::wkt(p) << " ";
        std::cout << "\n\tElements remaining: " << RT.size() << "\n";
    }

}

-----------
Key: POINT(-2 2)

Matched keys: 
    Elements remaining: 2
-----------
Key: POINT(-1 2)
    Removing close point: POINT(2 2)

Matched keys: POINT(-1 2) 
    Elements remaining: 1
-----------
Key: POINT(2 2)
    Removing close point: POINT(2.5 2.5)
Key: POINT(2.5 2.5)

Matched keys: POINT(2 2) 
    Elements remaining: 0