区分三维空间里几个点中相近的点和不相近的点，并将相近的点合为一个点输出

#include <iostream>
#include <vector>
#include <cmath>

// 定义三维点的结构体
struct Point3D {
    double x;
    double y;
    double z;
};

// 计算两个点之间的距离
double distance(const Point3D& p1, const Point3D& p2) {
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    double dz = p1.z - p2.z;
    return std::sqrt(dx * dx + dy * dy + dz * dz);
}

// 区分相近和不相近的点，并将结果存储在外部向量中
void classifyPoints(const std::vector<Point3D>& points, double threshold,
                    std::vector<Point3D>& similarPoints,
                    std::vector<Point3D>& differentPoints) {
    // 创建一个临时向量来存储相近的点
    std::vector<Point3D> tempSimilarPoints;

    // 比较每对点之间的距离
    for (size_t i = 0; i < points.size(); ++i) {
        // 将点添加到相近点的临时向量中
        tempSimilarPoints.push_back(points[i]);

        for (size_t j = i + 1; j < points.size(); ++j) {
            double dist = distance(points[i], points[j]);
            // 如果距离小于阈值，则将第二个点添加到相近点的临时向量中
            if (dist <= threshold) {
                tempSimilarPoints.push_back(points[j]);
            }
        }

        // 计算相近点的平均值
        Point3D averagePoint = {0.0, 0.0, 0.0};
        for (const auto& p : tempSimilarPoints) {
            averagePoint.x += p.x;
            averagePoint.y += p.y;
            averagePoint.z += p.z;
        }
        averagePoint.x /= tempSimilarPoints.size();
        averagePoint.y /= tempSimilarPoints.size();
        averagePoint.z /= tempSimilarPoints.size();

        // 将相近点的平均值添加到相近点向量中
        similarPoints.push_back(averagePoint);

        // 清空相近点的临时向量
        tempSimilarPoints.clear();
    }

    // 检查每个原始点是否在相近点的临时向量中
    for (const auto& p : points) {
        bool isSimilar = false;
        for (const auto& similarPoint : similarPoints) {
            if (distance(p, similarPoint) <= threshold) {
                isSimilar = true;
                break;
            }
        }
        // 如果点不在相近点的临时向量中，则将其添加到不相近点向量中
        if (!isSimilar) {
            differentPoints.push_back(p);
        }
    }
}

int main() {
    // 创建一个包含多个点的向量
    std::vector<Point3D> points = {
        {1.0, 2.0, 3.0},
        {4.0, 5.0, 6.0},
        {7.0, 8.0, 9.0},
        {3.0, 3.0, 3.0},
        {4.0, 4.0, 4.0}
    };

    // 定义相近的阈值
    double threshold = 2.0;

    // 创建向量来存储相近和不相近的点
    std::vector<Point3D> similarPoints;
    std::vector<Point3D> differentPoints;

    // 区分相近和不相近的点，并将结果存储在外部向量中
    classifyPoints(points, threshold, similarPoints, differentPoints);

    // 输出相近的点
    std::cout << "Similar points: ";
    for (const auto& point : similarPoints) {
        std::cout << "(" << point.x << ", " << point.y << ", " << point.z << ") ";
    }
    std::cout << std::endl;

    // 输出不相近的点
    std::cout << "Different points: ";
    for (const auto& point : differentPoints) {
        std::cout << "(" << point.x << ", " << point.y << ", " << point.z << ") ";
    }
    std::cout << std::endl;

    return 0;
}