A visualization method for adaptive combat scene generation

Abstract

The present invention relates to the technical field of combat scene visualization generation, and specifically to a method for adaptive combat scene visualization generation, comprising the following steps: S1, based on the modeling of the combat area, a mesh simplification algorithm is used to process the area, and by calling the polygonal mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygonal patches are merged to generate a rough model. The present invention uses a mesh simplification algorithm to process the combat area, delete redundant vertices and edges, merge adjacent polygonal patches, and improve computing efficiency and processing speed. Subdivision surface technology is called to interpolate and redistribute the initial model, thereby enhancing details and precision and improving the realism of the scene. A Laplace smoothing algorithm is used to further optimize the model, adjust vertex positions, eliminate sharp corners and noise, and improve visual effects and accuracy.

Description

Technical Field

[0001] The present invention relates to the technical field of combat scene visualization generation, and in particular to a method for adaptive combat scene visualization generation. Background Art

[0002] The field of combat scenario visualization technology focuses on the research and development of technologies for simulating and displaying battlefield environments, troop deployments, combat operations, and other scenarios during military operations. This technology utilizes advanced technologies such as computer graphics, virtual reality (VR), augmented reality (AR), and artificial intelligence (AI) to generate realistic three-dimensional battlefield images and dynamic scenes to assist commanders in tactical planning, combat simulations, training, and exercises. Through visualization technology, complex battlefield information can be more intuitively displayed, improving the accuracy and efficiency of command decisions, and enhancing training effectiveness and combat readiness.

[0003] The primary purpose of combat scenario visualization is to automatically adjust and generate battlefield visualizations tailored to actual combat needs through intelligent algorithms and dynamic data input. This approach generates accurate and timely battlefield images based on real-time battlefield data and environmental changes, supporting commanders' immediate decision-making and tactical adjustments, thereby enhancing operational flexibility and adaptability. This method has significant application value in military training, tactical exercises, and actual combat.

[0004] However, existing technologies have some shortcomings in actual operation. The display of complex battlefield information is not intuitive enough, making it difficult to effectively convey the overall situation and detailed changes, affecting the accuracy and efficiency of command decisions. The model lacks accuracy and detail, and the generated battlefield images and dynamic scenes lack realism, affecting training effectiveness and combat readiness. The processing speed is slow, and it is unable to generate updated battlefield images based on real-time battlefield data and environmental changes in a timely manner, limiting combat flexibility and adaptability. These shortcomings have adverse effects on both military training and actual combat. For example, in training, complex combat scenarios cannot be effectively simulated, affecting the quality of soldiers' training; in actual combat, the inability to update battlefield information in a timely manner may lead to delayed command decisions and affect combat effectiveness. Summary of the Invention

[0005] The purpose of the present invention is to solve the shortcomings of the prior art and to propose a visualization generation method for adaptive combat scenarios.

[0006] To achieve the above objectives, the present invention adopts the following technical solution: a method for generating a visualization of an adaptive combat scenario, comprising the following steps:

[0007] S1, based on the modeling of the combat area, uses the mesh simplification algorithm to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygon patches are merged to generate a rough model;

[0008] S2, performing refinement processing based on the rough model, interpolating and redistributing the vertices and edges of the initial model by calling subdivision surface technology, increasing the number of vertices and edges of the model, forming a polygonal mesh structure, and obtaining a refined model;

[0009] S3, performing optimization processing based on the refined model, by calling the Laplace smoothing algorithm to iteratively adjust the model vertices, calculate the positions of the neighboring vertices of each vertex, move the vertex position to the average position of its neighboring vertices, eliminate sharp corners and noise in the mesh, and obtain an optimized model;

[0010] S4, based on the optimized model, performs cross-domain knowledge transfer, calls pre-trained models and fine-tuning technology, loads the weights of the pre-trained model into the new model architecture, uses combat scenario data for fine-tuning training, adjusts the model parameters to match the new task, and obtains the transferred model;

[0011] S5, based on the migration model, performs sparse matrix decomposition, constructs a sparse matrix to represent the combat scenario data, decomposes the sparse matrix into a basic feature matrix and a combination weight matrix through non-negative matrix decomposition technology, optimizes the computational complexity, and uses the decomposed sparse matrix to reconstruct the combat scenario data with key features to obtain reconstructed scenario data.

[0012] Preferably, the rough model includes simplified vertex data, simplified edge data and merged polygonal patches, the refined model includes added vertex data, added edge data and refined polygonal patches, and the optimized model includes smoothed vertex data, adjusted edge data and optimized polygonal patches.

[0013] Preferably, based on the modeling of the combat area, a mesh simplification algorithm is used to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygonal patches are merged. The steps to generate a rough model are as follows:

[0014] S101, based on the modeling of the combat area, detect and delete redundant vertex and edge data. By scanning the polygon mesh data, redundant vertices and redundant edges are identified and deleted to obtain simplified polygon data;

[0015] S102, merging adjacent polygonal patches based on the simplified polygonal data, identifying merging patches by analyzing geometric characteristics of the adjacent patches, and performing merging processing to obtain optimized polygonal patches;

[0016] S103, performing geometric shape adjustment and refinement processing based on the optimized polygonal facets, performing geometric transformation and shape optimization on the facets, adjusting irregular shapes and performing refinement processing, and generating a rough model.

[0017] Preferably, based on the rough model, refinement processing is performed by calling subdivision surface technology to interpolate and redistribute the vertices and edges of the initial model, thereby increasing the number of vertices and edges of the model to form a polygonal mesh structure. The specific steps of obtaining the refined model are as follows:

