Three-dimensional gravel aggregate generation method based on generative adversarial network

Abstract

The invention provides a three-dimensional gravel aggregate generation method based on a generative adversarial network, which belongs to the technical field of three-dimensional object generation and comprises the steps of data processing, generator and discriminator construction, network training, sample generation and post-processing. A three-dimensional gravel aggregate model file is loaded, standardization processing is carried out, and the three-dimensional gravel aggregate model file is converted into three-dimensional voxel grid data. The generator adopts a five-layer three-dimensional transposed convolutional network to gradually generate a high-resolution gravel aggregate model, and the discriminator adopts the five-layer three-dimensional convolutional network to evaluate the authenticity of a generated sample. The post-processing operation comprises isolated point removal, gap interpolation filling, morphological closing and grid generation and surface smoothing operation, and the surface smoothness and the structural integrity of the generated sample are further improved. The method supports multiple resolution generation requirements and multiple file format input, and has the advantages of high generation quality, high training stability and wide engineering application.

Description

Technical Field

[0001] The present invention belongs to the technical field of three-dimensional object generation, and in particular relates to a three-dimensional crushed stone aggregate generation method based on a generative adversarial network. Background Art

[0002] Three-dimensional object generation is an important research direction in the fields of computer graphics, artificial intelligence, and virtual reality, and is widely used in many industries such as architectural design, game development, and medical imaging. Traditional three-dimensional modeling methods mainly rely on manual modeling and physical simulation. Although they can provide high-precision three-dimensional models, these methods are usually inefficient, especially when faced with complex and diverse three-dimensional objects. The generation process requires a lot of computing resources and cannot meet the needs of modern applications for efficient and diverse rapid generation.

[0003] As a deep learning method, generative adversarial networks (GANs) have made significant progress in the fields of image generation, image enhancement, and image translation in recent years, and have been gradually applied to the generation of three-dimensional objects. Through adversarial training of the generator and the discriminator, GANs can learn features from existing data and generate new three-dimensional samples. However, existing GAN-based three-dimensional generation methods still face several technical difficulties in practical applications. First, the storage formats of three-dimensional data are diverse, and common formats such as .obj, .stl, and .ply are large and complex, resulting in a more complex data preprocessing process when processing three-dimensional data. In particular, when generating high-resolution three-dimensional models, the computing and storage requirements increase significantly, limiting its scope of application. Secondly, most of the existing GAN models are designed for two-dimensional data. When directly extended to three dimensions, their efficiency and generation quality are limited. The spatial complexity of three-dimensional data is high, and the traditional convolutional neural network CNN and GAN have poor adaptability in three-dimensional space, resulting in the generated three-dimensional samples may have problems such as incomplete structure or insufficient details. In addition, mode collapse is prone to occur during GAN training. The generated samples lack diversity and are concentrated in a few modes, resulting in unstable quality of the generated results. This problem is particularly prominent in the task of generating three-dimensional objects.

[0004] Therefore, how to improve the efficiency, quality and stability of existing GAN methods in three-dimensional data generation remains a technical problem that needs to be solved urgently. Summary of the invention

[0005] In order to solve the problem of how to improve the efficiency, quality and stability of the existing GAN method in three-dimensional data generation, which is still an urgent problem to be solved, the present invention provides a three-dimensional crushed stone aggregate generation method based on a generative adversarial network.

[0006] In order to achieve the above object, the present invention provides the following technical solutions:

[0007] A method for generating three-dimensional crushed aggregate based on a generative adversarial network, comprising the following steps:

[0008] Voxelize three-dimensional crushed aggregate grid data in different formats to obtain training three-dimensional crushed aggregate voxel grid data;

[0009] Construct a generator model based on a five-layer three-dimensional transposed convolutional network, and construct a discriminator based on a five-layer three-dimensional convolutional network. The generator model and the discriminator constitute a generative adversarial network GAN model;

[0010] Use batch data points of size (100, 1, 1, 1) as input and training three-dimensional crushed aggregate voxel grid data as output to perform adversarial training on the GAN model. During the training process, input the batch data points into the generator model to generate new three-dimensional crushed aggregate voxel grids. The discriminator determines whether the new three-dimensional crushed aggregate voxel grids are real data based on the training three-dimensional crushed aggregate voxel grid data; when it is determined that the new three-dimensional crushed aggregate voxel grids are real data, the training is completed to obtain the 3DStoneGAN model;

[0011] Input a random noise vector into the 3DStoneGAN model, generate three-dimensional crushed aggregate voxel grid sample data through the generator of the 3DStoneGAN model, and perform post-processing on the three-dimensional crushed aggregate voxel grid samples to obtain a three-dimensional crushed aggregate model.

