A 3D printing concrete three-dimensional reconstruction method based on Gaussian sputtering

Abstract

This invention discloses a 3D reconstruction method for 3D printed concrete based on Gaussian sputtering, comprising the following steps: Step 1): Obtaining an RGBA image with the background removed; Step 2): Obtaining a predicted depth map using the existing monocular depth prediction model Marigold; Step 3): Performing sparse reconstruction using COLMAP to obtain sparse point clouds, camera intrinsics, and camera pose, creating a multi-view image dataset of the 3D printed concrete surface; Step 4): Using the predicted depth map from Marigold as a depth prior, regularizing the depth and normal of the 3D Gaussian sputtering model; Step 5): Calculating the minimum axis-aligned bounding box based on the sparse point cloud, and then expanding it outward to constrain the position of the 3D Gaussian sputtering model; Step 6): Generating a corresponding dense point cloud model; Step 7): Processing the generated dense point cloud model; thus achieving 3D reconstruction of 3D printed concrete. This invention can promote the sustainable development of 3D printed concrete technology in the construction industry.

Description

Technical Field

[0001] This invention relates to the field of concrete three-dimensional reconstruction technology, and specifically to a 3D printing concrete three-dimensional reconstruction method based on Gaussian sputtering. Background Technology

[0002] With the development of intelligent construction technology, 3D-printed concrete, as a highly controllable new construction method, is gradually being applied to the rapid prototyping of small and medium-sized structures and complex components. However, due to factors such as uneven material layer stacking, construction errors, and environmental interference, 3D-printed concrete components often exhibit structural defects such as geometric deformation. Therefore, there is an urgent need for an efficient and accurate three-dimensional reconstruction method to perform structural analysis, quality assessment, and optimization control. Traditional 3D reconstruction methods mostly rely on laser scanners to acquire point cloud data. Although these methods offer high accuracy, they are expensive, complex to operate, and have stringent requirements for the construction environment, limiting their widespread application in on-site or low-cost construction processes.

[0003] In the prior art, there is a method and system for underwater concrete 3D reconstruction based on the fusion of line structured light and stereo vision, which is disclosed in CN120107473A. This system deploys multimodal imaging devices to collect depth map and texture map data of concrete and generate a fused point cloud data model. It is costly and complex to operate, and deploying these devices faces considerable challenges, which limits its application in practical engineering. At the same time, this method relies on the joint calibration and synchronous imaging of structured light and stereo vision, which is highly sensitive to ambient light, water turbidity and imaging distance. The quality of the generated point cloud is easily affected by noise, water flow disturbance and other factors, requiring additional motion compensation and deformation repair steps. The overall process is complicated and cannot meet the requirements of conventional concrete component 3D reconstruction for simplified equipment, improved reconstruction accuracy and robustness. Summary of the Invention

[0004] In order to overcome the shortcomings of the existing technology, the purpose of this invention is to provide a 3D reconstruction method for 3D printed concrete based on Gaussian sputtering. This method enhances the quality of 3DGS reconstruction of 3D printed concrete surfaces, so as to promote the sustainable development of 3D printed concrete technology in the construction industry.

[0005] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering includes the following steps; Step 1): Use a camera to acquire multi-view RGB images of the 3D printed concrete model, and then process the acquired RGB images to obtain RGBA images with the background removed; Step 2): Using the existing monocular depth prediction model Marigold, input an RGBA image with the background removed, and output the corresponding predicted depth map; Step 3): Based on the RGB data preprocessed in Step 1), COLMAP is used to perform sparse reconstruction to obtain sparse point clouds, camera intrinsics, and camera pose. A multi-view image dataset of 3D printed concrete surface is created based on the RGB images preprocessed in Step 1 and the predicted depth map in Step 2. Step 4): Using Marigold's predicted depth map as a depth prior, regularize the depth and normal of the 3D Gaussian. Step 5): Add bounding box constraint loss to the algorithm, calculate the minimum axis-aligned bounding box (AABB) based on the sparse point cloud, and then expand it outward by 10% as the initial bounding box to constrain the position of the 3D Gaussian. Step 6): Train the multi-view image dataset of 3D printed concrete surface created in Step 3) using 3DGS to generate the corresponding dense point cloud model; Step 7): Process the generated dense point cloud model, including downsampling, SOR noise reduction, radius filtering, and DBSCAN clustering filtering, to achieve 3D reconstruction of 3D printed concrete; Step 8): Compare and verify the 3D reconstructed point cloud model with the laser-scanned point cloud model, and evaluate the model performance using relevant evaluation metrics.

