Unmanned aerial vehicle high-precision surveying and mapping control method, device, equipment and medium

Abstract

This application relates to a high-precision mapping and control method, apparatus, device, and medium for unmanned aerial vehicles (UAVs). The method acquires point cloud data and constructs an initial feature matrix containing geometric information. It then performs a single K-nearest neighbor search based on coordinates to construct a sparse base graph to fix the underlying topology. Next, it utilizes differentiable graph pooling units to perform learnable hierarchical pooling and coarsening on this base graph, generating a multi-scale graph structure to simulate the dynamic receptive field. Subsequently, sparse graph convolution is performed in parallel on these graphs at different scales to efficiently extract multi-scale features. These features are then fused through a cross-scale attention mechanism to capture information from local details to global context. Finally, the obtained segmentation and parameter results are parsed to generate control commands. This achieves coordinated optimization of high-precision point cloud real-time understanding and UAV autonomous control decision-making while avoiding the major computational bottleneck of layer-by-layer repetitive mapping.

Description

Technical Field

[0001] This invention belongs to the field of autonomous mapping and intelligent control of unmanned aerial vehicles (UAVs), and in particular relates to a high-precision mapping and control method, device, equipment and medium for UAVs. Background Technology

[0002] In the field of high-precision mapping for unmanned aerial vehicles (UAVs), LiDAR (Light Detection and Ranging) can generate dense 3D point clouds describing the geometric morphology of terrain and ground features. Real-time and accurate semantic parsing of this data is crucial for UAVs to achieve autonomous environmental perception and intelligent decision-making. In recent years, Graph Neural Networks (GNNs) have become an effective tool for processing point cloud data with irregular topological structures due to their powerful relational modeling capabilities. Among them, Dynamic Graph Convolutional Networks (DGCNNs) significantly improve the model's ability to capture local geometric structures and complex semantic relationships by dynamically reconstructing the neighborhood connection graph between points based on the features learned by each layer of the network, demonstrating superior accuracy in tasks such as point cloud segmentation and classification.

[0003] However, this method of dynamically reconstructing the graph structure layer by layer relies on repeatedly performing computationally complex K-nearest neighbor (k-NN) searches, which places an unbearable burden on UAV-borne computing systems that need to process massive point cloud data in real time. The stringent accuracy requirements of surveying applications also rule out traditional paths that sacrifice geometric details for efficiency, such as voxel downsampling or significantly simplifying the neighborhood size.

[0004] Therefore, in graph neural network applications for real-time UAV mapping, there exists a fundamental "accuracy-efficiency" contradiction—dynamic mapping is the core mechanism for achieving high-precision understanding, but its high computational cost is precisely the bottleneck for real-time applications. Existing technologies struggle to achieve efficient capture and real-time parsing of multi-scale high-order structures in point clouds without losing fine geometric information, which severely restricts the development of UAV mapping systems towards fully autonomous, highly responsive intelligent operation modes. Summary of the Invention

[0005] Therefore, it is necessary to provide a high-precision mapping and control method, device, equipment, and medium for unmanned aerial vehicles (UAVs) to address the aforementioned technical problems.

[0006] In a first aspect, this application provides a high-precision mapping and control method for unmanned aerial vehicles (UAVs), comprising:

[0007] S1. Acquire raw point cloud data collected by the UAV LiDAR sensor, and construct an initial point cloud feature matrix including coordinate features and geometric features by performing geometric feature calculations on the raw point cloud data.

[0008] S2. Based on the coordinate features in the initial point cloud feature matrix, perform a K-nearest neighbor search to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud.

[0009] S3. Using the initial point cloud feature matrix as the initial node features, the sparse base graph is pooled and coarsened through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set. Among them, the differentiable graph pooling unit aggregates and coarses the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer.

[0010] S4. Using the multi-scale node feature set as input, perform sparse graph convolution operations in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction.

[0011] S5. Input the multi-scale deep feature representation into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context.

[0012] S6. By analyzing the semantic segmentation and geometric parameter prediction results of the point cloud, the analysis results including the terrain model, ground feature vector information and the UAV operation status are obtained; based on the analysis results, control commands are generated to control the subsequent flight trajectory and scanning behavior of the UAV, and the UAV is controlled to perform corresponding operations according to the control commands.

[0013] Secondly, this application also provides a high-precision mapping and control device for unmanned aerial vehicles (UAVs) to implement the method described in the first aspect, the device comprising:

[0014] The point cloud feature initialization module is used to acquire raw point cloud data collected by the UAV LiDAR sensor. By performing geometric feature calculations on the raw point cloud data, an initial point cloud feature matrix including coordinate features and geometric features is constructed.

[0015] The sparse graph construction module is used to perform a K-nearest neighbor search based on the coordinate features in the initial point cloud feature matrix to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud.

[0016] The multi-scale graph processing module uses the initial point cloud feature matrix as the initial node features and performs pooling and coarsening processing on the sparse base graph through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set. Among them, the differentiable graph pooling unit aggregates and coarses the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer.

[0017] The deep feature extraction module is used to take the multi-scale node feature set as input and perform sparse graph convolution operations in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction.

[0018] The cross-scale fusion module is used to input multi-scale deep feature representations into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context.

[0019] The intelligent control decision module is used to obtain analytical results, including terrain model, ground feature vector information, and UAV operation status, by analyzing the semantic segmentation and geometric parameter prediction results of point cloud; based on the analytical results, it generates control commands to control the subsequent flight trajectory and scanning behavior of the UAV, and controls the UAV to perform corresponding operations according to the control commands.

[0020] Thirdly, this application also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement a high-precision mapping and control method for unmanned aerial vehicles as described in the first aspect.

[0021] Fourthly, this application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements a high-precision mapping control method for unmanned aerial vehicles as described in the first aspect.

[0022] The aforementioned high-precision mapping and control method, device, equipment, and medium for UAVs acquire point cloud data and construct an initial feature matrix containing geometric information. A sparse base graph is built using only one K-nearest neighbor search based on coordinates to fix the underlying topology. Then, a learnable hierarchical pooling and coarsening process is performed on this base graph using differentiable graph pooling units to generate a multi-scale graph structure to simulate the dynamic receptive field. Subsequently, sparse graph convolution is performed in parallel on these graphs of different scales to efficiently extract multi-scale features. These features are then fused through a cross-scale attention mechanism to capture information from local details to global context. Finally, the obtained segmentation and parameter results are parsed to generate control commands. This achieves coordinated optimization of high-precision point cloud real-time understanding and UAV autonomous control decision-making while avoiding the major computational bottleneck of repeated layer-by-layer mapping. Attached Figure Description

[0023] To more clearly illustrate the technical solutions in the embodiments or related technologies of this application, the accompanying drawings used in the description of the embodiments or related technologies will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0024] Figure 1 A flowchart illustrating a high-precision mapping and control method for unmanned aerial vehicles (UAVs) provided by this invention;

[0025] Figure 2 This is a schematic diagram of the process of pooling and coarsening a sparse basic graph in an optional embodiment of the present invention.

[0026] Figure 3 This is a structural schematic diagram of a high-precision mapping and control device for unmanned aerial vehicles (UAVs) provided by the present invention. Detailed Implementation

[0027] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0028] refer to Figure 1 The document presents a flowchart illustrating a high-precision mapping and control method for unmanned aerial vehicles (UAVs) provided in this application. The method includes the following steps:

[0029] S1. Acquire raw point cloud data collected by the UAV LiDAR sensor, and construct an initial point cloud feature matrix including coordinate features and geometric features by performing geometric feature calculations on the raw point cloud data.

[0030] Specifically, LiDAR sensors can be configured with sampling frequency and point cloud density parameters according to the needs of the mapping task, balancing data integrity and operational efficiency. Sampling frequency is typically positively correlated with flight speed and mapping accuracy; the faster the flight speed and the higher the accuracy requirement, the higher the sampling frequency needs to be. After acquiring the raw point cloud data, geometric features are calculated for each point cloud data point to construct an initial point cloud feature matrix. The coordinate features of the point cloud data points are used... It is represented in the form of Where i corresponds to the index of the i-th point in the point cloud data, and the range of values ​​for i when traversing all points is: (N is the total number of original point cloud data points); , , These represent the three-dimensional coordinate components of the i-th point in the UAV's onboard coordinate system. The onboard coordinate system has its origin at the UAV's centroid, with the X-axis pointing forward along the fuselage, the Y-axis to the right, and the Z-axis perpendicular to the fuselage and upward. This coordinate system can be aligned with the geodetic coordinate system through a coordinate transformation matrix, ensuring global consistency of the mapping data. Geometric features are selected based on key parameters that reflect the local geometry of the point cloud, including point cloud normals, curvature, variance of neighboring point distances, and point cloud density. Furthermore, the feature dimensions are uniformly adapted to subsequent model inputs.

[0031] Point cloud normal vectors are calculated using Principal Component Analysis (PCA). The core of PCA is solving for the covariance matrix of the neighborhood point set and extracting the eigenvector corresponding to the smallest eigenvalue. The key advantage of PCA is its ability to effectively remove redundant information from neighborhood points, focusing on the essential geometric shape. The specific steps are as follows: First, determine the points... K initial neighborhood point sets i corresponds to the i-th target point. This refers to the set of neighboring points surrounding the i-th point. The value of K needs to be set in conjunction with the point cloud density, typically between 10 and 30. The higher the point cloud density, the larger the value of K can be to avoid excessive concentration of neighboring points leading to feature distortion. The mean of the neighboring point set is then calculated. The formula is , where j is the index of the neighboring points of the i-th point, traversing The range of values ​​for j when considering all neighboring points is: The mean is essentially the geometric center of the neighborhood set of the i-th point, used to eliminate the influence of translation on the covariance calculation. The covariance matrix is ​​constructed based on the mean. The formula is , The covariance matrix corresponding to the i-th point, the denominator is taken as... To ensure unbiased estimation and avoid bias in covariance calculation when the sample size is small, this matrix is ​​a 3×3 symmetric matrix. The diagonal elements represent the variance of neighborhood points on each coordinate axis, reflecting the dispersion of the point set in the corresponding directions. The off-diagonal elements represent the covariance, reflecting the correlation between coordinate axes. (The text then abruptly shifts to a different topic: the covariance matrix.) Eigenvalue decomposition is performed, and the Jacobi iteration method is used to solve for the eigenvalues. and the corresponding feature vectors , For the smallest eigenvalue, The largest eigenvalue, the corresponding eigenvector Also sorted by corresponding eigenvalues; smallest eigenvalue corresponding feature vector That is, a point normal vector The formula is , , , These represent the components of the normal vector of the i-th point along the X, Y, and Z axes, respectively. The normal vector needs to be normalized to ensure... This avoids the amplitude difference affecting subsequent feature calculations.

