A tree real skeleton point extraction method, system, terminal and storage medium based on a deep neural network and a minimum spanning tree algorithm

Abstract

This invention belongs to the field of optical engineering technology and discloses a method, system, terminal, and storage medium for extracting true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm. The method includes: acquiring raw point cloud data; predicting the raw point cloud data using a deep neural network to obtain the vector, radius, and category information of each point cloud; centering the raw point cloud data according to the vector, radius, and category information of each point cloud, and extracting initial skeleton points using the minimum spanning tree algorithm; simplifying and smoothing the initial skeleton points, and updating them using a true skeleton point update method based on Euclidean clustering to obtain true skeleton points; and outputting the true skeleton points. This invention improves the accuracy of extracting true skeleton points of trees and enhances the reconstruction accuracy of tree models.

Description

Technical Field

[0001] This invention relates to the field of point cloud data processing technology, and in particular to a method, system, terminal, and storage medium for extracting real skeleton points of trees based on deep neural networks and minimum spanning tree algorithm. Background Technology

[0002] In the process of tree model reconstruction, skeleton points play an irreplaceable role. Accurate skeleton points provide crucial references for model generation and offer various important information, including radius. Furthermore, adjusting the density of skeleton points can indirectly control the accuracy and data volume of the branch and trunk model. Therefore, obtaining accurate and realistic skeleton points is extremely important for tree model reconstruction.

[0003] Most skeleton point extraction methods are based on the minimum spanning tree algorithm. This algorithm takes the original point cloud as input data and generates the final result through a series of optimization steps. However, due to the massive amount of point cloud data actually collected, calculating the skeleton points alone is time-consuming, and the final generated result is not accurate. Especially at branch forks, the algorithm has to move the skeleton points to achieve a smooth effect, which severely impacts the accuracy of the generated model. Since the skeleton points generated by this method lack radius information, the radius of the generated model is calculated from the radius of the first skeleton point (e.g., the root of the tree), and the radii of the remaining skeleton points need to be assigned in a progressively decreasing manner. Therefore, the tree model generated by this method has low accuracy and poor visual quality.

[0004] Therefore, existing technologies still need improvement. Summary of the Invention

[0005] The technical problem to be solved by the present invention is to provide a method, system, terminal and storage medium for extracting real skeleton points of trees based on deep neural networks and minimum spanning tree algorithm, in order to solve the problem of low accuracy of tree models generated by existing skeleton point extraction methods.

[0006] The technical solution adopted by this invention to solve the technical problem is as follows:

[0007] In a first aspect, the present invention provides a method for extracting the true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm, comprising:

[0008] Obtain raw point cloud data;

[0009] The original point cloud data is predicted based on a deep neural network to obtain the vector, radius, and category information of each point cloud.

[0010] Based on the vector, radius, and category information of each point cloud, the original point cloud data is centered, and the minimum spanning tree algorithm is used to extract the initial skeleton to obtain the initial skeleton points.

[0011] The initial skeleton points are simplified and smoothed, and the true skeleton points are updated based on the true skeleton point update method of Euclidean clustering.

[0012] Output the actual skeleton points.

[0013] In one implementation, the deep neural network includes: sparse convolutional layers, a backbone network layer, activation and normalization layers, and a branch segmentation head;

[0014] The prediction based on the original point cloud data using a deep neural network to obtain the vector, radius, and category information of each point cloud includes:

[0015] The original point cloud data is voxelized according to a preset spatial resolution to obtain sparse voxel mesh data.

[0016] The sparse voxel grid data is downsampled based on the deep neural network to extract multi-scale features. The features are then restored by progressive upsampling. The restored features are then connected to the downsampled features of the same scale by skip connections. The vector, radius, and category information of each point cloud are output by a multilayer perceptron.

[0017] In one implementation, the process of centering the original point cloud data based on the vector, radius, and category information of each point cloud, and extracting the initial skeleton using the minimum spanning tree algorithm to obtain initial skeleton points, includes:

[0018] Based on the category information, all point cloud data are classified to obtain leaf point cloud data and tree trunk point cloud data;

[0019] Based on the vector and the radius, the trunk point cloud data is centered using a geometric center alignment method to obtain centered trunk point cloud data.

[0020] The initial skeleton is extracted from the centered trunk point cloud data based on the minimum spanning tree algorithm to obtain the initial skeleton points.

[0021] In one implementation, the initial skeleton extraction of the centered trunk point cloud data based on the minimum spanning tree algorithm to obtain the initial skeleton points includes:

[0022] Initialize an empty set;

[0023] Traverse all point clouds in the centralized trunk point cloud data, select point clouds whose Euclidean distance is greater than or equal to a preset distance threshold, and add the selected point clouds to the initialized set to obtain the trunk point cloud set after removing redundant points.

[0024] The tree trunk point cloud after removing redundant points is triangulated to generate a triangle set;

[0025] Traverse each triangle in the set of triangles, add an undirected edge to each pair of vertices, and assign a weight to each edge to obtain a weighted undirected graph;

[0026] Based on the weighted undirected graph, the initial skeleton is extracted using the minimum spanning tree algorithm to obtain the initial skeleton points.

[0027] In one implementation, the simplification and smoothing of the initial skeleton points includes:

[0028] The subtree ratio method is used to filter the skeleton points of branches that do not meet the conditions in the initial skeleton points;

[0029] The error data removal strategy based on tree branch length rules removes error data from the filtered skeleton points, resulting in simplified skeleton points.

[0030] Initialize the root node of the simplified skeleton points, and use the root node as the starting point of the skeleton;

[0031] Starting from the beginning of the skeleton, the skeleton graph is traversed in a depth-first manner until the leaf node of each path is reached. When a branch point or the end of a path is found, the current path is defined as a skeleton segment, and a single skeleton extraction result is obtained.

[0032] For each skeleton segment of the extracted single skeleton, traverse point by point. For each skeleton point, calculate the average value of the neighboring points within the window, and update the coordinates of the skeleton point to the smoothed result based on the average value to obtain the smoothed initial skeleton point.

[0033] In one implementation, the true skeleton point update method based on Euclidean clustering updates the true skeleton points, including:

[0034] The smoothed initial skeleton points are distinguished according to the preset skeleton point radius threshold to obtain the skeleton points of the main trunk and the skeleton points of the middle layer branches.

[0035] Use the skeleton points of the main trunk as the initial skeleton points to be updated;

[0036] The true skeleton point update method based on Euclidean clustering updates the initial skeleton points to be updated, thereby obtaining the true skeleton points.

