Multi-mode fusion vortex extraction and separation method based on multi-view clustering

Abstract

The invention discloses a multi-modal fusion vortex extraction and separation method based on multi-view clustering. The method comprises the following steps: uniformly converting input three-dimensional volume grid data containing different types of units into a regular cubic grid; constructing an extreme value graph to quickly find an extreme value point; executing region growth by taking the extreme value point as a seed point to obtain a vortex region; generating vortex lines by utilizing a self-defined integrator; and carrying out surface extraction and smoothing processing on the separated vortex region so as to improve the visualization effect. Through combination of voxelization, advanced seed point screening, regional constraint vortex line generation and an innovative multi-view clustering technology, complex three-dimensional flow field data can be effectively processed, and high-precision automatic identification and separation of a vortex structure are realized. The overall process is as shown in Figure 1.

Description

Technical Field

[0001] The present invention relates to the technical field of computational fluid dynamics (CFD) data analysis and visualization, and in particular to a method for identifying, characterizing and separating vortex structures in complex three-dimensional flow field data. Background Art

[0002] Vortex structure is a ubiquitous and crucial flow phenomenon in fluid mechanics research and engineering applications, crucial for understanding turbulence mechanisms, aircraft aerodynamic performance, combustion efficiency, and the motion of biological fluids. Computational fluid dynamics (CFD) simulations generate massive amounts of three-dimensional flow field data, and accurately and efficiently extracting and analyzing vortex structure information from this data is a key step in CFD post-processing.

[0003] Currently, commonly used methods for identifying vortex structures include threshold segmentation or isosurface extraction based on flow field physical quantities (such as vorticity modulus, Q criterion, λ² criterion, △ criterion, etc.). However, these methods based on local scalar values are often sensitive to threshold selection, prone to noise generation, or can cause structural fragmentation and adhesion, making it difficult to accurately reflect the true morphology and topological relationships of the vortex core. Another common method is to track vortex lines, traces, or vortex lines. Although this method can reflect the flow path or vortex core trajectory, the selection strategy of seed points, the stability of the integration algorithm, and how to effectively organize and identify physically meaningful vortex structure clusters from a large number of linear structures remain challenges. In particular, when the flow field contains multiple vortex structures that are close to each other, of varying sizes, or complex shapes, existing methods struggle to achieve clear, accurate separation and independent characterization. Furthermore, actual CFD calculations often use unstructured grids with a variety of element types (such as tetrahedrons, hexahedrons, wedges, pyramids, and their higher-order forms), which poses difficulties in standardizing and automating vortex structure analysis processes. The challenge of uniformly processing mesh data from diverse sources and types, and developing robust and sophisticated vortex structure identification and separation techniques based on this, remains a pressing technical challenge in the field of CFD post-processing. Due to the lack of effective automated tools, a deep understanding of vortex structures in complex flow fields still relies heavily on manual intervention, which is inefficient and highly subjective. Summary of the Invention

[0004] In view of this, the existing technology has problems such as low vortex structure recognition accuracy, low degree of automation, difficulty in effectively separating dense or complex vortex structure clusters, and difficulty in uniformly processing grid data containing multiple unit types when processing complex three-dimensional flow field data. The present invention aims to provide a systematic, automated and high-precision three-dimensional vortex structure identification and separation method, which aims to effectively extract, characterize and separate vortex structures with physical significance from the original complex flow field data.

[0005] The object of the present invention is to provide a method for vortex extraction and separation based on multi-view clustering and multi-modal fusion. This method integrates data normalization, feature point recognition, region growing based on physical criteria, constrained vortex line tracking, and an innovative phased multi-view clustering technique through a series of sequentially executed steps, and finally realizes the accurate recognition and separation of vortex structures. The method includes the following main steps: voxelization, constructing an extreme value map to screen seed points, region growing, vortex line generation, multi-view clustering, vortex region separation, and surface treatment.

[0006] Preferably, the voxelization step is to perform normalization processing on the input three-dimensional volume grid data that may contain various types of elements such as hexahedrons, wedges, pyramids, and their higher-order forms, and convert it into a regular voxel grid composed of uniformly sized cube elements. Its steps include:

[0007] The first step is to decompose all non-tetrahedral elements into basic tetrahedral elements to form a pure tetrahedral grid;

[0008] The second step is to accurately map the physical quantity information from the pure tetrahedral grid to the target regular cube grid through an interpolation method, laying a foundation for subsequent unified analysis.

[0009] Preferably, the step of constructing an extreme value map and screening seed points includes:

[0010] The first step is to calculate the weight of each grid node on the generated regular voxel grid based on the physical scalar criterion selected by the user (for example, the Q criterion or lambda2 criterion commonly used in fluid mechanics, or the modulus of the vector field);

[0011] The second step is to perform a small offset processing on the nodes with the same weight to ensure the uniqueness of the weight;

[0012] The third step is to construct an extreme value map of the grid, which contains the edges between nodes and their weight relationships. Calculate the Morse index of each node using local neighborhood information to distinguish extreme points (maximum or minimum points) and saddle points. Through a gradient path tracking method accelerated by a hybrid CPU-GPU, start from the saddle point and track along the direction of the fastest change in the gradient to the extreme point to form a path;

[0013] The fourth step is to screen out high-quality extreme points according to preset conditions (for example, the volume of the bounding box formed by the extreme point and the saddle point is greater than the threshold, and the physical criterion values of the points on the path meet specific requirements, such as Q>0 or lambda2<0) as the initial seed points for subsequent region growing.

[0014] Preferably, the region growing step includes:

[0015] In the first step, starting from the initially selected seed points, perform region growing on the original unstructured grid or its tetrahedralized version.

[0016] In the second step, adopt a variant algorithm of breadth - first search (BFS). According to the condition that within a cell, the number of vertices whose lambda2 value is less than a given threshold exceeds a predetermined number (e.g., 3), gradually add the neighboring cells that meet the condition to the growing region and mark them using the "Regionld" array.

[0017] In the third step, after the growth is completed, perform post - processing, including removing cells with poor connectivity (e.g., the number of neighbors with the same Regionld is less than 4), and optionally using a density - based clustering algorithm (such as DBSCAN) to cluster the center points of all candidate region cells identified, to filter out noise and merge spatially adjacent and dense cell regions, and assign a common region ID (e.g., 1).

[0018] The steps for generating vortex lines include:

[0019] In the first step, inside the identified and merged vortex candidate cell regions (marked with a specific Regionld), generate a set of spatially distributed seed points.

[0020] In the second step, use a numerical integration algorithm, specifically the Runge - Kutta algorithm with adaptive step - size control, to integrate the vorticity vector field of the flow field, and perform two - way (forward and backward) tracking to generate a three - dimensional space curve representing the vortex core trajectory, that is, the vortex line. The integration process is subject to a region constraint: continuously check whether the integration points are within the cells of the target Regionld. If the number of consecutive steps that the integration path leaves the target region exceeds a preset threshold (maX_steps_outside_region), then terminate the integration in that direction. The generated vortex segment data (including point coordinates and corresponding vectors) is collected.

[0021] Preferably, the multi - view clustering is to perform complex clustering analysis on the generated set of vortex lines to distinguish vortex line clusters with different geometric or physical characteristics. The detailed algorithm process includes preliminary clustering based on geometric features and fine clustering based on multi - view feature fusion.

[0022] The preliminary clustering based on geometric features includes:

[0023] In the first step, filter out vortex lines that are too short.

[0024] In the second step, extract the spatial geometric features of each remaining vortex line. Specifically, calculate its axis - aligned bounding box (AABB) and extract the coordinates of 9 representative points (the center point and the center points of 8 octants) to form a 27 - dimensional feature vector.

[0025] In the third step, use a density-based clustering algorithm (such as DBSCAN) to cluster these high-dimensional geometric feature vectors, and initially divide the vortex lines with similar spatial forms into different clusters.

[0026] The refined clustering based on multi-view feature fusion includes:

[0027] In the first step, for each initially obtained vortex line cluster, extract richer multi-view features, including at least: Figure 1 (Voxel field occupancy feature), which represents the situation of the vortex line passing through each voxel in a predefined three-dimensional regular grid; Figure 2 (Distance field feature), which represents the shortest distance from the vortex line to each grid voxel; Figure 3 (Vector distribution histogram feature), which represents the direction distribution of points (such as velocity or vorticity) on the vortex line, and is obtained by calculating the normalized histogram of the polar angle and azimuth angle in the spherical coordinate system;

[0028] In the second step, based on the features of each view, calculate the similarity matrix (such as cosine similarity) between vortex lines;

[0029] In the third step, input these multi-view information (feature matrix and the similarity matrix sparsified by a threshold) into a multi-view graph attention network (Multi-view GAT) model that has been pre-trained through unsupervised contrastive learning (such as the MoCo framework, including a query and a key branch with momentum update) for inference, and obtain a fused feature vector that can capture the internal associations and differences of vortex lines;

[0030] In the fourth step, apply the spectral clustering algorithm to these fused features, determine the optimal number of clusters K by evaluating metrics such as the silhouette coefficient, and obtain the final refined clustering labels of the vortex lines within this initial cluster. The clustering results of all initial clusters are merged and re-numbered to form the global vortex line clustering result.

[0031] Preferably, the vortex region separation is to effectively "propagate" the obtained final global vortex line clustering label ("ClusterId") back to the unstructured grid cells that form the vortex candidate region. The algorithm includes the steps:

[0032] In the first step, perform initial label assignment based on the distance from the cell center point to the vortex line with a specific clustering label;

[0033] In the second step, use a label propagation algorithm (such as BFS) based on the cell adjacency relationship to spread the label from the initially assigned cells to the entire connected region until there are no more unvisited neighbors to which the label can be propagated;

[0034] In the third step, each cell is assigned a label reflecting the vortex structure cluster it belongs to and stored in a file, thereby achieving refined vortex region separation based on the intrinsic characteristics of the vortex lines.

[0035] Preferably, the surface processing step is to extract the outer boundary surface of each separated vortex structure region (a set of units with the same final label) in order to facilitate visualization and further analysis. The algorithm includes the following steps:

[0036] In the first step, by counting the number of times each two-dimensional patch appears in the cells within the region, the patches that appear only once (i.e., exposed patches) are identified, and a surface mesh representing the shape of the vortex structure is constructed.

[0037] In the second step, a surface smoothing algorithm (such as an iterative method based on Laplace smoothing, using a relaxation factor to control the vertex movement amplitude) can be applied to the surface mesh to reduce the jagged feeling and obtain a smoother and more natural visual effect.

[0038] The method described in the present invention can systematically process complex three-dimensional flow field data containing multiple unit types. By combining advanced feature point screening, region-constrained vortex line tracking and innovative multi-view clustering technology, it effectively overcomes the shortcomings of existing technologies in vortex structure recognition accuracy, degree of automation and ability to separate complex structures, providing a more powerful and accurate vortex structure analysis method for fluid mechanics research and engineering applications.

[0039] Based on the following detailed description of specific embodiments of the present invention in conjunction with the accompanying drawings, those skilled in the art will become more aware of the above and other objects, advantages and features of the present invention. BRIEF DESCRIPTION OF THE DRAWINGS

[0040] Hereinafter, some specific embodiments of the present invention will be described in detail in an illustrative and non-limiting manner with reference to the accompanying drawings. The same reference numerals in the drawings indicate the same or similar components or parts. It should be understood by those skilled in the art that these drawings are not necessarily drawn to scale. The objects and features of the present invention will become more apparent from the following description taken in conjunction with the accompanying drawings, in which:

[0041] Figure 1 The following is a brief description of the overall process of the present invention and each step.

[0042] Figure 2 Schematic diagram of how an unstructured grid is converted into a tetrahedral grid according to one embodiment of the present invention, including a hexahedron (left), a wedge (middle), and a quadrangular pyramid (right).

[0043] Figure 3 Schematic diagram of weighted average physical quantities of a tetrahedral mesh according to one embodiment of the present invention.

[0044] Figure 4 A schematic diagram of finding extreme points using the maximum gradient growth method according to one embodiment of the present invention.

[0045] Figure 5 It is a network architecture diagram for multi-view unsupervised contrastive learning clustering according to an embodiment of the present invention.

[0046] Figure 6 It is a schematic diagram of the vortex line clustering result according to an embodiment of the present invention, and each square represents a cluster.

[0047] Figure 7 It is a schematic diagram of the vortex region clustering result according to an embodiment of the present invention, and each square represents a cluster.

[0048] Figure 8 It is a schematic diagram of the surface smoothing processing result according to an embodiment of the present invention, and each square represents a cluster. Detailed implementation manners