[0018] S201, interpolating and redistributing vertices and edges based on the rough model, using an interpolation method to determine the positions of newly added vertices, evenly distributing the new vertices, and reconnecting the edges to generate an interpolation model;

[0019] S202, based on the interpolation model, applying subdivision surface technology to determine the positions of the subdivided vertices, forming a smooth surface by inserting new vertices and adjusting the positions of the original vertices, and performing multiple iterations to generate a subdivision surface model;

[0020] S203 , constructing a polygonal mesh structure based on the subdivision surface model, optimizing the distribution of vertices and edges, and ensuring the uniformity and stability of the mesh structure by redefining the positions of the vertices and edges of the polygons, thereby generating a refined model.

[0021] Preferably, based on the refined model, optimization processing is performed by calling the Laplace smoothing algorithm to iteratively adjust the model vertices, calculate the position of each vertex's neighboring vertices, move the vertex position to the average position of its neighboring vertices, eliminate sharp corners and noise in the mesh, and obtain the optimized model in the following steps:

[0022] S301, based on the refined model, calculating the positions of neighboring vertices of each vertex, performing initial adjustment of the vertex positions, moving each vertex to the average position of the neighboring vertices, eliminating sharp corners and noise in the mesh, and obtaining an initial vertex adjustment result;

[0023] S302, based on the initial vertex adjustment result, recalculate the neighboring vertex positions of each vertex, perform vertex position adjustment, move each vertex again to the average position of the neighboring vertices, optimize noise and irregularities in the mesh, and obtain an intermediate vertex adjustment result;

[0024] S303: Based on the intermediate vertex adjustment result, calculate the neighboring vertex positions of each vertex, perform final vertex position adjustment, move the vertex position to the average position of its neighboring vertices, and obtain an optimized model.

[0025] Preferably, based on the optimization model, cross-domain knowledge transfer is performed, pre-trained models and fine-tuning techniques are called, the weights of the pre-trained models are loaded into the new model architecture, and fine-tuning training is performed using combat scenario data. The parameters of the model are adjusted to match the new task. The specific steps for obtaining the migration model are as follows:

[0026] S401, based on the optimization model, load the pre-trained model weights, import the weight parameters of the pre-trained model, check the parameter matching, and make necessary adjustments to ensure that the weight parameters are correctly applied to the new model architecture, thereby obtaining the loaded weight model;

[0027] S402, based on the loaded weight model, fine-tuning training of combat scenario data is performed, by inputting combat scenario data, setting training batches and learning rates, training the model multiple times iteratively, adjusting model parameters to match new tasks, and verifying the training results to obtain a fine-tuned model;

[0028] S403, based on the fine-tuning model, optimize and verify the model parameters, adjust the model parameters, set a variety of validation sets for testing, record the performance of the model in the new task, record multiple parameters and performance indicators, and obtain the migration model.

[0029] Preferably, based on the migration model, sparse matrix decomposition is performed to construct a sparse matrix to represent the combat scenario data. The sparse matrix is ​​decomposed into a basic feature matrix and a combination weight matrix by non-negative matrix decomposition technology, and the computational complexity is optimized. The decomposed sparse matrix is ​​used to reconstruct the combat scenario data with key features. The steps of obtaining the reconstructed scenario data are specifically as follows:

[0030] S501, based on the migration model, performing sparse matrix decomposition, converting the combat scenario data into a sparse matrix using a block processing method, dividing the data into multiple small blocks, calculating the data density of each block, and constructing a sparse matrix to obtain a sparse matrix representation;

[0031] S502, performing matrix decomposition based on the sparse matrix representation, determining the positions of the basic feature matrix and the combination weight matrix by element-by-element updating, repeatedly adjusting element values ​​to allow the matrices to converge, and performing matrix reorganization to obtain the basic feature matrix and the combination weight matrix;

[0032] S503, based on the basic feature matrix and the combination weight matrix, a sparse matrix reconstruction process is performed, the basic feature matrix and the combination weight matrix are multiplied element by element using a matrix recombination method, and the reconstructed matrix is ​​obtained by repeatedly adjusting the combination to obtain the reconstructed scene data.

[0033] Preferably, the migration model includes loaded pre-trained weights, adjusted parameter configuration and adapted new task structure, and the reconstructed scene data includes basic feature matrix, combined weight matrix and key feature data.

[0034] Compared with the prior art, the advantages and positive effects of the present invention are:

[0035] This invention utilizes a mesh simplification algorithm to process the combat area, removing redundant vertices and edges and merging adjacent polygonal patches, improving computational efficiency and processing speed. Subdivision surface technology is used to interpolate and reallocate the initial model, enhancing detail and precision, and enhancing scene realism. A Laplace smoothing algorithm further optimizes the model, adjusting vertex positions, eliminating sharp corners and noise, and improving visual quality and accuracy. Pre-trained models and fine-tuning techniques are used to transfer cross-domain knowledge and adjust model parameters to suit new tasks, enhancing adaptability. Non-negative matrix factorization technology constructs and decomposes sparse matrices, optimizing computational complexity and ensuring the accuracy and integrity of scene data. These innovative processing logic and technical approaches enable this invention to utilize a mesh simplification algorithm to process the combat area, removing redundant vertices and edges and merging adjacent polygonal patches, improving computational efficiency and processing speed. Subdivision surface technology is used to interpolate and reallocate the initial model, enhancing detail and precision, and enhancing scene realism. A Laplace smoothing algorithm further optimizes the model, adjusting vertex positions, eliminating sharp corners and noise, and improving visual quality and accuracy. Through pre-training models and fine-tuning techniques, cross-domain knowledge transfer is performed, model parameters are adjusted to match new tasks, and adaptability is enhanced. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] Figure 1 Schematic diagram of the steps of the present invention. DETAILED DESCRIPTION

