A Large-Scale Forest Point Cloud Tree Segmentation Method Based on Incremental Greedy Algorithm

Abstract

This invention discloses a method for large-scale forest point cloud segmentation of individual trees based on a progressive greedy algorithm, comprising: acquiring airborne LiDAR point cloud data; using cloth-based simulated filtering to remove ground points from the point cloud; voxelization, using the AABB bounding box of the tree point cloud as the boundary, calculating the voxel key value corresponding to each point cloud and creating a corresponding voxel; using a spatial hash function to encode the voxel key value into a hash index and storing the pointer of the corresponding voxel at the index address; progressive greedy segmentation; post-processing; segmenting the point cloud according to the point cloud contained in each voxel and the individual tree cluster to which the voxel belongs; and outputting the point cloud of each tree. This invention adopts a bottom-up segmentation strategy, gradually passing inaccurate bottom-level information to accurate top-level information before segmentation, and starting from the overall distribution characteristics of the canopy rather than local highest points for the top-level information, avoiding difficult seed point identification and canopy detection steps, thus achieving fast greedy individual tree segmentation.

Description

Technical Field

[0001] This invention belongs to the field of point cloud data processing technology, specifically relating to a method for segmenting individual trees in a large-scale forest point cloud based on a progressive greedy algorithm. Background Technology

[0002] Over the past two decades, the rapidly developing LiDAR technology has enabled unprecedented precision in describing the 3D structure of trees and forests. Compared to time-consuming and laborious manual surveys, airborne platforms equipped with LiDAR sensors can efficiently complete large-scale forest surveys without being limited by terrain or other harsh environments. Furthermore, compared to traditional optical remote sensing methods that only acquire information about the forest surface, LiDAR can capture the complete 3D structure of the canopy and penetrate the canopy to a certain extent, accurately obtaining some understory information. Therefore, airborne LiDAR surveys have become a research hotspot in recent years. However, to obtain attribute data for each tree, it is first necessary to accurately and automatically separate individual trees in both vertical and horizontal directions.

[0003] Individual tree segmentation algorithms can identify and segment individual trees from point cloud data, but accurately and completely segmenting all trees remains a significant challenge. To address this, numerous scholars have proposed a variety of individual tree segmentation algorithms, which can be categorized based on the data type they process: raster-based segmentation, point cloud-based segmentation, and joint segmentation. However, raster-based and point cloud-based segmentation methods rely heavily on the selection of seed points, and the accuracy of seed point identification largely determines the accuracy of the final segmentation result, making it difficult to guarantee segmentation accuracy. Joint segmentation methods often sacrifice segmentation efficiency, resulting in high algorithm complexity. Furthermore, point cloud elevation normalization preprocessing is required before performing joint segmentation, but obtaining accurate understory topography in dense forest areas is difficult, leading to canopy distortion after normalization and affecting segmentation accuracy. Therefore, balancing segmentation accuracy and efficiency in individual tree segmentation is a current challenge. Summary of the Invention

[0004] The main objective of this invention is to overcome the shortcomings and deficiencies of existing technologies and propose a large-scale forest point cloud single-tree segmentation method based on a progressive greedy algorithm.

[0005] To achieve the above objectives, the present invention adopts the following technical solution:

[0006] A method for large-scale forest point cloud single-tree segmentation based on an incremental greedy algorithm includes the following steps:

[0007] Acquire airborne LiDAR point cloud data and use cloth simulation filtering to remove ground points from the point cloud;

[0008] Voxelization: Using the AABB bounding box of the tree point cloud as the boundary, calculate the voxel key value corresponding to each point cloud and create the corresponding voxel. Use a spatial hash function to encode the voxel key value into a hash index and store the pointer of the corresponding voxel at the index address.

[0009] A progressively greedy approach is used to partition the data, obtain candidate clusters of individual trees, and determine whether each candidate cluster is a correct individual tree based on the established rules for judging individual trees.

[0010] In post-processing, the minor axis length of each tree cluster is calculated, and it is determined whether the tree cluster is oversegmented based on the preset minimum tree radius. If it is oversegmented, it is attempted to merge it into a neighboring tree cluster.

[0011] The point cloud is segmented based on the point cloud contained in each voxel and the individual tree cluster to which the voxel belongs;

