基于pcl库prim最小生成树判断组成树的节点的子节点个数的c++代码

以下是基于pcl库，prim最小生成树判断组成树的节点的子节点个数的c++代码：

#include <pcl/point_types.h>
#include <pcl/io/pcd_io.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <pcl/features/normal_3d.h>
#include <pcl/kdtree/kdtree_flann.h>
#include <pcl/filters/voxel_grid.h>
#include <pcl/filters/passthrough.h>
#include <pcl/segmentation/extract_clusters.h>
#include <pcl/common/common.h>
#include <pcl/features/feature.h>
#include <pcl/common/distances.h>
#include <pcl/features/principal_curvatures.h>
#include <pcl/features/fpfh.h>
#include <pcl/registration/icp.h>
#include <pcl/registration/sample_consensus_prerejective.h>
#include <pcl/registration/ia_ransac.h>
#include <pcl/registration/correspondence_rejection_sample_consensus.h>
#include <pcl/registration/correspondence_estimation.h>
#include <pcl/registration/correspondence_rejection_one_to_one.h>
#include <pcl/registration/correspondence_rejection_distance.h>
#include <pcl/registration/transformation_estimation_lm.h>
#include <pcl/registration/transformation_validation_euclidean.h>
#include <pcl/registration/transforms.h>
#include <pcl/segmentation/region_growing_rgb.h>
#include <pcl/segmentation/region_growing.h>
#include <pcl/segmentation/sac_segmentation.h>
#include <pcl/segmentation/extract_polygonal_prism_data.h>
#include <pcl/segmentation/conditional_euclidean_clustering.h>
#include <pcl/segmentation/organized_multi_plane_segmentation.h>
#include <pcl/ModelCoefficients.h>
#include <pcl/search/search.h>
#include <pcl/search/kdtree.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/console/parse.h>
#include <iostream>
#include <fstream>
#include <ctime>
#include <math.h>
#include <vector>
#include <queue>

using namespace pcl;
using namespace std;

int main()
{
    // 读入点云数据
    PointCloud<PointXYZRGB>::Ptr cloud(new PointCloud<PointXYZRGB>);
    if (io::loadPCDFile<PointXYZRGB>("cloud.pcd", *cloud) == -1)
    {
        PCL_ERROR("Could not read file cloud.pcd \n");
        return (-1);
    }

    // 计算点云法向量
    NormalEstimation<PointXYZRGB, Normal> ne;
    ne.setInputCloud(cloud);
    search::KdTree<PointXYZRGB>::Ptr tree(new search::KdTree<PointXYZRGB>());
    ne.setSearchMethod(tree);
    ne.setRadiusSearch(0.01);
    PointCloud<Normal>::Ptr normals(new PointCloud<Normal>);
    ne.compute(*normals);

    // 构建kd树
    search::KdTree<PointXYZRGB>::Ptr kdtree(new search::KdTree<PointXYZRGB>);
    kdtree->setInputCloud(cloud);

    // prim最小生成树算法
    int num_points = cloud->points.size();
    vector<vector<double>> dist(num_points, vector<double>(num_points, -1.0));
    vector<double> min_dist(num_points, DBL_MAX);
    vector<int> parent(num_points, -1);
    vector<bool> visited(num_points, false);
    int start_point = rand() % num_points; // 随机选择一个起点
    visited[start_point] = true;
    for (int i = 0; i < num_points; i++)
    {
        if (i == start_point)
            continue;
        PointXYZRGB p1 = cloud->points[i];
        for (int j = i + 1; j < num_points; j++)
        {
            if (j == start_point)
                continue;
            PointXYZRGB p2 = cloud->points[j];
            if (dist[i][j] < 0.0)
            {
                double d = pcl::euclideanDistance(p1, p2);
                dist[i][j] = dist[j][i] = d;
            }
        }
    }
    for (int i = 0; i < num_points - 1; i++)
    {
        int min_index = -1;
        for (int j = 0; j < num_points; j++)
        {
            if (visited[j])
            {
                for (int k = 0; k < num_points; k++)
                {
                    if (!visited[k])
                    {
                        double d = dist[j][k];
                        if (d > 0.0 && d < min_dist[k])
                        {
                            min_dist[k] = d;
                            parent[k] = j;
                        }
                    }
                }
            }
        }
        double min_val = DBL_MAX;
        for (int j = 0; j < num_points; j++)
        {
            if (!visited[j] && min_dist[j] < min_val)
            {
                min_val = min_dist[j];
                min_index = j;
            }
        }
        if (min_index != -1)
        {
            visited[min_index] = true;
        }
    }

    // 统计每个节点的子节点个数
    vector<int> num_children(num_points, 0);
    for (int i = 0; i < num_points; i++)
    {
        if (parent[i] != -1)
        {
            num_children[parent[i]]++;
        }
    }

    // 输出每个节点的子节点个数
    for (int i = 0; i < num_points; i++)
    {
        cout << "Point " << i << " has " << num_children[i] << " children." << endl;
    }

    return 0;
}
``