[0037] In order to make the purpose, technical solutions and advantages of the present invention more clearly understood, the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention.

[0038] In the description of the present invention, it should be understood that the terms length, width, up, down, front, back, left, right, vertical, horizontal, top, bottom, inside, outside, etc., indicating positions or location relationships, are based on the positions or location relationships shown in the accompanying drawings and are intended only to facilitate the description of the present invention and simplify the description. They do not indicate or imply that the devices or components referred to must have a specific orientation, be constructed or operate in a specific orientation, and therefore should not be construed as limiting the present invention. In addition, in the description of the present invention, the term "a plurality" means two or more, unless otherwise specifically defined.

[0039] Example 1

[0040] See also Figure 1 The present invention provides a technical solution, a method for generating visualization of an adaptive combat scene, comprising the following steps:

[0041] S1, based on the modeling of the combat area, uses the mesh simplification algorithm to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygon patches are merged to generate a rough model;

[0042] S2, based on the rough model, performs refinement processing by calling the subdivision surface technology to interpolate and redistribute the vertices and edges of the initial model, increase the number of vertices and edges of the model, form a polygonal mesh structure, and obtain a refined model;

[0043] S3, based on the refined model, performs optimization processing by calling the Laplace smoothing algorithm to iteratively adjust the model vertices, calculate the position of each vertex's neighboring vertices, move the vertex position to the average position of its neighboring vertices, eliminate sharp corners and noise in the mesh, and obtain the optimized model;

[0044] S4, based on the optimized model, performs cross-domain knowledge transfer, calls the pre-trained model and fine-tuning technology, loads the weights of the pre-trained model into the new model architecture, uses combat scenario data for fine-tuning training, adjusts the model parameters to match the new task, and obtains the transferred model;

[0045] S5, based on the migration model, performs sparse matrix decomposition and constructs a sparse matrix to represent the combat scenario data. Through the non-negative matrix decomposition technology, the sparse matrix is ​​decomposed into a basic feature matrix and a combination weight matrix, the computational complexity is optimized, and the decomposed sparse matrix is ​​used to reconstruct the combat scenario data with key features to obtain the reconstructed scenario data.

[0046] In step S1, the area is processed using a mesh simplification algorithm based on modeling of the combat area, and the polygonal mesh parameters of the combat area are called to simplify and adjust the geometric shape. In the specific implementation process, the polygonal mesh parameters of the combat area are first read, including vertex, edge and patch data. Then, by deleting redundant vertices and edges of the polygonal mesh, the mesh complexity is reduced to ensure the simplicity of the model. Subsequently, the geometry is further simplified by merging adjacent polygonal patches. The merging operation is specifically as follows: the normal vectors of adjacent polygonal patches are calculated. If the angle between the normal vectors is less than a preset threshold, the patches are merged. The number of vertices and edges of the merged new patches is reduced to form a rough model. The simplified model file is saved in a file of a specified format, usually in .obj or .stl format, and the simplified model is used for subsequent refinement.

[0047] In step S2, the rough model is refined by interpolating and redistributing the vertices and edges of the initial model using subdivision surface technology, increasing the number of vertices and edges of the model, forming a polygonal mesh structure, and obtaining a refined model. The specific operation is: first read the vertex and edge data of the rough model, use the subdivision surface algorithm such as the Loop subdivision method to interpolate the initial vertices, and calculate the position of the newly added vertices. The interpolation formula is: the position of the new vertex is equal to the weighted average of the positions of its adjacent vertices. Then redistribute the edge data, and form a polygonal mesh structure by connecting the newly added vertices into new edges. After the refinement process, the number of vertices and edges of the model is significantly increased, and the details are richer. The refined model file is saved in .obj or .stl format for subsequent optimization processing.

[0048] In step S3, optimization is performed based on the refined model, and the Laplace smoothing algorithm is called to iteratively adjust the model vertices. The specific operations are: read the vertex data of the refined model, initialize the iteration parameters and the Laplace operator. By calculating the position of each vertex's neighboring vertices, the vertex position is moved to the average position of its neighboring vertices. The calculation formula is: the new vertex position is equal to the weighted average of the positions of its neighboring vertices. The iterative adjustment process is repeated until the vertex positions converge, eliminating sharp corners and noise in the mesh. The optimized model file is saved in .obj or .stl format, and the optimized model is used for subsequent cross-domain knowledge transfer.

[0049] In step S4, cross-domain knowledge transfer is performed based on the optimization model. The pre-trained model and fine-tuning techniques are called, the weights of the pre-trained model are loaded into the new model architecture, and fine-tuning training is performed using combat scenario data. The model parameters are adjusted to match the new task, and the migration model is obtained. The specific operation is as follows: First, the weights of the pre-trained model are loaded and the new model architecture is initialized. Then, the combat scenario data is read and data preprocessing is performed, including data normalization and feature extraction. The pre-processed data is input into the new model, and the parameters of the pre-trained model are fine-tuned using the gradient descent method and back-propagation algorithm. During the fine-tuning process, the learning rate and batch size are set, and multiple rounds of iterative training are performed until the model parameters converge. The migrated model file is saved in .h5 or .pth format, and the migrated model is used for subsequent sparse matrix decomposition.