[0012] Preferably, before model training, it also includes preprocessing the training three-dimensional crushed aggregate voxel grid data, specifically including the following steps:

[0013] If the voxel grid size in a certain dimension exceeds the target resolution, scale that dimension; if the voxel grid size in a certain dimension is less than the target resolution, create a zero-padded three-dimensional array with the target resolution by zero-padding, and copy the voxel grids smaller than the preset value to the corresponding positions of the array;

[0014] Use linear interpolation to adjust the size of the voxel grid after dimension scaling or grid copying.

[0015] Preferably, the first layer of the generator model uses a 3D deconvolution layer to convert the input latent space of size 100 into a three-dimensional space output with 512 channels through a convolution operation;

[0016] Use multiple "Conv+BN+Relu" combined structures to gradually change the output of the three-dimensional crushed aggregate voxel grid as the size of the input data and the number of channels change.

[0017] Preferably, the first layer of the discriminator uses a 3D convolutional layer to downsample the input three-dimensional crushed aggregate voxel grid and increase the number of feature channels through a convolution operation;

[0018] The "Conv3D + BN + LeakyRelu" structure is reused multiple times, and the spatial dimension is further reduced through downsampling operations, while increasing the number of feature channels until the final output layer; in the last layer of the discriminator, the Sigmoid activation function is used to obtain a single output value, which is used to judge whether the input data is real data. A value close to 1 indicates real, and a value close to 0 indicates fake.

[0019] Preferably, during the adversarial training process, the binary cross-entropy loss function is used, and the minimax game algorithm is adopted to optimize the generator model and the discriminator; the discriminator resets the gradient in each batch, generates fake data, calculates the outputs of real data and fake data, and then calculates the loss d_loss and performs backpropagation to update the weights; the generator resets the gradient, generates new fake data, calculates the loss g_loss, and deceives the discriminator by generating forged crushed aggregate, thereby performing backpropagation and updating the weights.

[0020] Preferably, the binary cross-entropy loss BCE Loss includes;

[0021] The loss function of the discriminator

[0022]

[0023] The loss function of the generator

[0024]

[0025] In the formula, E is the mean of the random variable, x ~ p data(x) is the mathematical expectation of the data set, p data(x) is the real data distribution, D(X) is the probability that the sample x assigned by the generator is real, and G(Z) is the output of the generator for the random input z sampled from the prior distribution P z (Z).

[0026] Preferably, the post-processing of the three-dimensional crushed aggregate voxel grid sample includes:

[0027] Removing the isolated points in the three-dimensional crushed aggregate voxel grid sample and retaining the largest connected body;

[0028] Performing an interpolation operation on the three-dimensional crushed aggregate voxel grid sample retaining the largest connected body to fill the internal voids;

[0029] Eliminating the holes on the surface of the sample after filling the internal voids through three-dimensional morphological closing operations, where the aperture of the holes is less than a preset value;

[0030] The Marching Cubes algorithm is used to extract the isosurface from the samples after eliminating holes and generate a mesh model;

[0031] The Laplacian smoothing algorithm is used to optimize the mesh surface of the mesh model and generate a three-dimensional crushed aggregate model.

[0032] The present invention also proposes a three-dimensional crushed aggregate generation system based on a generative adversarial network, including:

[0033] A data processing module for voxelizing three-dimensional crushed aggregate mesh data in different formats to obtain training three-dimensional crushed aggregate voxel mesh data;

[0034] A model construction module for constructing a generator model based on a five-layer three-dimensional transposed convolutional network and constructing a discriminator based on a five-layer three-dimensional convolutional network. The generator model and the discriminator constitute a generative adversarial network GAN model;

[0035] A model training module for performing adversarial training on the GAN model with batch data points of size (100, 1, 1, 1) as input and training three-dimensional crushed aggregate voxel mesh data as output. During the training process, the batch data points are input into the generator model to generate new three-dimensional crushed aggregate voxel meshes, and the discriminator determines whether the new three-dimensional crushed aggregate voxel meshes are real data through the training three-dimensional crushed aggregate voxel mesh data; when it is determined that the new three-dimensional crushed aggregate voxel meshes are real data, the training is completed to obtain a 3DStoneGAN model;

[0036] An aggregate generation module for inputting a random noise vector into the 3DStoneGAN model, generating three-dimensional crushed aggregate voxel mesh sample data through the generator of the 3DStoneGAN model, and performing post-processing on the three-dimensional crushed aggregate voxel mesh samples to obtain a three-dimensional crushed aggregate model.