[0006] The multi-view RGB images acquired in step 1) are derived from 3D printed concrete test block components printed in the 3D printed concrete laboratory. The acquired 3D printed concrete component images are segmented for the foreground and the white balance is unified using a convolutional neural network (CNN) with a U-Net structure. Calling the rembg library using Python - A convolutional neural network (CNN) with a Net structure segments the foreground of a multi-view RGB image. The model outputs a foreground / background segmentation mask, which is used to perform alpha blending on the original image to obtain a transparent background. Finally, an RGBA image with the background removed is returned.

[0007] Step 2) specifically includes: first, downloading the Marigold model and depth prediction checkpoint from the model library; then, configuring the model running environment and loading the checkpoint to complete model initialization on the computing device; inputting the preprocessed multi-view RGB images frame by frame into the monocular depth prediction model; the monocular depth prediction model extracts features and performs depth inversion through an encoder-decoder network, outputting a monocular predicted depth map corresponding to each image; by performing this inference process on all view images, complete multi-view depth map data is obtained.

[0008] Step 3) specifically includes: importing the multi-view RGB images processed in step 1) into COLMAP, performing feature extraction, feature matching, and sparse reconstruction in sequence to generate sparse point clouds and camera intrinsic and extrinsic parameters for each image; exporting the sparse model as cameras.txt, images.txt, and points3D.txt, and parsing images.txt to obtain the pose file required for 3D Gaussian Splatting (3DGS); saving the depth map obtained in step 2) according to the original image naming convention; and finally placing the RGB images, depth maps, pose files, and sparse point clouds into the images, depths, and sparse folders respectively to construct the 3DGS input dataset.

[0009] Step 4) specifically includes: The rendering normals are obtained by mixing the surface normal vectors of each Gaussian on the light source with the same weight as the opacity; the predicted normals are directly generated by regression during the training phase of the deep network; subsequently, a depth-normal regularization loss is formed; the input depth mask is binarized; the angle between the normals of the rendered normals and the predicted normals is calculated in the foreground region, and only pixels with an angle less than a threshold are retained as normal-consistent regions. The foreground consistent regions are merged with the background regions to obtain an effective mask, and the difference between the rendered depth and the predicted depth is calculated only within the mask; the depth loss further filters out outliers with squared errors exceeding a threshold, and finally, a weighted depth loss is calculated only for pixels that pass all conditions. and normal loss ; Step 5) specifically includes: aligning the bounding box (AABB) of the sparse point cloud along its axes, taking the minimum and maximum values ​​of each dimension of the point cloud, and expanding outward by 10% of the diagonal length as the margin to obtain the minimum and maximum values ​​of the bounding box; Introducing a bounding box constraint loss, for each Gaussian center point outside the bounding box, calculate the squared Euclidean distance to the nearest boundary, average the squared distances of all outside points, and then multiply by the weight. As a loss, the Gaussian position is constrained to remain within the bounding box through backpropagation.

[0010] Step 6) specifically includes: Using the multi-view image dataset constructed in step 3) as input, the three-dimensional Gaussian is initialized according to points3D.txt. Each three-dimensional point in the sparse point cloud is used as an initial Gaussian center, the covariance is set to an isotropic sphere, the color is taken from the RGB information of the sparse point cloud, and the transparency is initialized to 0.5 to obtain the initial low-density Gaussian representation. During training, the position, color, covariance scale, and transparency of the Gaussian are set as trainable variables. The 3DGS differentiable renderer combines the intrinsic and extrinsic parameters of each view camera to generate rendered images through projection and alpha blending. The photometric reprojection loss, depth loss, normal loss, and bounding box constraint loss are calculated. The Gaussian parameters are jointly optimized so that they gradually gather towards the surface of the real component and fill the space, evolving from sparse initialization to a complete dense 3D point cloud representation. In the early stage of training, the position and scale of Gaussians are frozen, and only color and transparency are optimized. In the middle stage, the position and covariance are gradually unfrozen to make the Gaussians converge to the real geometry and increase the point cloud density. In the later stage, the learning rate is reduced for fine optimization. During the training process, Gaussian pruning and merging are performed regularly to delete redundant Gaussians with low transparency in the long term and merge Gaussians with similar positions and consistent colors to suppress noise and maintain the compactness of the point cloud structure, and finally obtain a dense 3D point cloud model consistent with the target component.