[0050] In step S5, a sparse matrix representation of the combat scenario data is constructed by performing sparse matrix decomposition based on the migration model. Using non-negative matrix factorization, the sparse matrix is ​​decomposed into a base feature matrix and a combination weight matrix, optimizing computational complexity. The decomposed sparse matrix is ​​then used to reconstruct the combat scenario data with key features, resulting in reconstructed scenario data. The specific steps are as follows: First, the combat scenario data is read and a sparse matrix representation of the data features is constructed. Using non-negative matrix factorization and an iterative optimization algorithm, the sparse matrix is ​​decomposed into a base feature matrix and a combination weight matrix, using the formula: sparse matrix ≈ base feature matrix × combination weight matrix. The decomposition process iteratively updates the values ​​of the two matrices until the error converges. Using the decomposed base feature matrix and combination weight matrix, the combat scenario data is reconstructed and key features are extracted. The reconstructed scenario data file is saved in .csv or .txt format and used for the final visualization.

[0051] The coarse model includes simplified vertex data, simplified edge data and merged polygonal patches; the refined model includes added vertex data, added edge data and refined polygonal patches; the optimized model includes smoothed vertex data, adjusted edge data and optimized polygonal patches; the migration model includes loaded pre-trained weights, adjusted parameter configuration and adapted new task structure; the reconstructed scene data includes basic feature matrix, combined weight matrix and key feature data.

[0052] In this embodiment, based on the modeling of the combat area, a mesh simplification algorithm is used to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygonal patches are merged to generate a rough model. The specific steps are as follows:

[0053] S101, based on the modeling of the combat area, detect and delete redundant vertex and edge data. By scanning the polygon mesh data, redundant vertices and redundant edges are identified and deleted to obtain simplified polygon data;

[0054] S102, merging adjacent polygonal patches based on the simplified polygonal data, identifying merging patches by analyzing geometric characteristics of the adjacent patches, and performing merging processing to obtain optimized polygonal patches;

[0055] S103, based on the optimized polygonal patch, the geometric shape is adjusted and refined, and a rough model is generated by geometrically transforming and optimizing the patch, adjusting the irregular shape and performing refinement.

[0056] In sub-step S101, polygonal mesh data is scanned to identify and delete redundant vertices and edges, thereby simplifying polygonal data. First, a breadth-first search algorithm is used to scan the polygonal mesh vertex by vertex. During each scan, the connecting edges and adjacent vertices of the current vertex are recorded. The connectivity of each vertex is calculated to determine whether it is a redundant vertex. If the connectivity of a vertex is 2 and the two edges connected to it form a straight line geometrically, the vertex is a redundant vertex. Accordingly, the edges connecting the redundant vertices are marked and the information of the redundant edges is recorded. After deleting the redundant vertices and edges, the polygonal mesh data is updated and the connection relationship is rebuilt to ensure the integrity of the topological structure.

[0057] In sub-step S102, adjacent polygonal patches are merged based on the simplified polygon data. By calculating the geometric properties of each patch, such as the normal vector and area, patches with similar normal vectors and similar areas are identified. The iterative closest point algorithm (ICP) is used to match the patches to determine whether the merging conditions are met. The patches that meet the conditions are vertex merged and edge reconstructed, and the new polygon boundary is calculated using the merged vertex coordinates. In order to ensure geometric accuracy, the merged polygons are smoothed using the bilateral filtering algorithm to correct slight deformations caused by the merge. By optimizing the polygon patch data, the data is significantly reduced, the main features of the original geometric form are retained, and the simplicity and computational efficiency of the model are improved. The generated optimized polygon patch data has good coherence and simplification characteristics, providing an optimization basis for subsequent geometric adjustments.

[0058] In sub-step S103, geometric adjustments and refinement are performed based on the optimized polygonal patches. The least squares method is used to geometrically transform the optimized polygonal vertices, adjusting the irregular shapes to better conform to actual geographical features and operational requirements. Matrix operations are used to rotate, translate, and scale the patches to ensure the accuracy of geometric adjustments. For further refinement, the Catmull-Clark subdivision algorithm is used to subdivide the polygonal patches, making them smoother and more detailed. During the subdivision process, the coordinates of the newly added vertices are calculated through interpolation to ensure a natural transition in the patch shape. The resulting rough model maintains the original geometric features while maintaining higher detail and geometric accuracy. The generated model file is stored in the standard OBJ format, facilitating its application and presentation in subsequent combat simulations and analysis. This model not only improves the geometric accuracy of the combat area but also provides reliable data support for further tactical analysis and decision-making.

[0059] In this embodiment, based on the rough model, refinement processing is performed. By calling the subdivision surface technology, the vertices and edges of the initial model are interpolated and redistributed, the number of vertices and edges of the model is increased, and a polygonal mesh structure is formed. The steps of obtaining the refined model are as follows:

[0060] S201, based on the rough model, interpolation and redistribution of vertices and edges are performed, an interpolation method is used to determine the positions of newly added vertices, so that the new vertices are evenly distributed, and edges are reconnected to generate an interpolation model;

[0061] S202, based on the interpolation model, applying subdivision surface technology to determine the positions of the subdivided vertices, forming a smooth surface by inserting new vertices and adjusting the positions of the original vertices, and performing multiple iterative processes to generate a subdivision surface model;

[0062] S203, based on the subdivision surface model, constructing a polygonal mesh structure, optimizing the distribution of vertices and edges, and redefining the positions of the vertices and edges of the polygons to ensure the uniformity and stability of the mesh structure, thereby generating a refined model.