[0049] In order to make the invention more obvious and understandable in terms of its invention points, the present invention will be further described below in combination with specific steps. The present invention provides a method for vortex extraction and separation based on multi-modal fusion of multi-view clustering, and the overall process is as Figure 1 shown. Specifically, when implemented, the following operations are included: voxelization, constructing an extreme value map to screen seed points, region growing, vortex line generation, multi-view clustering, vortex region separation, and surface processing steps. The detailed process of the algorithm is as follows:

[0050] The voxelization includes the following operations: mesh decomposition, voxelization, and the steps of each operation are described in detail as follows:

[0051] The mesh decomposition includes the steps:

[0052] The first step is to determine the specific format of the input mesh to be processed. The method is to traverse each cell in the mesh;

[0053] The second step is that if the cell is already a tetrahedron, it remains unchanged. If it is a hexahedron cell, it is decomposed into 5 tetrahedrons. If it is a wedge-shaped cell, it is decomposed into 3 tetrahedrons. If it is a pyramid cell, it is decomposed into 2 tetrahedrons, as Figure 2 shown;

[0054] The third step is that for quadratic or higher-order cells, the corresponding decomposition algorithm is also applied to subdivide them into multiple linear tetrahedrons.

[0055] The fourth step is to correctly transfer the physical quantities (scalars, vectors, etc.) on the nodes of the original mesh to the nodes of the newly generated tetrahedral mesh.

[0056] The voxelization includes the steps:

[0057] First, define the range (bounding box) and resolution (determining the size and number of cubic cells) of the target regular cubic grid according to requirements;

[0058] Second, for each node P (or cell center, depending on the interpolation strategy) in the target cubic grid.

[0059] The interpolation process includes:

[0060] First, locate the tetrahedral cell. In the source pure tetrahedral grid, quickly find the tetrahedral cell T that contains the interpolation point P. A spatial location data structure (such as a k-d tree or octree) can be used to accelerate the search;

[0061] Second, calculate the barycentric coordinates (volume weights). Divide the tetrahedron T into 4 sub-tetrahedrons, each sub-tetrahedron being composed of the interpolation point P and three vertices of the original tetrahedron. The coordinates of point P can be expressed as a linear combination of the coordinates of the four vertices P = λ1P1 + λ2P2 + λ3P3 + λ4P4, where λ i is the volume weight, satisfying λ i ≥0 and λ1 + λ2 + λ3 + λ4 = 1. The weight λ i is proportional to the volume of the sub-tetrahedron formed by point P and the other three vertices, satisfying

[0062] Third, weighted average of physical quantities. Using the calculated volume weight λ i , linearly combine the physical quantity values f at the four vertices of the tetrahedron T to obtain the physical quantity value at the interpolation point P, f(P) = λ1f1 + λ2f2 + λ3f3 + λ4f4. For vector or other multi-component data, perform this interpolation calculation independently for each component. Repeating steps a - c for all nodes on the target regular cubic grid can effectively transfer the information carried by the source tetrahedral grid to a cubic grid with a unified structure and consistent size, as Figure 3 shown.

[0063] The construction of the extreme value graph for screening seed points includes:

[0064] First, weight calculation and uniqueness. Select a scalar physical criterion as the weight of the point. If a scalar value such as the Q criterion or lambda2 criterion is selected, directly use it as the weight. If a 3D vector (such as velocity or vorticity) is selected, then use its magnitude as the weight. Then, check the weights of all points. If there are points with the same weight, add a small positive value eps (for example, set to 0.0001) to the weight of one or more of these points repeatedly until the weights of all points are unique;

[0065] Step 2: Edge set construction. Obtain all the edges of all the cells in the grid. Create a data structure (such as a dictionary or an adjacency list) to store the set of adjacent edges for each point. For the two vertices u and v connected by an edge, ensure that the edge (u, v) is added to the edge sets of both u and v. When storing the edge, it is agreed to be represented as (u, v), where the weight of u is greater than that of v, thus preserving the magnitude relationship of the weights of the two vertices on the edge;

[0066] Step 3: Extreme value graph construction and path tracking: Use local neighborhood information to calculate the Morse index of each grid vertex, that is, calculate the number of its upper chains (edges connecting to neighbors with greater weights) and lower chains (edges connecting to neighbors with smaller weights). Determine whether the vertex is an extreme point (maximum point: no upper chain; minimum point: no lower chain) or a saddle point (there are upper chains and lower chains) according to the number of upper / lower chains. For the lambda2 criterion, usually construct a minimum value graph; for the Q criterion, usually construct a maximum value graph. Taking the maximum value graph as an example, for each saddle point (for example, the number of connected upper chains > 1), adopt the gradient path tracking method and track along the direction of the fastest weight growth (usually determined by the neighbor with the largest weight difference). If the gradient path crosses the boundary of the current calculation block, store partial path information (such as the starting point, the first point of the path, the last visited point), and continue to track after the calculation of the adjacent block is completed. If the path terminates at a maximum point within the current block, directly store the end point (maximum value) and the complete path. As Figure 4 shown, the point with a value of 6 is a saddle point, and two maximum points and the paths from the saddle point to the extreme points are found through this algorithm. In this way, the complete paths from the saddle point to the maximum point are obtained, and the points on each path branch are arranged in descending order of weight;

[0067] Step 4: Seed point screening: Screen the identified extreme points (such as maximum points) to obtain the seed points required for region growing in Step 3.

[0068] The screening conditions described above may include:

[0069] (1) The volume of the bounding box of the region formed by the extreme point and at least one of its associated saddle points is greater than a preset positive threshold;

[0070] (2) On the path sub-branch from the extreme point to the corresponding saddle point, the physical criterion values of all points (or a certain proportion of points, and the constraints can be relaxed as needed) need to meet the vortex characteristic conditions (for example, for the Q criterion, it is required that all Q values are greater than 0; for the lambda2 criterion, it is required that all lambda2 values are less than 0).

[0071] The above-mentioned region growing uses the high-quality seed points screened in the previous step to perform region growing on the processed structured grid to identify the preliminary vortex candidate regions. The detailed algorithm includes:

[0072] Step 1: Initialization. Create an integer array named "Regionld" for all cells in the grid and initialize all its values to 0. At the same time, initialize a global set visited to record the grid points (vertices) that have been processed by any seed point.

[0073] Step 2: Region growth based on BFS. Process each seed point in sequence. For a seed point, start a BFS process.