[0037] The present invention also provides a computer device, including a memory, a processor, and a computer program stored on the memory. The processor executes the computer program to implement the steps of any one of the three-dimensional crushed aggregate generation methods based on a generative adversarial network.

[0038] The present invention also provides a computer-readable storage medium. When the computer program stored on the storage medium is loaded by a processor, it can execute the steps of any one of the three-dimensional crushed aggregate generation methods based on a generative adversarial network.

[0039] The three-dimensional crushed aggregate generation method based on a generative adversarial network provided by the present invention has the following beneficial effects:

[0040] In the present invention, by performing voxelization processing on three-dimensional crushed aggregate grid data in different formats, it is transformed into unified three-dimensional crushed aggregate voxel grid data for training. The data format after voxelization is relatively unified, avoiding the problems brought by the original multiple complex formats and simplifying the data processing flow. Moreover, in subsequent model training, the voxelized data can be used more efficiently by the model, alleviating to a certain extent the problem of a substantial increase in the computing and storage requirements for high-resolution three-dimensional models and expanding the application scope.

[0041] By constructing a generator model based on a five-layer three-dimensional transposed convolutional network and a discriminator based on a five-layer three-dimensional convolutional network, a generative adversarial network (GAN) model is formed. This network structure designed for three-dimensional data is more adaptable to the spatial complexity of three-dimensional data compared to directly extending two-dimensional GAN to three dimensions. Through the three-dimensional convolutional network, the spatial features of three-dimensional data can be better learned, reducing problems such as incomplete structure or insufficient details in the generated three-dimensional samples, and improving the generation efficiency and quality. Based on the training data after voxelization processing, during the training process, the discriminator continuously judges whether the newly generated three-dimensional crushed aggregate voxel grid by the generator is real through the real three-dimensional crushed aggregate voxel grid data for training. This adversarial training method prompts the generator to continuously optimize, avoiding the generated samples concentrating on a few patterns, reducing the mode collapse phenomenon, and improving the diversity and quality stability of the generation results, especially effectively alleviating this prominent problem in the three-dimensional object generation task. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the embodiments of the present invention and their design schemes, the following will briefly introduce the drawings required for this embodiment. The drawings described below are only partial embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can be obtained based on these drawings.

[0043] Figure 1 It is a flowchart of a three-dimensional crushed aggregate generation method based on a generative adversarial network provided by an embodiment of the present invention;

[0044] Figure 2 It is a general architecture diagram of GAN according to an embodiment of the present invention;

[0045] Figure 3 It is a detailed architecture diagram of GAN according to an embodiment of the present invention; wherein, Figure 3 (a) is a generator diagram of the GAN architecture according to an embodiment of the present invention; Figure 3 (b) is a discriminator diagram of the GAN architecture according to an embodiment of the present invention; Figure 3 (c) is a schematic diagram of the principle of the GAN architecture according to an embodiment of the present invention;

[0046] Figure 4Some sample images generated by the trained 3DStoneGAN model according to the embodiments of the present invention; Figure 4 In (a), (c), and (e) of Figure 4 , the effect diagrams of a stone model generated when the main resolution is 64, 45, and 32 respectively; Figure 4 In (b), (d), and (f) of Figure 4 , the effect diagrams of another stone model generated when the main resolution is 64, 45, and 32 respectively;

[0047] Figure 5 The application effect diagram of the post - processing algorithm according to the embodiments of the present invention; among them, Figure 5 In (a) of Figure 5 , the effect diagram of the generated stone model without post - processing; Figure 5 In (b) of Figure 5 , the effect diagram of the generated stone model after post - processing. Specific embodiments

[0048] In order to enable those skilled in the art to better understand the technical solutions of the present invention and be able to implement them, the present invention will be described in detail below with reference to the accompanying drawings and specific embodiments. The following embodiments are only used to more clearly illustrate the technical solutions of the present invention and cannot be used to limit the protection scope of the present invention.

[0049] Embodiment 1

[0050] The present invention provides a method for generating three - dimensional crushed stone aggregates based on a generative adversarial network, specifically a method for generating three - dimensional crushed stone aggregates based on a generative adversarial network (GAN, as shown in Figure 2 ), as shown in Figure 1 . The implementation of this method includes the following steps:

[0051] Step 1, load the three - dimensional crushed stone aggregate grid data, perform voxelization processing on the loaded grid data, and pre - process the data after voxelization processing to construct a training dataset. Specifically, it includes:

[0052] First, load the three - dimensional crushed stone aggregate grid data. The grid data is usually in.obj,.stl, or.ply format, and the data contains vertex, edge, and face information.