[0037] In one implementation, the true skeleton point update method based on Euclidean clustering updates the initial skeleton points to be updated to obtain the true skeleton points, including:

[0038] Based on the initial skeleton points to be updated, the original point cloud data is subjected to Euclidean clustering to form a set of point cloud clusters;

[0039] Calculate the centroid position of each point cloud cluster in the set of point cloud clusters, and use the centroid position as the updated skeleton point position;

[0040] The position of each skeleton point in the initial skeleton points to be updated is updated to the centroid position of the corresponding point cloud cluster to obtain the real skeleton points.

[0041] Secondly, the present invention provides a system for extracting real skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm, comprising:

[0042] The acquisition module is used to acquire raw point cloud data;

[0043] The prediction module is used to predict the original point cloud data based on a deep neural network and obtain the vector, radius and category information of each point cloud.

[0044] The initial skeleton extraction module is used to center the original point cloud data based on the vector, radius and category information of each point cloud, and to extract the initial skeleton using the minimum spanning tree algorithm to obtain the initial skeleton points.

[0045] The true skeleton update module is used to simplify and smooth the initial skeleton points, and update the true skeleton points based on the true skeleton point update method of Euclidean clustering.

[0046] The output module is used to output the actual skeleton points.

[0047] Thirdly, the present invention provides a terminal, comprising: a processor and a memory, wherein the memory stores a tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm, and the tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm, when executed by the processor, is used to implement the tree skeleton point extraction method based on a deep neural network and a minimum spanning tree algorithm as described in the first aspect.

[0048] Fourthly, the present invention also provides a computer-readable storage medium storing a tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm. When executed by a processor, the tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm is used to implement the tree skeleton point extraction method based on a deep neural network and a minimum spanning tree algorithm as described in the first aspect.

[0049] The present invention, by employing the above technical solution, has the following effects:

[0050] This invention uses deep neural networks to predict raw point cloud data and extracts the initial skeleton using the minimum spanning tree algorithm, effectively reducing redundant information and generating representative and structured initial skeleton point data. Furthermore, by simplifying and smoothing the initial skeleton point data, the true skeleton points can be updated using a true skeleton point update method based on Euclidean clustering, reducing errors caused by point cloud noise and complex geometric structures, and enabling the final generated skeleton points to more accurately reflect the geometric structure of the tree. This invention improves the accuracy of true skeleton point extraction for trees and enhances the reconstruction accuracy of tree models. Attached Figure Description

[0051] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the structures shown in these drawings without creative effort.

[0052] Figure 1 This is a flowchart of the method for extracting the true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm in this invention.

[0053] Figure 2 This is the overall flowchart of the tree skeleton point extraction method based on deep neural network and minimum spanning tree algorithm in this invention.

[0054] Figure 3 This is a schematic diagram of a portion of the training dataset in this invention.

[0055] Figure 4 This is a schematic diagram of the deep neural network framework in this invention.

[0056] Figure 5 This is a schematic diagram of the branch and leaf separation effect in this invention.

[0057] Figure 6 This is a schematic diagram of the centralized point cloud of the present invention.

[0058] Figure 7 This is a schematic diagram of the skeleton points for extracting the main branches in this invention.

[0059] Figure 8 This is a schematic diagram of the smooth skeleton points in this invention.

[0060] Figure 9 This is a schematic diagram of the actual skeleton points in this invention.

[0061] Figure 10 This is a functional schematic diagram of the terminal in one implementation of the present invention.

[0062] The objectives, features, and advantages of this invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0063] To make the objectives, technical solutions, and advantages of this invention clearer and more explicit, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

[0064] Exemplary methods

[0065] Existing skeleton point extraction methods are all based on the minimum spanning tree algorithm. This algorithm takes the original point cloud as input data and generates the final result through a series of optimization steps. However, due to the massive amount of point cloud data actually collected, calculating the skeleton points alone requires a significant amount of time, and the final generated result is not accurate. Especially at branch forks, the algorithm has to move the skeleton points to achieve a smooth effect, which severely impacts the accuracy of the generated model. Since the skeleton points generated by this method lack information such as radius, the radius of the generated model is calculated from the radius of the first skeleton point (e.g., the root of the tree), and the radii of the remaining skeleton points need to be assigned in a progressively decreasing manner. Therefore, the tree model generated by this method has low accuracy and poor visual quality.

[0066] To address the above technical problems, this invention provides a method for extracting true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm. The method includes: acquiring raw point cloud data; predicting the raw point cloud data using a deep neural network to obtain the vector, radius, and category information of each point cloud; centering the raw point cloud data according to the vector, radius, and category information of each point cloud, and extracting initial skeleton points using the minimum spanning tree algorithm; simplifying and smoothing the initial skeleton points, and updating them using a true skeleton point update method based on Euclidean clustering to obtain true skeleton points; and outputting the true skeleton points. This invention improves the accuracy of extracting true skeleton points of trees and enhances the reconstruction accuracy of tree models.

[0067] like Figure 1 As shown, this embodiment of the invention provides a method for extracting the true skeleton points of a tree based on a deep neural network and a minimum spanning tree algorithm, including the following steps:

[0068] Step S100: Obtain the raw point cloud data.

[0069] In this embodiment, the method mainly uses a deep neural network to classify, predict, and shrink the original point cloud data to generate a centralized original point cloud result. Then, the centralized point cloud is processed using the minimum spanning tree algorithm to obtain initial skeleton points, which will be used for subsequent optimization and updating steps. To facilitate the reconstruction of the tree model, this embodiment also divides the real skeleton points into main branch skeleton points and intermediate layer skeleton points, which are used for the reconstruction of the main branch model and the crown model, respectively.

[0070] like Figure 2 As shown, the tree skeleton point extraction process based on deep neural networks and minimum spanning tree algorithm in this embodiment mainly consists of three steps:

[0071] First, deep learning is used to predict the raw point cloud data to obtain the vector, radius, and category information of each point cloud.

[0072] Then, the original point cloud data is processed through a series of steps, including centering and minimum spanning tree algorithm optimization, to obtain the initial skeleton points.

[0073] Finally, the initial skeleton points are updated to obtain the actual skeleton points, which are then classified into main branch skeleton points and intermediate layer skeleton points.

[0074] In this embodiment, in order for the subsequent algorithm to accurately predict the skeleton and perform semantic segmentation on the branches and leaves in the point cloud, a point cloud simulation dataset needs to be constructed to learn the geometric characteristics in space before predicting the original point cloud data based on the deep neural network.