[0011] Step 7) specifically includes: The dense point cloud obtained in step 6) is loaded into Open3D. Voxel downsampling is performed based on the point cloud size. The voxel size is calculated based on the point cloud bounding box size and the number of points. A safe voxel detection mechanism is used to gradually adjust the voxel size to ensure the number of points is within a reasonable range after downsampling before performing voxel downsampling. Statistical outlier filtering (SOR) is then applied to the downsampled point cloud. Outliers are identified and removed based on the local neighborhood distance of each point. Radius filtering is then performed, using a fixed search radius and the minimum number of neighborhood points to identify sparse regions and delete isolated or floating points. DBSCAN clustering is then performed on the point cloud, determining the cluster size based on density. Small clusters are identified as noise clusters and removed entirely. After outlier and noise clustering removal, normals are estimated using a neighborhood search-based normal calculation method, and the normal directions are made consistent. Finally, local smoothing is performed on the normals to ensure they are continuous and consistent within the spatial neighborhood, generating a smooth normal field suitable for subsequent reconstruction.

[0012] Step 8) specifically includes: For each pair of rendered and ground truth images, the peak signal-to-noise ratio (PSNR), structural similarity index (SSIM), and learned perceptual patch similarity (LPIPS) are calculated. Then, these three metrics are averaged across all viewpoints to obtain the final result. The reconstructed point cloud model is then read and registered with the ground truth model obtained from the laser scanner using the ICP algorithm. Finally, the chamfer distance (CD) is calculated.

[0013] The test analysis metrics in step 8) are: (1) Peak Signal-to-Noise Ratio (PSNR): A metric that measures the pixel error between the reconstructed image and the real image. The larger the value, the closer they are. (2) Structure Similarity Index Measure (SSIM): measures the similarity between two images in terms of brightness, contrast and structure. The closer to 1, the more similar they are. (3) Perceptual Image Patch Similarity (LPIPS): The perceptual difference between two images is compared using deep network features. The smaller the value, the more visually similar they are. (4) Chamfer Distance (CD): The proximity of two shapes is evaluated by calculating the distance from each point to the nearest point in the set of points of another point and averaging or summing all the points.

[0014] The beneficial effects of this invention are: This invention addresses practical applications by constructing a multi-view image dataset of 3D-printed concrete components and proposing a depth-prior-based 3D reconstruction model, Depth-3DGS, based on 3D Gaussian sputtering (3DGS). This model uses the classic 3DGS algorithm as a benchmark, incorporating depth and normal regularization constraints during the reconstruction process. Depth loss constrains the spatial position of the Gaussian distribution along the viewing direction, causing it to converge to the vicinity of the real surface. Normal loss corrects the local surface orientation and optimizes the geometry formed by the Gaussian distribution. These two methods work synergistically to constrain the 3D Gaussian distribution to approximate the real surface of the component from both position and shape perspectives, improving the geometric accuracy and surface consistency of the 3D reconstruction results.

[0015] This invention introduces bounding box constraint loss into the model, using scene axis-aligned bounding boxes determined by sparse point clouds to constrain the spatial distribution of 3D Gaussians. When the center of a Gaussian exceeds the bounding box range, the minimum Euclidean distance from it to the nearest bounding box surface is calculated, and the square of this distance is used as a penalty term. The penalties for all out-of-bounds Gaussians are averaged to form an overall constraint, thereby preventing Gaussians from spreading into invalid space, suppressing the generation of floating Gaussians and background noise, and improving the stability and accuracy of the reconstruction. Attached Figure Description

[0016] Figure 1 This is a multi-view RGB image dataset of 3D printed concrete for the present invention.

[0017] Figure 2 This is a flowchart illustrating the sparse reconstruction using COLMAP in this invention.

[0018] Figure 3 This is a flowchart of the Depth-3DGS training process of the present invention.

[0019] Figure 4 This is a flowchart of the point cloud data processing of the present invention. Detailed Implementation

[0020] The present invention will now be described in further detail with reference to the accompanying drawings.

[0021] Reference Figures 1-4 The specific steps of the present invention will be described in detail below.

[0022] Step 1: Use a camera to acquire multi-view RGB image data of the 3D printed concrete surface, and preprocess the images after acquisition.

[0023] In step one, a camera (48 megapixels) is used to photograph the 3D printed concrete test block component printed in the 3D printed concrete laboratory from various angles. When taking pictures, it is ensured that there is an overlap between adjacent angles of the test block, and the number of images is between 60 and 80.