[0053] Next, perform voxelization processing on the loaded grid data. Specifically, it includes the following steps: translate the grid to the coordinate origin to unify the coordinate system; scale the grid to a unit cube to ensure the unity of data size; then, use the trimish.voxelize tool to perform voxelization processing on the grid to obtain a three - dimensional array of size N×N×N, where each voxel represents whether the corresponding space in the grid is occupied.

[0054] Finally, the data preprocessing operation in Step 1 is an essential step in the 3D crushed aggregate generation process based on the generative adversarial network. Its purpose is to convert the 3D model data into standardized input data suitable for deep learning models. The specific steps are as follows:

[0055] Preprocess the voxel grid and adjust the size uniformly: If the voxel grid size in a certain dimension exceeds the target resolution, scale that dimension; if the voxel grid size is smaller than the target resolution, create a zero-padded 3D array of the target resolution by zero-padding, and copy the smaller voxel grid to the corresponding position in this array; finally, use linear interpolation to adjust the size of the voxel grid to ensure that all voxel grids conform to the unified target resolution. Finally, convert the processed voxel grid into a PyTorch-compatible Tensor format to support GPU batch processing and generate a PyTorch dataset suitable for deep learning training.

[0056] Step 2, construct the generator and discriminator, and form a generative adversarial network GAN model through the generator model and the discriminator.

[0057] Specifically, in Step 2, the generator and discriminator of the present invention are respectively responsible for generating high-fidelity 3D crushed aggregate voxel grid samples and determining the authenticity of the generated samples. The specific construction is as follows:

[0058] The architecture diagram of the generator is as shown in Figure 3 Figure (a). The input of the generator is a batch of input data points (random noise input) of size (100, 1, 1, 1). First, use the first layer of 3D transposed convolution layer (ConvTranspose3D) to convert the input latent space (size 100) into a larger 3D space output (512 channels) through convolution operations. The convolution kernel size of this transposed convolution layer is (4, 4, 4), the stride is 1, and no padding is used. Then, add a batch normalization (BN) layer, which is used to stabilize the training of the model during training and avoid problems such as gradient disappearance or gradient explosion. For this layer, use the 'Relu' activation function to introduce non-linearity.

[0059] Next, use multiple "Conv + BN + Relu" combined structures. As the number of channels gradually changes (512 → 256 → 128 → 64) until the output layer. Each layer's operation will adjust the spatial resolution and change the number of channels through the convolution kernel. The output of the generator is a 3D data with 1 channel and a size of 64×64×64. This layer uses the 'Tanh' activation function, and the output range is [-1, +1], representing the content of the generated 3D image.

[0060] The architecture diagram of the discriminator is as shown in Figure 3As shown in (b), the task of the discriminator is to determine whether the input image is from the real dataset or a fake image generated by the generator. The input to the discriminator is three-dimensional data with a size of 64×64×64 and only one channel. The first layer of the discriminator uses a 3D convolutional layer (Conv3D) to downsample the spatial dimensions of the input image from (64×64×64) to (32×32×32) and increase the number of feature channels (from 1 to 64) through the convolution operation. The convolutional kernel size of this layer is (4,4,4), the stride is 2, and the padding is 1. Next, the discriminator repeatedly uses the "Conv3D+BN+LeakyRelu" structure multiple times to further reduce the spatial dimensions through downsampling operations and increase the number of feature channels. Specifically, the number of channels gradually increases from 64 to 512, while the spatial dimensions are successively reduced to 16×16×16, 8×8×8, and 4×4×4 until the final output layer. In the last layer of the discriminator, a Sigmoid activation function is used to obtain a single output value, which is used to determine whether the input image is real data (close to 1 indicates real, close to 0 indicates fake).

[0061] Step 3, training and optimization of the network.

[0062] The working diagrams of the generator and discriminator are as shown in Figure 3 As shown in (c). The parameter settings of the generator and discriminator determine the number of their trainable parameters. The total number of trainable parameters of the generator is 14,290,944, and the total number of trainable parameters of the discriminator is 11,046,912. During the training process, these parameters will be adjusted according to the optimization objective to improve the performance of the generator and discriminator, ensuring the quality of the generated images and the accuracy of discrimination. Through the above structural design, the generator and discriminator can work effectively together to generate realistic three-dimensional images and accurately judge the authenticity of the images. And it has high training efficiency and model accuracy.

[0063] Table 1 and Table 2 list the architectures and parameter configurations of the generator and discriminator in detail respectively.

[0064] Table 1 Generator Architecture

[0065]

[0066]

[0067] Table 2 Discriminator Architecture

[0068]

[0069] Specifically, Table 3 lists the training options of the GAN model.