[0074] Step 3: Region simplification. After processing all seed points, traverse all cells marked with a positive Regionld. Calculate the number of neighbor cells with the same Regionld for each cell. If the number of neighbors is too small (e.g., less than 4), it is considered that the connectivity of the cell is poor, and its Regionld is reset to 0.

[0075] Step 4: Extract preliminary regions. Use a filter to extract all cells with a final Regionld greater than 0 to form a set of preliminarily identified vortex regions.

[0076] Step 5: Noise filtering and region merging. Calculate the geometric center coordinates of all vortex region cells extracted in the previous step. Convert the problem into a point cloud clustering problem. Apply the density-based clustering algorithm DBSCAN. According to the set neighborhood radius eps and the minimum number of neighbors min_samples required for core points, divide the cell center points that are dense enough in space into different clusters. Consider the points in sparse regions as noise. The clustering result assigns a cluster ID to each (non-noise) cell and stores it in a new cell data array named "Clusterld". For the convenience of subsequent vortex line generation processing, merge all non-noise regions (i.e., all valid clusters) and assign them a common final Regionld (set to 1).

[0077] The BFS process described above includes:

[0078] Step 1: Initialize a queue q and a set q_set for quickly checking membership, and add the current seed point (usually a vertex of the cell where the seed extreme point is located, or the seed point itself) to q and q_set.

[0079] Step 2: When the queue q is not empty, take a point current_point from the queue.

[0080] Find all cells containing this point;

[0081] In the third step, for each found cell current_cell, check whether it meets the physical criterion: for the Lambda2 criterion, check whether there are a sufficient number (e.g., more than 3) of vertices within the cell whose lambda2 values are less than the set threshold threshold (usually 0); for the Q criterion, check whether there are a sufficient number of vertices whose Q values are higher than the threshold;

[0082] In the fourth step, if the cell current_cell meets the condition, temporarily record its ID (e.g., put it into a temporary list). Then, check all the vertices that make up the cell, and add those vertices that have not been visited yet (i.e., neither in the global visited set nor in the q_set of the current seed point) to the queue q and the set q_set for subsequent exploration;

[0083] In the fifth step, after processing all the adjacent cells of a point current_point, add this point to the global visited set;

[0084] In the sixth step, when the queue q for a seed point becomes empty, it means that the exploration of the connected region starting from this seed point is completed. Evaluate the number of cells obtained in this growth. If the number is large enough (e.g., more than a set minimum size or a certain proportion of the total number of cells), then mark the Regionld of these cells as a unique positive integer (provided that their previous Regionld was still 0). Prepare an incremented ID for the next possible independent region. If the growth region is too small, the Regionld of its cells remains 0.

[0085] The specific process of the vortex line generation algorithm described above includes:

[0086] In the first step, data preparation, read the file containing vortex region information (such as the "Regionld" array). Obtain the data boundary. Check whether there is 3D vorticity vector field data. If not or it is a scalar field, calculate the gradient of this scalar field and store the result as a new vector field for subsequent vortex line generation;

[0087] In the second step, seed point generation: Generate a number of random seed points only within the cells where Regionld is equal to the target region ID. Specifically, when implementing, first calculate the overall bounding box of the target region cells, and randomly sample points within this range. Then, precisely check whether each random point is really inside the cell with the target Regionld. This check usually involves judging the geometric relationship between the point and the cell, and dealing with boundary cases as well as situations where interpolation may fail or return NaN values;

[0088] In the third step, generate vortex lines under regional constraints;

[0089] Step 4, result storage: Store all the collected vortex segment data in a file. This process includes creating a set of coordinates for all vortex line points, creating line elements for each vortex segment, and creating an array to store the vector data corresponding to each point. Append this vector array as point data to the final linear geometric data structure and set it to the active state. After completion of the construction, write this object to the specified file.

[0090] The specific process of the vortex line generation algorithm under regional constraints includes:

[0091] Step 1, initialize the integrator: Create an interpolator instance based on the prepared vorticity vector field for efficiently querying the vector values at any spatial point during the integration process. Define an integrator (a custom RK45 integrator) and configure parameters such as: minimum integration step size min_step, maximum integration step size max_step, accuracy tolerance tolerance, maximum integration path length max_propagation, velocity threshold terminal_speed for terminating the integration, and the global boundaries of the dataset.

[0092] Step 2, integrate each seed point: For each valid seed point, start the integration process according to the set integration direction (forward, backward, or bidirectional).

[0093] Step 3, verify the seed points: Before starting the integration, verify whether the seed points themselves are valid: Check whether the vorticity vector of the point exists, is valid (not None / NaN), and its magnitude is greater than the velocity threshold for terminating the integration; and use the cell locator to confirm that the seed point is indeed located within the target Regionld. If any of the checks fails, skip this seed point.

[0094] Step 4, iterative loop: For the verified seed points, use their positions and corresponding vectors as the first points of the vortex lines. Set the initial step size current_h (the magnitude is determined by initial_step, the sign is determined by the integration direction, and it is constrained within [min_step, max_step]). Enter the core iterative stepping loop.

[0095] Step 5, collect the results: When the integration attempts for all seed points and directions are completed, all successfully generated vortex segments containing at least two data points (point-vector pairs) are collected.

[0096] The core iterative stepping loop includes:

[0097] First step, perform a single step calculation: Calculate a series of intermediate slopes (K values), during which the vector values of intermediate points need to be queried multiple times, and check at any time whether there is an out-of-bounds situation or an invalid vector / low-speed situation. Calculate two candidate positions of the next point based on the fourth-order and fifth-order Runge-Kutta formulas. Compare the differences between the two to estimate the local truncation error;

[0098] Second step, adaptive step size adjustment: If the error is within the tolerance range, accept the current step, and use the fifth-order point and its corresponding vector as the result. Calculate an optimized and usually slightly larger proposed next step size according to the error ratio (constrained by the safety factor and the step size range). If the error exceeds the tolerance, reject the current step, do not move the point, and calculate a usually smaller proposed step size, preparing to retry with a smaller step size. The method returns the calculation result (accepted point, vector, proposed step size, acceptance status flag) or failure information (such as out-of-bounds, low speed, etc.);