[0024] The acquired multi-view RGB image data is preprocessed, including background removal and image numbering. Specifically, the background removal method calls the Rembg tool library and uses a U-Net-structured convolutional neural network (CNN) to segment the foreground, thus removing the background from the image. The statistics of each color channel are calculated, and the target values ​​of the three channels are unified into the same "grayscale / white point average value" to obtain the gain coefficient of each channel. These coefficients are used to linearly scale the B, G, and R channels of the entire image. Finally, the result is cropped to [0, 255] and output as the white-balanced image. The images are named in the format image_000x to facilitate the construction of the dataset in step three.

[0025] Step 2: Use the existing monocular depth prediction model Marigold to obtain the predicted depth map of the corresponding component; In step two, the first step is to obtain the trained monocular depth estimation model Marigold and deploy it on a computing device. Specifically, the corresponding version of the model weight file is downloaded from its official model library and placed in the preset weight folder in the model running directory as required. Then, the required runtime environment for the Marigold model is installed on the computing device, including dependency libraries, inference framework and GPU acceleration module, and the model initialization script is executed to load checkpoint, build network structure and allocate GPU memory resources.

[0026] After model preparation, the RGB images acquired in step one from each viewpoint are input frame by frame into the Marigold model. The model's encoder-decoder prediction network extracts and inverts depth features from the images, automatically generating a monocular predicted depth map corresponding to each RGB image. The Marigold model can infer the spatial depth distribution of objects based on image texture and structure without additional calibration or geometric priors, enabling rapid inference of depth information of concrete components from different shooting angles, and providing multi-view depth constraints for subsequent 3D reconstruction.

[0027] Step 3: Create a multi-view RGB image dataset of 3D printed concrete surface based on the RGB and depth images from Step 1 and Step 2.

[0028] Step three includes the following specific implementation process: First, the multi-view 3D printed concrete RGB images acquired and preprocessed in Step one are imported into COLMAP software. Feature extraction, feature matching, and sparse reconstruction are then performed sequentially to generate a sparse point cloud model of the target component, as well as the extrinsic pose matrix, intrinsic camera parameters, and image-point correspondence for each frame. Subsequently, the sparse model is converted into text format (cameras.txt, images.txt, points3D.txt) using COLMAP's model_converter tool, and the camera pose information is parsed from images.txt into the pose file required for 3DGS.

[0029] Next, the predicted depth maps obtained in step two are renamed according to the original image file names, maintaining a one-to-one correspondence with the RGB images. Then, the RGB images, depth maps, pose files, and sparse point clouds are... Figure 3 The directory structure shown is stored in the images / , depths / , and sparse / folders respectively; the sparse / directory contains the cameras.txt, images.txt, and points3D.txt files exported from COLMAP.

[0030] Step 4: Using Marigold's depth prediction map, add depth and normal regularization to 3DGS; In step four, the rendering depth is calculated by averaging the distances of the accumulated sampling points during the interaction between light and the scene. in, For rendering depth, it represents the desired distance from the camera along the line of sight to the surface of the 3D printed concrete component;N The total number of sampling points. Refers to the first The distance from each sampling point to the camera indicates the possible location of the 3D printed concrete component; Refers to the first Opacity of each sampling point; This indicates that the light reaches the first... The probability that a point was not previously obscured.

[0031] The rendering normals are derived from the surface normal vectors of each Gaussian or voxel on the same ray, and are output after being mixed with the same weight as the opacity; the predicted normals are obtained by direct regression from the network during training.

[0032] Through the loss function L d and L n Depth normals are regularized. First, the input depth_mask is normalized to a binary mask (>0.5 for foreground, ≤0.5 for background). Then, the angle between the normals of the rendered depth and the predicted depth is calculated for the foreground region. Only pixels with an angle less than the threshold td_degrees (set to 15°) are retained. No normal consistency check is performed on the background region. The foreground consistent region and the background region are merged to obtain the valid_bool mask. The depth difference is calculated only for the pixels within the mask. When calculating the depth loss, outliers with a depth error squared exceeding the threshold are filtered out. Finally, the weighted depth loss is calculated only for pixels that pass all filtering conditions.

[0033] A warmup mechanism is set up, and training is divided into three phases: In the freeze phase (before 2000 rounds), the depth loss weight and warmup factor are both 0, and depth loss is completely disabled; In the warm-up phase (from 2000 to 5000 rounds), the linear growth ratio is calculated so that the warmup factor increases linearly from 0 to 1; In the normal phase (more than 5000 rounds), the warmup factor is 1 and lambda_d_warmup = base_lambda_d, realizing the gradual introduction of depth and normal supervision.