[0070] In the present invention, the generator (Stone Generator) and discriminator (Stone Discriminator) models are initialized. The size of the latent vector is set to 100, and the output size is a cube of 64×64×64 with a single channel. Both are deployed on the GPU for calculation. The optimizer uses the Adam optimizer with a learning rate of 0.0001, and the β parameters are set to (0.5, 0.999). During the training process, the binary cross-entropy loss function (BCE Loss) is used for optimization.

[0071] Specifically, the binary cross-entropy loss BCE Loss includes;

[0072] The loss function of the discriminator

[0073]

[0074] The loss function of the generator

[0075]

[0076] In the formula, E is the mean of the random variable, x~p data(x) is the mathematical expectation of the data set, p data(x) is the true data distribution, D(X) is the probability that the sample x assigned by the generator is true, and G(Z) is the output of the generator for the random input z sampled from the prior distribution P z (Z).

[0077] The entire training process runs for 6000 epochs, and each epoch iterates through the data batches in the training set. Specifically, the discriminator resets the gradients in each batch, generates fake data, calculates the outputs of the real data and the fake data, then calculates the loss (d_loss) and performs backpropagation to update the weights; the generator resets the gradients, generates new fake data, calculates the loss (g_loss), and tries to deceive the discriminator by generating forged crushed stone aggregates, thus performing backpropagation and updating the weights. Every 100 batches, the training progress prints the current epoch, batch, discriminator loss, and generator loss. The optimization goal of the entire training is to enable the generator to generate more realistic crushed stone aggregates, while the discriminator learns to more effectively distinguish between real and forged samples.

[0078] Table 3 Training items

[0079]

[0080] After completing the GAN training, a three-dimensional gravel aggregate generation adversarial network model based on the generative adversarial network is obtained, namely the 3DStoneGAN model. Among them, only the generator model is used. By providing it with random inputs, new gravel aggregates are generated, and the output is the gravel aggregate structure.

[0081] Step 4: Perform three-dimensional sample generation and post-processing operations through the trained 3DStoneGAN model.

[0082] Specifically, in Step 4, after the 3DStoneGAN model is trained, a random noise vector is input into the generator model to generate a new three-dimensional gravel aggregate voxel grid sample. Since the generated samples may have uneven contours and internal voids, post-processing operations are required to optimize them. The specific post-processing steps are as follows:

[0083] Remove isolated points in the voxel grid and only retain the largest connected component: Identify the connected component in the voxel grid through connectivity analysis. First, perform connected component labeling on the binary voxel grid V th and calculate the size of each component Cs = count(l(x,y,z)). Only retain the largest connected component, and the remaining isolated points are removed to optimize the structural integrity of the sample. The formula is as follows:

[0084]

[0085] In the formula, C S is the size of the connected component; where l(x,y,z) represents the label of the voxel at position (x,y,z).

[0086] Use the interpolation method to fill voids: Perform interpolation operations on the voxel grid to improve the resolution and fill internal voids. The interpolation operation effectively improves the resolution of the three-dimensional voxel model and fills the voids in the generated samples. For a voxel grid V(x,y,z), define a high-resolution grid V(x',y',z'), and use the nearest neighbor interpolation function f(x',y',z') to calculate the interpolation value. The formula is as follows:

[0087] V interp (x',y',z') = f(x',y',z');

[0088] f(x',y',z') = V(round(x'),round(y'),round(z'));