[0063] In sub-step S201, the model is refined by interpolating and redistributing the vertices and edges of the rough model. First, the interpolation method is used to determine the position of the newly added vertices. During the vertex interpolation process, the Lagrange interpolation algorithm is used to determine the position of the newly added vertices by calculating the weight of each vertex so that they are evenly distributed. In the specific operation, each edge of the rough model is subdivided into several segments, and a new vertex is inserted in the middle of each segment. The coordinates of the vertex are calculated by the interpolation algorithm. Then, the edges are reconnected, and the edges after the new vertices are inserted are reorganized into polygonal patches. By using the bilinear interpolation method, the connection method of the newly added edges is smoother. After the interpolation model is generated, the number of vertices and edges of the model increases significantly, the vertex distribution is more even, and the connection of the edges is more reasonable, which lays a good foundation for subsequent subdivision processing.

[0064] In sub-step S202, the model is further refined by applying subdivision surface technology to the interpolation model. The Catmull-Clark subdivision algorithm is used, which is a subdivision surface method widely used in computer graphics. The specific operation steps include subdividing each polygonal face, inserting new vertices and adjusting the positions of the original vertices. For each face, the coordinates of the newly added vertex are first calculated. The vertex is located at the center of the original face. The calculation method is to take the average coordinate of all the vertices of the face as the new vertex coordinate. Then, the position of the original vertex is adjusted to make it closer to the center of gravity of the surrounding vertices. In the specific calculation, the new position of the original vertex is the weighted average of the original vertex, adjacent vertices and adjacent facet center points. Through multiple iterative processes, the details and smoothness of the model will increase after each iteration, and a subdivision surface model will be gradually generated. The subdivided model is smoother, the details are richer, and the surface quality is significantly improved.

[0065] In sub-step S203, the final refined model is generated by constructing and optimizing the polygonal mesh structure of the subdivision surface model. First, a new polygonal mesh structure is constructed based on the vertices and edges of the subdivision surface model. In the specific operation, the positions of the vertices and edges of each polygon are redefined to ensure the uniformity and stability of the mesh structure. A mesh optimization algorithm, such as the Laplacian smoothing algorithm, is used to iteratively adjust the positions of the vertices to make the mesh structure more uniform. During each iteration, the position of each vertex is recalculated, and the new vertex position is the weighted average of the original position of the vertex and the position of the adjacent vertices. Through multiple iterations, the mesh structure tends to be uniform. The final refined model has a high-quality polygonal mesh structure, the distribution of vertices and edges is more reasonable, and the surface is smoother and more stable, providing a good foundation for subsequent rendering and application.

[0066] In this embodiment, optimization processing is performed based on the refined model. By calling the Laplace smoothing algorithm, the model vertices are iteratively adjusted, the positions of the neighboring vertices of each vertex are calculated, and the vertex position is moved to the average position of its neighboring vertices to eliminate sharp corners and noise in the mesh. The specific steps of obtaining the optimized model are as follows:

[0067] S301, based on the refinement model, calculate the position of the neighboring vertices of each vertex, perform initial adjustment of the vertex position, move each vertex to the average position of the neighboring vertices, eliminate sharp corners and noise in the mesh, and obtain the initial vertex adjustment result;

[0068] S302, based on the initial vertex adjustment result, recalculate the neighboring vertex positions of each vertex, perform vertex position adjustment, move each vertex again to the average position of the neighboring vertices, optimize the noise and irregularities in the mesh, and obtain an intermediate vertex adjustment result;

[0069] S303: Based on the intermediate vertex adjustment result, the neighboring vertex positions of each vertex are calculated, and the final vertex position adjustment is performed to move the vertex position to the average position of its neighboring vertices to obtain an optimized model.

[0070] In sub-step S301, the positions of the neighboring vertices of each vertex are calculated based on the refined model, and an initial adjustment is performed on the vertex positions. Each vertex is moved to the average position of the neighboring vertices, eliminating sharp angles and noise in the mesh, and obtaining the initial vertex adjustment result. Specifically, the vertex and edge data of the refined model are first read. The data format is an array containing vertex coordinates and a list of edge connection information. Subsequently, for each vertex, the coordinates of its neighboring vertices are obtained, and the average position of the neighboring vertices is calculated. The formula is: the average position is equal to the sum of the coordinates of the neighboring vertices divided by the number of neighboring vertices. The position of each vertex is adjusted to this average position to eliminate sharp angles and noise. The specific algorithm steps include initializing the vertex position matrix, iteratively traversing each vertex, updating the vertex position, and saving the adjusted vertex position. The adjusted vertex data forms a new vertex position matrix, and the initial vertex adjustment result is saved as a new vertex data file in .obj or .stl format. The effect of the initial adjustment significantly reduces the noise and sharp angles in the mesh, providing a smooth foundation for subsequent optimization processing.

[0071] In substep S302, vertex positions are adjusted by recalculating the positions of each vertex's neighbors based on the initial vertex adjustment results. This recalculates each vertex toward the average position of its neighbors, optimizing noise and irregularities in the mesh, and obtaining an intermediate vertex adjustment result. In the specific implementation, the vertex data from the initial vertex adjustment result is first read. The data format is also an array containing vertex coordinates and a list of edge connectivity information. For each vertex, the average position of its neighboring vertices is recalculated using the same calculation formula: the average position is equal to the sum of the coordinates of the adjacent vertices divided by the number of adjacent vertices. The vertex position is adjusted to the new average position, further smoothing the vertex position and reducing irregularities and residual noise. The specific algorithm steps include reinitializing the vertex position matrix, repeatedly traversing each vertex and updating its position, and saving the new adjusted vertex positions. The adjusted vertex data forms a new vertex position matrix, and the intermediate vertex adjustment results are saved as a new vertex data file in .obj or .stl format. The effect of this intermediate adjustment further optimizes the smoothness and regularity of the model, providing a foundation for smoother vertex positions for the final optimization.