[0012] Output the point cloud for each tree.

[0013] Compared with the prior art, the present invention has the following advantages and beneficial effects:

[0014] 1. This invention adopts a bottom-up segmentation strategy, avoiding dependence on seed points; it gradually transmits inaccurate bottom-level information to accurate top-level information before segmentation, and starts from the overall distribution characteristics of the canopy rather than the local highest point for the top-level information, avoiding difficult seed point identification and canopy detection steps, thus achieving fast greedy single-tree segmentation.

[0015] 2. This invention applies the greedy algorithm to the field of single-tree segmentation, treating each point as a computation node, and actively searching for the most likely single-tree vertex to which it belongs without relying on the seed point.

[0016] 3. To take into account complex forest stand conditions such as mixed forests, this invention adopts a gradual segmentation strategy with crown width decreasing from large to small in order to reduce over-segmentation and under-segmentation.

[0017] 4. This invention employs a sparse voxel organization segmentation process to avoid constructing invalid voxels in non-point regions, thereby minimizing memory and time consumption while fully utilizing 3D information. Attached Figure Description

[0018] Figure 1 This is a flowchart of the method of the present invention;

[0019] Figure 2 This is a schematic diagram illustrating the principle of constructing sparse voxels;

[0020] Figure 3 This is a flowchart of the greedy partitioning implementation;

[0021] Figure 4 This is a diagram illustrating the principle of fitting residual calculation.

[0022] Figure 5 This is a diagram illustrating the calculation principle of the major and minor axis ratios and the relative positions of tree vertices. Detailed Implementation

[0023] The present invention will be further described in detail below with reference to the embodiments and accompanying drawings, but the embodiments of the present invention are not limited thereto.

[0024] Example

[0025] like Figure 1 As shown, the present invention provides a method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm, comprising the following steps:

[0026] S1. Acquire airborne LiDAR point cloud data and use cloth simulation filtering to remove ground points from the point cloud;

[0027] S2. Traditional voxelization methods require dividing the entire point cloud bounding box into voxels, resulting in significant waste of memory and computational resources. To address this issue, a sparse voxel partitioning approach is adopted to avoid constructing invalid voxels in pointless regions. Specifically, sparse voxels only store voxels containing points to save memory; and a hash function is used to encode the spatial index of voxels to ensure fast retrieval of voxel information via the spatial index. In this implementation, the specific steps are as follows:

[0028] Voxelization is performed using the AABB (Axis-Aligned Bounding Box) of the tree point cloud as the boundary. The voxel key value corresponding to each point cloud is calculated, and the corresponding voxel is created. For example... Figure 2 As shown, a spatial hash function is used to encode voxel key values ​​into hash indices and store pointers to the corresponding voxels at the index addresses.

[0029] Due to the constraints of voxel arrangement rules, greedy segmentation randomly selects any voxel with the same elevation as its assignment, leading to significant uncertainty and errors in the segmentation results. Therefore, this embodiment calculates the centroid of each voxel based on the coordinates of the point cloud contained within it, defining the voxel position using the voxel's centroid. The calculation formula is as follows:

[0030]