[0089] In the formula, V is the voxel network, (x,y,z) where x ∈ [0,N x -1], y ∈ [0,N y -1], z ∈ [0,N zThe coordinates of (-1]), (x’, y’, z’) are coordinates with higher resolution, and f(x', y', z') is the nearest neighbor interpolation function.

[0090] Eliminate small holes through three-dimensional morphological closing operation: The morphological closing uses a three-dimensional morphological closing operation to fill the tiny holes on the sample surface and avoid over-smoothing. Through a three-dimensional structure element B with size k, perform dilation operation and erosion operation on the voxel grid in sequence. The formula is as follows:

[0091]

[0092] In the formula, B is the structure element, represents the dilation operation, - represents the erosion operation

[0093] Generate a mesh model using the Marching Cubes algorithm: Extract the isosurface from the binary voxel grid through the Marching Cubes algorithm. For a given threshold (set to 0.5 in the implementation), calculate the vertices V and faces F of the mesh to form the final mesh M(V closed ).

[0094] Optimize the mesh surface using the Laplacian smoothing algorithm: Perform Laplacian smoothing on the generated mesh to reduce surface noise and sharp edges. The new position of each vertex v i is updated by iteratively calculating the average value of neighboring vertices. The formula is as follows:

[0095]

[0096] In the formula, v j t represents the position of the vertex, v i (t+1) represents the position of the vertex after update iteration, N(i) represents the set of neighbors, and d i represents the degree of node i.

[0097] For the analysis results of different resolutions, such as Figure 4As shown, there are significant differences in the quality of samples generated by the 3D crushed aggregate generation method based on the generative adversarial network at different resolutions (32×32×32, 45×45×45, and 64×64×64). For the 32×32×32 resolution, the overall structure of the generated samples is relatively rough, the surface texture is blurred, and only the general shape of the crushed aggregate can be presented, which is suitable for low-precision requirements; while at the 45×45×45 resolution, the surface details and coherence of the crushed aggregate have been significantly improved, the surface is smoother, and it is suitable for scenarios with medium-precision requirements; when the resolution is increased to 64×64×64, the texture clarity, surface fineness, and structural integrity of the generated samples reach the highest level, which is suitable for high-precision design scenarios.

[0098] For comparing the results of samples before and after post-processing, as Figure 5 shown, among which, Figure 5 (a) in it is the rendering of the generated stone model without post-processing; Figure 5 (b) in it is the rendering of the generated stone model after post-processing. As can be seen from Figure 5 (a), isolated points, surface voids, and irregular protrusions are common in the samples without post-processing, and the overall structural integrity is poor. As can be seen from Figure 5 (b), after the post-processing operation, by removing isolated points, interpolating to fill voids, morphological closing operation, and Laplacian smoothing optimization, the surface smoothness of the samples is significantly improved, small holes are effectively filled, and the generated crushed aggregate model is closer to the true appearance of the actual material. Especially at the 64×64×64 resolution, the samples optimized by post-processing show high-quality texture coherence and structural integrity, and are the generation results closest to the true crushed aggregate. Through the dual optimization of resolution and post-processing, the generated samples show strong application potential under different precision requirements.

[0099] The 3D crushed aggregate generation method based on the generative adversarial network proposed by the present invention solves the problems of diverse and complex 3D data formats through unified data voxelization processing, provides convenience for subsequent model training, improves data processing efficiency, and reduces the complexity of calculation and storage. Through the customized 3D convolutional network structure generator and discriminator, which are specifically designed for 3D data and are more adaptable to the spatial characteristics of 3D data, it can generate higher-quality, structurally complete, and detail-rich 3D models, improving the generation efficiency and quality. Based on the adversarial training method, it effectively reduces the problem of mode collapse in GAN training, ensures the diversity of generated samples, makes the generated results more stable and reliable, and enhances the practicality of the model in 3D object generation tasks.

[0100] Therefore, in the present invention, by loading a three-dimensional crushed aggregate model file and performing data preprocessing, after converting it into a standardized three-dimensional voxel grid, the generator gradually generates high-resolution three-dimensional crushed aggregates through a five-layer three-dimensional transposed convolutional network. The discriminator is used to determine whether the generated three-dimensional voxel grid is a real sample. During the adversarial training process, the generator and the discriminator are continuously optimized, and the finally generated samples have high realism and structural integrity. The post-processing operations include removing isolated points, interpolating to fill gaps, morphological closing operations, and surface smoothing to optimize the surface smoothness and details of the generated samples. This invention can support the generation requirements of different resolutions and support multiple file format inputs, and has the advantages of high generation quality, strong training stability, and wide application, and is applicable to fields such as architectural design, virtual reality, and game development.

[0101] Based on the same inventive concept, the present invention also provides a three-dimensional crushed aggregate generation system based on a generative adversarial network, including a data processing module, a model construction module, a model training module, and an aggregate generation module.

[0102] Specifically, the data processing module is used to perform voxelization processing on three-dimensional crushed aggregate grid data in different formats to obtain training three-dimensional crushed aggregate voxel grid data.

[0103] The model construction module is used to construct a generator model based on a five-layer three-dimensional transposed convolutional network and construct a discriminator based on a five-layer three-dimensional convolutional network. The generator model and the discriminator constitute a generative adversarial network GAN model.

[0104] The model training module is used to perform adversarial training on the GAN model with batch data points of size (100, 1, 1, 1) as the input and training three-dimensional crushed aggregate voxel grid data as the output. During the training process, the batch data points are input into the generator model to generate new three-dimensional crushed aggregate voxel grids, and the discriminator determines whether the new three-dimensional crushed aggregate voxel grids are real data through the training three-dimensional crushed aggregate voxel grid data; when it is determined that the new three-dimensional crushed aggregate voxel grids are real data, the training is completed to obtain a 3DStoneGAN model.

[0105] The aggregate generation module is used to input a random noise vector into the 3DStoneGAN model, generate three-dimensional crushed aggregate voxel grid sample data through the generator of the 3DStoneGAN model, and perform post-processing on the three-dimensional crushed aggregate voxel grid samples to obtain a three-dimensional crushed aggregate model.

[0106] Each module in the above three-dimensional crushed aggregate generation system based on a generative adversarial network can be implemented in whole or in part by software, hardware, or a combination thereof. Each of the above modules can be embedded in the processor of a computer device in hardware form or be independent of it, or can be stored in the memory of the computer device in software form, so that the processor can call and execute the operations corresponding to each of the above modules.

[0107] The present invention also provides a computer device, including a memory, a processor, and a computer program stored on the memory. The processor executes the computer program to implement the steps in the embodiment of the method for generating three-dimensional crushed aggregates. For the specific implementation method, reference can be made to the method embodiment, which will not be elaborated here.

[0108] Furthermore, the present invention also provides a non-transitory computer-readable storage medium containing instructions, on which a computer program is stored. For example, a memory containing instructions, and the above instructions can be executed by the processor of a computer device to complete the above method. For example, the non-transitory computer-readable storage medium can be a ROM, a random access memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, and an optical data storage device, etc. When the computer program is executed by the processor, it can implement the steps in the embodiment of the method for generating three-dimensional crushed aggregates. For the specific implementation method, reference can be made to the method embodiment, which will not be elaborated here.

[0109] Those skilled in the art should understand that the embodiments of the present invention can provide a method, a system, or a computer program product. Therefore, the present invention can be implemented in the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, the present invention can be implemented in the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk memories, CD-ROMs, optical memories, etc.) containing computer-usable program codes.