[0032] curvature parameters The eigenvalues ​​used to characterize the curvature of local surfaces in a point cloud are calculated based on eigenvalues ​​obtained from PCA decomposition. The specific formula is as follows: ,in The curvature corresponding to the i-th point, , , Let be the eigenvalues ​​of the covariance matrix at the i-th point, and satisfy . This formula normalizes the minimum eigenvalue, making the curvature range [0,1]. The closer the value is to 1, the flatter the surface (at this point...). near , The closer the value is to 0, the greater the degree of surface curvature (at this time...). much smaller , Curvature can effectively distinguish the surface morphology of terrain features such as planar and curved surfaces. Neighborhood point distance variance. The formula used to reflect the degree of dispersion of neighboring points is: ,in The variance of the distance to the i-th point, where j is the index of the neighboring point of the i-th point. Let the i-th point and its neighboring points be... The Euclidean distance, when expanded, is... ( (where is the coordinate component of the j-th neighboring point). A larger variance value indicates a more dispersed distribution of neighboring points, and is often used to identify feature regions such as edges and corners. The formula for calculating point cloud density features is: ,in The local density corresponding to the i-th point, For the i-th point For the center of the ball, Volume of a sphere with radius ( ), Consistent with the maximum distance threshold of K-nearest neighbor search, this feature is used to characterize the density of the point cloud in the local region of the i-th point, and helps to distinguish different land features such as vegetation and buildings.

[0033] Based on the aforementioned coordinate and geometric features, an initial point cloud feature matrix is ​​constructed. Where 0 represents the initial scale before pooling coarsening, and N is the total number of original point cloud data points, which varies with the mapping range and LiDAR sampling frequency, and is typically 0. - Order of magnitude; D is the feature dimension, satisfying 3 represents the coordinate feature dimension, and k represents the number of selected geometric features (in this embodiment) The corresponding normal vector, curvature, and neighborhood distance variance are: If point cloud density is added, then , Each row of the feature matrix corresponds to a feature vector of a point cloud data point, i.e. ,in Represents the initial scale matrix All feature components in the i-th row (corresponding to the i-th point) are used to construct a matrix by concatenating them row by row. The concatenation order is fixed as "coordinate features - geometric features" for easy processing in subsequent models. After construction, the feature matrix is ​​preprocessed by normalization, using the following formula: ,in Represents the initial scale matrix The normalized feature components of the feature in the i-th row and d-th column. Let d be the mean of the features in column d. Let d be the standard deviation of the d-th feature, where d corresponds to the column index of the feature matrix. The purpose is to eliminate the magnitude difference between different feature dimensions and improve the convergence speed and stability of model training.

[0034] S2. Based on the coordinate features in the initial point cloud feature matrix, perform a K-nearest neighbor search to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud.

[0035] Specifically, unlike the layer-by-layer K-nearest neighbor search operation mode in existing dynamic graph convolutional networks, a single K-nearest neighbor search can significantly reduce computational complexity, adapting to the computing power limitations of UAV onboard computing systems. K-nearest neighbor search uses coordinate features as its core basis and employs Euclidean distance as the distance metric between points. and The Euclidean distance formula is ,in The spatial distance between the i-th point and the j-th point. , , and , , These are the three-dimensional coordinate components of two points in the airborne coordinate system. This formula reflects the physical distance relationship of the point cloud in three-dimensional space.

[0036] During the search process, for each point Calculate the Euclidean distance by traversing all other point cloud data points. And filter out those that meet the requirements And the K points with the smallest distance are taken as the nearest neighbors, among which The maximum neighborhood distance threshold is preset and determined by the mapping task accuracy and point cloud density. It is typically taken as 2-3 times the average distance between point clouds to filter distant noise points and avoid distortion of neighborhood relationships. To improve search efficiency, the KD-tree algorithm is used to accelerate K-nearest neighbor queries. The KD-tree construction formula is based on the median of the point cloud coordinates, with the m-th layer having a dimension of... (Corresponding to X, Y, Z axis cycles), threshold division The median of the coordinates of all points in this dimension, i.e. (when m≡0) (when m≡1) (when m≡2) The median function distributes the point cloud equally across the current dimension, balancing the KD-tree structure and reducing backtracking during the search. Hierarchical partitioning transforms the 3D point cloud space into a binary tree structure, with the left subtree storing points less than or equal to the median in that dimension. The right subtree stores points greater than or equal to [a certain value]. The leaf nodes of the tree correspond to individual point cloud data points, reducing the search time complexity from brute-force search. Down to Adapting to the computing power limitations of drones. The search starts from the root node and compares the target point with the target point along the partitioning dimension. Given the size of the target point, recursively traverse the subtree while recording the current nearest neighbor. If the distance from the target point to the partition plane is less than the current nearest neighbor distance, backtrack to another subtree to ensure that no potential nearest neighbor is missed.

[0037] Construct a sparse foundation graph based on K-nearest neighbor search results. Where 0 corresponds to the initial scale. For a graph, there is a set of nodes, each node... A single point cloud data point corresponds to a unique point cloud data point. ; Let be the set of edges, if for If the K nearest neighbor is a point, then there exists an edge. , The edge connecting the i-th node and the j-th node represents the proximity relationship between the two points. The edge has no weight and only indicates the existence of a neighborhood association. Simultaneously, an adjacency matrix is ​​constructed for the corresponding graph. , The adjacency matrix corresponding to the initial scaled graph has the following element value rules: ,in The element corresponding to the i-th row and j-th column of the adjacency matrix. Point The K-nearest neighbor set, i.e., the set obtained earlier that satisfies And distance The set of the K nearest neighbors is the core relation connecting the K nearest neighbor search results and the graph structure. The matrix must satisfy... The symmetry relationship (i.e., if) yes The nearest neighbor is then Too If a one-way nearest neighbor exists (only one side is in the nearest neighbor set of the other), edges are forcibly added to make the matrix symmetric, avoiding the impact of graph asymmetry on subsequent convolution operations. To further reduce computational cost, the adjacency matrix is ​​sparsified using a sparse matrix storage format. ,in It is a unit column vector where only the i-th element is 1 and the rest are 0. This format only stores the position and value of non-zero elements, which can reduce storage space by more than 90% compared to dense matrices. At the same time, it ensures that subsequent convolution operations are performed only on non-zero elements, greatly reducing invalid computations.

[0038] S3. Using the initial point cloud feature matrix as the initial node features, the sparse base graph is pooled and coarsened through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set. Among them, the differentiable graph pooling unit aggregates and coarses the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer.

[0039] Specifically, the core advantage of differentiable graph pooling units lies in achieving end-to-end aggregation and coarsening of graph structure and node features through a learnable node allocation matrix, avoiding feature loss caused by manually designing pooling rules in traditional pooling methods. For the first... Each differentiable graph pooling unit takes the current layer graph structure as input. With node features ,in The corresponding pooling unit's level number. , The first The graph structure and node characteristics of the layers For the first Number of layer nodes For the first Layer node feature dimension. First, the node features are processed through two layers of multilayer perceptron (MLP). Perform nonlinear mapping to generate a node assignment matrix. , Corresponding to the The node allocation matrix of the layer, the forward propagation formula of MLP is: ,in This is the first layer weight matrix. Here, H is the first-layer bias vector, and H is the hidden layer dimension, typically taken as... This ensures that feature information is not lost during the mapping process; This is the weight matrix for the second layer. This is the second layer bias vector. For the first The number of nodes in the layer (next layer) graph structure (satisfying) (to reduce node size). The linear rectification function is given by the formula: This is used to introduce nonlinear feature mapping, breaking the expressive limitations of linear models; This is a normalization function that operates on the column dimensions of the node allocation matrix, ensuring... ( ), Corresponding allocation matrix number Layer Line 1 The elements of the column implement soft allocation of nodes to the next layer cluster centers, that is, each node is allocated to multiple nodes in the next layer with a certain weight, rather than hard partitioning, thus retaining more feature association information. , , , All parameters are learnable and are trained and optimized end-to-end along with the entire model. The optimization objective is to minimize the joint loss function of semantic segmentation and geometric parameter prediction, as shown in the formula. ,in For the total loss, The semantic segmentation loss is calculated using cross-entropy loss. The loss is predicted for geometric parameters (using mean squared error loss). , Weighting coefficients (can be taken as follows) , ), to balance the training priorities of the two tasks.

[0040] Based on node allocation matrix This completes the generation of the next layer of graph structure and node features. Layer node features It is obtained through feature-weighted aggregation, and the formula is: , Corresponding to the The node features of a layer, i.e., the features of each node in the next layer, are the weighted sum of the features of all nodes in the current layer according to their assigned weights, preserving the global correlation of features. Assign matrices to nodes The transpose of the matrix, with dimension After matrix multiplication, the features are realized from... Each node to Aggregation of nodes. Layer adjacency matrix It is obtained through graph structure aggregation, and the formula is: , Corresponding to the The adjacency matrix of the layer, where It is a normalization factor used to mitigate the feature magnitude deviation caused by the reduction in the number of nodes, so that the element magnitudes of the adjacency matrices of different layers are on the same order of magnitude, which facilitates model training. This is the adjacency matrix for the l-th layer. This operation uses an allocation matrix to pass the neighborhood relationships between nodes in the current layer to the next layer, preserving the topological relationships of the graph structure. After aggregation, it is necessary to... Perform binarization and set a threshold. ,like The value is then 1. Corresponding to the The element in the c1th row and c2th column of the layer adjacency matrix is ​​selected; otherwise, it is 0. This ensures that the graph structure of the next layer remains sparse, thus maintaining computational efficiency.

[0041] By cascading L differentiable graph pooling units, the sparse basic graph is sequentially processed. The process is performed to obtain a multi-scale graph hierarchy. With the corresponding multi-scale node feature set Where L is the total number of pooling unit layers, , These represent the top-level (coarse-grained) graph structure and node features, respectively. The number of pooling layers L is determined based on the point cloud size and onboard computing power, typically 3-5 layers. Too large a L can lead to excessive feature coarsening and loss of detail, while too small a L cannot effectively capture global features. The number of nodes in each layer is reduced proportionally, such as... (Round down) This ratio can be adjusted according to needs; it can be used when the point cloud size is large. To further reduce computational load, when the point cloud size is small, it can be taken as... To retain more details. Ultimately This is a coarse-grained map, corresponding to the global topology of the point cloud. The number of nodes is usually 1 / 8 to 1 / 32 of the original number of nodes. It is used to capture global features such as terrain undulation and overall layout of ground features. This is a fine-grained map, corresponding to the local geometric details of the original point cloud. It is used to capture local features such as the edges and textures of ground objects, forming a graph structure system that covers multi-scale features, providing a foundation for subsequent parallel convolution.

[0042] S4. Using the multi-scale node feature set as input, perform sparse graph convolution operations in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction.

[0043] Specifically, the parallel execution mode avoids the time accumulation of layer-by-layer processing, further improving the real-time performance of point cloud feature parsing. Convolution operations at each scale are performed independently, ultimately outputting deep features at the corresponding scale. For any scale map structure... Feature extraction is performed using the sparse graph convolution operator, and the core formula is: ,in For the first Deep features after layer graph convolution For the first The adjacency matrix of a layer with self-loops. For the first The original adjacency matrix of the layer, For the first The identity matrix corresponding to the layer (diagonal elements are 1, and the rest are 0) introduces self-loops to ensure that each node retains its own features during the convolution process, avoids feature dilution, and ensures that the node's own information is not covered by the features of its neighbors. for The corresponding degree matrix is ​​the th The diagonal matrix of the layer, diagonal elements , Indicates the first The element in the i-th row and j-th column of the adjacency matrix with self-loops. Corresponding to the The element in the i-th row and i-th column of the degree matrix, i.e., the degree of each node, is the sum of the row elements in the adjacency matrix with self-loops, and the inverse square root of the degree matrix. It is obtained by taking the square root of the diagonal elements and then inverting them, i.e. This is used to normalize the adjacency matrix, alleviate the training bias caused by uneven distribution of node degree in the graph structure, and make the feature update magnitude of each node consistent.

[0044] For the first Layer-learnable convolutional weight matrix, For the first Feature dimensions before convolution. For the first The feature dimension after convolution is usually taken as... This expands the feature dimensions and enhances the model's expressive power; the weight matrix uses the Xavier initialization method, represented as... ,in This represents a uniform distribution over the interval [a, b]. This initialization method adjusts the distribution interval to ensure that the feature variance during forward propagation is consistent with the gradient variance during backward propagation, thus avoiding gradient explosion or vanishing. For the first The convolutional layer bias vector is initialized to zero and adaptively adjusted during training to compensate for the mean shift after feature mapping. For non-linear activation functions, the LeakyReLU function is chosen, and the formula is as follows: ,in The preset negative slope is used to strike a balance between alleviating the vanishing gradient problem on the negative half-axis and preserving feature sparsity. Compared with the ReLU function, it can capture more negative feature information and enhance the nonlinear expressive ability of the model.

[0045] To improve convolution efficiency, sparse matrix operations are optimized, and... This is transformed into the product operation of a sparse matrix and a dense matrix, and the formula is as follows: ,in For the first Intermediate results of layer convolution, Consistent with the definition in S2, it is a point. The K-nearest neighbor set is used, and the summation range is limited to this set. This allows calculation to be performed only on the positions corresponding to non-zero elements, significantly reducing invalid computations and improving computational efficiency by an order of magnitude compared to dense matrix multiplication. Through the above convolution operation, each scale map... Output deep features After convolution, the features need to be batch normalized, using the following formula: ,in For the first Features after batch normalization For the first The element in the i-th row and d-th column of the feature after convolution. , The first The mean and variance of the feature in the d-th column of the layer within the current batch (batch size can be 32). To prevent the use of tiny values ​​with a denominator of zero, batch normalization can accelerate model convergence and suppress overfitting. This ultimately yields a multi-scale deep feature set. ,in Capture local geometric details, By capturing the global topological structure, features at different scales complement each other, providing comprehensive support for subsequent semantic parsing.

[0046] S5. Input the multi-scale deep feature representation into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context.

[0047] Specifically, the cross-scale attention fusion unit improves prediction accuracy by dynamically allocating weights to highlight key scale features. First, it analyzes deep features at each scale. Feature alignment and dimensionality unification are performed due to the varying number of nodes in graphs at different scales. Since they are different and cannot be directly fused, bilinear interpolation is used to map all features to the original point cloud scale. The interpolation formula is: ,in For the first Features after layer alignment For the first All components of the i-th row of the feature after layer alignment For the original point i, the first... Layer node set, assigned by node allocation matrix The position of the non-zero weight in the middle is determined (i.e. (the value of k); For the first The interpolation weights corresponding to the original point i in the layer are derived in reverse from the node assignment matrix, as shown in the formula: ,satisfy This ensures stable feature amplitudes after interpolation. Subsequently, the aligned features are dimension-unified using a 1×1 convolution, as shown in the formula. ,in For the first Features after unifying layer dimensions The projection weight matrix is... For projection bias, To unify the feature dimensions, it is usually taken as follows: or To adapt to the computational requirements of subsequent attention mechanisms; and As learnable parameters, they are optimized through training to map features at different scales to the same feature space, which facilitates the calculation of cross-scale similarity.

[0048] Based on unified dimensional features To calculate cross-scale attention weights, a scaled dot product attention mechanism is used. First, query vector, key vector, and value vector are generated, as shown in the formulas below. , , ,in , , The first The query vector, key vector, and value vector of the layer. , , All are learnable weight matrices. It is an attention dimension, and satisfies Ensure dimensional matching; Used to characterize the Query information for layer features Used to characterize the Key information of layer features Used to characterize the The value information of each layer's features is generated through the same feature mapping, ensuring semantic consistency. The attention weight calculation formula is as follows: ,in For the first Attention weights for layer features For the first The similarity function of the layer features themselves is expressed as a dot product, and the formula is as follows: , The trace operation (sum of diagonal elements) is used to... The similarity matrix of a dimension is transformed into scalar values, which intuitively reflect the similarity of the first dimension. The degree of correlation among the layer features themselves; It serves as a normalization factor to avoid numerical saturation caused by excessively high feature dimensions, thereby making the attention weight distribution more uniform. The function is applied to similarity values ​​across all scales, ensuring that the sum of the attention weights is 1. This enables dynamic weight allocation, highlighting scale features that contribute significantly to the task. Consistent with the normalization logic in graph pooling, both methods use exponential functions to enhance differences and achieve normalization.

[0049] Feature fusion is performed based on attention weights, using the following formula: ,in The fused global features integrate the advantages of features at various scales, including local scale features. When the scale is small, it provides detailed information, global scale features ( (When larger) provides contextual information. The fused features are input into the prediction head network, which includes a semantic segmentation branch and a geometric parameter prediction branch, both consisting of three MLP layers, sharing the feature maps of the first two layers (i.e., the weight matrices of the first two layers). , With bias , (Shared by two branches), each outputs different task results. The formula for the shared layer is: ,in For shared layer output features, , , To share hidden layer dimensions (as described below) , (Consistency), reducing parameter redundancy. The semantic segmentation branch outputs the class probability of each point, as shown in the formula. ,in This is the semantic segmentation result. This is the weight matrix for the third layer of the semantic segmentation branch. For the corresponding bias vector; The number of land feature categories is determined based on the surveying task (e.g., topography, buildings, vegetation, etc.). The function calculates the probability distribution for each row of feature vectors (a single point), and outputs the probability distribution for each category. The category with the highest probability is the semantic label for that point. It operates on the category dimension, ensuring that the sum of the category probabilities of a single point is 1.

[0050] The geometric parameter prediction branch outputs key geometric parameters of ground features, using the following formula: ,in For the geometric parameter prediction results, , , The weight matrix for each layer of the geometric parameter branch, For the corresponding bias vector; For the hidden layer dimension, and Consistent values ​​ensure a symmetrical branch structure. This branch represents the number of geometric parameters (e.g., slope, height, width, volume, etc.). It has no output activation function; it directly outputs the geometric parameters in continuous value form and optimizes the training using the mean squared error loss function. For the slope parameter, the conversion formula is as follows: ,in , The partial derivatives of elevation in the X and Y directions are derived from the results predicted by geometric parameters. Output directly.

[0051] S6. By analyzing the semantic segmentation and geometric parameter prediction results of the point cloud, the analysis results including the terrain model, ground feature vector information and the UAV operation status are obtained; based on the analysis results, control commands are generated to control the subsequent flight trajectory and scanning behavior of the UAV, and the UAV is controlled to perform corresponding operations according to the control commands.

[0052] Specifically, the terrain model is constructed using a digital elevation model (DEM) generation algorithm, based on elevation data from the geometric parameter prediction results. (Taken from (or original coordinate features) For the elevation value of the i-th point, the sparse area of ​​the point cloud is completed by inverse distance weighted interpolation (IDW), as shown in the formula: ,in The coordinates of the DEM grid nodes are given. The grid resolution is set according to the surveying accuracy requirements. A 1:1000 scale survey corresponds to a 1-meter resolution, and a 1:500 scale survey corresponds to a 0.5-meter resolution. M is the number of point clouds in the neighborhood of the node, usually 10-15, to ensure interpolation stability. The planar Euclidean distance between the grid node and the i-th point ( ), This is the distance attenuation factor (used to experimentally verify that this value can strike a balance between spatial smoothing and detail preservation; a value of 2 is acceptable). Let i be the elevation value of the i-th point ( and The definition is consistent with that in S1). This formula generates a regular grid DEM, which needs to be smoothed after generation to eliminate interpolation noise and make the terrain surface more continuous.

[0053] Ground feature vector information extraction based on semantic segmentation results With geometric parameter prediction results The steps are as follows: First, according to The point cloud set for each land cover category is determined, and contour extraction is performed on point clouds of the same type. The Canny edge detection algorithm is used, and the first step is to smooth the point cloud using a Gaussian filter. The filtering formula is as follows: ,in The standard deviation of the Gaussian kernel is taken as 0.5 to 2.0, and adjusted according to the point cloud noise level. The higher the noise, the better. The larger the value, the better; the second step is to calculate the gradient magnitude and direction, gradient magnitude... gradient direction , , The gradients in the x and y directions are respectively calculated using the Sobel operator. , The third step involves preserving edge points through non-maximum suppression, comparing the gradient magnitude of the current point with that of its neighbors along the gradient direction, and retaining only the points with local maxima. The fourth step uses a double thresholding method to determine the final set of edge points, setting a high threshold. With low threshold For example, it can satisfy A high threshold is used to identify strong edges, and a low threshold is used to connect weak edges. Strong edges are directly retained, and weak edges are retained if they are connected to strong edges; otherwise, they are discarded. A polygon fitting is performed on the edge point set using a least-squares fitting algorithm, and the fitting formula is as follows: ,in To fit the angle of the straight line, The distance from the origin to the straight line is used to obtain the feature vector profile through iterative fitting. The iteration terminates when the error between two consecutive fitting iterations is less than 1. Extract vector information such as vertex coordinates, side lengths, and area of ​​the contour. The area is calculated using the Shoelace formula, which is: ,in , where n is the number of contour vertices.

[0054] The drone operation status analysis, combined with prediction results and onboard sensor data, yields the following formula for calculating operation progress: ,in This represents the percentage of work progress. The area of ​​the surveyed region (obtained from the DEM and ground feature vector information, calculated by the grid counting method, which counts the total area of ​​the effective grids in the DEM and subtracts the area of ​​the overlapping region). The total area of ​​the task region (determined by the preset survey range, usually a rectangular area, area formula is...) , , (These represent the width and height of the mission area, respectively); the current position error of the UAV. ,in This is the position error value. The actual location of the drone was collected by GPS. The preset waypoint positions are generated by the mission planning system; attitude error ,in This represents the attitude error value. , , The roll, pitch, and yaw angles collected by the IMU , , A preset attitude angle is used to ensure the UAV flies horizontally or scans at a preset attitude. Point cloud density error can be calculated using the formula... To measure, among which This is the density error coefficient. The actual point cloud density (from S1) (Statistical mean values ​​are available) The target point cloud density (set according to the mapping accuracy, such as 50 points / square meter) is used to adjust the LiDAR sampling frequency later.

[0055] Control commands are generated based on the operational status analysis results, and a PID control algorithm is used to adjust the flight trajectory and scan parameters. Flight altitude adjustment command. ,in The target height instruction value, For reference height, it is determined by terrain elevation and safety distance. , The current location is the DEM elevation. For a safe distance, 5-10 meters is usually chosen. For height error, The drone's current altitude (collected by GPS); These are the proportional, integral, and differential coefficients, which are determined through trial and error. For example, taking... , , The proportional coefficient is used to quickly respond to errors, the integral coefficient is used to eliminate steady-state error (small errors accumulated over a long period), the derivative coefficient is used to suppress overshoot (avoiding highly frequent fluctuations), and the integral term... The differential term is the cumulative value of the error over time. The rate of change of error. LiDAR sampling frequency adjustment command. ,in The target sampling frequency command value, , The minimum and maximum sampling frequencies for LiDAR sensors (e.g., 50kHz-200kHz). The point cloud density error coefficient. Here, k is the error threshold, and k is the adjustment coefficient. This formula is based on the Sigmoid function, which makes the frequency change smoothly with the error, avoiding abrupt changes. When the actual density is higher than the target, the frequency approaches... ,when The time frequency approaches The trajectory correction command is implemented by replanning waypoints, with the new waypoint coordinates... ,in The corrected coordinates of the waypoints. The coordinates of the original track point. This is a correction factor (to control the correction range and avoid over-correction). unit direction vector ( (Using Euclidean norm ensures the vector magnitude is 1). The system uses preset waypoint coordinates to ensure the corrected direction points to these coordinates; the spacing between the corrected waypoints remains constant (e.g., 5 meters) to ensure stable flight. All control commands are encoded according to the UAV flight control system protocol (e.g., MavLink protocol, an open-source UAV communication protocol that supports bidirectional transmission of attitude, position, and sensor data). After being transmitted to the flight control system, the UAV's attitude and LiDAR operating status are adjusted via servos and sensor drive modules to achieve closed-loop control. The control cycle is set to 100ms to ensure real-time response.

[0056] The entire high-precision mapping and control method for UAVs constructs a sparse base graph through a single K-nearest neighbor search, and combines it with a KD-tree acceleration algorithm to reduce the search complexity from... Down to ( The time complexity notation (used to characterize the growth of algorithm execution time with data size N) avoids the high computational complexity of traditional dynamic graph convolutional networks (DLPs) that construct graphs layer by layer. Simultaneously, it utilizes differentiable graph pooling units to generate node allocation matrices through two layers of MLPs, achieving end-to-end coarsening of the graph structure. Combined with parallel sparse graph convolution operations and cross-scale attention fusion units, it dynamically allocates feature weights through a scaling dot product attention mechanism, achieving efficient capture and accurate fusion of local details and global context features of point clouds. Finally, it analyzes the prediction results and generates control commands through algorithms such as inverse distance weighted interpolation, Canny edge detection, and PID control, effectively resolving the "accuracy-efficiency" contradiction in existing technologies and improving the intelligence level and operational efficiency of UAV mapping systems.

[0057] The aforementioned high-precision mapping and control method for UAVs acquires point cloud data and constructs an initial feature matrix containing geometric information. It then performs a single K-nearest neighbor search based on coordinates to build a sparse base graph to fix the underlying topology. Next, it utilizes differentiable graph pooling units to perform learnable hierarchical pooling and coarsening on this base graph, generating a multi-scale graph structure to simulate the dynamic receptive field. Subsequently, sparse graph convolution is performed in parallel on these graphs of different scales to efficiently extract multi-scale features. These features are then fused through a cross-scale attention mechanism to capture information from local details to global context. Finally, the obtained segmentation and parameter results are parsed to generate control commands. This method achieves coordinated optimization of high-precision real-time point cloud understanding and UAV autonomous control decision-making while avoiding the major computational bottleneck of repeated layer-by-layer graph construction.

[0058] refer to Figure 2 In one optional embodiment, a sparse base graph is pooled and coarsened using cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy from fine to coarse and a corresponding multi-scale node feature set, including the following steps:

[0059] S11. For the current layer graph and its node features, a lightweight graph convolutional network is used to process the node features and generate a pooled score matrix that represents the original tendency score of each node assigned to each superpoint in the next layer. Among them, the superpoint is a high-order aggregated node formed by weighted aggregation of multiple nodes in the previous layer graph in the graph hierarchy. It is the product of the graph coarsening process and also the basic building block for constructing the next layer coarse-grained graph.

[0060] Specifically, this step aims to generate initial propensity scores for assigning superpoints to the nodes of the current layer graph to the next coarsening layer. The current layer graph and its node features correspond to the previously constructed sparse base graph or the intermediate layer graph generated in the previous round of coarsening. The initial layer corresponds to layer 0, and the node features are the feature matrices of the corresponding layer. The feature matrix of the initial layer This is the initial point cloud feature matrix. It consists of the coordinate and geometric features of the original point cloud, with the dimension being the total number of nodes in the original point cloud. With feature dimension The product of these is the basis for the feature input of the entire pooling and coarsening process.

[0061] Lightweight Graph Convolutional Networks (GCNs) are simplified graph convolutional structures adapted to the computing power of UAVs. Compared to conventional graph convolutions, they reduce the number of convolutional kernels and the dimension of hidden layers. Their core uses a simplified version of Graph Convolution (GCN), as shown in the following expression:

[0062]

[0063] This formula is used for node feature optimization before generating the pooling scoring matrix, where: Representing the The node feature matrix after lightweight graph convolution of the layer has dimensions and Consistency (the first) Number of layer nodes ×Feature Dimension ), used for subsequent generation of pooling score matrix Its core function is to enhance the distinguishability of node features and provide feature support for accurate allocation of super points; Representing the The adjacency matrix of the layer with self-loops is derived from the first... Layer original adjacency matrix With the identity matrix Adding them together gives ( ).

[0064] For the first The sparse adjacency matrix of the layer graph has dimensions of ,element The value can be 1 or 0, used to represent the first... Whether there is a neighborhood relationship between layer node i and node k is determined by the K nearest neighbor search result in S2; To and An identity matrix of the same dimension has diagonal elements of 1 and off-diagonal elements of 0. Adding self-loops is to ensure that each node retains its own characteristics when aggregating neighborhood information, thus preventing its own information from being covered by neighborhood features.

[0065] represent The corresponding degree matrix is ​​a diagonal matrix with dimensions equal to 1 / 2. Consistency ), its diagonal elements That is, the first The degree of node i in the adjacency matrix with self-loops is numerically equal to the number of neighboring nodes of node i plus 1 (self-connection). for The inverse square root matrix is ​​also a diagonal matrix with diagonal elements of 1. The inverse square root is used to normalize neighborhood information, avoid feature aggregation bias caused by differences in node degree, and ensure balanced feature aggregation weights for nodes of different degrees.

[0066] Representing the Learnable convolutional kernels for layer-lightweight graph convolutions, with dimension (the first layer) Layer feature dimension ×No. Layer feature dimension Because of its lightweight structure, the convolution kernel uses a 1×1 size, reducing the total number of parameters and computational load, making it suitable for the onboard computing power of UAVs. Its function is to perform linear transformation on the features after aggregating neighborhood information. Representing the The bias vector of the convolutional layer, with dimension equal to the first convolutional layer. Layer feature dimension Consistency is a learnable parameter used to adjust the feature offset and correct the feature deviation after linear transformation.

[0067] The order of operations is to first normalize the adjacency matrix with self-loops. This yields the normalized adjacency matrix; then it is compared with the original node feature matrix. Perform matrix multiplication to aggregate neighborhood features; then combine with the convolution kernel. Perform matrix multiplication to complete the eigenlinear transformation; finally, add a bias. It completes feature optimization before local neighborhood information aggregation and nonlinear transformation, and outputs the optimized feature matrix. .

[0068] Based on the optimized feature matrix A pooled scoring matrix is ​​generated through a fully connected layer. The specific expression is as follows:

[0069]

[0070] in, For the first Layered pooling scoring matrix, with dimension (the first layer) Number of layer nodes ×No. Number of layers exceeding the number of points ), matrix elements Representing the Layer node i is assigned to the first The original propensity score of layer superpoint j has no probabilistic significance and only provides a basic value for subsequent normalization; The learnable weights of the fully connected layer are of dimension (the first dimension is 1). Layer feature dimension ×No. Number of layers exceeding the number of points ), used to optimize features From the feature dimension Mapping to superpoint allocation dimension Establish the association between features and superpoints.

[0071] For the bias vector of the fully connected layer, the dimension is the same as that of the first layer. Number of layers exceeding the number of points Consistency is a learnable parameter used to correct rating bias and avoid the original tendency ratings being too high or too low overall. For the preset first The number of superpoints per layer is set according to the graph coarsening ratio, and usually satisfies the following requirements. This achieves scale compression of the graph structure. The lightweight graph convolutional network enhances the discriminative power of node features through the above two steps, ensuring that the original bias score accurately reflects the fit between nodes and superpoints, without changing the number of nodes, only optimizing feature representation to support subsequent allocation logic.

[0072] Superpoints are the core product of the graph coarsening process and are the basic building blocks of the next layer of coarse-grained graph. They are high-order aggregated nodes formed by weighted aggregation of multiple nodes in the current layer. Unlike a single original point cloud node, a superpoint integrates the features and neighborhood relationships of its constituent nodes, achieving scale compression and information abstraction of the graph structure. The number of superpoints is... It is the core element for constructing the next layer of coarse-grained graph.

[0073] S12. By normalizing the pooling score matrix row by row, the original bias scores are transformed into a probability distribution, forming a node assignment matrix. The node assignment matrix is ​​then used to perform weighted aggregation on the current layer's node features to generate the node features for the next layer. The expression for the weighted aggregation is:

[0074]

[0075] in, The first node is composed of node features. The node feature matrix of the layer graph. For hierarchical indexes, This is the initial point cloud feature matrix; Indicates the first Layer node assignment matrix, elements of the node assignment matrix Indicates the first Layer nodes Assigned to the Layer Super Point The probability of; Indicates the first Transpose of the node allocation matrix of the layer; Indicates the first The node feature matrix of the layer graph.

[0076] Specifically, this step completes the transfer of node features from the current layer to the next layer through normalization transformation and weighted aggregation. The core is to transform the original propensity score into a quantifiable allocation probability and generate the features of the superpoints in the next layer based on this probability.

[0077] The pooled rating matrix is ​​normalized row by row using the softmax function, which transforms the original bias ratings in each row into a probability distribution. The specific expression is as follows:

[0078]

[0079] In the formula, Assign a matrix to the nodes of the l-th layer. The element, i.e., the first Layer node i is assigned to the first The probability of exceeding point j in layer 1; This indicates that the softmax operation is performed along the matrix row dimension (corresponding to a single node), where j is the superpoint index, and the operation is performed by traversing the first row. All superpoints in the layer (1 to ); Pooling scoring matrix The elements are the original propensity scores from node i to superpoint j. The denominator is... For the first The sum of the original scores of all superpoints corresponding to layer node i after being transformed by an exponential function, where This is a natural exponential function, which amplifies the differences in the original scores while ensuring that the result is positive, thus avoiding the influence of negative scores on probability calculations. This is the index for superpoint traversal, serving the same purpose as j, but only used to distinguish between the summation variable and the result variable; For the first The number of supernodes in each layer determines the range of the summation. The summation operation in the denominator ensures that the sum of elements in each row is 1, satisfying the basic properties of a probability distribution, ultimately forming the node allocation matrix. This ensures that the allocation relationship can be quantified, providing a probabilistic basis for subsequent weighted aggregation.

[0080] Weighted aggregation processing uses matrix multiplication to transfer node features to super-node features, as shown in the following expression:

[0081]

[0082] in, Representing the The node feature matrix of the layer graph has dimensions of , For the first Number of layer nodes For the feature dimension (which remains constant across all levels), each row Corresponding to the The D-dimensional feature vector of layer node i, This is a hierarchical index, starting with a value of 0, representing the initial level. hour, This is the initial point cloud feature matrix, whose elements d is the d-th feature of node i in layer 0 (d is the feature index, traversing from 1 to D, corresponding to coordinate, geometric and other feature dimensions). Representing the The node allocation matrix of the layer has dimensions of , For the first Number of superpoints in the layer, elements Representing the Layer node i is assigned to the first The probability of a layer superpoint j takes values ​​in the range [0,1] and satisfies the following conditions: (Guaranteed by softmax row normalization). for The transpose of the matrix, with dimension Transposed element That is, the j-th row corresponds to the first row. Layer superpoint j, the i-th column corresponds to the first superpoint j. Layer node i's core function is to reverse-map the probability weights at the node level to the supernode level, thus changing the dimension from the number of nodes. Exceeding the limit The transformation provides dimensional adaptation for feature aggregation. Representing the The node feature matrix (supernode feature matrix) of the layer graph has dimensions of Its elements (The d-th dimension feature of the j-th superpoint, where j is the superpoint index and d is the feature index) is obtained through the following element-wise operation:

[0083]

[0084] In the formula, i is the node traversal index, and the traversal index is the 1st node. All nodes in the layer (1 to ); and For the same probability value, the index order changes only due to matrix transpose; For the first The d-th dimension feature of layer node i. This operation represents a certain dimension feature of each supernode, which is the d-th dimension feature. The result of weighted summation of the corresponding dimensional features of all nodes in the layer according to the assigned probability achieves "soft aggregation" of node features. This not only preserves the differences in the contribution of different nodes to the superpoint, but also completes the scale abstraction and compression of features, ensuring that the integrated superpoint features constitute the core information of the node.

[0085] S13. Use the node assignment matrix to coarsen the adjacency matrix of the current layer graph, generating a sparse adjacency matrix for the next layer graph; the expression for graph coarsening is:

[0086]

[0087] in, Indicates the first The adjacency matrix of the layer graph. Indicates the first The sparse adjacency matrix of the layer graph.

[0088] Specifically, this step, based on the node assignment matrix, coarsens the adjacency matrix of the current layer graph, generating a sparse adjacency matrix between superverts in the next layer. This maintains the topological relationships of the graph structure, ensuring that the coarsened graph still reflects the proximity relationships between superverts. The graph coarsening process uses matrix multiplication to pass on the topological relationships between nodes, generating the adjacency matrix between superverts. The specific expression is as follows:

[0089]

[0090] in, The original adjacency matrix of the l-th layer graph has dimensions of . , is a sparse matrix, with elements The value can be 1 or 0. Indicates the first Layer node i and node k have a neighborhood relationship (determined by K-nearest neighbor search). This indicates no neighborhood relationship, where i and k are both node indices. Traversing the ... All nodes in the layer (1 to ), which can be the adjacency matrix of the initial sparse base graph or the intermediate layer adjacency matrix generated in the previous round of coarsening.

[0091] The calculation process consists of two steps: the first step is to calculate... The intermediate correlation matrix is ​​obtained. The specific expression is , Dimensions ,element In the formula, j is the node index, k is the superpoint index, and i is the summation variable (traversing node 1 to k). ), Representing the Layer node j and the first The association weight of the superpoint k in the layer is essentially to transform the neighborhood relationship between nodes into the association strength between the node and the superpoint.