[0075] As an example, simulation software (such as SpeedTree Games, a 3D tree modeling software) can be used to generate tree models in batches and sample them into point clouds to obtain a point cloud simulation dataset. The specific steps are as follows:

[0076] 1) Point cloud generation:

[0077] A simulated drone collects data along its flight path around a tree model, generating an RGB image (red, green, and blue channels) with a resolution of approximately 2.1 MP (1920×1080 pixels). A three-dimensional point cloud is then reconstructed using aerial triangulation to form virtual tree point cloud data. The generated point cloud is denoted as:

[0078] ;

[0079] Each point cloud Includes its three-dimensional spatial coordinates ( ) and color features ( ).

[0080] 2) Noise enhancement:

[0081] To address photogrammetric noise, point clouds need to be transformed, including point dilation and erosion. Furthermore, random illumination variations are incorporated, and a random skybox is assigned to each tree. The noise distribution characteristics of the processed point cloud can be described as follows:

[0082] ;

[0083] in, (.) indicates a point cloud transformation operation that includes the above noise simulation.

[0084] Based on the above point cloud generation steps, the distribution characteristics of the generated point cloud simulation data include:

[0085] 1) Point density variation, i.e., the density of points varies in different areas;

[0086] 2) Missing regions, for example, partial point loss caused by self-occlusion;

[0087] 3) Noise, simulating errors in photogrammetry.

[0088] The final point cloud simulation dataset includes 100 apple trees, 100 cherry trees, 100 eucalyptus trees, 100 ginkgo trees, 100 pine trees, and 100 walnut trees. To predict the radius and vector of each point, the skeleton points corresponding to each tree were also generated simultaneously in this embodiment. Considering the generalization ability of deep neural networks, different data sizes were set for different types of trees. Apple and cherry trees had the smallest data size, ginkgo and pine trees had the largest, while eucalyptus and walnut trees had a relatively moderate data size.

[0089] like Figure 3 As shown, Figure 3 The image shows a portion of the point cloud simulation dataset. Based on the number of point clouds, the data size for apple trees is approximately 880,000 points, cherry trees approximately 97,000 points, eucalyptus trees have the fewest at around 226,000 points, ginkgo trees approximately 4,524,000 points, pine trees have the largest at around 5,974,000 points, and walnut trees have around 440,000 points. The number of point clouds for trees of similar types is similar.

[0090] In order to train a deep neural network, the point cloud simulation dataset is divided into two parts according to a certain ratio. One part is used as the pre-training data of the deep neural network, and the other part is used as the original point cloud data. The trained deep neural network is then used to predict the original point cloud data to obtain the vector, radius and category information of each point cloud.

[0091] like Figure 1 As shown, this embodiment of the invention provides a method for extracting the true skeleton points of a tree based on a deep neural network and a minimum spanning tree algorithm, including the following steps:

[0092] Step S200: Based on a deep neural network, predict the original point cloud data to obtain the vector, radius, and category information of each point cloud.

[0093] To predict the geometric features of each skeleton point cloud in the original point cloud data, a deep neural network was constructed and trained in this embodiment; wherein, the geometric features predicted by the deep neural network include:

[0094] 1) Skeleton point cloud radius , used to represent a point The surrounding local spatial scale;

[0095] 2) Skeleton point cloud direction , is a normalized direction vector pointing to the central axis.

[0096] Specifically, the geometric features are represented as follows:

[0097] ;

[0098] in, .

[0099] Specifically, in one implementation of this embodiment, the following steps are included before step S200:

[0100] Step S201a: Construct the deep neural network; wherein the deep neural network includes: sparse convolutional layers, backbone network layers, activation and normalization layers, and branch segmentation heads;

[0101] Step S201b: Obtain a pre-training dataset, and train the deep neural network based on the pre-training dataset to obtain the trained deep neural network.

[0102] In this embodiment, the deep neural network uses U-net (an encoder-decoder architecture based on convolutional neural networks) as the backbone network, and is combined with the sparse architecture SpConv (a spatially sparse convolution library) to improve computational efficiency. Specifically, the deep neural network includes the following main components:

[0103] 1) Sparse convolution: The encoder uses sparse convolution to perform large-scale feature exchange; the decoder uses submanifold convolution to avoid feature inflation and improve computational efficiency.

[0104] 2) Backbone Network: The U-net backbone consists of a series of encoders and decoders. The encoders downsample feature maps (with a stride of 2) and utilize residual connections to preserve details. After being connected layer by layer, the encoders and decoders are passed to three fully connected network branches, which extract the following features from each point cloud: orientation. ,radius ,category .

[0105] 3) Activation and normalization: Each convolutional layer is followed by a ReLU (Rectified Linear Unit) activation function and batch normalization.

[0106] 4) Branch and leaf segmentation head: Add a fully connected network branch to implement semantic segmentation of branches and leaves, classifying each voxel point as a branch or leaf.

[0107] In this embodiment, the deep neural network is trained based on the aforementioned pre-training dataset to obtain the trained deep neural network. During the specific training process, cross-entropy loss or class imbalance loss can be used for training, and an optimizer can be used to configure the training parameters; alternatively, a pre-trained model transfer learning method can be used for learning, and an automatic parameter tuning framework can be used to adjust the parameters. After training, the deep neural network can parse and label real point cloud data, providing basic information for subsequent point cloud processing.

[0108] Specifically, in one implementation of this embodiment, step S200 includes the following steps:

[0109] Step S201: Perform voxelization on the original point cloud data according to a preset spatial resolution to obtain sparse voxel mesh data.

[0110] Step S202: Based on the deep neural network, the sparse voxel grid data is downsampled to extract multi-scale features. The features are restored by progressive upsampling. The restored features are then connected to the downsampled features of the same scale by skip connections. The vector, radius, and category information of each point cloud are output by a multilayer perceptron.

[0111] In this embodiment, voxelized point cloud data is used as input; therefore, the original point cloud data also needs to be voxelized. Specifically, the point cloud data... Voxelization is performed according to a certain spatial resolution, and mapped to a sparse voxel mesh:

[0112] ;

[0113] in, A set of indices for a 3D mesh. Representative point cloud in voxels The features within the voxel include coordinate and color information. Voxelization is performed at a resolution of 1 cm, resulting in high density of point cloud features within each voxel.