[0110] The present invention is described with reference to the flowcharts and / or block diagrams of methods, apparatuses (systems), and computer program products according to the embodiments of the present invention. It should be understood that each flow and / or block in the flowcharts and / or block diagrams can be implemented by computer program instructions, and the combination of the flows and / or blocks in the flowcharts and / or block diagrams can also be implemented. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing devices generate a device for implementing the specified functions in Figure 1 one or more flows or multiple flows and / or blocks Figure 1 one or more blocks or multiple blocks.

[0111] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to operate in a particular manner, such that the instructions stored in the computer-readable memory produce a manufacture including instruction means that implement the functions specified in one or more of the procedures Figure 1 one or more procedures and / or boxes Figure 1 and / or boxes specified.

[0112] These computer program instructions can also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer-implemented process, whereby the instructions executed on the computer or other programmable apparatus provide steps for implementing the functions specified in one or more of the procedures Figure 1 one or more procedures and / or boxes Figure 1 and / or boxes specified.

[0113] It should be noted that the above-described specific embodiments can enable those skilled in the art to more comprehensively understand the present invention, but do not limit the present invention in any way. Therefore, although this specification and the embodiments have described the present invention in detail, those skilled in the art should understand that the present invention can still be modified or equivalently replaced; and all technical solutions and improvements that do not depart from the spirit and scope of the present invention are covered by the protection scope of the patent of the present invention. Any reference numeral in the claims should not be regarded as limiting the claimed claim. Any simple change or equivalent replacement of the technical solutions that can be obviously obtained by any person skilled in the art within the technical scope disclosed by the present invention belongs to the protection scope of the present invention.

Claims

1. A three-dimensional crushed aggregate generation method based on a generative adversarial network, characterized in that Including: Voxelize the 3D crushed aggregate grid data in different formats to obtain the 3D crushed aggregate voxel grid data for training; Construct a generator model based on a five-layer 3D transposed convolutional network, and construct a discriminator based on a five-layer 3D convolutional network. The generator model and the discriminator constitute a generative adversarial network GAN model; Use a batch of data points of size (100, 1, 1, 1) as input and the 3D crushed aggregate voxel grid data for training as output to perform adversarial training on the GAN model. During the training process, input the batch of data points into the generator model to generate a new 3D crushed aggregate voxel grid. The discriminator determines whether the new 3D crushed aggregate voxel grid is real data based on the 3D crushed aggregate voxel grid data for training; When it is determined that the new 3D crushed aggregate voxel grid is real data, the training is completed to obtain the 3DStoneGAN model; Input a random noise vector into the 3DStoneGAN model, generate 3D crushed aggregate voxel grid sample data through the generator of the 3DStoneGAN model, and perform post-processing on the 3D crushed aggregate voxel grid sample to obtain a 3D crushed aggregate model.