[0092] Second step calculation ,Right now , obtained the Layer adjacency matrix Its dimensions are ,element In the formula, m and n are superpoint indices (traversing from 1 to n). j and i are the summation variables (respectively traversing node 1 to node 1). ), Representing the The association strength between layer superpoint m and superpoint n is such that the larger the value, the closer the neighborhood relationship between the node sets corresponding to the two superpoints.

[0093] The initial dense matrix needs to be binarized into a sparse adjacency matrix. The specific binarization formula is as follows:

[0094]

[0095] in, A preset threshold (which can be set from 0.1 to 0.3, and adjusted according to sparsity requirements and onboard computing power) is used to determine whether there is a neighborhood relationship between superpoints. The larger the value, the stronger the sparsity and the smaller the computational load, but some weakly related topological information may be lost. The binarized first The elements of the sparse adjacency matrix are m and n, which are superpoint indices. A value of 1 indicates that superpoint m and superpoint n have a neighborhood relationship, and 0 indicates no relationship. This maintains the sparsity of the graph structure, adapts to the limitations of onboard computing power, and preserves the core topological relationships between superpoints. These are the elements of the superpoint correlation strength matrix before binarization, i.e., the original correlation strength values ​​obtained in the first step of the operation.

[0096] S14. Construct the next layer graph based on the node characteristics and sparse adjacency matrix of the next layer graph.