[0034] in, For deep loss, To predict depth, it represents the surface position of the 3D printed concrete component inferred by the current 3DGS model; The reference depth represents the surface location of the 3D-printed concrete component estimated by the Marigold model.

[0035] in, For normal loss, The predicted normal is the surface normal vector of the concrete component estimated by the 3DGS model, representing the local tilt direction of the 3D printed concrete component surface inferred by the current 3DGS model. The reference normal is the surface normal vector of the concrete member derived from the depth map estimated by the Marigold model. It represents the unit outward normal vector of the ideally shaped surface and is used to describe the desired direction of the concrete member surface in space.

[0036] Step 5: Using the bounding box of the sparse point cloud computing 3D printed concrete specimen obtained in Step 3, introduce bounding box constraint loss to constrain the position of the 3DGS. Step five involves first reading the sparse point cloud (points3D.txt) obtained in step three, extracting the coordinates of all three-dimensional points, and calculating the minimum and maximum values ​​for each of the x, y, and z dimensions to form an initial axis-aligned bounding box (AABB). Then, the overall diagonal length of the point cloud is calculated. , The maximum coordinate vector of the point cloud. The minimum coordinate vector of the point cloud is obtained by expanding it outward by 0.1L along each dimension in the three-dimensional space as a safety margin, resulting in the expanded bounding box boundary vectors bbox_min and bbox_max.

[0037] After defining the bounding box, perform training on each Gaussian center point during 3DGS training. Determine if the value exceeds the bounding box; if it is less than `bbox_min` or greater than `bbox_max` in any dimension, calculate the minimum Euclidean distance to the corresponding nearest bounding box face, and use the squared distance as a penalty term for that point. Average the squared distances of all out-of-bounds Gaussian values ​​to obtain the bounding box constraint loss. in, For the bounding box constraint loss, measure whether the reconstructed concrete component leaks into the external space of the component; This is the set of out-of-bounds Gaussians, i.e., the set of locations where concrete is incorrectly predicted by the Depth-3DGS model. For the first i The minimum distance from the center of a Gaussian cross-boundary Gaussian to the nearest surface of the bounding box, i.e., the degree to which that point deviates from the boundary of the reference concrete member.

[0038] Step 6: Train the Depth-3DGS model using the dataset created in Step 3; In step six, the multi-view dataset prepared in step three is first input into Depth-3DGS. Before training begins, the 3D Gaussian sphere needs to be initialized according to the points3D.txt file of COLMAP: the 3D coordinates of each sparse point in COLMAP are used as the center position of an initial 3D Gaussian sphere, and the covariance of this Gaussian sphere is set to an isotropic small spherical distribution to ensure that the initial Gaussian sphere has a small coverage area and a stable shape. The color parameters are directly read from the RGB values ​​in the COLMAP point cloud, and the transparency is initialized to 0.5 so that all Gaussians contribute moderately in the early stage of training without prematurely occluding or disappearing completely.

[0039] During model training, all the Gaussians initialized above are treated as trainable variables, including their position, color, covariance scale, and transparency. Using the 3DGS differentiable renderer, projection and alpha blending are performed on these Gaussians conditioned on the camera intrinsics and extrinsic parameters of each training view to obtain the rendered image. Subsequently, the photometric reprojection loss, depth loss, normal loss, and bounding box constraint loss between the rendered image and the ground image are calculated to form the total loss function.

[0040] in, The total loss measures the overall deviation between the currently reconstructed concrete member and the reference concrete member. For luminance loss, specifically Loss and The combination of losses, i.e. This indicates the degree of visual consistency between the reconstructed concrete component and the reference concrete component; To account for depth loss, the location of the reconstructed concrete component surface is constrained; To account for normal loss, the orientation of the reconstructed concrete component surface is constrained; To mitigate the loss of the enclosure box, the reconstructed concrete components must be confined to a reasonable spatial range and are set up accordingly. , 0.1, 0.05, 0.1.