[0031] Where c is the center of the voxel, and n is the number of points contained within the voxel; (x i y i , z i Let be the coordinates of the i-th point within the voxel. The voxelization resolution V is related to the point density and stand characteristics. When the point density is low, the resolution V should be appropriately reduced to ensure that voxels of the same tree are interconnected. However, too low a resolution may smooth out the features between adjacent trees, leading to undersegmentation problems in subsequent segmentation. For point densities greater than 400 pts / m 2For scenes with a crown width greater than 1m, a resolution V of 0.1m can be used.

[0032] S3. Progressively greedy segmentation to obtain candidate single tree clusters, and determine whether each candidate single tree cluster is a correct single tree according to the established single tree judgment rules.

[0033] Greedy algorithms are algorithms that make the best or optimal choice in each step, aiming for the best or optimal final result. The problem of segmenting individual trees in airborne LiDAR point clouds can be abstracted as an optimization problem of finding the most likely tree to which each LiDAR point belongs. Assuming each tree has one and only one highest point, the problem can be transformed into finding the most likely highest point to which each point belongs. Treating each LiDAR point as a graph node, considering the connectivity of individual tree branches and leaves, each node can find a shortest path to its own highest point. For highest points that are not to which the node belongs, either they are unreachable due to disconnectivity, or the graph distance is much greater than the correctly assigned highest point. However, since the highest point is unknown, a precise 3D target cannot be given. Therefore, shortest path methods such as Dijkstra's algorithm are used for global solution. To this end, assuming the highest point of each tree is at infinity, the direction vector of each point to its assigned highest point should be closest to (0, 0, 1) (zenith direction). The above problem can be derived as follows: under connectivity constraints, each node aims to find the highest point in the direction with the smallest zenith angle. A greedy approach can be used for local solving, i.e., finding the node with the smallest zenith angle connected to each node within a local area. Once all nodes have completed their calculations, the entire scene will generate multiple directed graphs. The root node of each directed graph is the highest point of a tree, and this directed graph represents all the nodes included in a single tree. For example... Figure 3 As shown, a node P0 located at the junction of individual trees typically has a smaller zenith angle when connected to node P2 on its own tree (Tree3) compared to when connected to node P1 on the adjacent tree (Tree2). Therefore, this method ensures that adjacent trees are separated from the canopy recesses while preserving more information below the canopy of individual trees, taking into account the connectivity characteristics of sparse nodes in the understory.

[0034] In this embodiment, the progressive greedy partitioning step includes:

[0035] For any voxel i, firstly, based on the maximum greedy range R, find its corresponding neighboring voxel j through the voxel index; then calculate the zenith angle of the line connecting voxel i and each neighboring voxel j, and point voxel i to the neighboring voxel j with the smallest zenith angle; after all voxels have been calculated, construct a directed graph based on the pointer of each voxel, and find all root nodes (root voxels) in the directed graph; each root node (root voxel) corresponds to a single tree vertex, and all voxels connected to it form a candidate single tree cluster;

[0036] Wherein, the zenith angle α between any two voxelsi,j This is the angle between the line connecting the two voxels and the zenith direction, calculated using the following formula:

[0037]

[0038] in, zenith direction, c i and c j These are the centers of mass of the two voxels, respectively.

[0039] The parent voxel of each voxel is the neighborhood range R. i The nearest voxel with the smallest inner zenith angle is voxel c. i Father's body c father Expressed as:

[0040] c father =c j =argmin(α) i,j wherec j ∈R i

[0041] For any voxel c i First, based on the neighborhood range R i Identify the neighboring voxels from which the zenith angle needs to be calculated, and then calculate c. i The zenith angle with each neighboring voxel, finally c i The voxel c that points to the smallest zenith angle j That is, c i paternal hormones;

[0042] After the parent voxel is found, all voxels fall into two categories: those with a parent voxel found and those without. Voxels without a parent voxel are root voxels, which may be the voxels of the highest point of a single tree.

[0043] The voxel that finds the parent voxel is the leaf voxel. By recursively searching for the parent voxel, it can eventually be classified into a certain root voxel. All voxels belonging to the same root voxel are the components of the same tree. Based on different root voxels, all voxels are divided into different clusters, and each cluster corresponds to a tree.

[0044] Tree canopy surfaces are typically not strictly convex; locally convex branches are surrounded by concave areas, which can lead to branch vertices being incorrectly identified as root nodes, resulting in oversegmentation of individual trees. Increasing the greedy range R when searching for parent voxels allows branch vertices to be merged into neighboring root voxels, thus avoiding this problem. However, a large greedy range may ignore the concave features between adjacent trees, leading to smaller trees being incorrectly merged into neighboring trees, causing undersegmentation. For multi-layered forests with significant variations in canopy size and tree height, using a single greedy range for greedy segmentation is insufficient to simultaneously address both oversegmentation and undersegmentation of individual trees. Therefore, this invention employs a progressive segmentation strategy, using a series of gradually decreasing greedy range values ​​R for greedy segmentation. Larger greedy range values ​​are used to segment trees with larger canopies, while smaller greedy range values ​​are used to segment trees with smaller canopies.

[0045] In this embodiment, the asymptotic greedy partitioning employs a series of gradually decreasing greedy range values ​​R. i Perform incremental iterative greedy partitioning separately;

[0046] In the initial iteration, a greedy segmentation is performed on all voxels using a preset maximum greedy range value R, and the individual tree cluster features after segmentation are calculated. If the individual tree judgment rule is met, it is marked as a real individual tree and the corresponding voxel is deleted. Then, the maximum greedy range value R2 = R1 - V is reduced, and greedy segmentation and individual tree judgment are performed again on the remaining voxels. The above process is iterated until the greedy range is the same as the voxel resolution V.

[0047] Accurately identifying the real individual trees in the segmentation results during the progressive segmentation process is crucial to ensuring the segmentation accuracy of the algorithm. Based on a thorough analysis of the morphological characteristics of individual trees, this invention integrates and constructs multiple rules for judging the morphology of individual trees. In this embodiment, the specific rules for judging individual trees include the surface point fitting residual, the ratio of major and minor axes, and the relative position of tree vertices. When the morphological characteristics of a segmentation cluster simultaneously satisfy all three rules, the cluster is judged to be a real individual tree.

[0048] The surface point fitting residuals are the fitting residuals of the Pollock canopy model for each individual tree's surface voxels. The Pollock model can describe various canopy morphologies from conical to ellipsoidal, and is widely used to represent the canopy morphology of individual trees. The objective function of the Pollock canopy model is:

[0049]

[0050] Among them, (x j y j , z j ) represents the coordinates of the crown center point of the current single tree, a is the radius along the z-axis, b is the radius in the xy plane, and c is the crown shape parameter;

[0051] The surface point fitting residual is expressed as:

[0052]

[0053] Among them, (x i y i , z i ) represents the coordinates of the i-th surface point in the current single tree; r ij Ir is the fitting residual at that point. j The percentage of inlier points whose fitting residual for the current single tree is less than a threshold; n is the number of surface points contained in the current single tree, when Ir j Less than the specified threshold I th At that time, the single wood cluster meets the surface point ratio requirement.

[0054] The in-place rate of the surface fitting residuals for real individual trees is usually large, while the in-place rate of the surface fitting residuals for two or more trees that are misclassified into a cluster is usually small. Figure 4 As shown.

[0055] The ratio of the major and minor axes is used to determine whether the shape of a single tree is close to a circle; generally, the ratio of the major and minor axes of the projection of the tree crown point onto the xy plane should be close to 1. Considering that the calculation of the OBB bounding box of the single tree's projection point is easily affected by noise, interfering with the calculation results of the major and minor axes, the ratio of the first and second eigenvalues ​​of the projection point is used to approximate the ratio of the major and minor axes. First, the covariance matrix C of the single tree's projection point is calculated. 2×2 :

[0056]

[0057] in, Here, m is the centroid of the single-tree projection point, and m is the total number of voxels contained within the cluster; c i It represents the center of mass of a certain voxel.

[0058] Then, singular value decomposition (SVD) is used to decompose the covariance matrix to obtain the eigenvalues ​​λ1 and λ2. The ratio of the major axis to the minor axis, ls, is then defined as:

[0059]

[0060] The threshold for ls is set to 2. If the threshold is less than 2, the tree is considered to meet the major and minor axis constraints; otherwise, the tree is considered to be segmented incorrectly.

[0061] The relative position of a tree vertex is defined as whether a tree vertex is located in a position such as... Figure 5 Within the blue box shown, if a single tree falls within this area, its shape is considered reasonable; otherwise, the cluster segmentation is considered incorrect. Specifically:

[0062] Calculate the eigenvectors v1 and v2 of the single tree projection point, and calculate the projected coordinates proj of all points in the cluster on v1 and v2. i =[v1·(x i ,y i ),v2·(x i ,y i [)], and obtain the maximum and minimum values ​​v after projection. 1_min v 1_max v 2_min and v 2_max Then the projected coordinates of the highest point (tree vertex) of the cluster are [z_max] v1 ,z_max v2 The following conditions must be met:

[0063]

[0064] The three judgment rules strictly judge individual trees from three aspects: surface point distribution, overall crown shape, and highest point position, which can avoid the problem of undersegmentation of individual trees as much as possible.

[0065] S4. Post-processing: Calculate the minor axis length of each individual tree cluster and determine whether it is an over-divided individual tree cluster based on the preset minimum individual tree radius.

[0066] Due to noise and extremely prominent branches, even with a gradual strategy during the segmentation process, over-segmentation of a few branches may still occur. Therefore, after the greedy segmentation, a post-processing step for over-segmentation is introduced, specifically:

[0067] Calculate the minor axis length of each individual tree cluster, based on the set minimum individual tree radius R. min Determine if the length of the minor axis is less than R. min Identify potentially oversegmented individual tree clusters;

[0068] If so, find its adjacent tree clusters, calculate the morphological characteristics of the over-segmented tree cluster after merging it into the neighboring tree clusters, and determine the interior point ratio Ir after merging. m Compared with the original interior point rate Ir of neighboring single tree clusters o Does the relationship between them satisfy Ir? o -Ir m <0.2×Ir o Whether the ratio of the major and minor axes and the relative positions of the tree vertices satisfy the single-tree judgment rules;

[0069] If all conditions are met, the single tree cluster is merged into a neighboring single tree cluster; otherwise, it is classified as a noise cluster. If the requirements are met with multiple neighboring single tree clusters, it is merged into the single tree cluster with the highest internal point ratio.

[0070] S5. Segment the point cloud based on the point cloud contained in each voxel and the individual tree cluster to which the voxel belongs;

[0071] S6. Finally, output the point cloud of each tree.

[0072] It should also be noted that, in this specification, terms such as "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0073] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for large-scale forest point cloud single-tree segmentation based on an incremental greedy algorithm, characterized in that, Includes the following steps: Acquire airborne LiDAR point cloud data and use cloth simulation filtering to remove ground points from the point cloud; Voxelization: Using the AABB bounding box of the tree point cloud as the boundary, calculate the voxel key value corresponding to each point cloud and create the corresponding voxel. Use a spatial hash function to encode the voxel key value into a hash index and store the pointer of the corresponding voxel at the index address. A progressively greedy partitioning algorithm is used to obtain candidate clusters of single trees. Each candidate cluster is then judged as a correct single tree based on a defined single-tree identification rule. The progressively greedy partitioning algorithm includes: For any voxel i, firstly, based on the maximum greedy range R, find its corresponding neighboring voxel j through the voxel index; then calculate the zenith angle of the line connecting voxel i and each neighboring voxel j, and point voxel i to the neighboring voxel j with the smallest zenith angle; after all voxels have been calculated, construct a directed graph based on the pointing of each voxel, and find all root nodes in the directed graph; each root node corresponds to a single tree vertex, and all voxels connected to it form a candidate single tree cluster; Wherein, the zenith angle α between any two voxels i,j This is the angle between the line connecting the two voxels and the zenith direction, calculated using the following formula: in, zenith direction, c i and c j These are the centers of mass of the two voxels; The parent voxel of each voxel is the neighborhood range R. i The nearest voxel with the smallest inner zenith angle is voxel c. i Father's body c father Expressed as: c father =c j =argmin(α i,j )wherec j ∈R i For any voxel c i First, based on the neighborhood range R i Identify the neighboring voxels from which the zenith angle needs to be calculated, and then calculate c. i The zenith angle with each neighboring voxel, finally c i The voxel c that points to the smallest zenith angle j That is, c i The paternal element; After the parent voxel is found, all voxels fall into two categories: those with a parent voxel found and those without. Voxels without a parent voxel are root voxels, which may be the voxels of the highest point of a single tree. The voxel that finds the parent voxel is the leaf voxel. By recursively searching for the parent voxel, it can eventually be classified into a certain root voxel. All voxels belonging to the same root voxel are the components of the same tree. Based on different root voxels, all voxels are divided into different clusters, and each cluster corresponds to a tree. In post-processing, the minor axis length of each tree cluster is calculated, and it is determined whether the tree cluster is oversegmented based on the preset minimum tree radius. If it is oversegmented, it is attempted to merge it into a neighboring tree cluster. The point cloud is segmented based on the point cloud contained in each voxel and the individual tree cluster to which the voxel belongs; Output the point cloud for each tree.

2. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 1, characterized in that, Voxelization also includes calculating the centroid of each voxel based on the coordinates of the point cloud contained in each voxel, defining the voxel position using the voxel's centroid. The calculation formula is as follows: Where c is the center of the voxel, and n is the number of points contained within the voxel; (x i y i , z i ) represents the coordinates of the i-th point within the voxel.

3. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 1, characterized in that, The asymptotic greedy partitioning uses a series of progressively decreasing greedy range values ​​R. i Perform incremental iterative greedy partitioning separately; In the initial iteration, all voxels are greedily segmented using a preset maximum greedy range R, and the individual tree cluster features after segmentation are calculated. If the individual tree judgment rule is met, it is marked as a real individual tree and the corresponding voxel is deleted. Then, the maximum greedy range value R2 = R1 - V is reduced, and greedy segmentation and individual tree judgment are performed again on the remaining voxels. This process is iterated until the greedy range is the same as the voxel resolution V.

4. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 1, characterized in that, The established rules for judging individual trees specifically include the point ratio within the surface points, the ratio of major to minor axes, and the relative position of the tree vertices; when the morphological characteristics of a segmented cluster simultaneously satisfy all three rules, the cluster is judged to be a real individual tree.

5. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 4, characterized in that, The surface point fitting residuals are the fitting residuals of the Pollock canopy model for each individual tree's surface voxels. The objective function of the Pollock canopy model is: Among them, (x j y j , z j ) represents the coordinates of the crown center point of the current single tree, a is the radius along the z-axis, b is the radius in the xy plane, and c is the crown shape parameter; The surface point fitting residual is expressed as: Among them, (x i y i , z i ) represents the coordinates of the i-th surface point in the current single tree; r ji Ir is the fitting residual at that point. j The percentage of inlier points whose fitting residual for the current single tree is less than a threshold; n is the number of surface points contained in the current single tree, when Ir j Less than the specified threshold I th At that time, the single wood cluster meets the surface point ratio requirement.

6. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 4, characterized in that, The major-minor axis ratio is used to determine whether the shape of a single tree is close to a circle; the major-minor axis ratio is approximated by the ratio of the first and second eigenvalues ​​of the projection points. First, the covariance matrix C of the projection points of the single tree is calculated. 2×2 : in, Here, m is the centroid of the single-tree projection point, and m is the total number of voxels contained within the cluster; c i The center of mass of a voxel; Then, singular value decomposition (SVD) is used to decompose the covariance matrix to obtain the eigenvalues ​​λ1 and λ2. The ratio of the major axis to the minor axis, ls, is then defined as: The threshold for ls is set to 2. If the threshold is less than 2, the tree is considered to meet the major and minor axis constraints; otherwise, the tree is considered to be segmented incorrectly.

7. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 4, characterized in that, The relative positions of the tree vertices are as follows: Calculate the eigenvectors v1 and v2 of the single tree projection point, and calculate the projected coordinates proj of all points in the cluster on v1 and v2. i =[v1·(x i ,y i ),v2·(x i ,y i [)], and obtain the maximum and minimum values ​​v after projection. 1_min v 1_max v 2_min and v 2_max Then the projected coordinates of the highest point of the cluster are [z_max] v1 ,z_max v2 The following conditions must be met:

8. The method for large-scale forest point cloud single-tree segmentation based on a progressive greedy algorithm according to claim 1, characterized in that, Post-processing specifically includes: Calculate the minor axis length of each individual tree cluster, based on the set minimum individual tree radius R. min Determine if the length of the minor axis is less than R. min Identify potentially oversegmented individual tree clusters; If so, find its adjacent tree clusters, calculate the morphological characteristics of the over-segmented tree cluster after merging it into the neighboring tree clusters, and determine the interior point ratio Ir after merging. m Compared with the original interior point rate Ir of neighboring single tree clusters o Does the relationship between them satisfy Ir? o -Ir m <0.2×Ir o Whether the ratio of the major and minor axes and the relative positions of the tree vertices satisfy the single-tree judgment rules; If all conditions are met, the single tree cluster is merged into a neighboring single tree cluster; otherwise, it is classified as a noise cluster. If the requirements are met with multiple neighboring single tree clusters, it is merged into the single tree cluster with the highest internal point ratio.

Images