[0097] Specifically, this step is the iterative construction of the graph structure, the core of which is the generation of the first graph structure based on S12. Layer node feature matrix and the first layer generated by S13 Layer sparse adjacency matrix, construct the complete first layer Layered graph. Nodes are superverts defined in S11, and edges are formed by a sparse adjacency matrix. Once determined, an element of 1 indicates the existence of an edge between corresponding supervertices, while 0 indicates none. This forms a new graph with the same structure as the previous layer but a coarser scale, providing input for the next round of coarsening.

[0098] S15. Take the next layer graph and its node features as the new current layer input, and repeat steps S11 to S14 a preset number of times to generate a multi-scale graph hierarchy and the corresponding multi-scale node feature set.

[0099] Specifically, this step generates a multi-scale graph hierarchy through iterative iteration. The preset number of iterations, i.e., the number of cascaded differentiable graph pooling units, is set based on the point cloud scale, onboard computing power, and mapping accuracy requirements. Too many iterations can lead to over-coarsening of features and loss of detail, while too few iterations will fail to fully capture global features. During the iteration process, the layer graph and corresponding node features output in each round constitute a link in the multi-scale structure. After the iteration terminates, a complete multi-scale system is formed, specifically as follows: The multi-scale graph hierarchy is... L is the preset number of iterations (i.e., the number of cascaded differentiable graph pooling units), where , For the set of nodes at level l ( At that time, the original point cloud node, (Time is over) For the first Layer binarization of sparse adjacency matrix.

[0100] Multi-scale node feature set is The feature matrices of each layer satisfy a recursive relationship. And each layer of the adjacency matrix satisfies In the formula Binarization, in essence, is based on thresholding. Classifying the elements of the input matrix as 0 / 1 serves the same purpose as the aforementioned binarization formula, but is merely a simplified symbol. For the first Layer binarization of sparse adjacency matrix, For the first Binarize the sparse adjacency matrix at each layer to ensure that the graph structure at each layer is a sparse matrix.

[0101] initial layer This represents the finest scale, corresponding to the local details of the original point cloud. Highest dimension ( , (This represents the total number of nodes in the original point cloud); as the number of iterations increases, the layer scale gradually coarsens, and the number of superpoints gradually decreases. ), The number of superpoints in the Lth layer (the last layer) is used to synchronously compress the feature matrix dimension. Gradually become The feature representation leans more towards global topology and overall relationships. This multi-scale system transmits feature and topological information layer by layer, preparing for subsequent parallel graph convolutions (for each layer). Separate convolutions) and cross-scale feature fusion (aggregating features from each layer) It provides a complete input foundation, ensuring that the model can capture both local details and global relationships.