[0072] In sub-step S303, the positions of each vertex's neighboring vertices are calculated based on the intermediate vertex adjustment results, and a final vertex position adjustment is performed, shifting the vertex position toward the average position of its neighboring vertices to obtain an optimized model. Specifically, the vertex data of the intermediate vertex adjustment results is first read. The data format is still an array containing vertex coordinates and a list of edge connectivity information. For each vertex, the average position of its neighboring vertices is recalculated using the same calculation formula: the average position is equal to the sum of the adjacent vertex coordinates divided by the number of adjacent vertices. The position of each vertex is adjusted to the calculated average position to ensure final smoothing of the vertex position and eliminate residual noise. The specific algorithm steps include reinitializing the vertex position matrix, performing a final traversal and updating the position of each vertex, and saving the final adjusted vertex positions. The final adjusted vertex data forms a new vertex position matrix, and the vertex data file of the optimized model is saved in .obj or .stl format. The final optimization process significantly improves the smoothness and consistency of the model, eliminating all sharp corners and noise. The optimized model has high-quality geometry and provides accurate and reliable basic data for subsequent applications.

[0073] In this embodiment, cross-domain knowledge transfer is performed based on the optimization model. The pre-trained model and fine-tuning technology are called, the weights of the pre-trained model are loaded into the new model architecture, and fine-tuning training is performed using combat scenario data. The model parameters are adjusted to match the new task. The specific steps for obtaining the transferred model are as follows:

[0074] S401, based on the optimization model, load the pre-trained model weights, import the pre-trained model weight parameters, check the parameter matching, and make necessary adjustments to ensure that the weight parameters are correctly applied to the new model architecture, and obtain the loaded weight model;

[0075] S402, based on the loaded weight model, fine-tuning training of combat scenario data is performed. By inputting combat scenario data, setting training batches and learning rates, the model is trained multiple times, model parameters are adjusted to match the new task, and the training effect is verified to obtain a fine-tuned model;

[0076] S403, based on the fine-tuning model, optimize and verify the model parameters. By adjusting the model parameters, setting up multiple validation sets for testing, recording the performance of the model in the new task, recording multiple parameters and performance indicators, and obtaining the migration model.

[0077] In the S401 sub-step, the weights of the pre-trained model are loaded based on the optimization model. The specific steps are as follows: First, prepare the data of the optimization model. The data format is an array and a list containing vertex and edge information. At the same time, prepare the weight parameter file of the pre-trained model, usually in the format of .h5 or .pth. Then, through the programming interface (such as TensorFlow or PyTorch), import the weight parameters of the pre-trained model and check the matching of the parameters with the new model architecture. The specific inspection process includes traversing the weight parameters and matching them with the corresponding layers in the new model architecture to ensure the consistency of shape and dimension. If a mismatch is found, make necessary adjustments, such as resetting or reshaping the parameters, to ensure that the weight parameters are correctly applied to the new model architecture. After the adjustment is completed, load the weights of the pre-trained model and obtain the loaded weight model. The loaded weight model is used for the next step of fine-tuning training to ensure that the model has basic cognitive capabilities and provides a basis for adapting to new tasks.

[0078] In sub-step S402, fine-tuning training of combat scenario data is performed based on the loaded weight model. The specific steps are as follows: First, prepare the combat scenario data. The data format is a standardized numerical matrix containing the characteristics and label information of the scenario. Then, set the training parameters, including the training batch size and learning rate, which are generally selected based on the amount of data and the complexity of the task. Input the combat scenario data into the loaded weight model, and use the gradient descent method (such as the Adam optimizer) for multiple iterative training to adjust the model parameters to match the new task. During the training process, the changes in the loss function are monitored in real time, and the gradient is calculated through forward propagation and backpropagation to update the model weight parameters. Verification is performed regularly during the training process to evaluate the performance of the model on the validation set to ensure that the model does not overfit. After the training is completed, a fine-tuned model is obtained. The fine-tuned model contains the weight parameters and structure adapted to the new task, providing a strong foundation for the final migration model.

[0079] In substep S403, model parameters are optimized and validated based on the fine-tuned model. The specific steps are as follows: First, prepare multiple validation sets in the same format as the training data, ensuring that the validation sets cover a variety of combat scenario characteristics. Then, load the fine-tuned model through the programming interface and set various parameter optimization strategies, including adjusting the learning rate and regularization parameters. Test each validation set, and record model performance metrics such as accuracy, recall, and F1 score. The specific steps include: inputting the validation set data, performing forward propagation, calculating the model output, comparing it with the actual labels, and calculating performance metrics. Based on the test results, further fine-tune the model parameters, and repeat the above process until the model performs stably and well on each validation set. Finally, obtain the optimized transfer model and save the transfer model file in .h5 or .pth format. The transfer model not only performs well on combat scenario data but also has broader adaptability and robustness, providing reliable support for practical applications.

[0080] In this embodiment, based on the migration model, sparse matrix decomposition is performed to construct a sparse matrix to represent the combat scenario data. The sparse matrix is ​​decomposed into a basic feature matrix and a combination weight matrix using non-negative matrix decomposition technology to optimize the computational complexity. The decomposed sparse matrix is ​​used to reconstruct the combat scenario data with key features. The steps for obtaining the reconstructed scenario data are as follows:

[0081] S501, based on the migration model, performs sparse matrix decomposition, uses a block processing method to convert the combat scenario data into a sparse matrix, divides the data into multiple small blocks, calculates the data density of each block, and constructs a sparse matrix to obtain a sparse matrix representation;