2. The three-dimensional crushed aggregate generation method based on a generative adversarial network according to claim 1, characterized in that, Before model training, it also includes preprocessing the 3D crushed aggregate voxel grid data for training, specifically including the following steps: If the voxel grid size of a certain dimension exceeds the target resolution, scale that dimension; if the voxel grid size of a certain dimension is less than the target resolution, create a zero-padded 3D array of the target resolution by zero-padding, and copy the voxel grid smaller than the preset value to the corresponding position of the array; Use linear interpolation to adjust the size of the voxel grid after dimension scaling or grid copying.

3. The three-dimensional crushed aggregate generation method based on a generative adversarial network according to claim 1, characterized in that, The generator model uses the first layer of 3D transposed convolutional layer to convert the input latent space of size 100 into a 3D space output with 512 channels through convolutional operations; Use multiple "Conv+BN+Relu" combined structures, and gradually change the output of the 3D crushed aggregate voxel grid as the size and number of channels of the input data change.

4. The method for generating three-dimensional crushed aggregate based on a generative adversarial network according to claim 3, wherein The first layer of the discriminator uses a 3D convolutional layer to downsample the input 3D crushed aggregate voxel grid and increase the number of feature channels through convolutional operations; Repeat the use of the "Conv3D+BN+LeakyRelu" structure multiple times, further reduce the spatial size through downsampling operations, and increase the number of feature channels until the final output layer; in the last layer of the discriminator, use the Sigmoid activation function to obtain a single output value, which is used to determine whether the input data is real data. A value close to 1 indicates real, and a value close to 0 indicates fake.

5. The three-dimensional crushed aggregate generation method based on a generative adversarial network according to claim 1, characterized in that, Use the binary cross-entropy loss function and the minimax game algorithm to optimize the generator model and the discriminator during the adversarial training process; the discriminator resets the gradient in each batch, generates fake data, and calculates the outputs of the real data and the fake data, and then calculates the loss d_loss and performs backpropagation to update the weights; The generator resets the gradient, generates new fake data, calculates the loss g_loss, and deceives the discriminator by generating forged crushed aggregates, thereby performing backpropagation and updating the weights.

6. The three-dimensional crushed aggregate generation method based on a generative adversarial network according to claim 5, characterized in that The binary cross-entropy loss BCE Loss includes; Loss function of the discriminator Loss function of the generator Where E is usually the mean of a random variable, and x ~ p data(x) is the mathematical expectation of the data set, and p data(x) is the true data distribution, D(X) is the probability that the sample x assigned by the generator is real, and G(Z) is the output of the generator for the random input z sampled from the prior distribution P z (Z).

7. The three-dimensional crushed aggregate generation method based on a generative adversarial network according to claim 1, wherein The post-processing of the three-dimensional crushed aggregate voxel grid sample includes: Removing the isolated points in the three-dimensional crushed aggregate voxel grid sample and retaining the largest connected component; Performing an interpolation operation on the three-dimensional crushed aggregate voxel grid sample that retains the largest connected component to fill the internal voids; Eliminating the holes on the surface of the sample after filling the internal voids through a three-dimensional morphological closing operation, where the aperture of the holes is less than a preset value; Using the Marching Cubes algorithm to extract the isosurface from the sample after eliminating the holes to generate a mesh model; Using the Laplacian smoothing algorithm to optimize the mesh surface of the mesh model to generate a three-dimensional crushed aggregate model.

8. A three-dimensional crushed aggregate generation system based on a generative adversarial network, characterized in that, Including: A data processing module for voxelizing three-dimensional crushed aggregate grid data in different formats to obtain training three-dimensional crushed aggregate voxel grid data; A model construction module for constructing a generator model based on a five-layer three-dimensional transposed convolutional network and constructing a discriminator based on a five-layer three-dimensional convolutional network, where the generator model and the discriminator constitute a generative adversarial network GAN model; A model training module for performing adversarial training on the GAN model with batch data points of size (100,1,1,1) as input and training three-dimensional crushed aggregate voxel grid data as output. During the training process, the batch data points are input into the generator model to generate new three-dimensional crushed aggregate voxel grids, and the discriminator determines whether the new three-dimensional crushed aggregate voxel grids are real data through the training three-dimensional crushed aggregate voxel grid data; When it is determined that the new three-dimensional crushed aggregate voxel grid is real data, the training is completed to obtain a 3DStoneGAN model; An aggregate generation module for inputting a random noise vector into the 3DStoneGAN model, generating three-dimensional crushed aggregate voxel grid sample data through the generator of the 3DStoneGAN model, and performing post-processing on the three-dimensional crushed aggregate voxel grid sample to obtain a three-dimensional crushed aggregate model.

9. A computer device, comprising a memory, a processor, and a computer program stored on the memory, characterized in that, The processor executes the computer program to implement the steps of the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is loaded by the processor, it can execute the steps of the method according to any one of claims 1 to 7.

Images