[0099] Third step, loop body processing, and process according to the returned result: If the step is accepted and the point / vector is valid, enter the region check phase. Use the cell locator to determine the cell where the new point is located and its Regionld. Update a counter that records the number of consecutive steps leaving the target region. If this counter exceeds the preset threshold, it is considered that the vortex line has deviated too far from the target region, and the integration in the current direction is terminated. If it is not terminated due to region problems, add the accepted data point to the list of the current vortex segment, update the total integration distance, set the end point of the phase to the current point of the next iteration, and update the integration step size. If the step is rejected, do not add a new point, only reduce the step size and retry. Include a termination mechanism to prevent a dead loop from occurring when the step size reaches the minimum value and still cannot meet the accuracy. Other termination conditions include: The integration loop will also terminate under any of the conditions such as reaching the maximum integration length, reaching the preset maximum number of steps limit, the integration point moving out of the data boundary, vector interpolation failure, or the vector speed being lower than the threshold;

[0100] The multi-view clustering mentioned above is to perform fine clustering on the generated vortex lines to distinguish different vortex structures. The specific algorithm process includes:

[0101] First step, vortex line preprocessing, read the vortex line file generated in step four. Filter out all vortex lines with lengths less than a specific threshold (for example, set according to the flow field scale) to prevent short vortex lines from interfering with the clustering effect;

[0102] Second step, the first stage of clustering, preliminary clustering based on geometric features;

[0103] Third step, prepare for the second stage;

[0104] Fourth step, perform fine clustering based on multi-view feature fusion in the second stage, and process each sub-cluster and its corresponding three similarity matrices;

[0105] Step 5, Global result merging. Merge the final clustering labels (from the second stage) obtained within each sub-cluster (from the first stage). Arrange these labels in the order of processing the sub-clusters, and re-assign each cluster a globally unique number. In this way, the final global clustering result of all vortex lines is obtained.

[0106] The first-stage clustering described above includes:

[0107] Step 1, Feature extraction. For each vortex line that has passed through preprocessing, extract the coordinates of all points that make it up. Calculate the axis-aligned bounding box (AABB) of this vortex line to obtain the minimum and maximum boundary values in the x, y, and z directions. Based on the AABB, calculate nine representative spatial points: the geometric center point of the bounding box and the center points of its eight octants. Concatenate the coordinates of these nine three-dimensional points (a total of 9 * 3 = 27 values) to form a 27-dimensional geometric feature vector. Record the original vortex line index corresponding to each feature vector. Skip the vortex lines for which features cannot be successfully calculated;

[0108] Step 2, Preliminary clustering. Apply the density-based clustering algorithm DBSCAN to the set of all successfully generated 27-dimensional feature vectors. Set the neighborhood radius eps and the parameter of the minimum number of neighbors required for core points. DBSCAN identifies the regions where data points are dense as clusters in the 27-dimensional feature space and marks the points in sparse regions as noise;

[0109] Step 3, Result sorting and output. Create an array of the same length as the total number of original vortex lines, initialized to -1. Fill in the corresponding positions of the array with the cluster labels calculated by DBSCAN according to the previously recorded index correspondence. For the vortex lines that were skipped in the feature generation stage, their labels remain -1. Then, for each obtained cluster ID (including the -1 noise cluster), extract all the vortex lines belonging to this cluster and their associated point and vector data, and save them to separate files. The result obtained in this stage is sub-vortex line clusters preliminarily grouped by geometric features.

[0110] The preparations before the second stage described above include multi-view feature extraction and similarity calculation:

[0111] The multi-view feature extraction described above includes:

[0112] (1) Voxel field occupancy feature. First, divide the entire flow field space into a three-dimensional regular grid (voxel grid). For each vortex line, determine whether it passes through each voxel of this grid. Generate a binary feature vector, the vector dimension is equal to the total number of voxels, and the corresponding position is 1 indicating passing through and 0 indicating not passing through;

[0113] (2) Distance field feature: For the same three-dimensional regular grid, calculate the shortest distance from each vortex line to the center of each voxel (or the nearest point within the voxel) of the grid. Generate a feature vector with the dimension equal to the total number of voxels, and each element is the corresponding shortest distance value;

[0114] (3) Vector distribution histogram feature: Extract the three-dimensional vectors (e.g., velocity or vorticity) of all valid points that make up the vortex line. Convert these Cartesian vectors to spherical coordinate pairs (polar angle theta ∈ [0, π], azimuth angle phi ∈ [-π, π]). Calculate histograms for the theta angle and phi angle of all valid points respectively. Divide the angle ranges (theta: [0, π], phi: [-π, π]) into a specified number of intervals, and count the number of angles falling into each interval. Normalize the two obtained count histograms (e.g., divide by the total number of points) to convert them into frequency histograms. Finally, concatenate the frequency histograms of theta and phi into a single long vector as the direction distribution feature of the vortex line.

[0115] The calculated similarity matrix uses the set of feature vectors of each view obtained, and calculates the cosine similarity between pairwise vortex lines within the view respectively. In this way, for each sub-cluster, three similarity matrices will be obtained, corresponding to the voxel field, distance field, and vector distribution histogram respectively for each view. Figure 3 each view.

[0116] The processing of each sub-cluster and its corresponding three similarity matrices includes:

[0117] (1) Feature fusion reasoning:

[0118] The first step is to perform threshold processing on the three similarity matrices: Set the elements with similarity less than a certain preset threshold to 0. This is to convert the dense similarity matrix into a sparse graph adjacency relationship that can better represent strong associations and avoid the graph being fully connected;

[0119] In the second step, the original view feature matrix and the processed sparse similarity matrix (as the weighted adjacency matrix) are input into a pre-trained unsupervised contrastive learning network model for inference. Example of the network architecture: a multi-view fusion model based on the Graph Attention Network (GAT) is adopted. For each view, the data passes through two isomorphic GAT encoders respectively: the query encoder (Encoder-q) and the momentum encoder (Encoder-k). The parameters of Encoder-q are updated by gradients during the training phase, and the parameters of Encoder-k are the momentum-updated version of the parameters of Encoder-q. Example of model hyperparameters: the hidden feature dimension of GAT hidden_features = 128, the number of GAT attention heads heads = 8, and the final output dimension H of the encoder and the fusion MLP (FusionMLP) = 1024. Hyperparameters related to contrastive learning: temperature coefficient temperature = 0.1, momentum update coefficient m = 0.999, and negative sample queue size queue_size = 1024. Inference phase: only forward propagation is performed. The features X, edge index edge_index, and edge attributes edge_attr (from the sparse similarity matrix) are input into the query GAT encoder to obtain the embeddings z1, z2, and z3 of the three views. The fused embedding fused_q is obtained by querying the FusionMLP. (Note: The momentum branch, contrastive loss, and reconstruction loss calculations are only required in the training phase, and only the query branch is used to generate the fused features in the inference phase). The fused feature vectors (with dimension H) of each vortex line are obtained. The network architecture is as Figure 5 shown.

