Introduction
Additive manufacturing represents one of the most dynamic research directions in modern manufacturing, offering significant advantages in material utilization, geometric flexibility, and process automation. However, quality control remains a critical challenge, particularly in the detection and characterization of surface defects. In my research, I focus on surface porosity defects, which are among the most frequent anomalies encountered in components produced by additive processes. These defects, often appearing as small cavities or gas pores, can severely affect mechanical properties such as fatigue strength and corrosion resistance. Traditional image-based inspection methods fail to capture the three-dimensional geometric context of surface irregularities, and the distribution of porosity on a workpiece surface is highly irregular. Consequently, automated detection becomes difficult to realize with conventional two-dimensional sensing.
To overcome these limitations, I have investigated the use of 3D point cloud data generated by line laser scanning. Point clouds naturally encode geometric depth and surface topology, making them especially suitable for detecting localized depression type defects such as sand foundry defects. In the context of sand foundry defects, the surface may contain pit marks, gas holes, and rough regions that are difficult to detect reliably in grayscale or color images. In my work, I specifically target the automatic identification and quantification of surface porosity by developing a complete pipeline that includes scanner calibration, preprocessing, denoising, simplification, semantic segmentation, and finally defect quantification.
The main contributions of my thesis are as follows:
- I designed a practical line laser scanning system for acquiring high-density point clouds from metal components produced by additive manufacturing.
- I proposed a coordinate transformation based calibration approach to correct the angular deviation of the line laser scanner.
- I compared multiple spatial index structures, including grid, kd-tree, and octree, and selected a raster-based indexing scheme to accelerate neighborhood search operations.
- I developed a feature-preserving non-uniform point cloud simplification method that uses curvature information to detect important regions containing potential sand foundry defects while reducing redundancy in flat areas.
- I constructed a multi-scale semantic segmentation model using PointNet feature extraction at multiple radii (2 mm, 4 mm, and 6 mm) to label each point as normal or defective.
- I applied mean-shift clustering and tangent plane projection to compute the number, cross-sectional area, and depth of each surface porosity defect.
Extensive experiments on real production workpieces demonstrate that the proposed method achieves a training accuracy of 94.46% and a final defect detection accuracy of 98.15% on the available dataset. The feature-preserving simplification also reduces computation time for semantic segmentation significantly compared to processing the original point cloud directly.
Related Work
Surface Defect Detection: From Images to Point Clouds
Surface inspection is essential in foundry and welding processes because defects such as sand foundry defects often form during layer-by-layer material deposition. Early systems relied on human visual inspection, which is slow and subjective. Then, instrument-based methods using ultrasound, X-ray, or infrared thermography were introduced. Although these techniques provide non-contact inspection, they have limitations in cost, safety, and sensitivity to environmental conditions. With the advancement of optical sensors and computing hardware, machine vision approaches using CCD cameras have become prevalent. Image-based algorithms, including threshold segmentation, feature extraction, and deep learning, have been applied to detect scratches, cracks, and pits on rolled steel surfaces. However, for three-dimensional anomalies like sand foundry defects, a 2D image loses critical spatial information. Consequently, depth sensing and 3D point cloud processing have attracted increasing attention.
In point cloud analysis, surface defects can be detected through geometric feature changes. Traditional methods involve calculating curvature, normal vectors, and local height differences, followed by thresholding or clustering. These approaches are sensitive to noise and often require manual tuning. More recently, deep neural networks such as PointNet and PointNet++ have been employed for classification and semantic segmentation of point clouds. PointNet offers permutation invariance via max pooling and an end-to-end trainable architecture. PointNet++ extends it by applying hierarchical feature learning on local neighborhoods. In my work, I adopt PointNet as the backbone to extract local features from point neighborhoods at multiple scales, then concatenate these features to classify each point.
Point Cloud Preprocessing
A raw point cloud obtained from a line laser scanner usually contains millions of points, including the base plate, noise, and other non-workpiece regions. Preprocessing is therefore crucial. Common steps include filtering, simplification, and spatial indexing. Filtering algorithms such as bilateral filtering, radius filtering, and statistical filtering are widely used. Radius filtering is effective for removing scattered outliers while preserving dense regions. Statistical filtering assumes that k-nearest neighbor distances follow a Gaussian distribution and removes points with average distances exceeding a threshold. However, in regions where sand foundry defects are present, the density is often lower, and statistical filtering may inadvertently remove defect points. Therefore, I chose radius filtering for outlier removal.
Simplification methods aim to reduce data volume. Voxel grid filtering replaces points in each voxel by their centroid, but this process can erode small defects. In response, I designed a curvature-aware simplification that preserves high-curvature areas while aggressively simplifying flat areas. This approach is particularly useful for maintaining the geometry of sand foundry defects during detection.
Line Laser Scanning System and Calibration
System Configuration
I used a Gocator 2150 line laser scanner manufactured by LMI Technologies. This device emits a line laser onto the object surface and captures the reflected light via a CCD array. The system operates on the principle of laser triangulation, which measures the deformation of the laser line caused by surface height variations. The scanner has a resolution of 0.02 mm in the z-direction, a measurement range of 400 mm, and a field of view between 158 and 365 mm. This resolution is sufficient to detect small porosity defects on the order of a few millimeters. The scanning speed can be as high as 5000 Hz, allowing dense point cloud acquisition during or after the manufacturing process.
The scanner is mounted near the welding torch within the additive manufacturing machine. The scan path is controlled by the machine’s motion system. During scanning, the workpiece moves relative to the line laser, producing a series of profiles that are combined into a dense 3D point cloud. In my experiments, the scanner was installed at a fixed orientation, but due to mechanical tolerances and thermal effects, a slight angular tilt was observed, typically ranging from 0.5° to 2°. For a long rectangular workpiece, this tilt can cause up to 2 mm height deviation along the z-axis, which could distort geometric feature extraction. I therefore implemented a calibration procedure based on plane fitting and coordinate rotation.
Scanner Position Calibration
To correct the angular misalignment, I extracted the largest plane in the point cloud using RANSAC (Random Sample Consensus). The largest plane corresponds to the base plate of the workpiece. In 3D space, the fitted plane is represented by the equation:
$$ Ax + By + Cz + D = 0 $$
with a normal vector $\mathbf{n} = (a, b, c)$. The goal is to rotate this normal vector to align with the z-axis $\mathbf{z} = (0, 0, 1)$. The angle $\theta$ between the normal and the z-axis is computed as:
$$ \cos\theta = \frac{\mathbf{n} \cdot \mathbf{z}}{|\mathbf{n}| \, |\mathbf{z}|} = \frac{c}{\sqrt{a^2+b^2+c^2}} $$
Then I constructed the rotation matrix using the Rodrigues formula:
$$
\mathbf{R} = \begin{bmatrix}
1 – (b^2+c^2)(1-\cos\theta) & ab(1-\cos\theta) – c\sin\theta & ac(1-\cos\theta) + b\sin\theta \\
ab(1-\cos\theta) + c\sin\theta & 1 – (a^2+c^2)(1-\cos\theta) & bc(1-\cos\theta) – a\sin\theta \\
ac(1-\cos\theta) – b\sin\theta & bc(1-\cos\theta) + a\sin\theta & 1 – (a^2+b^2)(1-\cos\theta)
\end{bmatrix}
$$
After applying this rotation to all points, the surface normal of the base plate becomes approximately parallel to the z-axis. I validated this calibration on 30 workpieces, and the measured angle between the fitted plane normal and the z-axis was reduced to nearly zero, as summarized in the table below.
| Workpiece set | Mean angle before calibration (°) | Mean angle after calibration (°) |
|---|---|---|
| Set 1 (10 samples) | 1.42 | 0.03 |
| Set 2 (10 samples) | 1.65 | 0.02 |
| Set 3 (10 samples) | 0.98 | 0.04 |
Point Cloud Preprocessing
Extraction of Workpiece Surface Region
Raw point clouds contain both the workpiece and the substrate plate. To isolate the region of interest, I performed height-based segmentation. The point cloud is divided into horizontal slices with a step size of 0.2 mm. A histogram of point counts with respect to height is constructed. The ideal cut height $H_m$ is selected as the height where the point count drops to a local minimum on the upper side of the highest layer. A tolerance margin $H_t = 2$ mm is subtracted to preserve edge features:
$$ H = H_m – H_t $$
Points with height less than $H$ are removed. This step effectively removes the substrate and lower layers, leaving only the top surface of the workpiece.
Spatial Indexing
In order to perform neighborhood searches efficiently, I compared three spatial index structures: grid, kd-tree, and octree. The grid method divides the bounding box of the point cloud into small cubic cells of edge length $L$. For a point cloud with minimum and maximum coordinates $(x_{\min}, y_{\min}, z_{\min})$ and $(x_{\max}, y_{\max}, z_{\max})$, the number of cells in each dimension is:
$$ n_x = \left\lfloor \frac{x_{\max}-x_{\min}}{L} \right\rfloor + 1,\quad n_y = \left\lfloor \frac{y_{\max}-y_{\min}}{L} \right\rfloor + 1,\quad n_z = \left\lfloor \frac{z_{\max}-z_{\min}}{L} \right\rfloor + 1 $$
For k-nearest-neighbor searches, an optimal cell size can be estimated by:
$$ L = \sqrt[3]{\frac{(x_{\max}-x_{\min})(y_{\max}-y_{\min})(z_{\max}-z_{\min}) \cdot 3}{2N}} $$
where $N$ is the total number of points. For radius search, I set $L = 2r$ where $r$ is the search radius. The table below shows the search times (in seconds) for different methods on the same workpiece containing 1,088,893 points.
| Search type | Grid | KD-tree | Octree |
|---|---|---|---|
| K=20 | 37.1 | 86.6 | 84.2 |
| K=30 | 42.2 | 89.1 | 85.5 |
| K=40 | 60.3 | 92.7 | 87.3 |
| r=2mm | 26.2 | N/A | 88.3 |
| r=4mm | 31.4 | N/A | 90.2 |
| r=6mm | 51.1 | N/A | 91.5 |
The grid structure clearly outperforms the tree-based structures in both kNN and radius searches. This is because the point cloud density is high and tree structures suffer from deep recursion when splitting densely populated areas. Hence, I adopted the grid-based indexing as the primary spatial storage method.
Denoising with Radius Filter
I compared three denoising methods: bilateral filtering, radius filtering, and statistical filtering. Bilateral filtering is designed to smooth Gaussian noise while preserving edges, but it is computationally expensive and less effective on scattered outliers. Statistical filtering tends to remove points in sparse regions, which often correspond to the boundary of sand foundry defects. Radius filtering, on the other hand, counts the number of points within a sphere of radius $r$ around each point. If this count is less than a threshold $t$, the point is removed. In my experiments, I used a search radius of $r=2$ mm and a threshold $t$ derived from the distribution of neighborhood counts. The following table summarizes the performance on a representative workpiece.
| Method | Remaining points | Defect area preserved? | Outlier removal quality |
|---|---|---|---|
| Original | 1,072,049 | Yes | No outliers removed |
| Radius filter | 1,071,205 | Yes (almost all) | Excellent |
| Statistical filter | 1,069,330 | No (defect partially removed) | Good but loses boundary |
Radius filtering was chosen because it preserves the geometric structure of porosities while reliably removing isolated noise points.
Feature-Preserving Non-Uniform Simplification
Conventional voxel filtering replaces all points inside a cubic voxel with the centroid of those points. This approach greatly reduces point count but also shrinks or smooths out small concavities, thereby losing key information for detecting sand foundry defects. To address this problem, I propose a curvature-aware simplification method. For each point $p_i$, I compute its curvature from the covariance matrix of its local neighborhood. Let the neighborhood contain $k$ points, with centroid $\bar{p}$, and covariance matrix $\mathbf{C}$:
$$ \mathbf{C} = \frac{1}{k} \sum_{q \in \text{nbr}(p_i)} (q – \bar{p})(q – \bar{p})^T $$
The eigenvalues of $\mathbf{C}$ are denoted $\lambda_0 \leq \lambda_1 \leq \lambda_2$. The curvature at $p_i$ is defined as:
$$ \delta_i = \frac{\lambda_0}{\lambda_0 + \lambda_1 + \lambda_2} $$
Using a radius of 3 mm, I calculated curvature for all points on a workpiece. The results confirmed that defect regions exhibit significantly higher curvature variation than flat areas. I then divided the space into voxels of edge length $d$. For each voxel, if the curvature variation across points inside the voxel is below a threshold $T_c=0.0015$, the voxel is considered flat and replaced by its centroid. If the variation exceeds $T_c$, the voxel is marked as a candidate defect region and preserved using random sampling at the original local density.
The simplification results for the workpiece shown earlier are given in the table below.
| Voxel edge (mm) | All points | Defect region points |
|---|---|---|
| Original | 1,072,049 | 165 |
| 1.4 | 91,610 | 162 |
| 1.6 | 78,563 | 158 |
| 1.8 | 61,070 | 156 |
| 2.0 | 62,228 | 156 |
| 2.2 | 53,265 | 155 |
Even with a 20-fold reduction in total point count, the defect region retains almost all of its original points. This demonstrates the effectiveness of the proposed method in preserving the geometry of surface porosity defects.
Comparison to Standard Voxel Filter
To further quantify the advantage of my method, I compared it with standard voxel filtering at the same input scale. The following table presents the number of points in seven known porosity defects before and after simplification by both methods.
| Defect ID | Original points | My method | Voxel filter |
|---|---|---|---|
| 1 | 86 | 86 | 19 |
| 2 | 51 | 50 | 8 |
| 3 | 53 | 50 | 11 |
| 4 | 48 | 48 | 8 |
| 5 | 36 | 35 | 7 |
| 6 | 85 | 85 | 11 |
The standard voxel filter drastically reduces the number of points in defect areas, causing loss of the fine depression signature. My method preserves nearly all defect-related points while still simplifying the overall cloud.
Multi-Scale Semantic Segmentation Model
Architecture Overview
The goal of the detection model is to identify each point in the reduced point cloud as “normal” or “defect”. Since the workpiece surface is large and defect regions are small, I designed a multi-scale region-based classification approach. First, the point cloud is divided into flat and candidate regions based on the curvature map generated during simplification. Flat regions are directly labeled as normal. For candidate regions, I compute a local feature vector for each point by extracting neighborhood information at three different radii.
The model structure is illustrated conceptually as follows: For a query point $p$, at each radius $r_i \in \{2,4,6\}$ (in mm), I retrieve the set of neighboring points within that radius. If the set contains more than 48 points, I perform farthest point sampling (FPS) to select 48 points. If it contains fewer, I duplicate points randomly until 48 points are obtained. These sampled point sets are then passed through the PointNet feature extraction network, which consists of two T-Net alignment structures, three 1D convolutional layers, and a max pooling layer. The output of PointNet for each scale is a 1024-dimensional feature vector. The three scale-specific vectors are concatenated to form a global high-dimensional feature vector of length 3072.
The concatenated vector is fed into a four-layer fully connected classifier (3072 → 1024 → 512 → 256 → num_classes). The final layer uses softmax to produce the probability of the point belonging to the defect class. The model is trained using cross-entropy loss. The overall detection pipeline is summarized in the following equations:
$$ f_{\text{feat}} = \left[ \text{PointNet}(S_{2}),\; \text{PointNet}(S_{4}),\; \text{PointNet}(S_{6}) \right] \in \mathbb{R}^{3072} $$
$$ y_p = \text{softmax}\left( \mathbf{W}_3 \cdot \text{ReLU}(\mathbf{W}_2 \cdot \text{ReLU}(\mathbf{W}_1 \cdot f_{\text{feat}} + b_1) + b_2) + b_3 \right) $$
where $S_{r_i}$ is the sampled neighborhood set at radius $r_i$.
Farthest Point Sampling
Farthest point sampling (FPS) is a deterministic resampling algorithm that selects points to uniformly cover the original point set. Given an input set $Q$ and a target set $P$, FPS starts by selecting an arbitrary point $q_0$ from $Q$. It then repeatedly selects the point in $Q$ that is farthest from all points in $P$ in terms of Euclidean distance. The algorithm terminates when $|P| = 48$. FPS is preferable to random sampling because it preserves the spatial distribution and geometric features, which is essential for accurately describing shallow depressions such as early-stage sand foundry defects.
Region-Based Segmentation
Porosity defects typically appear as localized depressions with high curvature. To separate these regions from flat areas, I use the curvature feature computed previously. After the non-uniform simplification, each voxel is already labeled as either flat or candidate. Points within flat voxels are assigned the “normal” class label directly, skipping the deep neural network inference. Only candidate voxels undergo feature extraction. This prefiltering greatly reduces inference time because candidate regions usually cover less than 5% of the workpiece surface. After classification, all points classified as defective are clustered using mean-shift to identify individual defect instances.
Mean-Shift Clustering
The mean-shift algorithm is a non-parametric clustering method that does not require knowing the number of clusters in advance. Given a point set $P = \{p_1, p_2, \dots, p_n\}$, the algorithm iterates the following update rule for each point $p$:
$$ m(p) = \frac{\sum_{q \in N_r(p)} q \cdot G(q-p)}{\sum_{q \in N_r(p)} G(q-p)} – p $$
where $N_r(p)$ is the set of points within radius $r$, and $G$ is a kernel function. A commonly used kernel is the Epanechnikov kernel defined as:
$$ G(x) = \begin{cases} 1 – \|x\|^2 / r^2, & \|x\| \le r \\ 0, & \|x\| > r \end{cases} $$
The point $p$ is shifted to $p \leftarrow p + m(p)$ until the shift magnitude is below a threshold $\epsilon$. Points that converge to the same mode are grouped into the same cluster. In my experiments, I set the bandwidth $r=2$ mm, which is suitable for separating close defects while merging points belonging to the same pore.
Defect Quantification
Once each defect cluster is identified, I compute its cross-sectional area and depth. The edge points of a cluster are found by searching for points within the cluster that have k-nearest neighbors belonging to the normal class. Using least squares, I fit a tangent plane $\Pi$ to these edge points. The equation of the plane is:
$$ z = a x + b y + c $$
Then all points of the defect cluster are projected onto the plane $\Pi$. The projected polygon’s area is calculated via the shoelace formula, and the maximum perpendicular distance from the projected points to the original defect points is used as the depth of the defect.
The following table shows the measured quantitative attributes for six actual porosity defects on test workpieces.
| Defect ID | Cross-sectional area (mm²) | Maximum depth (mm) |
|---|---|---|
| 1 | 6.2 | 2.8 |
| 2 | 11.9 | 2.2 |
| 3 | 13.3 | 3.6 |
| 4 | 14.3 | 3.2 |
| 5 | 6.2 | 2.7 |
| 6 | 10.8 | 2.9 |
To verify the accuracy of this quantification, I manually segmented the defect regions in the point cloud and computed the same metrics. The relative errors between my automatic measurements and the manual measurements are shown below.
| Defect ID | Area error (%) | Depth error (%) |
|---|---|---|
| 1 | -8.8 | -3.4 |
| 2 | -4.8 | -4.3 |
| 3 | -4.3 | 0.0 |
| 4 | -4.0 | -8.5 |
| 5 | -6.1 | -10.0 |
| 6 | -2.7 | -9.3 |
All errors are within 10%, which is acceptable for precise surface quality control.
Experiments and Results
Dataset and Experimental Setup
I used a dataset containing point clouds of 34 real workpieces produced by additive manufacturing. Among them, there were 54 verified surface porosity defects. To increase the size of the training set, I applied random rotations, translations, and scaling operations, generating 68 workpieces with 108 porosity defects in total. The dataset was split into training and testing sets with an 80/20 ratio. The hardware environment consisted of a Windows 10 64-bit system, an NVIDIA GTX 1080 Ti GPU, an Intel i5-9300H CPU, and 8 GB RAM. The algorithms were implemented in Python 3.8.
Training Hyperparameters
I performed a grid search over two optimizer types (Adam and SGD) and ten learning rates from 0.001 to 0.01 with step 0.001, while keeping dropout at 0.4. The training accuracy results are shown in the table below.
| Learning rate | Adam accuracy (%) | SGD accuracy (%) |
|---|---|---|
| 0.001 | 93.15 | 93.54 |
| 0.002 | 93.05 | 93.63 |
| 0.003 | 92.96 | 94.10 |
| 0.004 | 93.35 | 93.49 |
| 0.005 | 93.55 | 94.46 |
| 0.006 | 93.95 | 93.17 |
| 0.007 | 93.15 | 93.32 |
| 0.008 | 93.45 | 93.65 |
| 0.009 | 93.75 | 93.54 |
| 0.01 | 93.55 | 94.18 |
The best performance was obtained using the SGD optimizer with a learning rate of 0.005, yielding a training accuracy of 94.46%.
Defect Detection Accuracy
I evaluated the complete detection pipeline on the original 34 workpieces. Each workpiece contained at least one known surface porosity. The results are summarized below.
| Metric | Value |
|---|---|
| Total number of defects | 54 |
| Correctly detected defects | 53 |
| Missed defects | 1 |
| False positives | 0 |
| Overall detection accuracy | 98.15% |
| Missed defect rate | 1.85% |
| False positive rate | 0% |
The missed defect was a very shallow pore with a depth of less than 0.5 mm, which was close to the scanning resolution. This indicates that the current scanner resolution may limit the detection of extremely shallow defects, but in practice such defects rarely affect the mechanical integrity.
Simplification and Computational Efficiency
To evaluate the impact of my simplification method on detection time, I compared two processing paths: (1) performing semantic segmentation directly on the original simplified point cloud without curvature-based prefiltering, and (2) applying my feature-preserving simplification first and then performing semantic segmentation only on the candidate regions. For three challenging workpieces, the results are shown below.
| Workpiece ID | Original point count | Time to segment original (s) | Point count after simplification | Time to segment simplified (s) |
|---|---|---|---|---|
| 1 | 1,088,893 | 25.6 | 62,228 | 8.4 |
| 2 | 566,293 | 18.2 | 48,578 | 6.1 |
| 3 | 565,480 | 18.5 | 41,051 | 5.3 |
These results demonstrate a substantial speedup while maintaining high accuracy. The simplification step reduces the number of points that need to pass through the deep network, because most flat regions are classified heuristically as normal.
Qualitative Results
I visualized several raw point clouds and their detection results. In one typical example, the point cloud contained two large surface pores. The semantic segmentation model correctly labeled the points inside the pores as defect points (shown in red), while the surrounding flat region remained uncolored (normal). Another example involved a multi-layer workpiece with a tiny pore on the top layer. The method successfully identified the pore even though it was only a few millimeters across. In a third example, three pores were detected and their 3D shapes were well preserved, enabling accurate quantification. These qualitative observations confirm that point cloud semantic segmentation is a powerful tool for detecting sand foundry defects in additive manufacturing.
Conclusion and Future Work
Summary
In this thesis, I presented a complete point cloud processing pipeline for automatic surface porosity defect detection in additive manufacturing. The main contributions are summarized as follows:
- I introduced a line laser scanning system that captures high-density 3D point clouds of workpiece surfaces. A RANSAC-based plane fitting and Rodriguez rotation was applied to correct the scanner’s angular tilt.
- I investigated several preprocessing techniques and chose radius filtering for outlier removal and a raster-based grid structure for fast neighborhood searching.
- I proposed a curvature-aware non-uniform point cloud simplification method that preserves the geometry of sand foundry defects while drastically reducing the point cloud size. In the test dataset, the simplification ratio reached approximately 5% without losing important defect points.
- I developed a multi-scale semantic segmentation model using PointNet feature extractors at three distinct radius scales. The concatenated 3072-dimensional feature vector was used to classify each candidate point as normal or defective. The model achieved 94.46% training accuracy and 98.15% detection accuracy on production workpieces.
- I integrated mean-shift clustering and tangent plane projection to compute the number of defects and their cross-sectional area and depth, with errors under 10% compared to manual measurements.
This work demonstrates that point cloud technologies can significantly improve the automation and reliability of surface inspection in foundry and additive manufacturing environments. The combination of geometric preprocessing and deep learning provides a robust solution for detecting sand foundry defects that are otherwise difficult to identify using conventional 2D imaging.
Future Research Directions
Although the proposed method achieves satisfactory results, several improvements can be made in the future:
- Detection of more defect types: The current model focuses on porosity (pores and concavities). In future work, I plan to extend the model to classify other surface anomalies, such as cracks, undercuts, and spatter, by enriching the training dataset and introducing additional geometric features derived from the point cloud.
- Faster and lighter models: The PointNet backbone can be replaced by more efficient architectures such as PointNet++ or point transformer models to improve inference speed and handle even larger point clouds in real time.
- In-situ monitoring: Instead of post-process scanning, integrating the defect detection algorithm in real-time during layer-by-layer manufacturing would enable immediate feedback and adaptive correction. This requires optimizing the algorithm for low latency and incorporating it into the control loop of the additive manufacturing machine.
- Multi-sensor fusion: Combining multiple line laser scans from different views, along with RGB images, may provide a more comprehensive representation of complex workpiece surfaces and further improve the detection of shallow defects.
- Large-scale industrial deployment: The dataset used in this study is relatively small. To ensure the robustness of the deep learning model across different materials, geometries, and manufacturing conditions, a large-scale production dataset should be collected. This would allow better generalization and validation of the proposed pipeline.
In conclusion, the proposed point cloud-based method offers an effective and practical solution for surface porosity defect detection in additive manufacturing. By preserving geometry through a curvature-aware simplification and using a multi-scale deep semantic segmentation model, my work achieves high detection accuracy and efficient computation. The methods presented herein can be adapted to other industrial inspection scenarios where sand foundry defects or similar surface irregularities need to be quantified automatically.