[0041] The training epochs were set to 30,000. In the early stages of training, to avoid significant model distortion, the Gaussian positions and scales were frozen, and only color and transparency were optimized to quickly approximate realistic images. Subsequently, position and covariance training were gradually enabled, allowing the 3D surface to be gradually optimized and closer to its true shape. Towards the end of training, the learning rate was reduced, and fine-tuning with small steps enhanced the detail representation of the Gaussians. During training, the Gaussian set was also periodically pruned and merged: Gaussians with minimal long-term contribution to transparency were removed, and Gaussians with similar positions and colors were merged to reduce redundancy, improve rendering efficiency, and maintain model compactness.

[0042] After the above training process, the Depth-3DGS model will gradually converge and finally output a three-dimensional scene representation composed of a large number of differentiable 3D Gaussians. The geometric distribution of Gaussians gradually fits the real surface of the concrete component, and its color attributes and transparency distribution also accurately reflect the texture and local details of the concrete surface, so that the output 3D Gaussian model has both good geometric accuracy and appearance consistency.

[0043] Step 7: Preprocess the dense point cloud model obtained in Step 6 to remove noise points, reduce point cloud density, and improve the stability of subsequent mesh reconstruction. The steps include voxel downsampling, statistical outlier filtering (SOR), radius filtering, DBSCAN-based clustering noise removal, and normal smoothing. Step seven involves first importing the dense point cloud into an Open3D point cloud object and determining whether to perform voxel downsampling based on the number of points. When automatic voxel mode is selected, the voxel size is automatically calculated based on the point cloud bounding box size and the number of points; for example, when the point cloud is too dense, the automatically calculated voxel size can be between 0.005 and 0.02. In this embodiment, the voxel size is set to 0.01. Before performing voxel downsampling, a safe voxel detection mechanism verifies whether the voxel size will cause an excessive decrease in the number of points. If the initial voxel size is too large, it is reduced proportionally until a safe threshold is reached, for example, the voxel size is reduced from 0.02 to 0.014, and then to 0.01 to meet the point count requirement before performing downsampling. Secondly, statistical outlier filtering (SOR) is performed on the downsampled point cloud. This filtering method identifies outliers based on the average distance of each point's K-neighborhood. The number of neighbors for SOR is set to 20, and the standard deviation factor is set to 0.5. Then, radius filtering is performed. This method checks the local neighborhood density of each point with a fixed search radius. When a point has insufficient neighbors within a certain radius, it is considered noise. The set radius is 0.05m, and the minimum number of neighbors is set to 100. This method is mainly used to remove sparse noise points in boundary areas or floating in the air. Finally, the density-based DBSCAN clustering algorithm performs cluster detection on the point cloud to identify and remove small-scale noise clusters. The neighborhood radius of DBSCAN is set to 0.03m, the minimum number of points to form a core point is set to 50, and clusters with a size of less than 200 points are judged as noise and removed. This step can effectively identify small anomalous point clusters caused by reconstruction errors, depth estimation errors, or background texture. After completing the density and structure-related cleanup, normal estimation is performed on the point cloud. The K-neighbor-based normal estimation method is selected, with the search neighborhood K set to 30. The normal directions are uniformly processed, and the estimated normals are smoothed locally with first or second order. Local average smoothing is performed within a neighborhood radius of 0.05m to make the normals more continuous in the local area, thereby improving the surface consistency of subsequent mesh reconstruction.

[0044] Step 8: Compare and verify the final processed point cloud with the laser scanning model, and evaluate the model performance using relevant evaluation metrics.

[0045] Step eight involves testing and analyzing the indicators: (1) Peak Signal-to-Noise Ratio (PSNR): An image quality index calculated based on mean square error (MSE), used to represent the degree of difference between the reconstructed image and the original image. The higher the value, the closer the image is to the original image and the better the quality. The calculation formula is as follows: in, Image height (number of rows); Image width (number of columns); Original image in location Pixel value at; Image to be evaluated at location Pixel value at; The maximum value of the image pixels.

[0046] (2) Similarity Index (SSIM): measures the similarity between two images in terms of brightness. Contrast and structure The three similarity indicators are used to calculate the similarity between the two images. The closer the value is to 1, the more similar the two images are and the better their quality. The formula is as follows: in, For brightness similarity; Original image The average pixel value within a local window; Image to be evaluated The average pixel value within the same local window; For contrast similarity; Original image Pixel standard deviation within a local window; Image to be evaluated Pixel standard deviation within a local window; For structural similarity; for and The covariance within a local window reflects the degree of linear correlation between pixels; , , These are weight parameters; , , It is a constant.