[0120] (2) Final clustering: Apply the spectral clustering algorithm to the set of fused feature vectors of all vortex lines within the sub-clusters (with dimension N vortex lines x H-dimensional features). Before performing spectral clustering, the optimal number of clusters K needs to be determined. Traverse each possible k value within the predefined range of the number of clusters: for each k, perform spectral clustering. Calculate the silhouette coefficient of the clustering result. The silhouette coefficient measures the compactness within the cluster and the separation between clusters, with a score range of [-1, 1], and the closer to 1, the better. The pre-computed distance matrix can be used during the calculation. Record the silhouette coefficient and clustering labels corresponding to each k value. Trace the k value with the highest effective silhouette coefficient and its corresponding clustering result. If the silhouette coefficients obtained for all tried k values are not satisfactory (for example, all are less than or equal to the threshold) but there is at least a valid clustering result, a fallback strategy is adopted: select the k corresponding to the highest valid score and re-perform spectral clustering to obtain the labels. If the clustering fails completely (for example, all k values are incorrect or only one cluster is generated), the label may be None. The vortex line clustering result is as Figure 6 shown.

[0121] The aforementioned vortex region separation maps the obtained vortex line clustering result back to the original unstructured grid cells, realizing the fine separation of the vortex region based on the vortex line clusters. The algorithm process includes:

[0122] The first step is initialization. Obtain the final global clustering label "Clusterld" cell data array from the input vortex line data and convert it into an array clusterid_narray. Create an array labels with the same length as the total number of unstructured grid cells and initialize all elements to 0 (indicating that all cells are initially unassigned labels). At the same time, create an array nearest_dist with a length also equal to the total number of cells to record the distance from each cell to the nearest vortex line, and initialize it to infinity (float('inf'));

[0123] The second step is the initial label assignment based on distance: Traverse each vortex line after clustering in step five. For each vortex line, obtain its clustering label (obtained from clusterid_narray and add 1 to avoid confusion with the unlabeled 0). Construct an efficient spatial index for the points that make up the vortex line, query the nearest distance from the center points of all grid cells to all points on the current vortex line, and obtain the distance distances from each cell center point to the vortex line. Traverse all cell center point indices i. If the distance from cell center point i to the current vortex line is less than a set threshold (for example, 0.05), and this distance is smaller than the previously recorded nearest_dist[i], then update: reset the label labels[i] of cell i, and at the same time update nearest_dist[i] = dist. This step initially assigns the cluster label of a certain vortex line to the cells close to it;

[0124] The third step is label propagation based on adjacency relationship (BFS): Put the indices of all cells assigned non-zero labels in the initial assignment stage into a double-ended queue queue, and add these cell indices to the visited set. Enter the loop as long as the queue queue is not empty;

[0125] The fourth step is result saving. Save the finally calculated cell label array labels to a file as the result of the vortex region separation, and the result is as Figure 7 shown.

[0126] The aforementioned BFS algorithm includes:

[0127] The first step is to take out a cell index current_cell from the queue;

[0128] The second step is to obtain its current label current_label = labels[current_cell];

[0129] Step 3: Traverse all the neighbor cells neighbor of the current cell current_cell (which can be obtained through the pre-computed cell adjacency relationship cell_neighbors);

[0130] Step 4: If the neighbor neighbor has not been visited yet, then: Set the label labels[neighbor] of the neighbor to be the same as the current_label of the current cell; Add the neighbor neighbor to the queue queue for subsequent propagation; Finally, add the neighbor neighbor to the visited set. This process will spread the label from the initial cells close to the vortex line to the entire connected region along the cell adjacency relationship until there are no more unvisited neighbors to propagate.

[0131] The surface treatment is to perform surface extraction and smoothing on the separated vortex structures to improve the visualization effect. The algorithm process includes:

[0132] Step 1: Boundary surface extraction, for each valid vortex structure cluster (i.e., the set of cells with the same non-zero final label ClusterId) identified in Step 6;

[0133] Step 2: Surface smoothing processing; Apply a surface smoothing algorithm, such as a method based on Laplacian smoothing, to the extracted polygonal surface mesh.

[0134] The boundary surface extraction algorithm includes:

[0135] Step 1: Filter out all three-dimensional cells belonging to the cluster;

[0136] Step 2: Traverse these cells and extract all two-dimensional "facets" that form their boundaries (e.g., the 4 triangular faces of a tetrahedron);

[0137] Step 3: Create a unique identifier for each extracted facet. This is usually achieved by sorting the indices of its constituent vertices (e.g., in ascending order) to ensure that the same geometric facet gets the same identifier regardless of which cell it belongs to or the vertex order;

[0138] Step 4: Use a data structure (such as a hash table or dictionary) to count how many times each unique facet identifier appears in all the three-dimensional cells of the current cluster, i.e., calculate the "reference count";

[0139] Step 5: After traversing all the cells and counting the reference counts of all the facets, filter out those facets with a reference count of exactly 1. These facets are the boundary parts that belong to only one three-dimensional cell within the cluster and are not shared with any other cells within the cluster, and they together form the outer boundary of the cluster;

[0140] Step 6: Collect all the patches determined to be the outer boundary and the vertices they contain, and construct a polygonal surface mesh that geometrically accurately represents the external shape of the cluster of vortex structures.

[0141] The surface smoothing process needs to perform iterations a specified number of times (for example, iterations = 50). Each iteration includes:

[0142] Step 1: Traverse each vertex v on the surface mesh. For the current vertex v, find the set of neighbor vertices N(v) that are directly connected to it through the mesh edges.

[0143] Step 2: Calculate the arithmetic mean of the coordinates of these neighbor vertices to obtain a "target" average position P avg =(∑P n ) / |N(v)|, where P n is the coordinate of neighbor n.

[0144] Step 3: According to a set relaxation factor RelaxationFactor (between 0 and 1, for example, set to 0.08), update the position P v of vertex v to: P vnew =P v +RelaxationFactor*(P avg -P v ). That is, move the vertex a small distance along the direction from the current position to the target average position. After repeating the number of iterations, the positions of the mesh vertices will gradually tend to the average of their neighborhoods, effectively eliminating sharp features and noise, making the entire surface look smoother and more natural. The processed smooth surface mesh can be used for high-quality visualization display, and the results are as Figure 8 shown.