[0114] In this embodiment, the prediction process of the deep neural network is as follows: Figure 4 As shown, this deep neural network starts with an N×F voxel input and progressively downsamples through an encoder to extract multi-scale features. In the encoder branch, each stage contains a residual block (ResBlock) and a downsampling operation (Encoder), with the number of feature channels progressively increasing (2, 4, 8, 16, 32, 64 in sequence). In the decoder branch, the corresponding upsampling operation (Decoder) module restores the features through progressive upsampling and simultaneously performs skip connections with features of the same scale from the encoder. Finally, a multilayer perceptron (MLP) outputs three branches: orientation, radius, and class, to meet the requirements of branch separation and point cloud centering.

[0115] Specifically, for each point cloud The deep neural network outputs the following feature information:

[0116] 1) Category Labels Each point cloud is assigned a category label based on the network's prediction results. ∈ (leaves, branches), thus achieving semantic segmentation of point clouds.

[0117] 2) Color information ( ): Optimize and update the colors of the point cloud to generate a more realistic color distribution.

[0118] 3) Vector information The network further outputs a direction vector. = ( ), to represent the direction in which each point in the point cloud points towards the center of the tree trunk, and = 1.

[0119] 4) Local radius The spatial scale relationship of points is represented by predicting the distance (i.e. radius) from each point cloud to the center of the trunk.

[0120] Based on the above features, the predicted point cloud set can be formally represented as:

[0121] ;

[0122] in, =( ).

[0123] In this embodiment, the vector, radius, and category information of each point cloud are predicted by a deep neural network. This facilitates the subsequent centering operation of the trunk point cloud based on the predicted information, which helps to accurately extract the initial skeleton points.

[0124] like Figure 1 As shown, this embodiment of the invention provides a method for extracting the true skeleton points of a tree based on a deep neural network and a minimum spanning tree algorithm, including the following steps:

[0125] Step S300: Based on the vector, radius and category information of each point cloud, the original point cloud data is centered, and the initial skeleton is extracted using the minimum spanning tree algorithm to obtain the initial skeleton points.

[0126] In this embodiment, for the predicted point cloud set It is necessary to separate the leaf point cloud from the tree trunk point cloud, and to center the tree trunk point cloud so that the centered tree trunk point cloud can more indirectly reflect the real tree skeleton, which is helpful for the subsequent extraction of the initial skeleton points.

[0127] Specifically, in one implementation of this embodiment, step S300 includes the following steps:

[0128] Step S301: Classify all point cloud data based on the category information to obtain leaf point cloud data and tree trunk point cloud data;

[0129] Step S302: Based on the vector and the radius, the trunk point cloud data is centered using a geometric center alignment method to obtain centered trunk point cloud data.

[0130] Step S303: Based on the minimum spanning tree algorithm, the initial skeleton of the centered trunk point cloud data is extracted to obtain the initial skeleton points.

[0131] In this embodiment, after the deep neural network completes its prediction, it first bases the prediction on the category label. The point cloud is classified, thus separating it into two parts:

[0132] 1) Leaves dotting the clouds :satisfy =Point cloud data of leaves;

[0133] 2) Tree trunk dotted with clouds :satisfy =Point cloud data of tree branches.

[0134] The results of point cloud classification are as follows Figure 5 As shown. For tree trunk point clouds In this embodiment, further processing using centralized operations is required.

[0135] For the classified tree trunk point cloud This embodiment proposes a centralization method based on geometric center alignment. It assumes that the geometric relationship of each point cloud is determined by its direction vector and local radius, and that the point cloud is aligned along the predicted direction vector. movement radius The distance allows mapping of the point cloud to the center of its skeleton, achieving centralization of the trunk point cloud:

[0136] ;

[0137] For point clouds = ( The location of its central point is calculated using the following formula:

[0138] ;

[0139] The centralization process moves each predicted trunk point cloud back to a position closer to the skeleton point, forming a centralized point cloud:

[0140] .

[0141] like Figure 6 As shown, Figure 6 (a) is a point cloud diagram of the tree trunk. Figure 6 (b) is a schematic diagram of the point cloud after centering the trunk portion. Figure 6 (c) is a schematic diagram comparing the point cloud before and after centralization (blue is the point cloud before centralization, and red is the point cloud after centralization). The centralized point cloud after the movement is smaller in volume than the original point cloud, and each point is closer to the skeleton point, which makes up for the algorithm failure caused by the missing part of the point cloud.

[0142] The centering operation of the tree trunk point cloud used in this embodiment is crucial because it provides standardized input for obtaining the true tree skeleton. By eliminating geometric offsets caused by variations in branch complexity or density in the point cloud, the centered point cloud can more indirectly reflect the true tree skeleton, which is helpful for subsequent steps.

[0143] In this embodiment, the point cloud after the centering operation already has a rudimentary skeleton shape, but it is still necessary to extract a reasonable skeleton point path from these point clouds. Therefore, this embodiment uses the MST algorithm (Minimum Spanning Tree algorithm) to process the result of branch point cloud centering, aiming to further simplify the data and make the skeleton points more representative.

[0144] In one implementation of this embodiment, step S303 includes the following steps:

[0145] Step S303a: Initialize an empty set;

[0146] Step S303b: Traverse all point clouds in the centralized trunk point cloud data, select point clouds whose Euclidean distance is greater than or equal to a preset distance threshold, and add the selected point clouds to the initialized set to obtain the trunk point cloud set after removing redundant points.

[0147] Step S303c: Triangulate the tree trunk point cloud after removing redundant points to generate a triangle set;

[0148] Step S303d: Traverse each triangle in the triangle set, add an undirected edge to each pair of vertices, and assign a weight to each edge to obtain a weighted undirected graph;

[0149] Step S303e: Based on the weighted undirected graph, the initial skeleton is extracted using the minimum spanning tree algorithm to obtain the initial skeleton points.

[0150] As an example, the initial skeleton point extraction process based on the minimum spanning tree algorithm in this embodiment is as follows:

[0151] 1) Redundant point removal:

[0152] In centralized point cloud data, some point clouds are too close to other point clouds and contribute little to the final skeleton result. Therefore, this embodiment uses a centralized point cloud set. Represents a point cloud, in which, The Euclidean distance between the two is defined as:

[0153] ;

[0154] In this embodiment, a distance threshold τ = 2mm is set. If two points in the point cloud... and satisfy <τ, then the decision point Redundant points are removed from the set. The specific process of the algorithm is as follows:

[0155] First, initialize the empty set. .

[0156] Then, iterate through all points in the centralized point cloud set P. :if ∈ All satisfy d( , If ) ≥ τ, then join in .

[0157] After the traversal is complete, output the filtered set of points. A point cloud set with redundant points removed. This will be used as input for subsequent calculations.

[0158] 2) Construct a weighted undirected graph:

[0159] The point cloud data after removing redundant points is denoted as... = { | i = 1, 2, ..., M}, where M is the number of remaining points in the point cloud. Next, this embodiment will... Delaunay triangulation (a spatial partitioning method that divides a set of points into triangles or tetrahedrons) is performed to generate a weighted graph of vertices and edges. The geometric constraints of Delaunay triangulation are as follows:

[0160] For any triangle Its circumcircle does not contain any other points in the point cloud set. Among all possible triangular mesh structures, maximize the minimum angle to reduce the occurrence of long, thin triangles.

[0161] By analyzing point cloud sets Performing Delaunay triangulation yields a point cloud composed of a set of triangles. Based on this, for each edge... Assign weights (i.e., the Euclidean distance between the two endpoints), the weights are defined as follows:

[0162] ;

[0163] The process of constructing a weighted graph includes the following steps:

[0164] First of all, Perform Delaunay triangulation to generate a set of triangles T.

[0165] Then, iterate through each triangle in T, for each pair of vertices ( , Add an undirected edge and calculate its weight using the formula above. .

[0166] Finally, we obtain a weighted undirected graph G = (V, E, w), where V is the set of nodes in the graph (i.e., the filtered point cloud), E is the set of edges, and w is the weight function.

[0167] 3) Initial skeleton extraction results using the MST algorithm:

[0168] After constructing the weighted undirected graph G, the MST algorithm is further used to extract the initial skeleton result. MST is a subgraph T = ( , ), satisfying the following properties:

[0169] T is a connected graph with no cycles; the sum of the edge weights corresponding to T is... Minimum. Specifically, given a weighted undirected graph G = (V, E, w), its minimum spanning tree can be constructed using Prim's algorithm (a greedy algorithm for finding the minimum spanning tree in a weighted connected graph), as follows:

[0170] First, initialize the point set. = { }, initial point This is a root node that has already been determined.

[0171] Secondly, find the point from the set of remaining points. and Points in This makes the edge weight Minimum, and satisfying .

[0172] Again, join in At the same time, the corresponding edge ( , ) join in .

[0173] Finally, repeat the above steps until... = V.

[0174] For graph T, the following properties are guaranteed to hold:

[0175] | | = |V |, | | = |V | 1.

[0176] After the minimum spanning tree extraction process, complex point cloud networks can be directly simplified into tree structures, preserving the main skeleton connectivity and removing redundant connections, which is the basis for subsequent extraction of real skeleton points.

[0177] like Figure 1 As shown, this embodiment of the invention provides a method for extracting the true skeleton points of a tree based on a deep neural network and a minimum spanning tree algorithm, including the following steps:

[0178] Step S400: The initial skeleton points are simplified and smoothed, and the true skeleton points are updated based on the true skeleton point update method of Euclidean clustering.

[0179] In this embodiment, after generating the initial skeleton points, the skeleton may still contain many redundant branches or erroneous topologies. To obtain a simpler and more accurate skeleton structure, further simplification is required.

[0180] Specifically, in one implementation of this embodiment, step S400 includes the following steps:

[0181] Step S401: Use the subtree ratio method to filter the skeleton points of branches that do not meet the conditions in the initial skeleton points;

[0182] Step S402: Based on the error data removal strategy of the tree branch length rule, the error data in the filtered skeleton points is removed to obtain the simplified skeleton points.

[0183] In this embodiment, a skeleton simplification method based on subtree ratio and branch length is proposed. The method mainly includes the following steps: deleting unimportant small edges according to the subtree ratio, clearing erroneous data based on the rules of the end branch length, and simplifying the skeleton as a whole.

[0184] 1) Delete unimportant small edges based on subtree ratio:

[0185] This embodiment uses the subtree ratio method to remove unimportant small edges. In the initial skeleton point results, some small branches have low importance to the overall skeleton structure and weak correlation with the trunk. To reduce the interference caused by these redundant structures, this embodiment uses the subtree ratio method to filter the skeleton points of small branches that do not meet the conditions. The subtree ratio is defined as the ratio of the total length of a subtree to the total length of the parent subtree, denoted as . The specific calculation method is as follows:

[0186] Let the unsimplified skeleton structure be represented as a directed weighted graph T = (V, E, w), where V is the set of nodes and E is the set of edges. This represents the edge weight (or distance) from node i to node j. For node j... its subtree length Defined as:

[0187] ;

[0188] in, Indicated by For all nodes in the subtree rooted at the root, express arrive Euclidean distance.

[0189] Subtree ratio It can be defined as:

[0190] ;

[0191] in, Represents child nodes The length of the subtree, From arrive Direct side rights.

[0192] When subtree ratio When the edge is less than a given threshold τ, The corresponding smaller branches are considered unimportant and are deleted. The processing procedure is as follows:

[0193] First, starting from the root node, traverse the skeleton nodes and calculate the subtree length of each node. .

[0194] Then, for each edge Calculate its subtree ratio .

[0195] Finally, a judgment is made: if ( , If the value of edge is less than τ (where τ = 0.219), then the edge is determined not to be an important part of the skeleton and is deleted along with its subtree.

[0196] Repeat the above steps until all nodes have been traversed.

[0197] 2) Error data removal based on tree branch length rules:

[0198] Even in the simplified skeleton structure, there may still be significantly elongated terminal branches, which typically originate from noise or unreasonable data sampling. To further improve the simplification effect, this embodiment proposes an error data removal strategy based on branch length rules.

[0199] Set nodes The direct child nodes are The formula for determining the value based on the length of the branch is:

[0200] ;

[0201] in, Represents tree branches The length of α is the magnification factor (α = 3 in this embodiment). This is the length of the previous branch. If the branch... Beyond the branch above it If the value is α times the value of the data, then the branch is considered erroneous and should be removed from the skeleton. The actual operation includes the following steps:

[0202] First, traverse from the end node of the skeleton to the root node, and for each edge ( , ),like >α· (in, (Indicates the length of the previous section), then delete the branch. .

[0203] Then, ensure that the skeleton remains connected after the branches are pruned.

[0204] Finally, update all relevant properties of the skeleton (such as edge weights and node radii) and ensure the integrity of the skeleton's topology.

[0205] Simplifying the minimum spanning tree yields a skeleton point that more closely resembles the actual situation. Eliminating the influence of small, messy skeleton points facilitates subsequent steps.

[0206] In this embodiment, after initial skeleton point extraction and simplification, the complete skeleton structure typically consists of a series of connected segments. To further analyze the topology and geometry of the skeleton, individual skeleton segments need to be extracted and smoothed to improve smoothness.

[0207] Specifically, in one implementation of this embodiment, step S400 further includes the following steps:

[0208] Step S403: Initialize the root node of the simplified skeleton point and use the root node as the starting point of the skeleton.

[0209] Step S404: Starting from the starting point of the skeleton, traverse the skeleton graph in a depth-first manner until the leaf node of each path is reached. When a branch point or the end of a path is found, define the current path as a skeleton segment to obtain the single skeleton extraction result.

[0210] Step S405: For each skeleton segment of the extracted single skeleton, traverse point by point. For each skeleton point, calculate the average value of the neighboring points within the window, and update the coordinates of the skeleton point to the smoothed result based on the average value to obtain the smoothed initial skeleton point.

[0211] In this embodiment, a single skeleton extraction and smoothing algorithm is proposed. This algorithm extracts skeleton segments one by one from a complex skeleton graph and performs post-processing to improve smoothness, ensuring the geometric continuity of the final skeleton segments and their consistency with the original data. The single skeleton extraction process is as follows: Figure 7 As shown, Figure 7In the diagram, (1), (2), (3), and (4) represent different methods for extracting skeleton path segments.

[0212] The specific steps are as follows:

[0213] 1) Single skeleton extraction:

[0214] A multi-branch skeleton structure typically consists of several trunks, branching points, and branches. In order to extract each coherent skeleton segment, this embodiment starts from the branching point and explores the skeleton graph by using the Depth-First Search (DFS) algorithm (an algorithm used to traverse or search tree or graph structures) to determine the connected paths between the branching point and the leaf nodes.

[0215] Definition of a bifurcation point: In a skeleton graph T = (V, E), if the out-degree (i.e., the number of edges emanating from a node v∈V) satisfies If , then it is defined as a bifurcation point. Conversely, if If v is a leaf node, then v is considered a leaf node.

[0216] The method for extracting skeleton path segments is as follows:

[0217] First, initialize the root node as This serves as the starting point for the skeleton;

[0218] Then, from Initially, the skeleton graph is traversed using the DFS algorithm, and for each path, the process continues until a leaf node is reached;

[0219] Whenever a fork point (or the end of a path) is found, the current path is defined as a skeleton segment and stored in the extraction results.

[0220] Let the root node The first path is p = { , , , . . . , The path extraction algorithm follows these constraints:

[0221] If node (i>0) satisfies: or If it is a leaf node, then the path is truncated. , , , . . . , Store it as a skeleton segment.

[0222] 2) Smooth each individual skeleton segment:

[0223] During skeleton segment extraction, depth-first search can generate irregular small segments, and the geometric distribution of the original points often contains significant discreteness, which may lead to unsmooth skeleton points or geometric abrupt changes. Therefore, this embodiment performs smoothing processing on each individual skeleton segment to enhance its geometric continuity.

[0224] This embodiment employs a window averaging smoothing method to smooth the point set in each skeleton segment. Let skeleton segment P = { , , . . . , }, each skeleton point It is a three-dimensional coordinate point ( , , Coordinates smoothed by the weighted average function of the sliding window. Defined as:

[0225] ;

[0226] Where: W is the size of the sliding window (W = 6 in this embodiment); This represents the valid points within the window; to avoid missing data at window boundary points, the boundaries are filled using an extension method. The specific algorithm flow is as follows:

[0227] First, each skeleton segment is traversed point by point.

[0228] Then, for each skeleton point Calculate the average value of neighboring points within the window.

[0229] Finally, update the coordinates of the skeleton points to the smoothed result. .

[0230] The advantages of the window smoothing method lie in its simple computation, high efficiency, and suitability for large-scale skeleton data processing. To verify the smoothing effect, this embodiment compares the smoothed skeleton points with the original point cloud point set for consistency. All points of the smoothed skeleton segment... satisfy:

[0231] ;

[0232] in, For the maximum allowable error distance ( (0.001) It represents Euclidean distance.

[0233] like Figure 8As shown, the gray dots represent points before smoothing, and the blue dots represent points after smoothing. This algorithm can effectively extract skeleton segments one by one, and simultaneously perform post-processing to enhance smoothness, providing higher-quality data support for subsequent skeleton processing (such as modeling, analysis, etc.).

[0234] In this embodiment, after smoothing, some skeleton points in the initial skeleton points are located deep into the tree canopy, resulting in significant deviations in their predictions. Therefore, it is necessary to differentiate and update these skeleton points.

[0235] Specifically, in one implementation of this embodiment, step S400 further includes the following steps:

[0236] Step S406: The smoothed initial skeleton points are distinguished according to the preset skeleton point radius threshold to obtain the skeleton points of the main trunk and the skeleton points of the middle layer branches.

[0237] Step S407: Use the skeleton points of the main trunk as the initial skeleton points to be updated;

[0238] Step S408: Update the initial skeleton points to be updated using the true skeleton point update method based on Euclidean clustering to obtain the true skeleton points.

[0239] In this embodiment, a threshold value of rthres = 5cm is set for the radius of the skeleton points to distinguish between the skeleton points of the main branches and the intermediate branches. The screening criteria are defined as follows:

[0240] ;

[0241] in, This represents the position and radius of the i-th skeleton point.

[0242] After screening, the skeleton points of the main branches are obtained in this embodiment and used as the initial skeleton points to be updated in subsequent calculations. Due to the complex mathematical calculations required, the prediction results of these initial skeleton points to be updated may contain some errors. To ensure the accuracy of the skeleton points, this embodiment proposes a clustering-based method for updating the true skeleton points. For example... Figure 9 As shown, this method combines the geometric distribution characteristics of the initial skeleton points to be updated and the original point cloud, and obtains a higher-precision skeleton point set by cutting the original point cloud and recalculating the skeleton point positions based on the centroid.

[0243] In one implementation of this embodiment, step S408 includes the following steps:

[0244] Step S408a: Perform Euclidean clustering on the original point cloud data based on the initial skeleton points to be updated to form a set of point cloud clusters;

[0245] Step S408b: Calculate the centroid position of each point cloud cluster in the set of point cloud clusters, and use the centroid position as the updated skeleton point position;

[0246] Step S408c: Update the position of each skeleton point in the initial skeleton points to be updated to the centroid position of the corresponding point cloud cluster to obtain the real skeleton points.

[0247] In this embodiment, the specific steps of the clustering-based true skeleton point update method are as follows:

[0248] 1) Perform Euclidean clustering on the original point cloud data based on the initial skeleton points to be updated:

[0249] Given the initial skeleton point set N = { | i = 1, 2, ..., m}, where This represents the i-th initial skeleton point to be updated. The original point cloud is:

[0250] P = { | j = 1, 2, ..., k}, where, Let represent the j-th point in the point cloud. To perform Euclidean clustering on the point cloud data using the initial skeleton points to be updated, we define each pair of adjacent skeleton points (...) , The midpoint distance and direction vector are used as the basis for judgment.

[0251] The midpoint position is: The length of the midpoint vector is .

[0252] Then, for each point in the original point cloud Calculate its relationship with two skeleton points. and The distance is used to determine whether it lies in the vector direction and the distance is less than the distance to the vector. Within a certain range. If this distance condition is met, the point is assigned to the nearest skeleton point cluster. This operation essentially segments the point cloud P according to the geometric constraints defined by the skeleton points, thus forming a set of point cloud clusters:

[0253] ;

[0254] Each point cloud cluster It is assigned to the skeleton point The set of points constitutes:

[0255] .

[0256] 2) Calculate the centroid of the point cloud cluster:

[0257] For each point cloud cluster ∈ Calculate the position of its centroid. As the updated skeleton point location. Centroid Calculate using the following formula:

[0258] ;

[0259] in, Represents point cloud clusters The number of midpoints.

[0260] 3) Update the initial skeleton point positions:

[0261] Update the position of each skeleton point in the initial skeleton point set to be updated to its corresponding point cloud cluster. The location of the center of mass, that is:

[0262] ;

[0263] After calculating the centroids of all point cloud clusters, an updated skeleton point set is generated:

[0264] ;

[0265] This clustering-based real skeleton point update method effectively improves the accuracy of skeleton nodes and reduces errors caused by point cloud noise.

[0266] like Figure 1 As shown, this embodiment of the invention provides a method for extracting the true skeleton points of a tree based on a deep neural network and a minimum spanning tree algorithm, including the following steps:

[0267] Step S500: Output the actual skeleton points.

[0268] In this embodiment, the output true skeleton points are the already classified skeleton points, which include main branch skeleton points and intermediate layer skeleton points.

[0269] In summary, this embodiment achieves the goals of redundant point removal, Delaunay triangulation, and minimum spanning tree extraction in a centralized point cloud through an optimization algorithm based on MST. This effectively reduces redundant information and generates representative and structured initial skeleton point data. Furthermore, by combining point cloud geometric information and the initial skeleton points, Euclidean clustering is performed on the original point cloud, and the positions of the initial skeleton points are updated based on the centroid positions of the point cloud clusters, ultimately yielding the true skeleton points. The entire process improves the accuracy of skeleton point prediction while reducing errors caused by point cloud noise and complex geometric structures. The final generated skeleton points more accurately reflect the geometric structure of trees, providing a high-precision skeleton data foundation for tree model reconstruction.

[0270] This embodiment achieves the following technical effects through the above technical solution:

[0271] This embodiment uses a deep neural network to predict the original point cloud data and extracts the initial skeleton using the minimum spanning tree algorithm, effectively reducing redundant information and generating representative and structured initial skeleton point data. Furthermore, by simplifying and smoothing the initial skeleton point data, the true skeleton points can be updated using a real skeleton point update method based on Euclidean clustering, reducing errors caused by point cloud noise and complex geometric structures. This allows the final generated skeleton points to more accurately reflect the geometric structure of the tree. This embodiment improves the accuracy of extracting the true skeleton points of the tree and enhances the reconstruction accuracy of the tree model.

[0272] Exemplary device

[0273] Based on the above embodiments, the present invention also provides a system for extracting real skeleton points of trees based on deep neural networks and minimum spanning tree algorithm, comprising:

[0274] The acquisition module is used to acquire raw point cloud data;

[0275] The prediction module is used to predict the original point cloud data based on a deep neural network and obtain the vector, radius and category information of each point cloud.

[0276] The initial skeleton extraction module is used to center the original point cloud data based on the vector, radius and category information of each point cloud, and to extract the initial skeleton using the minimum spanning tree algorithm to obtain the initial skeleton points.

[0277] The true skeleton update module is used to simplify and smooth the initial skeleton points, and update the true skeleton points based on the true skeleton point update method of Euclidean clustering.

[0278] The output module is used to output the actual skeleton points.

[0279] This embodiment achieves the following technical effects through the above technical solution:

[0280] This embodiment uses a deep neural network to predict the original point cloud data and extracts the initial skeleton using the minimum spanning tree algorithm, effectively reducing redundant information and generating representative and structured initial skeleton point data. Furthermore, by simplifying and smoothing the initial skeleton point data, the true skeleton points can be updated using a real skeleton point update method based on Euclidean clustering, reducing errors caused by point cloud noise and complex geometric structures. This allows the final generated skeleton points to more accurately reflect the geometric structure of the tree. This embodiment improves the accuracy of extracting the true skeleton points of the tree and enhances the reconstruction accuracy of the tree model.

[0281] Based on the above embodiments, the present invention also provides a terminal, the principle block diagram of which can be as follows: Figure 10 As shown.

[0282] The terminal includes: a processor, a memory, an interface, a display screen, and a communication module connected via a system bus; wherein, the processor of the terminal provides computing and control capabilities; the memory of the terminal includes a computer-readable storage medium and internal memory; the computer-readable storage medium stores an operating system and computer programs; the internal memory provides an environment for the operation of the operating system and computer programs in the computer-readable storage medium; the interface is used to connect to external devices; the display screen is used to display relevant information; and the communication module is used to communicate with a cloud server or other devices.

[0283] When executed by a processor, this computer program is used to implement a method for extracting the true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm.

[0284] It will be understood by those skilled in the art that Figure 10 The schematic diagram shown is merely a partial structural diagram related to the present invention and does not constitute a limitation on the terminal to which the present invention is applied. A specific terminal may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0285] In one embodiment, a terminal is provided, comprising: a processor and a memory, the memory storing a tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm, the tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm being executed by the processor to implement the above-described tree skeleton point extraction method based on a deep neural network and a minimum spanning tree algorithm.

[0286] In one embodiment, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores a tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm, the tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm being executed by a processor to implement the above-described tree skeleton point extraction method based on a deep neural network and a minimum spanning tree algorithm.

[0287] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, database, or other media used in the embodiments provided by this invention can include both non-volatile and volatile memory.