[0082] S502, performing matrix decomposition based on the sparse matrix representation, determining the positions of the basic feature matrix and the combination weight matrix by element-by-element updating, repeatedly adjusting the element values ​​to converge the matrices, and performing matrix reorganization to obtain the basic feature matrix and the combination weight matrix;

[0083] S503, based on the basic feature matrix and the combined weight matrix, the sparse matrix is ​​reconstructed. The basic feature matrix and the combined weight matrix are multiplied element by element using a matrix reorganization method. The reconstructed matrix is ​​obtained by repeatedly adjusting the combination to obtain the reconstructed scene data.

[0084] In sub-step S501, the combat scenario data is converted into a sparse matrix through a block processing method. The combat scenario data contains a large amount of spatial and temporal information, which can be represented in matrix form. To improve processing efficiency, the original data is divided into multiple small blocks, each of which contains a relatively dense data area. A block diagonal matrix format is used, and each small block is stored independently. Its data density is calculated, and the data density is defined as the ratio of non-zero elements to the total elements. The non-zero elements in the sparse matrix are screened out using the ratio, and a sparse matrix representation is constructed. Hash mapping technology is used to record the position and value of non-zero elements, reducing storage space and improving retrieval speed. The resulting sparse matrix retains the main characteristics of the combat scenario data, while significantly reducing the complexity of data storage and calculation, providing an optimized input data format for the subsequent matrix decomposition step.

[0085] In the S502 sub-step, matrix decomposition processing is performed based on the sparse matrix representation. The non-negative matrix decomposition technology is used to decompose the sparse matrix into a basic feature matrix and a combined weight matrix. The specific operation includes an element-by-element update algorithm. By initializing a random non-negative matrix, the error is calculated element by element, and the element values ​​of the basic feature matrix and the combined weight matrix are updated so that the product of the two matrices gradually approaches the original sparse matrix. During the iterative process, the gradient descent method is used for each update to adjust the element value to minimize the error function and ensure matrix convergence. After multiple iterations, the error gradually decreases and reaches the preset convergence condition, obtaining a stable basic feature matrix and a combined weight matrix. In this way, the original sparse matrix is ​​decomposed into two low-dimensional matrices, which not only retains the key features of the data, but also greatly reduces the computational complexity, facilitating further data processing and analysis.

[0086] In substep S503, a sparse matrix reconstruction process is performed based on the basic feature matrix and the combined weight matrix. Using a matrix reorganization method, the basic feature matrix and the combined weight matrix are multiplied element-by-element to generate a reconstructed matrix. This process involves performing a product operation on each matrix element, accumulating the results, and reconstructing the sparse matrix row by row and column by column. To ensure the accuracy of the reconstruction results, a quadratic optimization algorithm is used to perform error correction and refinement on the reconstructed matrix, adjusting the combined weights to ensure high consistency between the reconstructed matrix and the original data. After multiple adjustments, the error of the reconstructed matrix is ​​minimized, and reconstructed scenario data is ultimately generated. The generated reconstructed scenario data file is stored in a standard sparse matrix format, making it easy to use in combat simulation and analysis. This reconstructed data not only retains the key features of the original combat scenario but also significantly improves data processing efficiency, providing accurate and reliable basic data for combat strategy formulation and simulation.

[0087] The above are merely preferred embodiments of the present invention and do not limit the present invention in any other form. Any technician familiar with the profession may use the technical content disclosed above to change or modify it into an equivalent embodiment with equivalent changes and apply it to other fields. However, any simple modification, equivalent change and modification made to the above embodiment based on the technical essence of the present invention without departing from the content of the technical solution of the present invention shall still fall within the scope of protection of the technical solution of the present invention.

Claims

1. A method for generating visualization of adaptive combat scenarios, characterized in that: The following steps are involved: Based on the modeling of the combat area, a mesh simplification algorithm is used to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygonal patches are merged to generate a rough model. Based on the rough model, refinement processing is performed, by calling subdivision surface technology to interpolate and redistribute the vertices and edges of the initial model, increase the number of vertices and edges of the model, form a polygonal mesh structure, and obtain a refined model; Based on the refined model, an optimization process is performed, by calling a Laplace smoothing algorithm, iteratively adjusting the model vertices, calculating the positions of the neighboring vertices of each vertex, moving the vertex position to the average position of its neighboring vertices, eliminating sharp corners and noise in the mesh, and obtaining an optimized model; Based on the optimization model, cross-domain knowledge transfer is performed, pre-trained models and fine-tuning techniques are called, the weights of the pre-trained models are loaded into the new model architecture, and fine-tuning training is performed using combat scenario data. The model parameters are adjusted to match the new task, and a migration model is obtained; Based on the migration model, sparse matrix decomposition is performed to construct a sparse matrix. The sparse matrix is ​​represented as combat scenario data. The sparse matrix is ​​decomposed into a basic feature matrix and a combination weight matrix using non-negative matrix decomposition technology. The computational complexity is optimized. The decomposed sparse matrix is ​​used to reconstruct combat scenario data with key features to obtain reconstructed scenario data. The specific content of optimizing the computational complexity is as follows: The original data is divided into multiple small blocks, each of which contains a relatively dense data area. A block diagonal matrix format is used, and each small block is stored independently. The data density is calculated and defined as the ratio of non-zero elements to the total elements. The non-zero elements in the sparse matrix are screened out using the ratio of non-zero elements to the total elements, and a sparse matrix representation is constructed. The hash mapping technology is used to record the position and value of non-zero elements. The resulting sparse matrix retains the main characteristics of the combat scenario data.

2. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: The rough model includes simplified vertex data, simplified edge data and merged polygonal patches, the refined model includes added vertex data, added edge data and refined polygonal patches, and the optimized model includes smoothed vertex data, adjusted edge data and optimized polygonal patches.

3. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: Based on the modeling of the combat area, a mesh simplification algorithm is used to process the area. By calling the polygon mesh parameters of the combat area, the geometric shape is simplified and adjusted, redundant vertices and edges are deleted, and adjacent polygon patches are merged. The steps to generate a rough model are as follows: Based on the modeling of the combat area, redundant vertex and edge data is detected and deleted. By scanning the polygon mesh data, redundant vertices and edges are identified and deleted to obtain simplified polygon data. Based on the simplified polygon data, adjacent polygon patches are merged, and the merged patches are identified by analyzing the geometric characteristics of the adjacent patches, and the merged patches are processed to obtain optimized polygon patches; Based on the optimized polygonal patch, the geometric shape is adjusted and refined, and a rough model is generated by geometrically transforming and optimizing the patch, adjusting the irregular shape and performing refinement.

4. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: Based on the rough model, refinement is performed by calling subdivision surface technology to interpolate and redistribute the vertices and edges of the initial model, thereby increasing the number of vertices and edges of the model and forming a polygonal mesh structure. The specific steps for obtaining the refined model are as follows: Based on the rough model, interpolation and redistribution of vertices and edges are performed, and the positions of newly added vertices are determined by an interpolation method so that the new vertices are evenly distributed, and edges are reconnected to generate an interpolation model; Based on the interpolation model, applying subdivision surface technology, determining the position of the subdivided vertices, forming a smooth surface by inserting new vertices and adjusting the positions of the original vertices, and performing multiple iterative processes to generate a subdivision surface model; Based on the subdivision surface model, a polygonal mesh structure is constructed, the distribution of vertices and edges is optimized, and the positions of the vertices and edges of the polygons are redefined to ensure the uniformity and stability of the mesh structure and generate a refined model.

5. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: Based on the refined model, optimization processing is performed by calling the Laplace smoothing algorithm to iteratively adjust the model vertices, calculate the position of each vertex's neighboring vertices, move the vertex position to the average position of its neighboring vertices, eliminate sharp corners and noise in the mesh, and obtain the optimized model in the following steps: Based on the refined model, the positions of the neighboring vertices of each vertex are calculated, and the initial vertex positions are adjusted to move each vertex to the average position of the neighboring vertices, thereby eliminating sharp corners and noise in the mesh and obtaining an initial vertex adjustment result; Based on the initial vertex adjustment result, the neighboring vertex positions of each vertex are calculated again, and the vertex positions are adjusted to move each vertex to the average position of the neighboring vertices again, thereby optimizing the noise and irregularity in the grid and obtaining an intermediate vertex adjustment result; Based on the intermediate vertex adjustment result, the neighborhood vertex position of each vertex is calculated, and a final vertex position adjustment is performed to move the vertex position to the average position of its neighborhood vertices to obtain an optimized model.

6. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: Based on the optimization model, cross-domain knowledge transfer is performed, pre-trained models and fine-tuning techniques are called, the weights of the pre-trained models are loaded into the new model architecture, and fine-tuning training is performed using combat scenario data. The model parameters are adjusted to match the new task. The specific steps for obtaining the transferred model are as follows: Based on the optimization model, load the pre-trained model weights, import the pre-trained model weight parameters, check the parameter matching, and make necessary adjustments to ensure that the weight parameters are correctly applied to the new model architecture to obtain the loaded weight model; Based on the loaded weight model, fine-tuning training of combat scenario data is performed, by inputting combat scenario data, setting training batches and learning rates, training the model multiple times, adjusting model parameters to match new tasks, and verifying the training effect to obtain a fine-tuned model; Based on the fine-tuning model, the model parameters are optimized and verified. By adjusting the model parameters, setting up a variety of validation sets for testing, recording the performance of the model in the new task, recording multiple parameters and performance indicators, and obtaining the migration model.

7. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: Based on the migration model, sparse matrix decomposition is performed to construct a sparse matrix to represent the combat scenario data. The sparse matrix is ​​decomposed into a basic feature matrix and a combination weight matrix using non-negative matrix decomposition technology to optimize the computational complexity. The decomposed sparse matrix is ​​used to reconstruct the combat scenario data with key features. The steps for obtaining the reconstructed scenario data are as follows: Based on the migration model, sparse matrix decomposition is performed, and the combat scenario data is converted into a sparse matrix using a block processing method. The data is divided into multiple small blocks, the data density of each block is calculated, and a sparse matrix is ​​constructed to obtain a sparse matrix representation; Based on the sparse matrix representation, matrix decomposition processing is performed, the positions of the basic feature matrix and the combination weight matrix are determined by element-by-element updating, the element values ​​are repeatedly adjusted to allow the matrix to converge, and the matrix is ​​reorganized to obtain the basic feature matrix and the combination weight matrix; Based on the basic feature matrix and the combined weight matrix, a sparse matrix reconstruction process is performed, and the basic feature matrix and the combined weight matrix are multiplied element by element using a matrix reorganization method. The reconstructed matrix is ​​obtained by repeatedly adjusting the combination to obtain the reconstructed scene data.

8. The method for generating visualization of an adaptive combat scenario according to claim 1, characterized in that: The migration model includes the loaded pre-trained weights, the adjusted parameter configuration, and the adapted new task structure.

Images