[0145] The above steps constitute a complete method flow for identifying and separating vortex structures in a three-dimensional flow field. Those skilled in the art should understand that without departing from the scope and spirit of the present invention, changes and modifications can be made to the specific implementation details of the present invention.

Claims

1. A method for vortex extraction and separation based on multi-view clustering and multi-modal fusion, characterized in that: The following steps are involved: (1) Voxelization step: converting the input 3D volume mesh data containing various cell types and sources into a regular voxel grid composed of cubic cells of uniform size for standardization of subsequent calculations; (2) Seed point screening step: On the regularized voxel grid, the weight of each grid point is calculated based on a preset physical scalar criterion (such as the Q criterion or the lambda2 criterion), and a unique processing is performed. Then, an extreme value graph containing the relationship between edges and their weights is constructed. By calculating the local neighborhood Morse index and gradient path tracing, extreme value points that meet the conditions of the region bounding box and path physical characteristics are screened out as seed points for subsequent region growth; (3) Region growing step: starting from the seed point, a region growing algorithm based on a breadth-first search (BFS) variant is executed on the original unstructured grid or its tetrahedronized grid, and the initial vortex candidate unit area connected to the seed point is identified and marked according to the number of vertices in the unit that meet a specific physical criterion threshold; (4) vortex line generation step: generating spatially distributed seed points within the vortex candidate unit area, and using a numerical integration algorithm based on the flow field vorticity vector field, such as the Runge-Kutta algorithm with adaptive step size control, bidirectionally tracking and generating three-dimensional vortex lines representing the vortex core trajectory, wherein the integration process is constrained by the boundary of the unit area, and the tracking in this direction is terminated when the vortex line continuously leaves the area for more than a predetermined number of steps; (5) Multi-view clustering step: performing a staged, multi-view clustering operation on the vortex line set to distinguish vortex line clusters with different structures or characteristics; (6) Vortex region separation step: The vortex line clustering results are mapped back to the grid cells corresponding to the vortex candidate unit area to achieve refined vortex structure region separation based on vortex line cluster labels. The separated vortex region is then subjected to surface extraction and smoothing by an algorithm to improve visualization.

2. The method according to claim 1, wherein The voxelization step specifically includes: Step 1: Decompose the non-tetrahedral elements in the original unstructured grid into basic linear tetrahedral elements to ensure that all elements have a tetrahedral structure. The decomposition method includes: (1) The hexahedron is decomposed into 5 tetrahedrons; (2) The wedge is decomposed into three tetrahedrons; (3) The pyramid is decomposed into two tetrahedrons; (4) High-order elements are subdivided into multiple linear tetrahedra; At the same time, the physical quantities on the original mesh nodes are correctly transferred to the newly generated tetrahedral mesh nodes, and the output is a pure tetrahedral unstructured mesh; Step 2: Interpolate from the tetrahedral mesh to a regular cubic mesh, defining the extent and resolution of the target regular cubic mesh; for each node (or cell center) in the target mesh, locate the tetrahedral cell T where it is located in the source tetrahedral mesh; Step 3: Calculate the centroid coordinates (volume weight) of the point relative to the four vertices of tetrahedron T, where the weight is proportional to the volume of the sub-tetrahedron formed by point P and the three vertices and the sum is 1; Step 4: Using the volume weights, linearly combine the physical quantities (scalar or vector components) at the four vertices of the tetrahedron T to obtain the interpolated physical quantity values at the target grid nodes, thereby completing the information mapping.

3. The method according to claim 1, characterized in that, The specific seed point screening includes: Step 1: Weight assignment and uniqueness. Select a scalar physical criterion (Q criterion or lambda2 criterion, or the magnitude of the vector field) as the weight; check and process points with the same weight by adding a small offset value (eps, such as 0.0001) to ensure the uniqueness of each point's weight. Step 2: Construct the edge set and relationships. Obtain all the edges of all the elements in the grid, create an edge set for each point, and ensure that the edges are represented as (u, v) with the weight of u greater than v when storing the edges. Step 3: Construct the extreme value graph and path tracking. Calculate the Morse index (the number of upper and lower chains) of each point to distinguish extreme points and saddle points; for saddle points (taking the maximum value graph as an example, the number of connected upper chains > 1), use the hybrid CPU-GPU gradient path tracking method to trace along the direction of the fastest growing gradient to the maximum value point, handle the case of crossing the computational block boundary, and store the complete descending path from the saddle point to the extreme point in descending order. Step 4: Seed point filtering. Use the extreme points that meet the screening conditions as seed points. The screening conditions include: (1) The volume of the bounding box of the region formed by the extreme point and at least one associated saddle point is greater than 0. (2) On the path sub-branch from the extreme point to the corresponding saddle point, the physical criterion values of points that meet a preset ratio (e.g., all or a certain ratio) conform to the vortex characteristics (e.g., Q > 0 or lambda2 < 0).

4. The method according to claim 1, wherein After the region growing step, it also includes: Step 1: Region simplification. Traverse all the elements marked with the valid region ID, calculate the number of neighbor elements with the same region ID. If the number of neighbors is less than the preset threshold, reset the region ID of this element to 0 and remove the elements with poor connectivity. Step 2: Noise filtering and region merging. Extract all the elements with the remaining valid region ID, and calculate their geometric center points. Step 3: Transform the problem into a point cloud clustering problem. Apply the density-based clustering algorithm. According to the neighborhood radius eps and the minimum number of neighbors min_samples of the core points, divide the unit center points that are densely enough in space into different clusters, and regard the sparse points as noise. Step 4: For the convenience of subsequent processing, assign a common final region ID to all the elements in the non-noise clusters.