[0288] In summary, this invention provides a method, system, terminal, and storage medium for extracting true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm. The method includes: acquiring raw point cloud data; predicting the raw point cloud data using a deep neural network to obtain the vector, radius, and category information of each point cloud; centering the raw point cloud data based on the vector, radius, and category information of each point cloud, and extracting initial skeleton points using the minimum spanning tree algorithm; simplifying and smoothing the initial skeleton points, and updating them using a true skeleton point update method based on Euclidean clustering to obtain true skeleton points; and outputting the true skeleton points. This invention improves the accuracy of extracting true skeleton points of trees and enhances the reconstruction accuracy of tree models.

[0289] It should be understood that the application of the present invention is not limited to the examples above. Those skilled in the art can make improvements or modifications based on the above description, and all such improvements and modifications should fall within the protection scope of the appended claims.

Claims

1. A method for extracting true skeleton points of trees based on deep neural networks and the minimum spanning tree algorithm, characterized in that, include: Obtain raw point cloud data; The original point cloud data is predicted based on a deep neural network to obtain the vector, radius, and category information of each point cloud. Based on the vector, radius, and category information of each point cloud, the original point cloud data is centered, and the minimum spanning tree algorithm is used to extract the initial skeleton to obtain the initial skeleton points. The initial skeleton points are simplified and smoothed, and the true skeleton points are updated based on the true skeleton point update method of Euclidean clustering. Output the actual skeleton points; The simplification and smoothing process for the initial skeleton points includes: The subtree ratio method is used to filter the skeleton points of branches that do not meet the conditions in the initial skeleton points; The error data removal strategy based on tree branch length rules removes error data from the filtered skeleton points, resulting in simplified skeleton points. Initialize the root node of the simplified skeleton points, and use the root node as the starting point of the skeleton; Starting from the beginning of the skeleton, the skeleton graph is traversed in a depth-first manner until the leaf node of each path is reached. When a branch point or the end of a path is found, the current path is defined as a skeleton segment, and a single skeleton extraction result is obtained. For each skeleton segment of the extracted single skeleton, traverse point by point. For each skeleton point, calculate the average value of the neighboring points within the window, and update the coordinates of the skeleton point to the smoothed result based on the average value to obtain the smoothed initial skeleton point. The method for updating true skeleton points based on Euclidean clustering includes: The smoothed initial skeleton points are distinguished according to the preset skeleton point radius threshold to obtain the skeleton points of the main trunk and the skeleton points of the middle layer branches. Use the skeleton points of the main trunk as the initial skeleton points to be updated; The true skeleton point is updated by updating the initial skeleton point to be updated based on Euclidean clustering to obtain the true skeleton point. The true skeleton point update method based on Euclidean clustering updates the initial skeleton points to be updated to obtain the true skeleton points, including: Based on the initial skeleton points to be updated, the original point cloud data is subjected to Euclidean clustering to form a set of point cloud clusters; Calculate the centroid position of each point cloud cluster in the set of point cloud clusters, and use the centroid position as the updated skeleton point position; The position of each skeleton point in the initial skeleton points to be updated is updated to the centroid position of the corresponding point cloud cluster to obtain the real skeleton points.

2. The method for extracting true tree skeleton points based on deep neural networks and minimum spanning tree algorithm according to claim 1, characterized in that, The deep neural network includes: sparse convolutional layers, backbone network layers, activation and normalization layers, and branch segmentation heads; The prediction based on the original point cloud data using a deep neural network to obtain the vector, radius, and category information of each point cloud includes: The original point cloud data is voxelized according to a preset spatial resolution to obtain sparse voxel mesh data. The sparse voxel grid data is downsampled based on the deep neural network to extract multi-scale features. The features are then restored by progressive upsampling. The restored features are then connected to the downsampled features of the same scale by skip connections. The vector, radius, and category information of each point cloud are output by a multilayer perceptron.

3. The method for extracting true tree skeleton points based on deep neural networks and minimum spanning tree algorithm according to claim 1, characterized in that, The process involves centering the original point cloud data based on the vector, radius, and category information of each point cloud, and then extracting the initial skeleton using the minimum spanning tree algorithm to obtain initial skeleton points, including: Based on the category information, all point cloud data are classified to obtain leaf point cloud data and tree trunk point cloud data; Based on the vector and the radius, the trunk point cloud data is centered using a geometric center alignment method to obtain centered trunk point cloud data. The initial skeleton is extracted from the centered trunk point cloud data based on the minimum spanning tree algorithm to obtain the initial skeleton points.

4. The method for extracting true tree skeleton points based on deep neural networks and minimum spanning tree algorithm according to claim 3, characterized in that, The initial skeleton extraction of the centered trunk point cloud data based on the minimum spanning tree algorithm is used to obtain the initial skeleton points, including: Initialize an empty set; Traverse all point clouds in the centralized trunk point cloud data, select point clouds whose Euclidean distance is greater than or equal to a preset distance threshold, and add the selected point clouds to the initialized set to obtain the trunk point cloud set after removing redundant points. The tree trunk point cloud after removing redundant points is triangulated to generate a triangle set; Traverse each triangle in the set of triangles, add an undirected edge to each pair of vertices, and assign a weight to each edge to obtain a weighted undirected graph; Based on the weighted undirected graph, the initial skeleton is extracted using the minimum spanning tree algorithm to obtain the initial skeleton points.

5. A system for extracting true tree skeleton points based on deep neural networks and the minimum spanning tree algorithm, used to implement the method for extracting true tree skeleton points based on deep neural networks and the minimum spanning tree algorithm as described in any one of claims 1-4, characterized in that, include: The acquisition module is used to acquire raw point cloud data; The prediction module is used to predict the original point cloud data based on a deep neural network and obtain the vector, radius and category information of each point cloud. The initial skeleton extraction module is used to center the original point cloud data based on the vector, radius and category information of each point cloud, and to extract the initial skeleton using the minimum spanning tree algorithm to obtain the initial skeleton points. The true skeleton update module is used to simplify and smooth the initial skeleton points, and update the true skeleton points based on the true skeleton point update method of Euclidean clustering. The output module is used to output the actual skeleton points.

6. A terminal, characterized in that, include: The processor and memory, wherein the memory stores a program for extracting real tree skeleton points based on a deep neural network and a minimum spanning tree algorithm, and the program for extracting real tree skeleton points based on a deep neural network and a minimum spanning tree algorithm, when executed by the processor, is used to implement the operation of the method for extracting real tree skeleton points based on a deep neural network and a minimum spanning tree algorithm as described in any one of claims 1-4.

7. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm. When executed by a processor, the tree skeleton point extraction program based on a deep neural network and a minimum spanning tree algorithm is used to implement the tree skeleton point extraction method based on a deep neural network and a minimum spanning tree algorithm as described in any one of claims 1-4.

Images