[0102] In one alternative embodiment, sparse graph convolution operations are performed in parallel on the graph at each scale of the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction, including:

[0103] S21. Obtain the first [item] in the multi-scale graph hierarchy. Node features and sparse adjacency matrix of the layer graph; based on the sparse adjacency matrix, find the node of the first layer. The set of neighboring nodes for each node in the layer graph.

[0104] Specifically, this step provides input data for the graph convolution operation and determines the neighborhood range, obtaining the first... The node features and sparse adjacency matrix of the layer graph both originate from the aforementioned multi-scale graph hierarchy, corresponding to the first layer. The superpoint feature matrix and the binarized sparse adjacency matrix of the layer. Node features are the features of the first layer. The coarsened feature matrix of the layer carries the core information at that scale; the sparse adjacency matrix defines the neighborhood relationships between nodes in that layer, providing a basis for finding the set of neighboring nodes.

[0105] The sparse adjacency matrix is ​​used to find the set of neighboring nodes for each node. Specifically, the logic involves traversing the row elements of the corresponding node in the matrix, and the nodes corresponding to all positions with a value of 1 constitute the set of neighboring nodes for that node. The set of neighboring nodes only contains nodes with direct neighborhood relationships, ensuring that subsequent convolution operations only aggregate valid spatial association information and avoid interference from irrelevant nodes on the features.