5. The method according to claim 1, characterized in that In the vortex line generation step, the specific implementation of the numerical integration algorithm includes: Step 1: Initialize the configuration. Set the integration environment, including creating an instance for efficiently querying the vorticity vector, and configuring the parameters of the RK45 (Runge-Kutta-Fehlberg algorithm) integrator (minimum / maximum step size, precision tolerance, maximum integration length, termination velocity threshold, global boundary). Step 2: Seed point verification. For each generated seed point, check its validity (the vorticity vector is non-empty and its magnitude is greater than the threshold, and confirm that it is within the target region ID). Step 3: RK45 iterative stepping. Starting from the valid seed point, enter the iterative loop. In each iteration, perform one RK45 stepping calculation to calculate the 4th and 5th order candidate points, estimate the local truncation error, and adaptively adjust the step size based on the comparison between the error and the tolerance (increase if accepted, decrease if rejected). Step 4: Region constraint check. If the stepping is accepted and the point is valid, check the cell where the new point is located and its region ID, update the step counter for continuously leaving the target region. If the counter exceeds the preset threshold, terminate the current direction integration. Step 5: Data recording and termination. If not terminated due to region problems, add the accepted points and vectors to the vortex line list, update the total distance and the current point, and update using the proposed step size. Step 6: The loop terminates when any one of the conditions of region constraint termination, maximum length, maximum number of steps, out-of-bounds, interpolation failure, or low speed is met.

6. The method according to claim 1, characterized in that, The multi-view clustering is divided into two stages. The first stage, namely the preliminary clustering based on geometric features, specifically includes: Step 1: Data preprocessing. Filter out all short vortex lines with lengths less than a specific threshold. Step 2: Geometric feature extraction. For each remaining vortex line, calculate its axis-aligned bounding box (AABB). Step 3: Calculate nine feature points based on the AABB: the geometric center point and the center points of the eight octants. The three-dimensional coordinates of these nine points (a total of 27 values) form a 27-dimensional feature vector. Step 4: Preliminary clustering. Apply a density-based clustering algorithm (such as the Density-Based Spatial Clustering of Applications with Noise algorithm DBSCAN) to the set of all successfully generated 27-dimensional feature vectors, using the preset neighborhood radius eps and the minimum number of neighbors min_samples for core points to perform clustering in the 27-dimensional feature space and obtain the preliminary vortex line cluster labels. Step 5: Result sorting. Map the obtained cluster labels back to the original vortex line indices, and save the vortex line data belonging to the same cluster (including the noise cluster) separately.

7. The method according to claim 6, characterized in that, The second stage of the multi-view clustering, namely the fine clustering based on multi-view feature fusion, first requires multi-view feature extraction and similarity calculation, specifically including: For the vortex lines within each preliminary clustering cluster, calculate the features of the following three views: Step 1: View 1, voxel field occupancy feature. Divide the flow field space into a three-dimensional regular grid, and generate a feature vector for each vortex line representing whether it passes through each grid voxel. Step 2: View 2, distance field feature. For the same three-dimensional regular grid, generate a feature vector for each vortex line representing its shortest distance to each grid voxel. Step 3: View 3, vector distribution histogram feature. Extract the three-dimensional vectors (such as velocity or vorticity) of the points on the vortex line, convert them to spherical coordinates (polar angle theta, azimuth angle phi), calculate the normalized frequency histograms of theta and phi respectively (using a predetermined number of bins), and splice the two histograms into a single feature vector. Step 4: For the feature matrix of each view, calculate the cosine similarity between vortex lines respectively to obtain the similarity matrices corresponding to the three views.

8. The method according to claim 7, characterized in that In the second stage of the multi-view clustering step, fine-grained clustering based on multi-view feature fusion, including feature fusion and final clustering, specifically includes: Step 1: Feature fusion inference. For each preliminary clustering cluster and its corresponding three-view similarity matrix, first perform threshold processing on the similarity matrix to achieve sparsification; Step 2: Input the processed similarity matrix (as a weighted adjacency matrix) and the corresponding feature matrix into a multi-view graph attention network (Multi-view GAT) model that has been pre-trained through unsupervised contrastive learning for inference; this model includes isomorphic query encoders (Encoder-q, parameter gradient update) and momentum encoders (Encoder-k, parameter momentum update) as well as a fusion module (FusionMLP). The inference process only performs forward propagation to obtain the fused high-dimensional vortex line feature H; Step 3: Final clustering. Apply the spectral clustering algorithm to the obtained fused vortex line features. Calculate the silhouette coefficient within a predetermined range of the number of clusters, and select the number of clusters K that maximizes (and is effective) the silhouette coefficient as the optimal number of clusters; Step 4: Perform spectral clustering to obtain the final clustering labels of the vortex lines within this preliminary cluster; Step 5: Global result merging. Merge the final clustering labels obtained within all preliminary clustering clusters in order and re-assign a globally unique cluster number.

9. The method according to claim 1, wherein The specific steps of the vortex region separation include: Step 1: Initialization. Obtain the global vortex line clustering label array; create a cell label array of the same length as the number of unstructured grid cells, initialized to 0; Step 2: Create an array nearest_dist to record the distance from each cell to the nearest vortex line, initialized to infinity; Step 3: Initial label assignment based on distance. Traverse each vortex line with a clustering label and construct a spatial index of its points; Step 4: Query the nearest distance from the center points of all grid cells to the current vortex line. If the distance from the center point of a certain cell to the current vortex line is less than the preset threshold and less than the currently recorded nearest distance, then update the label of this cell to the clustering label of the current vortex line (plus 1 to distinguish unlabeled) and update the nearest distance array; Step 5: Label propagation based on adjacency relationship. Put all the cell indices that are assigned non-zero labels in Step 2 into a queue. When the queue is not empty, take out a cell, obtain its label, and traverse all its neighbor cells. If a neighbor cell has not been visited, set its label to be the same as the current cell, and add it to the queue and the visited set. This process continues until the queue is empty, completing the diffusion of labels within the connected region.

10. The method according to claims 1 and 9, characterized in that, This method includes a final surface processing step, specifically including: Step 1: Boundary surface extraction. For each set of vortex region cells with valid clustering labels separated, traverse the three-dimensional cells therein and extract all two-dimensional boundary "patches"; Step 2: Create a unique identifier by normalizing the patch vertex indices and count the number of times each unique patch appears in the current region cell set (reference count); Step 3: Filter out the patches whose reference count is exactly 1. These patches together constitute the outer boundary of the vortex area. Step 4: Surface smoothing: The extracted outer boundary polygonal surface mesh is iteratively smoothed using a Laplacian-based smoothing algorithm. In each iteration, for each vertex on the mesh, the arithmetic mean of the coordinates of all its neighboring vertices is calculated to obtain the target position. Move the vertices a small distance from their current positions toward the target average position, according to the specified relaxation factor (e.g. 0.08). Repeat this process for the specified number of iterations to achieve a visually smoother surface.

Images