[0047] (3) Perceptual Image Loss (LPIPS): An index based on deep neural network features to measure the degree of visual difference between the reconstructed concrete component image and the reference concrete component image. The smaller the value, the more similar the two images appear to the human eye. The calculation formula is as follows: in, Images of concrete components reconstructed from the Depth-3DGS model; A reference concrete component image taken by a camera; For the first The height of the layer feature map; For the first Width of the layer feature map; No. Layered network in location The normalized eigenvector at that location; No. Weight coefficients of layer features; (4) Chamfer Distance (CD): Measures the overall geometric deviation between the reconstructed concrete component and the reference concrete component at the point cloud level. It reflects the similarity of the two shapes by calculating the average distance from each point to the nearest point in another point cloud. The calculation formula is as follows: in, This represents the 3D point cloud of the concrete component reconstructed from the Depth-3DGS model. The first item represents the 3D point cloud of the reference concrete component obtained by a laser scanner. any point arrive The sum of the minimum distances, the second term represents any point arrive The sum of the minimum distances. The larger the distance, the greater the difference between the reconstructed concrete component and the actual concrete component; the smaller the distance, the smaller the difference between the reconstructed concrete component and the actual concrete component.

[0048] Final experimental results, compared with 3DGS: Table 1 Experimental Results Model PSNR SSIM LPIPS CD 3DGS 33.8168869 0.9669407 0.0483692 1.71072607 Depth-3DGS 39.3664627 0.9952617 0.0081449 1.153086 In summary, the Depth-3DGS 3D reconstruction model for 3D printed concrete proposed in this invention significantly improves reconstruction accuracy, achieving intelligent, precise, and automated reconstruction of 3D printed concrete surfaces. Experimental results show that PSNR is improved by 16.41%, SSIM by 2.93%, LPIPS is reduced by 83.16%, and chamfer distance CD is reduced by 32.60%. This model outperforms existing methods in all these aspects, providing strong support for further promoting the intelligent analysis and engineering application of 3D printed concrete structures. Furthermore, the efficiency and reliability of this method lay a solid foundation for in-depth research and practice in related fields.

Claims

1. A method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering, characterized in that, Includes the following steps; Step 1): Use a camera to acquire multi-view RGB images of the 3D printed concrete model, and then process the acquired RGB images; Obtain an RGBA image with the background removed; Step 2): Using the existing monocular depth prediction model Marigold, input an RGBA image with the background removed, and output the corresponding predicted depth map; Step 3): Based on the RGB data preprocessed in Step 1), COLMAP is used to perform sparse reconstruction to obtain sparse point clouds, camera intrinsics, and camera pose. A multi-view image dataset of 3D printed concrete surface is created based on the RGB images preprocessed in Step 1 and the predicted depth map in Step 2. Step 4): Using Marigold's predicted depth map as a depth prior, regularize the depth and normal of the 3D Gaussian. Step 5): Add bounding box constraint loss to the algorithm, calculate the minimum axis-aligned bounding box (AABB) based on the sparse point cloud, and then expand it outward by 10% as the initial bounding box to constrain the position of the 3D Gaussian. Step 6): Train the multi-view image dataset of 3D printed concrete surface created in Step 3) using 3DGS to generate the corresponding dense point cloud model; Step 7): Process the generated dense point cloud model; It includes downsampling, SOR noise reduction, radius filtering, and DBSCAN clustering filtering to achieve 3D reconstruction of 3D printed concrete.

2. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 1, characterized in that, The multi-view RGB images acquired in step 1) are derived from 3D printed concrete test block components printed in the 3D printed concrete laboratory. The acquired 3D printed concrete component images are segmented for the foreground and the white balance is unified using a convolutional neural network with a U-Net structure. Calling the rembg library using Python - A convolutional neural network with a Net structure segments the foreground of a multi-view RGB image. The model outputs a foreground / background segmentation mask, which is then used to perform alpha blending on the original image to obtain a transparent background. Finally, an RGBA image with the background removed is returned.

3. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 2, characterized in that, Step 2) specifically includes: first, downloading the Marigold model and depth prediction checkpoint from the model library; then, configuring the model running environment and loading the checkpoint to complete model initialization on the computing device; inputting the preprocessed multi-view RGB images frame by frame into the monocular depth prediction model; the monocular depth prediction model extracts features and performs depth inversion through an encoder-decoder network, outputting a monocular predicted depth map corresponding to each image; by performing this inference process on all view images, complete multi-view depth map data is obtained.

4. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 3, characterized in that, Step 3) specifically includes: importing the multi-view RGB images processed in step 1) into COLMAP, performing feature extraction, feature matching, and sparse reconstruction in sequence to generate sparse point clouds and camera intrinsic and extrinsic parameters for each image; exporting the sparse model as cameras.txt, images.txt, and points3D.txt, and parsing images.txt to obtain the pose file required for 3D Gaussian Splatting (3DGS); saving the depth map obtained in step 2) according to the original image naming convention; and finally placing the RGB images, depth maps, pose files, and sparse point clouds into the images, depths, and sparse folders respectively to construct the 3DGS input dataset.

5. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 4, characterized in that, Step 4) specifically includes: The rendering normals are obtained by mixing the surface normal vectors of each Gaussian on the light source with the same weight as the opacity; the predicted normals are directly generated by regression during the training phase of the deep network; subsequently, a depth-normal regularization loss is formed; the input depth mask is binarized; the angle between the normals of the rendered normals and the predicted normals is calculated in the foreground region, and only pixels with an angle less than a threshold are retained as normal-consistent regions. The foreground consistent regions are merged with the background regions to obtain an effective mask, and the difference between the rendered depth and the predicted depth is calculated only within the mask; the depth loss further filters out outliers with squared errors exceeding a threshold, and finally, a weighted depth loss is calculated only for pixels that pass all conditions. and normal loss .

6. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 5, characterized in that, Step 5) specifically includes: aligning the bounding box with the axis of the sparse point cloud, taking the minimum and maximum values ​​of each dimension of the point cloud, and expanding outwards by the diagonal length as the margin to obtain the minimum and maximum values ​​of the bounding box; Introducing a bounding box constraint loss, for each Gaussian center point outside the bounding box, calculate the squared Euclidean distance to the nearest boundary, average the squared distances of all outside points, and then multiply by the weight. As a loss, the Gaussian position is constrained to remain within the bounding box through backpropagation.

7. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 6, characterized in that, Step 6) specifically includes: Using the multi-view image dataset constructed in step 3) as input, the three-dimensional Gaussian is initialized according to points3D.txt. Each three-dimensional point in the sparse point cloud is used as an initial Gaussian center, the covariance is set as an isotropic sphere, and the color is taken from the RGB information of the sparse point cloud to obtain the initial low-density Gaussian representation. During training, the position, color, covariance scale, and transparency of the Gaussian are set as trainable variables. The 3DGS differentiable renderer combines the intrinsic and extrinsic parameters of each view camera to generate rendered images through projection and alpha blending. The photometric reprojection loss, depth loss, normal loss, and bounding box constraint loss are calculated. The Gaussian parameters are jointly optimized so that they gradually gather towards the surface of the real component and fill the space, evolving from sparse initialization to a complete dense 3D point cloud representation. In the early stage of training, the position and scale of Gaussians are frozen, and only color and transparency are optimized. In the middle stage, the position and covariance are gradually unfrozen to make the Gaussians converge to the real geometry and increase the point cloud density. In the later stage, the learning rate is reduced for fine optimization. During the training process, Gaussian pruning and merging are performed regularly to delete redundant Gaussians with low transparency in the long term and merge Gaussians with similar positions and consistent colors to suppress noise and maintain the compactness of the point cloud structure, and finally obtain a dense 3D point cloud model consistent with the target component.

8. The method for three-dimensional reconstruction of 3D printed concrete based on Gaussian sputtering according to claim 7, characterized in that, Step 7) specifically includes: The dense point cloud obtained in step 6) is loaded into Open3D. Voxel downsampling is performed based on the point cloud size. The voxel size is calculated based on the point cloud bounding box size and the number of points. A safe voxel detection mechanism is used to gradually adjust the voxel size to ensure the number of points is within a reasonable range after downsampling before performing voxel downsampling. Statistical outlier filtering (SOR) is then applied to the downsampled point cloud. Outliers are identified and removed based on the local neighborhood distance of each point. Radius filtering is then performed, using a fixed search radius and the minimum number of neighborhood points to identify sparse regions and delete isolated or floating points. DBSCAN clustering is then performed on the point cloud, determining the cluster size based on density. Small clusters are identified as noise clusters and removed entirely. After outlier and noise clustering removal, normals are estimated using a neighborhood search-based normal calculation method, and the normal directions are made consistent. Finally, local smoothing is performed on the normals to ensure they are continuous and consistent within the spatial neighborhood, generating a smooth normal field suitable for subsequent reconstruction.

Images