[0106] S22, for the first For each node in the layer graph, the node features and corresponding edge features of the nodes in the corresponding neighbor node set are aggregated through spatial graph convolution operation to update the layer graph. The node features of the layer graph; where the expression for the spatial graph convolution operation is:

[0107]

[0108] in, Indicates the first Nodes in the layer graph Updated node features Represents the learnable weight matrix. Represents a node The set of neighboring nodes, and Representing nodes respectively and neighboring nodes The degree normalization coefficient, Indicates the first Neighbor nodes in the layer graph Node characteristics, Indicates the connection node with neighboring nodes Edge characteristics, This represents a multilayer perceptron function used to encode edge features.

[0109] Specifically, this step aggregates neighborhood and edge features through spatial graph convolution operations to update node features. The core is to fuse information from the node itself, its neighbors, and edges, thereby enhancing the spatial expressive power of the features. The formula for spatial graph convolution operations includes... Representing the The updated node features of node i in the layer graph maintain the same dimensionality as before the update, integrating information from neighboring nodes and edges, making them more distinctive than the original features. Represents the learnable weight matrix, with dimensions being the product of the feature dimension and the target feature dimension (usually both are kept consistent to maintain feature dimension stability). Its function is to perform a linear transformation on the aggregated neighborhood information, thereby optimizing features and providing learnable parameters for model training. The set of neighboring nodes of node i represents the set of all nodes that have a neighborhood relationship with node i found in step S21. j is the index of the neighboring node in the set. Traverse all nodes in the set to complete the full coverage of neighborhood information. and and are the degree normalization coefficients for node i and its neighbor node j, respectively, calculated from the self-loop degree of the corresponding node. The self-loop degree is the degree of a node in the self-loop adjacency matrix, which is the sum of the node's own connections and the connections of its neighboring nodes. Let i be the square root of the degree of self-looping at node i. Let be the square root of the degree of node j with self-loops. The reciprocal of the product of the two is used to normalize the aggregated information, balance the feature contributions of nodes with different degrees, and avoid nodes with high degrees from excessively dominating the aggregated results. The original node features of neighbor node j in the l-th layer graph are those that have not been updated by this convolution and serve as the basic data source for neighborhood information aggregation. The edge features representing the edge connecting node i and its neighbor node j can be generated based on the spatial relationship (such as Euclidean distance, included angle) or attribute differences between nodes i and j. They are used to supplement the details of the association between nodes and enrich the dimension of feature expression. This represents a multilayer perceptron function used to encode edge features. It consists of an input layer, hidden layers, and an output layer. The input dimension is consistent with the edge feature dimension, and the output dimension is consistent with the node feature dimension, ensuring that edge features can be directly added and fused with node features. Its core function is to perform nonlinear transformation and dimensional adaptation on the original edge features, thereby enhancing the ability of edge features to represent node associations.

[0110] The entire computation process is executed sequentially as follows: First, edge features are encoded using a multilayer perceptron. The encoded edge features are then added to the original features of neighboring nodes to obtain the fused edge information neighborhood node features. Next, the normalization process is completed by dividing by the square root of the product of the degree normalization coefficients of nodes i and j. The processing results for all neighboring nodes are summed to obtain the aggregated neighborhood information. Finally, the results are combined with the learnable weight matrix. Multiply and output the updated features of node i. .

[0111] S23, regarding the first All nodes in the layer graph execute step S22 in parallel to complete one graph convolution operation, obtaining the first... The intermediate features of the layer diagram are represented.

[0112] Specifically, for the first All nodes in the layer graph execute step S22 in parallel. Parallel computation here refers to simultaneously aggregating and updating the features of the neighbor sets of all nodes in the layer, without processing them sequentially. This design significantly improves the efficiency of convolution operations, adapts to the parallel processing requirements of multi-scale graph structures, and avoids efficiency bottlenecks caused by single-node operations. After one graph convolution operation is completed, the... The features of all nodes in the layer have been updated, resulting in the intermediate feature representation of that layer. This intermediate feature representation has only undergone one neighborhood aggregation and has not yet fully integrated multi-level neighborhood information; it is a transitional feature that provides the foundation for subsequent convolutional optimizations.

[0113] S24, in the Repeatedly perform graph convolution operations a preset number of times on the layer graph to obtain the first layer. Deep feature representation of layer diagrams.

[0114] Specifically, in the The graph convolution operation is repeatedly performed a preset number of times on the layer graph. The preset number of times is set according to the feature abstraction requirements and computing power limitations, and can be 2-4 times. The core of multiple convolution operations is to achieve multi-order neighborhood information aggregation. The first convolution aggregates the information of the direct neighbors (1st order neighbors), the second convolution aggregates the information of the neighbors of the direct neighbors (2nd order neighbors), and so on. The more times it is performed, the wider the range of aggregated neighbors becomes, and the more the features are biased towards global abstract relationships. During the repeated convolution process, the updated features are used as the input for the next convolution, and the weight matrix... With multilayer perceptron The parameters are iteratively optimized synchronously during training to ensure the rationality of feature aggregation. After a preset number of iterations, the result is obtained. The deep feature representation of the layer graph not only retains the core information at this scale, but also integrates multi-level neighborhood associations, thus possessing stronger semantic expressive power.

[0115] S25. Perform steps S21 to S24 in parallel on all layers in the multi-scale graph hierarchy to generate multi-scale deep feature representations.

[0116] Specifically, steps S21 to S24 are executed in parallel on all layers in the multi-scale graph hierarchy, ranging from the finest to the coarsest scale. The convolution operations of each layer are independent, allowing other layers to start their operations without waiting for one layer to complete, maximizing computational resources and improving overall feature extraction efficiency. After all layers complete a preset number of graph convolution operations, a multi-scale deep feature representation is generated. This representation is a set of deep features at different scales. Fine-scale features focus on local geometric details, while coarse-scale features focus on global topological relationships. These complementary features provide comprehensive feature support for subsequent cross-scale feature fusion and final mapping tasks (such as feature identification and terrain modeling).

[0117] In one optional embodiment, the construction of edge features in spatial graph convolution operations includes the following steps:

[0118] S31. In a multi-scale graph hierarchy, for the currently updated node and one of its neighboring nodes, obtain the three-dimensional coordinates of the currently updated node and the three-dimensional coordinates of the neighboring node.

[0119] Specifically, this step involves acquiring basic data for edge feature construction, the core of which is extracting the 3D coordinates of a pair of related nodes. The node currently being updated corresponds to the node whose feature is to be updated in the S22 spatial graph convolution, i.e., node i in the previous formula; its neighboring node is any node in the set of neighboring nodes of this node, corresponding to node j in the previous formula. Both come from the currently processed first node in the multi-scale graph hierarchy. Layer diagram. The source of 3D coordinates matches the layer scale: for the initial layer (the finest scale), the coordinates are directly taken from the 3D spatial coordinates of the original point cloud; for the coarsening layer (a layer composed of superpoints), the coordinates are the average of the 3D coordinates of the aggregate nodes corresponding to the superpoints, that is, obtained by weighted averaging of the 3D coordinates of all the upper-layer nodes contained in the superpoint, ensuring that the edge features of the coarsening layer can still reflect the real spatial relationships. The obtained 3D coordinates must correspond to the node features of the graph convolution operation to maintain the consistency of spatial information.

[0120] S32. Calculate the coordinate difference vector between the currently updated node and its neighboring nodes, and calculate the Euclidean distance between the currently updated node and its neighboring nodes.

[0121] Specifically, this step generates two types of core spatial information through coordinate operations, providing basic vectors and values ​​for edge feature concatenation. First, the coordinate difference vector is calculated. Taking the currently updated node as the reference, its three-dimensional coordinates are subtracted from the three-dimensional coordinates of its neighboring nodes to obtain the differences in the corresponding three dimensions, forming a three-dimensional difference vector.

[0122] Let the three-dimensional coordinates of the node i currently being updated be... The three-dimensional coordinates of neighbor node j are Then the coordinate difference vector for This vector not only reflects the relative positions of two points in each spatial dimension (positive direction means node i is in front of / above / to the right of node j in the corresponding dimension, negative direction means the opposite), but also reflects the relative offset magnitude, making it a core representation of spatial relative position. The Euclidean distance is calculated based on the aforementioned coordinate difference vector, taking its L2 norm, specifically... ,in Let be the Euclidean distance between node i and node j, representing the linear spatial distance between the two points. The larger the value, the farther apart the two points are in space. It is a key indicator for describing the degree of spatial connection between the two points.

[0123] S33. Concatenate the coordinate difference vector and the Euclidean distance into a new vector, which serves as the edge feature connecting the currently updated node with its neighboring nodes; whereby the edge feature is used to describe the spatial relative relationship between the two points.

[0124] Specifically, this step generates the final edge features through vector concatenation, achieving the fusion of spatial relative position and distance information. The concatenation method is sequential, combining the three-dimensional coordinate difference vector with the one-dimensional Euclidean distance in turn to form a four-dimensional edge feature vector, i.e., the edge features. The specific form is ,in , , These are the components of the coordinate difference vector in the x, y, and z dimensions, respectively. The distance is Euclidean. The concatenated edge feature vector simultaneously encompasses both relative position and absolute distance spatial information, comprehensively describing the spatial relationship between node i and node j—clearly indicating the orientational differences between the two points and reflecting their distance, providing rich and semantic input for the multilayer perceptron used in the edge feature encoding in the previous section. This edge feature has a fixed four-dimensional dimension, unaffected by layer scale, ensuring a consistent input dimension for subsequent multilayer perceptrons. This eliminates the need to adjust the model structure with each coarsening level, adapting to the requirements of multi-scale parallel convolution, and ensuring consistent representation logic for edge features across different scale layers, facilitating information alignment during cross-scale feature fusion.

[0125] In one optional embodiment, the multi-scale deep feature representation is input into the cross-scale attention fusion unit, the attention weights between features of different scales are calculated, and the features of different scales are weighted and fused according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that fuse local details and global context, including the following steps:

[0126] S41. Use the coarsest scale feature in the multi-scale deep feature representation as the query vector; concatenate the deep feature representations of all scales in the multi-scale deep feature table to obtain the concatenated features, and project the concatenated features into key vectors and value vectors respectively.

[0127] Specifically, this step prepares the core vectors for attention computation. Through feature selection, concatenation, and projection, it constructs the three types of vectors required by the attention mechanism: query, key, and value, laying the foundation for cross-scale fusion. The coarsest-scale feature is taken from the highest-level layer feature in the aforementioned multi-scale deep feature representation. This scale feature, after multiple rounds of coarsening and convolution, best reflects the global topology and overall contextual relationships, making it suitable as the benchmark for attention queries. It is then used as the query vector. The dimension is the product of the number of nodes at the coarsest scale and the feature dimension. The dimension is then unified through linear projection to ensure compatibility with the key vector. The logic for constructing the concatenated features is to sequentially concatenate deep features at all scales in the multi-scale deep feature representation according to the node dimension, covering all feature information from the finest to the coarsest, preserving both local details and global correlations.

[0128] Let the multi-scale deep features be represented as ( (For the coarsest scale level), then the splicing features The expression is:

[0129]

[0130] in, This is a vector concatenation function that merges features from different layers along the node dimension, allowing the concatenated features to simultaneously carry information from different levels of abstraction. The concatenated features are then passed through two independent linear projection layers to generate key vectors. Sum value vector The projection process is expressed as follows:

[0131]

[0132]

[0133] in, and These are the learnable projective weight matrices for the key vector and the value vector, respectively, with the dimension being the product of the concatenated feature dimension and the target dimension (the target dimension is the same as the dimension after the query vector is projected). and These are the bias vectors for the corresponding projection layers, with dimensions consistent with the target dimension. The core function of projection is to unify the dimensions of the three types of vectors, ensuring that attention calculations can be performed correctly, while optimizing feature representation through learnable parameters.

[0134] S42. Calculate the attention weight matrix between the query vector and the key vector, where the attention weight matrix is ​​used to represent the correlation strength between the coarsest scale feature and all scale features in the multi-scale deep feature representation.

[0135] Specifically, this step generates an attention weight matrix by calculating the similarity between the query vector and the key vector, quantifying the association strength between the coarsest-scale feature and features at all scales. The attention weight matrix is ​​calculated using a scaled dot product attention mechanism, with the specific expression as follows:

[0136]

[0137] in, This is the attention weight matrix, with dimensions equal to the product of the number of nodes at the coarsest scale and the total number of concatenated feature nodes. The matrix elements... Represents the coarsest scale. Among the node features and splicing features, the first... The association strength of each node feature takes values ​​in the range [0,1], and the sum of the elements in each row is 1, satisfying the probability distribution characteristics. This is the projected query vector. Let be the transpose of the key vectors. Matrix multiplication of these two vectors calculates the similarity between pairwise features; higher similarity indicates a stronger association between the corresponding features. The denominator is... Scaling factor The dimension of the key vector is used to mitigate the vanishing gradient problem of the Softmax function caused by excessively large similarity values ​​under high-dimensional features, ensuring the rationality of weight allocation. The Softmax function normalizes the similarity results row by row, making the sum of the weights in each row equal to 1, strengthening the weight proportion of strongly correlated features and weakening the influence of non-correlated features. The final attention weight matrix accurately characterizes the correlation between global context features and features at each scale, providing a quantitative basis for subsequent weighted fusion.

[0138] S43. Use the attention weight matrix to perform a weighted summation of the value vectors to generate the fused global context features.

[0139] Specifically, this step involves weighted summation of the value vectors based on the attention weight matrix, fusing features at different scales according to their correlation strength to generate global contextual features that combine global and local information. The specific expression for the weighted summation is as follows:

[0140]

[0141] in, The fused global context features have the same dimensions as the query vector (number of nodes at the coarsest scale × target feature dimension), and each element is the result of a weighted sum of the corresponding elements of the value vector according to attention weights. Value vector The attention weight matrix carries feature information at all scales. Differential weights are then assigned to these features—features with high correlation strength are given larger weights and dominate the fusion result; features with low correlation strength have smaller weights to reduce interference with the fusion result.

[0142] The essence of this process is to use global context features as a benchmark, selectively aggregate closely related feature information from various scales, and achieve the organic integration of global context and local details, so that the fused features have both global control capabilities and can accurately capture key local details.

[0143] S44. Input the global context features into the fully connected layer for processing, and output the semantic category label and geometric parameters of each point in the original point cloud data to form the point cloud semantic segmentation and geometric parameter prediction results.

[0144] Specifically, this step processes the fused global context features through a fully connected layer to map the features to the prediction results, outputting the final point cloud semantic segmentation and geometric parameter prediction results. The fully connected layer adopts a multi-layer stacked structure, and the specific process is as follows: first, the first two fully connected layers perform non-linear transformation and dimensional adjustment on the global context features to enhance the semantic expressive power of the features; finally, the prediction results are output through the output layer, and the dimension of the output layer is set according to the prediction task.

[0145] Semantic category labels are used to annotate the land cover category (such as road, building, vegetation, etc.) to which each point in the original point cloud data belongs. The probability value is output by the corresponding category neuron in the output layer, and the final category is determined by the .argmax function. Geometric parameters are used to describe the spatial geometric attributes of the point cloud target (such as size, position, pose, etc.). The output layer directly outputs continuous values, and the prediction accuracy is optimized by regression task.

[0146] The final output covers every point in the original point cloud data, including both semantic segmentation category information and geometric parameter quantization information, achieving a complete mapping from multi-scale features to prediction results, and meeting the core task requirements of point cloud processing.

[0147] The aforementioned high-precision mapping and control method for UAVs acquires point cloud data and constructs an initial feature matrix containing geometric information. It then performs a single K-nearest neighbor search based on coordinates to build a sparse base graph to fix the underlying topology. Next, it utilizes differentiable graph pooling units to perform learnable hierarchical pooling and coarsening on this base graph, generating a multi-scale graph structure to simulate the dynamic receptive field. Subsequently, sparse graph convolution is performed in parallel on these graphs of different scales to efficiently extract multi-scale features. These features are then fused through a cross-scale attention mechanism to capture information from local details to global context. Finally, the obtained segmentation and parameter results are parsed to generate control commands. This method achieves coordinated optimization of high-precision real-time point cloud understanding and UAV autonomous control decision-making while avoiding the major computational bottleneck of repeated layer-by-layer graph construction.

[0148] It should be understood that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0149] Based on the same inventive concept, this application also provides an apparatus for implementing the aforementioned high-precision mapping and control method for unmanned aerial vehicles (UAVs). The solution provided by this apparatus is similar to the implementation described in the above method; therefore, the specific limitations in one or more embodiments of the high-precision mapping and control apparatus for UAVs provided below can be found in the limitations of the high-precision mapping and control method for UAVs described above, and will not be repeated here.

[0150] In one exemplary embodiment, such as Figure 3 As shown, a high-precision mapping and control device 30 for unmanned aerial vehicles (UAVs) is provided to implement the methods in the above-described method embodiments. The device includes:

[0151] The point cloud feature initialization module 31 is used to acquire the raw point cloud data collected by the UAV LiDAR sensor and construct an initial point cloud feature matrix including coordinate features and geometric features by performing geometric feature calculations on the raw point cloud data.

[0152] The sparse graph construction module 32 is used to perform a K-nearest neighbor search based on the coordinate features in the initial point cloud feature matrix to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud.

[0153] The multi-scale graph processing module 33 is used to pool and coarsen the sparse base graph using the initial point cloud feature matrix as the initial node features and through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set. Among them, the differentiable graph pooling unit aggregates and coarsens the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer.

[0154] The deep feature extraction module 34 is used to take the multi-scale node feature set as input and perform sparse graph convolution operation in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction.

[0155] The cross-scale fusion module 35 is used to input multi-scale deep feature representations into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context.

[0156] The intelligent control decision module 36 is used to obtain the analysis results, including terrain model, ground feature vector information and UAV operation status, by analyzing the semantic segmentation and geometric parameter prediction results of point cloud; generate control commands for controlling the subsequent flight trajectory and scanning behavior of UAV based on the analysis results, and control UAV to perform corresponding operations according to the control commands.

[0157] Embodiments of this application also provide a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps in the aforementioned method embodiments.

[0158] Embodiments of this application also provide a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps in the above-described method embodiments.

[0159] For the device embodiments, since they basically correspond to the method embodiments, the relevant parts can be referred to in the description of the method embodiments. The device embodiments described above are merely illustrative. The components described as separate parts may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this disclosure according to actual needs. Those skilled in the art can understand and implement this without creative effort.

[0160] The above-described embodiments are merely illustrative of several implementation methods of the embodiments of this application, and their descriptions are relatively specific and detailed. However, they should not be construed as limiting the scope of the patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the embodiments of this application, and these modifications and improvements all fall within the protection scope of the embodiments of this application.

Claims

1. A high-precision mapping and control method for unmanned aerial vehicles (UAVs), characterized in that, The method includes: S1. Acquire raw point cloud data collected by the UAV LiDAR sensor, and construct an initial point cloud feature matrix including coordinate features and geometric features by performing geometric feature calculation on the raw point cloud data. S2. Based on the coordinate features in the initial point cloud feature matrix, perform a K-nearest neighbor search to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud. S3. Using the initial point cloud feature matrix as the initial node features, the sparse base graph is pooled and coarsened through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set; wherein, the differentiable graph pooling unit aggregates and coarsens the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer. S4. Using the multi-scale node feature set as input, perform sparse graph convolution operations in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction. S5. Input the multi-scale deep feature representation into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context. S6. By parsing the point cloud semantic segmentation and geometric parameter prediction results, the parsing results including terrain model, ground feature vector information and UAV operation status are obtained; control commands for controlling the subsequent flight trajectory and scanning behavior of the UAV are generated according to the parsing results, and the UAV is controlled to perform corresponding operations according to the control commands.

2. The method according to claim 1, characterized in that, The sparse base graph is pooled and coarsened by cascading multiple differentiable graph pooling units to generate a multi-scale graph hierarchy from fine to coarse and a corresponding multi-scale node feature set, including: S11. For the current layer graph and its node features, the node features are processed by a lightweight graph convolutional network to generate a pooling score matrix that represents the original tendency score of each node assigned to each superpoint in the next layer; wherein, the superpoint is a high-order aggregated node in the graph hierarchy formed by weighted aggregation of multiple nodes in the previous layer graph, which is the product of the graph coarsening process and also the basic building block for constructing the next layer coarse-grained graph; S12. By normalizing the pooling score matrix row by row, the original bias score is transformed into a probability distribution, forming a node allocation matrix; the node allocation matrix is ​​used to perform weighted aggregation processing on the node features of the current layer to generate the node features of the next layer graph; wherein, the expression for the weighted aggregation processing is: in, The first node is composed of the node features. The node feature matrix of the layer graph. For hierarchical indexes, The initial point cloud feature matrix; Indicates the first The node allocation matrix of the layer, the elements of the node allocation matrix Indicates the first Layer nodes Assigned to the Layer Super Point The probability of; Indicates the first The transpose of the node allocation matrix of the layer; Indicates the first The node feature matrix of the layer graph; S13. Using the node allocation matrix, perform graph coarsening on the adjacency matrix of the current layer graph to generate a sparse adjacency matrix for the next layer graph; wherein, the expression for the graph coarsening is: in, Indicates the first The adjacency matrix of the layer graph, Indicates the first The sparse adjacency matrix of the layer graph; S14. Construct the next layer graph based on the node characteristics and the sparse adjacency matrix of the next layer graph; S15. Take the next layer graph and its node features as the new current layer input, and repeat steps S11 to S14 a preset number of times to generate the multi-scale graph hierarchy and the corresponding multi-scale node feature set.

3. The method according to claim 2, characterized in that, The sparse graph convolution operation is performed in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction, including: S21. Obtain the first [scale] in the multi-scale graph hierarchy. The node features of the layer graph and the sparse adjacency matrix; based on the sparse adjacency matrix, find the first... The set of neighboring nodes for each node in the layer graph; S22, for the first For each node in the layer graph, the node features and corresponding edge features of the nodes in the corresponding set of neighboring nodes are aggregated through spatial graph convolution operation to update the layer graph. The node features of the layer graph; wherein, the expression for the spatial graph convolution operation is: in, Indicates the first Nodes in the layer graph The updated node features, Represents the learnable weight matrix. Represents a node The set of neighboring nodes, and Representing nodes respectively and neighboring nodes The degree normalization coefficient, Indicates the first Neighbor nodes in the layer graph Node characteristics, Indicates the connection node with neighboring nodes Edge characteristics, This represents a multilayer perceptron function used to encode edge features; S23, regarding the first All nodes in the layer graph execute step S22 in parallel to complete one graph convolution operation, obtaining the first... The intermediate features of the layer diagram are represented; S24, in the first Repeatedly perform graph convolution operations a preset number of times on the layer graph to obtain the first... Deep feature representation of layer diagrams; S25. Steps S21 to S24 are executed in parallel on all layers in the multi-scale graph hierarchy to generate the multi-scale deep feature representation.

4. The method according to claim 3, characterized in that, The construction methods of the edge features in the spatial graph convolution operation include: S31. In the multi-scale graph hierarchy, for the currently updated node and one of its neighboring nodes, obtain the three-dimensional coordinates of the currently updated node and the three-dimensional coordinates of the neighboring node. S32. Calculate the coordinate difference vector between the currently updated node and the neighboring node, and calculate the Euclidean distance between the currently updated node and the neighboring node. S33. Concatenate the coordinate difference vector and the Euclidean distance into a new vector, which serves as the edge feature connecting the currently updated node and the neighboring node; wherein the edge feature is used to describe the spatial relative relationship between the two points.

5. The method according to any one of claims 1 to 4, characterized in that, The process involves inputting the multi-scale deep feature representation into a cross-scale attention fusion unit, calculating attention weights between features of different scales, and performing weighted fusion of features of different scales based on the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context. S41. Use the coarsest scale feature in the multi-scale deep feature representation as the query vector; concatenate the deep feature representations of all scales in the multi-scale deep feature table to obtain the concatenated features, and project the concatenated features into key vectors and value vectors respectively. S42. Calculate the attention weight matrix between the query vector and the key vector, wherein the attention weight matrix is ​​used to represent the correlation strength between the coarsest scale feature and all scale features in the multi-scale deep feature representation; S43. Use the attention weight matrix to perform a weighted summation on the value vector to generate the fused global context features; S44. The global context features are input into a fully connected layer for processing, and the semantic category label and geometric parameters of each point in the original point cloud data are output to form the point cloud semantic segmentation and geometric parameter prediction results.

6. A high-precision mapping and control device for unmanned aerial vehicles (UAVs), used to implement the method according to any one of claims 1 to 5, characterized in that, The device includes: The point cloud feature initialization module is used to acquire raw point cloud data collected by the UAV LiDAR sensor and construct an initial point cloud feature matrix including coordinate features and geometric features by performing geometric feature calculations on the raw point cloud data. The sparse graph construction module is used to perform a K-nearest neighbor search based on the coordinate features in the initial point cloud feature matrix to construct a sparse base graph that reflects the initial physical proximity relationship of the point cloud. The multi-scale graph processing module is used to use the initial point cloud feature matrix as the initial node features, and to perform pooling and coarsening processing on the sparse base graph through multiple cascaded differentiable graph pooling units to generate a multi-scale graph hierarchy structure from fine to coarse and a corresponding multi-scale node feature set; wherein, the differentiable graph pooling unit aggregates and coarsens the graph structure and node features of the current layer through a learnable node allocation matrix to generate a coarser graph in the next layer. The deep feature extraction module is used to take the multi-scale node feature set as input and perform sparse graph convolution operation in parallel on the graph at each scale in the multi-scale graph hierarchy to extract multi-scale deep feature representations at different levels of abstraction. The cross-scale fusion module is used to input the multi-scale deep feature representation into the cross-scale attention fusion unit, calculate the attention weights between features of different scales, and perform weighted fusion of features of different scales according to the attention weights to generate point cloud semantic segmentation and geometric parameter prediction results that integrate local details and global context. The intelligent control decision module is used to obtain analysis results including terrain model, ground feature vector information, and UAV operation status by analyzing the point cloud semantic segmentation and geometric parameter prediction results; generate control commands for controlling the subsequent flight trajectory and scanning behavior of the UAV based on the analysis results, and control the UAV to perform corresponding operations according to the control commands.

7. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the method of any one of claims 1 to 5.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method of any one of claims 1 to 5.

Images