Deep Fusion of Kinematic Features and Task-Aware Partition Planning for Mold Surface Robotic Polishing

Abstract

Robotic polishing in CAD-free industrial settings relies on point-cloud data, yet noise and non-uniform sampling often compromise kinematic feasibility and finishing quality. This paper proposes an adaptive motion planning approach with explicit kinematic constraints. A downsampling–clustering–mapping-back strategy is first employed for rapid workpiece extraction. Subsequently, an improved supervoxel representation and attributed adjacency graph (AAG) are developed, utilizing a multi-objective energy formulation to partition sub-regions that satisfy geometric consistency and kinematic reachability. To handle point-cloud noise, a lightweight neural network predicts scanning directions and step-distance coefficients, followed by thick-slice serpentine path generation. Finally, closed-loop verification ensures safety through inverse-kinematics and safety-margin checks. Experimental results demonstrate consistent sub-micron finishing quality, with Ra ≈ 0.6 μm on complex mold surfaces. Moreover, the proposed pipeline achieves a 7.5× preprocessing speedup, completing workpiece extraction in 1.14 s for a 237,640-point scan, and improves kinematic feasibility to 100% IK success while reducing the mean TCP normal deviation by ~76% compared with a PCA-based baseline.

1. Introduction

Robotic manipulators have become the primary platform for precision finishing of mold surfaces due to their high accuracy, repeatability, and flexibility [1,2]. Yet mold surfaces often feature sharp curvature changes, complex boundaries, and reachability limitations, imposing multiple constraints on trajectory planning: coverage completeness, orientation continuity, efficiency, and safety [3], and potentially energy consumption. In addition, energy consumption minimization has been considered as an objective in trajectory planning, aiming to select energy-efficient motions rather than optimizing geometric criteria alone [4]. Automatic trajectory generation that is both efficient and high-quality for such workpieces is still challenging [5]. In this context, ‘efficient’ refers to the minimization of computational time during the preprocessing and planning stages, while ‘high-quality’ denotes a trajectory that ensures full kinematic feasibility (collision-free, singularity-free) and consistent surface coverage.

Manual teaching-based offline programming lacks robustness in ensuring consistent quality. CAD-based offline programming has matured as an alternative, with research focused on geometric slicing, tool-axis orientation planning, and process modeling. Wang et al. [6] integrated manipulator polishing process planning with existing CAD systems for systematic offline trajectory and parameter generation. Jamshidi and Budak [7] embedded a CAD-based polishing force model into robotic toolpath planning for complex surface finishing. However, these methods become impractical when reliable CAD models are unavailable or when fixture deviations and wear-induced geometry changes occur.

To reduce dependence on idealized models and precise calibration, sensor-based automatic path planning has become a research focus in recent years. In particular, 3D vision systems can directly acquire point cloud data from physical objects and enable model-free geometric-driven planning [8]. Wang et al. [9] generated initial toolpath points from measured point cloud slicing and further smoothed path curves and tool orientation fluctuations using spline interpolation and optimization strategies, thereby improving robustness to discontinuities caused by noise. Xiao et al. [10] proposed a model-driven polishing toolpath planning method for mold surfaces represented by point clouds, unifying model-free geometric representation with trajectory generation within a unified computational framework. Ren et al. [11] developed a point-cloud-driven polishing path planning system using slice projection to extract features; however, errors tend to propagate when point clouds are sparse or locally incomplete, and mesh partitioning strategies directly affect efficiency and stability.

Despite recent progress, point-cloud-driven polishing of curved mold surfaces still faces three practical limitations:

• Efficiency Bottlenecks: Large-scale point clouds impose significant computational and storage burdens, often creating efficiency bottlenecks in processing.
• Lack of Task-Oriented Organization: Existing segmentation methods prioritize geometric consistency but lack task-oriented region organization, making it difficult to explicitly consider coverage efficiency, tool direction-change costs, and reachability risks.
• Insufficient Verification: Planning evaluation typically remains at the geometric level, lacking a unified closed-loop verification framework that integrates kinematic reachability and safety margins.

Consequently, the primary objective of this study is to establish a comprehensive, closed-loop robotic polishing framework that specifically addresses the limitations of existing methods regarding computational efficiency, kinematic reachability, and process consistency. By integrating a rapid preprocessing strategy (D-C-M) with task-aware graph partitioning, this work aims to bridge the gap between unorganized point clouds and executable, high-quality robot trajectories for complex mold surfaces.

2. Point-Cloud Preprocessing and Workpiece Foreground Extraction via the D-C-M Strategy

Measured point clouds acquired in industrial settings typically contain substantial background noise and outliers, with data scales often reaching millions of points [12]. Directly performing region partitioning and path planning on raw high-resolution point clouds would incur prohibitive computational cost and render downstream algorithms highly sensitive to noise and background interference. This section aims to rapidly extract high-precision workpiece foreground point clouds from mixed point clouds while preserving surface details as much as possible.

Due to the inherent systematic errors in optical measurement devices, the raw point cloud $P={\left\{p_i\right\}}_{i=1}^N$ inevitably contains outlier noise points (Figure 1a) [13]. To ensure the numerical stability of subsequent topological computations, statistical outlier removal is first applied to $P$. Specifically, the mean distance ${\overline{d}}_i$ from each point $p_i$ to its $k$-nearest neighbors is computed (Equation (1)), based on which a Gaussian-assumption-based rejection criterion is established:

$$\overline{d_i}={\displaystyle \frac{1}{k}}{\displaystyle \sum }_{j\in N_k\left(i\right)}\left|\left|p_i-p_j\right|\right|$$

(1)

where $k$ is the number of nearest neighbors, ${\mathcal{N}}_k\left(i\right)$ denotes the index set of the $k$-NN of point $p_i$, and $N$ is the total number of points.

If ${\overline{d}}_i$ satisfies Equation (2), the corresponding point is identified as an outlier and removed, thereby yielding a denoised point cloud (Figure 1b).

$$\overline{d_i}>\mu +\alpha \sigma$$

(2)

Here, $\mu$ and $\sigma$ denote the mean and standard deviation of the global distribution of ${\overline{d}}_i$, respectively, and $\alpha$ is a sensitivity coefficient (details are provided in

Table A1. Summary of key hyperparameters and their selection rationale.

Algorithm Stage	Parameter (Symbol)	Value	Selection Rationale
Preprocessing	Outlier Sensitivity (α)	2.0	Standard statistical threshold (≈2σ) assuming approximately Gaussian measurement noise; removes sparse outliers while retaining the majority of inliers.
	Mapping Threshold (δmap)	Adaptive	Computed as $min\left({\delta }_{map}, c·v_0\right)$ to balance label diffusion with boundary precision during mapping-back.
Partitioning	Seed Constraint (cg, cs)	1.5/2.0	Fixed empirically to control seed density relative to the local feature scale and maintain stable supervoxel growth across datasets.
	Graph Weight Balance (γ)	0.5	Selected via sensitivity analysis (Pareto frontier in Figure 5) to balance kinematic connectivity and geometric adherence.
	Similarity Decay (λ)	10.0	Controls the steepness of feature-similarity decay; set empirically to obtain clear separation between intra-region and inter-region affinities.
	Merge Threshold (τenergy)	−1.0 × 10−4	Small negative threshold to enforce strictly monotonic energy reduction and suppress numerical noise-induced marginal merges.
Path Planning	Loss Weights (λdir, λk)	Tuned	Tuned to balance convergence rates of the direction branch (cosine loss) and the step-distance branch (MSE).
	ROI Inset Ratio (αinset)	0.5	Set to $0.5·s_{base}$ to ensure the tool center remains strictly inside the boundary during path generation.
Validation	Safety Margin (dsafe)	2.0 mm	Conservative threshold set significantly higher than the robot repeatability (±0.03 mm) to ensure safe operation under perception uncertainty.

of Appendix A).

Although the above statistical filtering (Equations (1) and (2)) effectively removes discrete measurement noise, the resulting point cloud remains fundamentally a mixed data field containing both the target workpiece and non-machining background. To address this, we propose a downsampling–clustering–mapping-back (D-C-M) strategy. This approach aims to tackle the dual challenge of background separation and feature fidelity, with spatial decoupling as its core principle. The algorithm first introduces a voxel-based downsampling mechanism to construct a sparse representative point set from the denoised dense data. The specific construction process is described below.

To reduce the data scale while preserving the macroscopic spatial structure of the point cloud, a voxel grid is first introduced to discretize the filtered point cloud. Given a voxel edge length $v_0$, the geometric centroid of all points within each non-empty voxel is computed, yielding a compact representative point set $D={\left\{{\tilde{p}}_j\right\}}_{j=1}^M\left(M\ll N\right)$, as defined in Equation (3). This procedure maps the complex raw data space onto a sparse representative point space, substantially shrinking the search domain for subsequent clustering.

$$\widetilde{P_j}={\displaystyle \frac{1}{\left|V_j\right|}}{\displaystyle \sum }_{PϵV_j}P$$

(3)

where $V_j$ denotes the set of raw points falling into the j-th non-empty voxel, and $\mid V_j\mid$ is its cardinality.

Although voxelization reduces the data scale, background noise still needs to be removed. Therefore, density-based clustering is performed in the reduced space. Specifically, DBSCAN is applied to the representative point set $D$ [14]. Since the number of points involved in clustering decreases from $N$ to $M$, the computational complexity is reduced from $O\left(N\log N\right)$ to $O\left(M\log M\right)$. As shown in Figure 2a, density-based clustering can effectively identify and separate the target workpiece (the red dominant cluster) from background disturbances (the gray and blue clusters), and each representative point ${\tilde{p}}_j$ is assigned a cluster label $l_D$.

Although clustering results distinguish the workpiece from the background, the representative point set $D$ loses fine-grained surface details. To recover the original resolution, a label mapping-back operation is performed. For any point $p\in P$ in the raw point cloud, its nearest neighbor ${\tilde{p}}^{*}$ in the representative set $D$ is queried using a KD-tree, and the cluster label is propagated according to spatial proximity [15]:

$$l_P\left(p\right)=\left\{\begin{array}{cc}{l}_D\left({\tilde{p}}^{*}\right),& if \left||p-{\tilde{p}}^{*}|\right|\le {\delta }_{map},\hfill \\ -1,& otherwise.\hfill \end{array}\right.$$

(4)

where $l_P\left(\cdot \right)$ and $l_D\left(\cdot \right)$ denote the cluster labels in the raw and representative point sets, respectively; ${\tilde{p}}^{*}$ is the nearest representative point of $p$; $c$ is a scale coefficient; ${\delta }_{max}$ is the upper bound of the mapping threshold; and label −1 indicates unassigned.

Here, the mapping-back threshold is defined as ${\delta }_{map}=\min \left({\delta }_{max},c{v}_0\right)$, which is introduced to prevent excessive label diffusion into unrelated regions. As shown in Figure 2c, this step successfully projects the semantic information from the low-dimensional representative space back to the original high-dimensional space. The mapped point cloud preserves a macroscopic density distribution consistent with that of the raw point cloud. A small number of points near the boundary remain unlabeled, resulting in a mapping-back success rate of 98.5%.

The core advantage of the D-C-M strategy lies in exchanging minimal geometric position uncertainty for a 7.5-fold improvement in processing speed (see

Table 1. Comparison of the D-C-M strategy with other background removal methods.

	N (Original)	M (Downsampled)	Mapping-Back Success Rate (%)	Mapping Distance 95th (mm)	Processing Time (s)	Speedup
D-C-M	237,640	11,882	98.5	1.78	1.14	7.5
DS-Only	237,640	11,882	N/A	N/A	0.78	11.0
FR-DBSCAN	237,640	N/A	100.0	N/A	8.59	1.0

). From a theoretical error perspective, the displacement deviation introduced by voxelization is bounded by the voxel diagonal length (Equation (5)). In practical data, point clouds concentrate on the workpiece surface, and the statistical error is significantly smaller than this conservative upper bound.

$$\left||p-\tilde{p}|\right|\le \sqrt{3}{v}_0,$$

(5)

Table 1 provides a quantitative comparison demonstrating the performance advantages of this method. Compared to clustering directly on full-resolution point clouds or using downsampling data alone, the D-C-M strategy processes large-scale point clouds in just 1.14 s while maintaining a 98.5% mapping-back success rate. This demonstrates that the method not only meets the geometric accuracy requirements for manipulator polishing but also exhibits the potential for real-time performance compatible with industrial production cycles.

3. Task-Aware Region Partitioning for Manipulator Polishing

Although the preprocessing strategy described above effectively removes background noise and yields a high-accuracy workpiece point cloud, the resulting data remain an unstructured and semantically disconnected set of discrete points. Direct global toolpath planning on such data can hardly meet the requirements of manipulator polishing in terms of trajectory continuity and kinematic reachability [16]. To bridge the gap between geometric disorder and machining order, this section presents a coarse-to-fine task-aware region partitioning framework. Specifically, the scattered point cloud is first supervoxelized into geometrically homogeneous units. An attributed adjacency graph is then constructed to model the topological relationships among these units. Finally, a multi-objective energy optimization that integrates kinematic constraints is formulated to generate continuous task sub-regions that are executable by the manipulator.

Before proceeding, to explicitly quantify kinematic feasibility in the subsequent partitioning stage, the robotic polishing system is modeled as a six-degree-of-freedom serial manipulator (Figure 3). Its workspace is constrained by joint limits. The reachability metric used in Equation (18) is computed based on the inverse-kinematics (IK) solver associated with this specific kinematic chain.

3.1. Supervoxel Construction for the Sampled Point Cloud

To transform the unstructured point cloud into an optimizable structured representation, this stage discretizes the processed point cloud $P$ into a supervoxel set $S={\left\{s_u\right\}}_{u=1}^{N_s}$, where each supervoxel serves as a basic unit with locally consistent geometry. The classical Voxel Cloud Connectivity Segmentation (VCCS) algorithm often suffers from uneven seed distribution and poor boundary adherence when handling non-uniformly sampled point clouds [17]. To address these limitations, this paper introduces adaptive improvements to both the initialization and region-growing mechanisms of VCCS.

During the initialization stage, to enhance the sensitivity of the algorithm to mold-surface features, we abandon the conventional VCCS seeding strategy that relies on a fixed resolution. Instead, a density-adaptive seed estimation mechanism is adopted. Specifically, the number of seeds $n_{seeds}$ is dynamically determined from the axis-aligned bounding box (AABB) volume $V$ of the point cloud and the desired spatial resolution $r_s$ (Equation (6)). Subsequently, a feature space that integrates spatial coordinates and surface normals is constructed, and K-means initialization is performed within this space. This strategy encourages seeds to be preferentially distributed in regions with large curvature variations rather than being uniformly scattered over flat areas, thereby ensuring that the resulting segmentation units can better represent the underlying surface morphology from the outset.

$$n_{seeds}=\min \left(\lfloor {\displaystyle \frac{V}{r_s^3}}\rfloor ,{\displaystyle \frac{N}{S_{min}^{seg}}},N_{max}^{seed}\right)$$

(6)

Here, $S_{min}^{seg}$ denotes the minimum number of points required for a single supervoxel, and $N_{max}^{seed}$ is the predefined upper bound on the number of seeds.

During the region-growing stage, to prevent supervoxels from crossing sharp edges or right-angle boundaries of the workpiece, and thus blurring geometric features, a strict normal-consistency constraint is introduced [18]. A candidate neighboring point $p_j$ is merged into the current supervoxel only when it simultaneously satisfies the spatial distance constraints (Equations (7) and (8)) and the normal-angle criterion with respect to the current seed point as defined in Equation (9). This constraint mitigates over-segmentation and ensures a high degree of geometric continuity within each generated supervoxel. After the growth process, a feature descriptor is extracted for each supervoxel $s_u$, including its centroid, mean normal vector, and shape index. These attributes are further normalized using PCA-weighted standardization and serve as the basic properties for subsequent topological modeling.

$$\left||p_j-p_i|\right|<d_{step}$$

(7)

$$\left||p_j-p_{seed}|\right|<d_{global}$$

(8)

$$\angle \left(n_i,n_j\right)\le {\theta }_{seg}$$

(9)

where $p_i$ is the current seed point, $p_j$ is a neighboring candidate point, $p_{seed}$ is the initial seed of the current supervoxel, $n_i$ and $n_j$ are the corresponding estimated normals, and $\angle \left(n_i,n_j\right)$ denotes the included angle between two normals.

Here, ${\theta }_{seg}$ is weakly adapted to the supervoxel scale in the experiments to prevent region growing from expanding across curvature discontinuities and sharp edges.

The supervoxelization results are illustrated in Figure 4, where the point cloud is decomposed into small patches with relatively uniform geometric characteristics. The supervoxel size is jointly constrained by $r_s$, $d_{step}$, $d_{global}$, and $S_{min}^{seg}$, leading to an overall multi-modal distribution. In implementation, $d_{global}=c_g{r}_s$ and $d_{step}=c_s{\overline{d}}_{\mathrm{knn}}$, where ${\overline{d}}_{\mathrm{knn}}$ denotes the local mean KNN spacing. The coefficients $c_g$ and $c_s$ are fixed across all experiments (details are provided in Table A1 of Appendix A).

3.2. Attributed Adjacency Graph Construction and Edge Weight Modeling

After obtaining the supervoxel set, this section constructs an undirected weighted attributed adjacency graph (AAG) $G=\left(V,E,W\right)$, which encodes local topological relationships and multi-source similarities into a weighted graph structure to serve as the input for subsequent optimization. Here, the vertex set $V$ corresponds one-to-one to the supervoxels. Each vertex $v_u\in V$ encapsulates the supervoxel centroid $c_u$, mean normal $n_u$, and a 16-dimensional feature vector $f_u$, forming the basic information unit for the following graph-based optimization.

During the graph connectivity construction, to accommodate the anisotropic scale variations in curved mold surfaces, we discard the conventional neighborhood criterion based on a fixed radius and instead design a scale-adaptive dynamic thresholding mechanism. The decision of whether to establish an edge between two supervoxels is determined by a spatial distance threshold $d_{thr}\left(i,j\right)$ and a normal-angle threshold ${\theta }_{thr}\left(i,j\right)$, as defined in Equations (10) and (11).

$$d_{thr}\left(i,j\right)=\mathrm{clip}\left(d_0\left(1+\eta \log {\displaystyle \frac{m_i+m_j}{2m_{\mathrm{ref}}}}\right),d_{min},d_{max}\right)$$

(10)

$${\theta }_{thr}\left(i,j\right)=\mathrm{clip}\left({\theta }_0\left(1+\beta \left(1-{\displaystyle \frac{d_{ij}}{d_{thr}\left(i,j\right)}}\right)\right),{\theta }_{min},{\theta }_{max}\right)$$

(11)

where $d_0$ and ${\theta }_0$ are the base distance/normal thresholds, $\eta$ and $\beta$ are scale-adaptation coefficients, $\left(d_{min},d_{max}\right)$ and $\left({\theta }_{min},{\theta }_{max}\right)$ are lower/upper bounds, and $c_i,c_j$ denote the centroids of supervoxels $s_i,s_j$. Here, $d_{ij}=\parallel c_i-c_j\parallel$ denotes the centroid distance between two supervoxels. $m_i$ and $m_j$ represent the numbers of points contained in the corresponding supervoxels and are used as a proxy for their scales, while $m_{ref}$ is a reference scale. The clipping operator is defined as $\mathrm{clip}\left(x,a,b\right)=\min \left(\max \left(x,a\right),b\right)$ to ensure that the thresholds remain within a reasonable range.

This dynamic mechanism endows the algorithm with scale adaptivity. In relatively flat regions with large curvature radii, longer-range connections are allowed to accelerate merging. In contrast, in areas with abrupt curvature changes or fine geometric details, stricter spatial and normal constraints are enforced. Specifically, no edge is established when the average curvature difference exceeds the threshold, i.e., $\mid {\kappa }_i-{\kappa }_j\mid >{\kappa }_{thr}$. As a result, erroneous connections across sharp edges are effectively blocked during graph construction, thereby preserving the sharp geometric features of the workpiece.

During the edge-weight computation stage, to precisely characterize the merging tendency between adjacent nodes, the final edge weight $w_{final}$ is designed as a composite measure of local geometric continuity and global feature consistency. As shown in Equation (12), this weight is constructed by linearly coupling the geometric similarity term $w_{geom}$ and the high-dimensional feature similarity $S_{feat}$:

$$w_{final}\left(i,j\right)=\gamma ·w_{geom}\left(i,j\right)+\left(1-\gamma \right)·S_{feat}\left(i,j\right)$$

(12)

Here, the balancing factor $\gamma$ (details are provided in Table A1 of Appendix A). is introduced to trade off local geometric continuity and global feature consistency, where $w_{geom}$ is the geometric similarity term (distance/normal/curvature-based) and $S_{feat}$ is the feature similarity computed in Equations (13) and (14).

To eliminate the influence of different physical scales, the geometric similarity $w_{geom}$ integrates the spatial Euclidean distance, normal-angle deviation, and curvature difference. Each component is mapped into the [0, 1] range via a Gaussian kernel, thereby ensuring a normalized and comparable metric.

The feature similarity $S_{feat}$ is designed to capture higher-order shape variations. Considering that different dimensions of the 16-dimensional feature descriptor contribute unequally to shape characterization, a PCA explained-variance-weighted Euclidean distance is employed (Equation (13)), which is further transformed into a similarity score using an exponential function (Equation (14)):

$$distanc{e}_{weighted\left(i,j\right)}=\sqrt{{\displaystyle \sum }_k{w}_k{(f_{i,k}-f_{j,k})}^2}$$

(13)

$$S_{feat}\left(i,j\right)=\exp \left(-\lambda ·distanc{e}_{weighted\left(i,j\right)}\right)$$

(14)

To determine the optimal balancing factor γ in Equation (12), we conducted a systematic parameter perturbation study. As illustrated in Figure 5, we analyzed the trade-off between segmentation quality (Fusion Quality Score) and kinematic reachability (Graph Connectivity Ratio) by sweeping the weighting parameter γ from 0 to 1. The results show a clear Pareto frontier: increasing the kinematic weight improves graph connectivity but slightly degrades the geometric adherence of supervoxels. At low $\gamma$ (<0.2), the connectivity is insufficient (<70%) to guarantee a complete toolpath. As $\gamma$ increases, connectivity rises sharply and saturates around $\gamma$ = 0.65. Beyond this point, further increasing the weight yields diminishing returns in connectivity while excessively penalizing geometric features. Therefore, we empirically set $\gamma$ = 0.5 (near the “elbow” point) to balance high segmentation quality with robust kinematic connectivity.

Here, $f_{i,k}$ denotes the $k$-th component of the feature vector of the $i$-th supervoxel. The weight $w_k$ is adaptively determined from the PCA explained-variance ratio and satisfies ${\sum }_k{w}_k=1$, thereby automatically emphasizing features with higher discriminative power. The hyperparameter $\lambda$ controls the steepness of similarity decay.

As shown in Figure 6, this composite weighting strategy results in strong connections only within regions where nodes are not only spatially adjacent but also highly consistent in surface texture and morphological attributes. In contrast, for nodes that are spatially close yet exhibit substantially different attributes, the edge weights are suppressed. This provides clear gradient cues and boundary priors for the subsequent energy-minimization-based graph-cut optimization.

3.3. Energy-Minimization Task Partitioning for Executable Manipulator Polishing

Based on the constructed attributed adjacency graph, the region partitioning problem is mathematically formulated as a graph partitioning problem. To overcome the limitation of conventional geometric segmentation methods that lack awareness of the manipulator’s machining capability, we cast the partitioning as a multi-term energy minimization problem. In this formulation, the energy terms represent geometric continuity, compactness, and manipulator reachability, respectively. The goal is to find an optimal partition $R=\left\{R_k\right\}$ that minimizes the total system energy $E_{total}$. As shown in Equation (15), the energy function is defined as a weighted sum, which enables a tight coupling between geometric features and task constraints:

$$E_{\mathit{total}}={\displaystyle \sum }_{R\in \mathcal{R}}[w_h{E}_{\mathit{hom}}\left(R\right)+w_c{E}_{\mathit{compact}}\left(R\right)+w_r{E}_{\mathit{reach}}\left(R\right)+w_p{E}_{\mathit{path}}\left(R\right)]$$

(15)

Here, $w_h,w_c,w_r,$ and $w_p\ge 0$ are the weighting coefficients for the corresponding energy terms.

To ensure the geometric integrity of the partitioned regions, the energy function first introduces a homogeneity term $E_{hom}$ and a compactness term $E_{compact}$. Specifically, $E_{hom}\left(R\right)$ (Equation (16)) penalizes the dispersion of feature vectors within each region relative to the regional mean ${\mu }_R$, thereby encouraging the separation of regions with significantly different surface properties:

$$E_{hom}\left(R\right)={\displaystyle \sum }_{v_u\in R}\parallel {\mathrm{f}}_u-{\mu }_R{\parallel }_2^2,{\mu }_R={\displaystyle \frac{1}{\mid R\mid }}{\displaystyle \sum }_{v_u\in R}{\mathrm{f}}_u$$

(16)

The compactness energy $E_{\mathit{compact}}\left(R\right)$ is constructed based on the coefficient of variation in the centroid-distance distribution within each region, aiming to suppress the formation of elongated or fragmented regions. Let $r_u=\parallel c_u-{\overline{c}}_R\parallel$ denote the distance from node $u$ to the region centroid ${\overline{c}}_R$. This term is defined as:

$$E_{compact}\left(R\right)={\displaystyle \frac{\sigma \left(r\right)}{\mu \left(r\right)+\epsilon }}$$

(17)

Here, $\mu \left(r\right)$ and $\sigma \left(r\right)$ denote the mean and standard deviation of the distance set, respectively.

Building upon the geometric constraints, to endow the partitioning results with machining executability, the model further introduces two key task-aware terms. The reachability energy $E_{reach}\left(R\right)$ explicitly incorporates the manipulator’s kinematic constraints into the optimization objective:

$$E_{reach}\left(R\right)=1-S_{reach}\left(R\right)$$

(18)

Here, $S_{reach}\left(R\right)\in \left[0,1\right]$ is obtained by uniformly sampling $n_r$ points within the region and computing the success rate of inverse-kinematics (IK) solutions. This term drives the optimization to avoid region configurations located near the workspace boundary or in the vicinity of kinematic singularities [17].

In addition, the path-complexity energy $E_{path}\left(R\right)$ aims to optimize the texture-processing direction on the surface. The algorithm projects the regional point set onto the local tangent plane, computes the eigenvalues ${\lambda }_1\ge {\lambda }_2$ of the resulting 2D covariance matrix, and defines:

$$E_{path}\left(R\right)={\displaystyle \frac{{\lambda }_2}{\left({\lambda }_1+\epsilon \right)}}$$

(19)

Minimizing this energy functional tends to generate serpentine strip-shaped regions with dominant elongation directions, a morphology that aligns well with the subsequent serpentine scanning strategy, thereby minimizing tool reorientation transitions and reducing the dynamic impact of accelerations and decelerations on the robotic arm.

Due to the non-convexity of the objective function $\Delta E_{total}$ and the high computational cost of $E_{reach}$, direct global optimization constitutes an NP-hard problem [19]. To address this, we design an efficient two-stage greedy merging strategy. The algorithm first utilizes the low-cost consistency increment $\Delta E_{hom}$ (Equation (20)) to rapidly screen potential merge candidates in $O\left(1\right)$ time:

$$\Delta E_{hom}\left(A,B\right)={\displaystyle \frac{n_A{n}_B}{n_A+n_B}}|\left|{\mu }_A-{\mu }_B\right|{|}^2$$

(20)

where $n_A$ and $n_B$ are the numbers of nodes in regions A and B. Subsequently, only the prescreened candidate pairs undergo recalculation of the complete energy variation $\Delta E_{total}\left(A,B\right)$ including the kinematic term, yielding precise energy gains.

A merge is accepted if $\Delta E_{total}\left(A,B\right)<{\tau }_{energy}$. Here, we set ${\tau }_{energy}=-1.0\times {10}^{-4}$ to ensure strict energy reduction and avoid merges driven by numerical noise. Iterating this process until no region pair can reduce total energy further yields a stable task-aware partitioning. Figure 7 shows that valid merges monotonically decrease total energy throughout iteration, converging to a stable solution.

To further eliminate sawtooth artifacts and isolated fragments at region boundaries and provide continuous region contours for subsequent path planning, the optimized region boundaries undergo lightweight normal-weighted smoothing to suppress jaggedness and avoid crossing sharp edges [20]. Figure 8 shows the final region partitioning.

4. Coverage Toolpath Generation for Manipulator-Executable Polishing

Based on the task-aware partitioning obtained in the previous section, the mold surface has been structured into a set of sub-regions suitable for machining. However, to generate high-quality polishing trajectories within these unstructured sub-regions, it is still necessary to overcome the local geometric uncertainty and the physical constraints of manipulator motion. Traditional purely geometric planning methods often struggle to simultaneously ensure coverage rate while taking into account trajectory smoothness and executability. For this purpose, this section proposes a hybrid path planning method assisted by data-driven decision-making. We will first utilize a deep learning model to replace traditional geometric operators to obtain robust process principal directions, then combine them with a thick-slicing technique to generate topologically consistent coverage paths, and finally complete the trajectory temporal mapping from task space to joint space through kinematic optimization.

4.1. Learning-Based Process Parameter Prediction via Deep Geometric Feature Fusion

Although task-aware partitioning in the previous section decomposes the complex global planning problem into lower-dimensional local subproblems, generating concrete paths still requires addressing the challenge of local geometric uncertainty. Near curvature discontinuities or boundaries, PCA-based principal directions derived from second-order statistical moments tend to produce unstable results or even sign flips [21]. Additionally, fixed step distances struggle to simultaneously balance machining efficiency and consistent material removal [22]. To address this, we propose a data-driven process parameter decision method that jointly predicts the region scanning direction $t^{*}$ and step-distance coefficient $k^{*}$ using a lightweight dual-head network, thereby replacing conventional analytical operators.

To achieve geometric perception beyond conventional analytical operators, we construct an informative feature space capturing local topological context. A 128-dimensional task-aware descriptor fuses multi-scale geometric cues as network input (

Table 2. Composition of the 128-D task-aware descriptor used for direction and step-distance prediction.

Feature Group	Dim.	Representative Statistics (Examples)
Geometric statistics	20	Coordinate moments, AABB size, aspect ratios
PCA-based shape cues	15	Principal-component magnitudes and ratios
Curvature descriptors	20	Variance, extrema, curvature ratios
Normal distribution	30	Mean, normal consistency, dispersion
Boundary cues	15	Boundary-point ratio, edge length,
Density statistics	10	Local point density and multi-scale spacing
Higher-order interactions	18	Mixed statistics across multiple cues

). The backbone uses a lightweight MLP (~$7.4\times {10}^4$ parameters), designed with shared features and parallel dual-head branches for simultaneous direction and step-distance coefficient prediction (Figure 9).

To eliminate training instability caused by features with different scales, all input feature vectors undergo Z-score normalization, mapping them to a standard normal distribution space. This accelerates gradient backpropagation and model convergence.

To enhance the stability of normals and curvatures under noisy and non-uniform sampling conditions, we introduce a learnable geometric attribute estimator to predict point cloud normals and curvatures, aggregating them into region-level statistical features as network input. The estimator is first pretrained on public point cloud attribute datasets and then fine-tuned on acquired workpiece point clouds to adapt to the actual data distribution [23,24].

Regarding supervision signal construction, the ground-truth scanning direction $t_{gt}$ is obtained through offline pseudo-label generation: we constructed a dataset containing approximately 20,000 local point cloud patches, of which 80% are used for training and 20% for validation. The ground-truth step-distance coefficient $k_{gt}$ is determined starting from a baseline step distance derived from the tool’s effective contact width and preset overlap ratio, and the step distance range is then cropped and calibrated according to regional curvature statistics, forming $\left(t_{gt},k_{gt}\right)$ label pairs available for training [25].

Based on the region-level features and offline-generated supervision signals described above, we train the lightweight MLP to jointly predict the region scanning direction $t^{*}$ and step-distance coefficient $k^{*}$.

The direction prediction head outputs a vector $d\in {ℝ}^3$, which is strictly constrained to a unit scanning direction $t^{*}$ through $L_2$ normalization.

$$t^{*}={\displaystyle \frac{d}{{\parallel d\parallel }_2+\epsilon }},d\in {ℝ}^3$$

(21)

where $\epsilon$ is a small positive constant preventing division by zero.

The step-distance coefficient head produces an unbounded scalar $r$, which undergoes Sigmoid squashing (Equation (22)) followed by affine scaling to the range $\left[k_{min},k_{max}\right]$, obtaining the bounded step-distance coefficient $k^{*}$.

$$k^{*}=k_{min}+\left(k_{max}-k_{min}\right)\sigma \left(r\right),\sigma \left(x\right)={\displaystyle \frac{1}{1+e^{-x}}}$$

(22)

where $k_{\mathit{min}}$ and $k_{\mathit{max}}$ are specified by process parameters.

With $\left(t^{*},k^{*}\right)$ obtained, we further compute the region baseline strip step distance $s_{base}$, which serves as the step advance and strip generation parameter for the thick-slice serpentine coverage in Section 4.2, defined as:

$$s_{base}=k^{*}\cdot 2\cdot R_{eff}\cdot \left(1-overlap\right)\cdot \cos \left({\theta }_{tilt}\right)$$

(23)

where $2R_{eff}$ is the effective contact band width, $\mathit{overlap}$ is the inter-strip overlap ratio, and $\cos \left({\theta }_{tilt}\right)$ projects contact width to the direction orthogonal to scanning direction in the tangent plane, yielding effective line spacing. The predicted $t^{*}$ determines the strip progression vector $u_g$ and guides the thick-slice serpentine path generation as a directional constraint [26].

For joint optimization of direction and step predictions, training uses a weighted loss function $\mathcal{L}$ balancing the two objectives:

$$\mathcal{L}={\lambda }_{dir}{\mathcal{L}}_{dir}+{\lambda }_k{\mathcal{L}}_k$$

(24)

where the direction loss adopts a cosine similarity form ${\mathcal{L}}_{dir}=1-\mid t^{*}\cdot t_{gt}\mid$, the step-distance loss uses mean squared error ${\mathcal{L}}_k={\parallel k^{*}-k_{gt}\parallel }_2^2$, and ${\lambda }_{dir}$ and ${\lambda }_k$ are balance coefficients. Training employs early stopping and weight decay to suppress overfitting.

Figure 10 presents comparative results between this method and the conventional PCA approach. It can be seen that in flat regions (Figure 10a,b), the predicted scanning direction $t^{*}$ is essentially consistent with PCA directions; however, near curvature discontinuities or boundaries (Figure 10c,d), conventional PCA directions exhibit obvious deflection and sign flips, while the proposed $t^{*}$ maintains consistency with local surface geometry, further indicating that the deep learning-based approach demonstrates superior robustness in complex regions [27].

To quantitatively evaluate the prediction accuracy of the proposed MLP, we further plot the regression between predicted and ground-truth values for the azimuth φ, elevation θ, and step-distance coefficient k* on the test set (N = 2000), as shown in Figure 10e–g. The plots report R² as well as error metrics (MSE and SSE), indicating strong agreement between predictions and ground truth for all three outputs.

Through the above processing, the sign ambiguity of the scanning direction $t^{*}$ within regions is eliminated, establishing a globally consistent direction field representation. However, this consistency addresses the sign stability of the geometric direction field; in the subsequent serpentine coverage, to minimize idle motion, the tool traversal directions of adjacent strips naturally exhibit alternating changes, which represents the tool reversal phenomenon arising from trajectory organization strategy and will be discussed in the next section regarding its orientation continuity handling.

4.2. Topology-Aware Thick-Slice Serpentine Path Planning

Upon obtaining locally optimal scanning direction $t^{*}$ and step-distance coefficient $k^{*}$ from the deep learning model, the core objective of path planning is to convert these discrete process parameters into continuous, smooth, and complete-coverage mechanical arm trajectories. Rather than employing traditional projection methods, we introduce a topology-aware thick-slice approach: stratifying the region three-dimensionally along the strip advancement direction $u_g$ and mapping the complex surface manifold to a local two-dimensional parametric domain, thus enabling both regularized strip generation and topology-cognizant serpentine connectivity [28,29].

Since serpentine coverage uses reciprocal tool motions to enhance machining efficiency, the feed directions of adjacent strips necessarily alternate. To maintain the continuity of the end-effector orientation and machining contact throughout the coverage, orientation interpolation and heading selection must be carefully constrained at strip transitions and direction reversals. We construct a K-nearest neighbor (KNN) undirected graph over the regional point cloud and propagate normal vector consistency via breadth-first search (BFS). Specifically, if the angular difference between normal vectors at two adjacent points exceeds 90°, the normal of the neighboring point is flipped to enforce local consistency: $n_i\cdot n_j>0,\forall \left(i,j\right)\in \mathcal{N}$, where $\mathcal{N}$ denotes the adjacency set in the KNN graph. Following local consistency enforcement, the region-averaged normal is computed as $\overline{\mathrm{n}}={\displaystyle \frac{1}{N}}{\sum }_{i=1}^N{n}_i$. The desired outward normal direction is represented by the unit vector $e_z={(0,0,1)}^{\top }$ aligned with the work frame z-axis. Should $\overline{\mathrm{n}}\cdot e_z<0$, all region normals are globally flipped to enforce global consistency: the normals are unified to reside within the half-space defined by $e_z$.

Figure 11a illustrates the local k-nearest neighbor graph prior to BFS-based normal consistency, wherein some reversed normals are present (indicated by red arrows). Figure 11b demonstrates that following BFS propagation and global orientation alignment, all normals are uniformly directed toward the +z direction of the work coordinate system, with only a representative subset of normals rendered for visualization purposes.

Despite achieving global normal consistency, residual noise points at the region boundaries may still induce path perturbations during the subsequent filling operation. To address this, an SDF-based inward offset is applied to the Region of Interest (ROI) prior to slice generation. Taking the reference step size $s_{\mathit{base}}$, as defined in Equation (23), the inward offset distance is formulated as

$$d_{inset}=\alpha s_{base},\alpha =0.5$$

(25)

The ROI point cloud is orthogonally projected onto a region-local 2D plane and discretized through rasterization; this 2D coordinate plane is constructed based on the region’s mean normal vector and scanning direction. The signed distance field (SDF) is computed on this 2D grid via Euclidean distance transform; for each 3D point $p$, orthogonal projection yields the 2D grid coordinates $\left(u_g\left(p\right),v_g\left(p\right)\right)$, which are subsequently used to query the corresponding grid SDF value and perform threshold-based filtering. The 2D coordinates $\left(u_g,v_g\right)$ are constructed from the region’s mean normal $\overline{\mathrm{n}}$ and scanning direction $t^{*}$, following the construction scheme detailed in Equations (28) and (29), with $n_{avg}$ replaced by $\overline{\mathrm{n}}$. The SDF computation and query operations are performed on this region-level 2D rasterized grid.

To ensure connectivity preservation, the outermost boundary contour of the region is first extracted from the 2D grid and subjected to a morphological closing operation, which fills small cracks and voids; subsequently, the signed distance field is computed only within the interior of this outer contour boundary. Consequently, the threshold criterion $\mathrm{SDF}\left(p\right)>d_{\mathit{inset}}$ effectively removes only a narrow strip along the region periphery, thereby preserving the topological connectivity of the inset ROI in most cases; should fragmentation occur, the largest connected component is retained while isolated components are discarded [30].

For each point p in the original point cloud, the signed distance to the region boundary $\mathrm{SDF}\left(p\right)$ is computed. Only points satisfying the condition $\mathrm{SDF}\left(p\right)>d_{\mathit{inset}}$ are preserved, thereby effectively eliminating unstable boundary artifacts and yielding the inset ROI point cloud, as illustrated in Figure 12a.

For the processed ROI point cloud, the algorithm performs thick-slice discretization along the strip stepping direction $u_g$. The projection direction $u_g$ is constructed by the cross product of the region’s average normal and the scanning direction $t^{*}$ (Equation (26)).

$$d_i=p_i\cdot u_g$$

(26)

where $u_g={\displaystyle \frac{\overline{\mathrm{n}}\times t^{*}}{\parallel \overline{\mathrm{n}}\times t^{*}\parallel }}$ is a unit vector.

The slice layer thickness is set to $h=s_{base}$. Compared to single-layer slicing, this strategy partitions the point cloud into several overlapping controlled subsets $S_i$ (Equation (27)), effectively ensuring the integrity of local geometric features [31].

$$S_i=\left\{\begin{array}{c}{p}_j\mid d_{min}+ih\le p_j\cdot u_g<d_{min}+\left(i+1\right)h\end{array}\right\}$$

(27)

where $d_{min}=mi{n}_i{d}_i$ and $d_{max}=ma{x}_i{d}_i$.

To enable dimensionality reduction in the three-dimensional path planning problem, a locally following coordinate frame $\left(u,v,t^{*}\right)$ is established for each slice subset (Equations (28) and (29)), wherein the v-axis is aligned with the principal tangential direction, thereby transforming the complex spatial point cloud into a structured local 2D parametric domain.

$$u={\displaystyle \frac{u_g-\left(u_g\cdot n_{avg}\right)n_{avg}}{\parallel u_g-\left(u_g\cdot n_{avg}\right)n_{avg}\parallel }},v=u\times n_{avg}$$

(28)

When $\parallel u_g-\left(u_g\cdot n_{avg}\right)n_{avg}\parallel$ is too small, it degenerates to constructing $u$ and $v$ using the global coordinate system to avoid numerical instability.

$$u_i=p_i\cdot u,v_i=p_i\cdot v$$

(29)

Within the local parametric plane, a set of approximately parallel scanning lines $u=u_0+m{s}_{\mathit{base}}$ are established at uniform intervals in the $u$ direction with spacing $s_{\mathit{base}}$. Points along each scanning line are sorted according to the $v$-coordinate and subsequently subjected to sparse resampling along the $v$ direction using $s_{base}$ as the target inter-point distance, thereby generating equidistant parallel processing strips.

The algorithm constructs parallel scanning line sets ${\mathrm{Band}}_m$ (Equation (30)) with uniform spacing $s_{\mathit{base}}$ and performs coordinate-based sorting and resampling operations on the point cloud along the v-axis. To address the idle-motion inefficiency inherent in conventional path planning, a topology-aware serpentine connection strategy is employed: adjacent scanning line endpoints are alternately connected based on parity, and transition segments are strategically inserted across slice boundaries following a minimum-distance criterion. The serpentine path topology ensures monotonic progression through the parametric domain, effectively preventing path self-intersection and abrupt normal discontinuities. Figure 13 illustrates the projection of the serpentine polyline path (computed for a single region) back onto the 3D surface, where gray lines represent scanning line boundaries, blue dots denote equidistant sample points, and red polylines depict the resultant serpentine machining trajectory.

$${\mathrm{Band}}_m=\{p\in S_i\mid \mid u\left(p\right)-u_m\mid <{\displaystyle \frac{{\mathit{s}}_{\mathit{base}}}{2}}\},u_m=u_0+m{s}_{base}$$

(30)

The initial path is geometrically connected; however, the sharp corners at U-shaped turns easily cause acceleration discontinuities during manipulator motion. To address this dynamics challenge, we introduce piecewise B-spline fitting for parametric fitting of the machining segments and employ cubic Bezier curves for corner rounding transitions. To prevent excessive smoothing that causes loss of workpiece edge features, the algorithm introduces a surface normal angle threshold $\Delta {\theta }_{max}$: when the pose deviation caused by fitting is too large, the algorithm automatically reverts to the original path, thereby achieving a dynamic balance between geometric fidelity and motion smoothness in high-curvature regions.

$$\Delta {\theta }_{max}=\underset{i}{max} \arccos \left(n_i·n_{i+1}\right)$$

(31)

where $n_i$ is the surface outward normal at the $i$-th sample point of the path. During computation, $n_i\cdot n_{i+1}$ is clamped to $\left[-1,1\right]$ to avoid numerical errors.

Through normal consistency and thick-slice planning, as well as adaptive trajectory refinement processing, we have successfully constructed a complete path from discrete point clouds to continuous machining trajectories. This path does not yet include the joint physical constraints of the manipulator and the dynamic properties of the time dimension. To transform the static geometric curve into motion commands that can be directly executed by the manipulator controller, the next section will further introduce inverse kinematics solving and dynamics constraints, elucidating the mapping and optimization methods from task-space poses to joint-space time trajectories [32].

4.3. Kinematically Feasible Pose Mapping and Temporal Trajectory Parameterization via Inverse Kinematics

The path point set generated in the previous section satisfies geometric coverage requirements; however, to convert it into executable instructions for the manipulator, we must solve the nonlinear mapping problem from Cartesian space to joint space while simultaneously satisfying pose process requirements, joint continuity, and dynamics limits.

First, to ensure consistency of the polishing contact state, we need to transform geometric points with only position information into TCP poses containing six-degree-of-freedom information. Unlike traditional machining, manipulator polishing requires the tool axis to strictly follow the local surface normal or maintain a specific inclination angle [31]. For this purpose, we construct the following local surface coordinate system $R_s\left(k\right)$ based on the path tangent $t_k$ and surface normal $n_k$:

$$R_s\left(k\right)=\left[\begin{array}{ccc}{\widehat{t}}_k& b_k& n_k\end{array}\right]$$

(32)

where ${\widehat{t}}_k$ is the normalized feeding direction, and the binormal vector $b_k$ is determined by the right-hand rule. To eliminate non-orthogonality caused by measurement noise, Gram–Schmidt orthogonalization correction is introduced during the construction process. On this basis, considering that practical processes often require setting a forward tilt angle or lateral tilt angle to optimize material removal rate, the final tool coordinate system pose $R_{tcp}\left(k\right)$ is defined as the result of rotating the local frame about the binormal by tilt angle ${\theta }_{tilt}$:

$$R_{tcp}\left(k\right)=R_s\left(k\right)R_{tilt}\left({\theta }_{tilt}\right)$$

(33)

Meanwhile, combined with the geometric offset $h_c$, corresponding to the contact wheel radius and preload force, the spatial position of the TCP is determined as

$$p_{tcp}\left(k\right)=p_k+h_c{z}_{tcp}\left(k\right),z_{tcp}\left(k\right)=R_{tcp}\left(k\right)e_z$$

(34)

After obtaining a continuous sequence of Cartesian poses, the algorithm faces the core challenge of maintaining smooth joint configuration among multiple IK solutions. The kinematic redundancy of the manipulator may lead to drastic jumps or even singularities in joint space at adjacent trajectory points. To address this problem, we introduce the minimum displacement criterion when solving the inverse kinematics:

$$q_k=IK\left(p_{tcp}\left(k\right),R_{tcp}\left(k\right)\right),q_{min}\le q_k\le q_{max}$$

(35)

where $q_{min},q_{max}$ are the physical joint stroke limits for each joint of the manipulator. During the solving process, the solution closest to the previous joint configuration $q_{k-1}$ in the Euclidean distance sense is selected to avoid frequent jumps among multiple inverse solution branches. For individual trajectory points that are reachable in the workspace but infeasible in IK due to pose constraints, they are only used for diagnostic and region-level statistics; the final output trajectory for evaluation is the repaired feasible sequence, and the IK success rate is subsequently calculated based on this.

Finally, to convert the discrete joint angle sequence into a dynamic trajectory executable by the controller, the path must undergo time parameterization. This paper adopts a trapezoidal velocity profile-based planning algorithm, assigning a time scale $t$ to the joint sequence, ensuring that at any instant the velocity and acceleration of each joint are strictly limited within physical bounds:

$$\mid {\dot{q}}_i\left(t\right)\mid \le {\dot{q}}_{i,\mathit{max}},\mid {\ddot{q}}_i\left(t\right)\mid \le {\ddot{q}}_{i,\mathit{max}}$$

(36)

where ${\dot{q}}_{i,max},{\ddot{q}}_{i,max}$ are the joint velocity and acceleration limits set by the manufacturer. Through time parameterization, the geometrically continuous joint path is converted into a time trajectory $q\left(t\right)$ satisfying the controller’s dynamic constraints, which can be directly used for manipulator controller interpolation and execution.

To ensure operational safety in unstructured environments, the system incorporates a continuous collision detection module based on signed distance fields. During trajectory generation, the algorithm computes in real time the minimum signed distance $\varphi \left(\cdot \right)$ from the sample point set ${\mathrm{x}}_{k,m}$ on the tool entity to environmental obstacles. Only when the entire trajectory satisfies the following safety margin constraint is it judged as valid [33]:

$$\varphi \left({\mathrm{x}}_{k,m}\right)\ge d_{\mathrm{safe}}$$

(37)

This geometry–physics dual verification mechanism ensures that the final generated trajectory not only meets process requirements but also possesses high robustness and safety in engineering implementation.

Through the systematic processing from trajectory refinement to kinematic mapping described above, we have successfully transformed unstructured measurement point clouds into executable time trajectories $q\left(t\right)$ that satisfy manipulator dynamics constraints. At this point, the trajectory planning architecture for point-cloud-driven polishing of mold surfaces has been constructed at the theoretical level.

5. Robotic Polishing Simulation and Experiments

This section systematically verifies the proposed method from both theoretical and engineering practice perspectives. First, through a high-precision simulation environment, the kinematic feasibility, safety, and process geometric features of planned trajectories are quantitatively assessed. On this basis, a physical polishing platform is established, through which the surface roughness metrics after actual machining verify the effectiveness and consistency of simulation analysis conclusions in physical machining.

The workpiece used in this study is a complex curved injection-mold core made of S136 (AISI 420) stainless steel. The material was heat-treated to a hardness of 48–52 HRC. S136 is widely used for injection-mold tooling due to its good polishability and corrosion resistance. In the heat-treated condition, its microstructure is typically dominated by tempered martensite, which is generally associated with stable mechanical properties and reduced variability in abrasive material removal.

5.1. Simulation-Based Trajectory Executability and Process-Level Quality Evaluation

In the scenario of point-cloud-driven polishing on mold surfaces, the point-cloud-driven polishing path planning method proposed in this paper is systematically verified. The simulation platform employs the Gazebo–MoveIt integrated framework under ROS [34]. The experimental subject is a six-degree-of-freedom industrial manipulator, with its key parameters specified, as shown in

Table 3. Basic attributes of six-DOF industrial manipulator.

Attributes	Values
DOF	6
Rated payload (kg)	5
Arm extension (mm)	952.5
Repeatability (mm)	±0.03
Max TCP speed (m/s)	3
Robot weight (kg)	16.5

. The visual input adopts point clouds acquired by Mech-Eye LOG-S, and after preprocessing, the point cloud serves as both the planning input and collision detection scenario [35]. The planning result generated by the thick-slice serpentine algorithm is shown in Figure 14.

To quantitatively evaluate trajectory executability, this paper adopts the signed distance field (SDF) as the primary performance metric. Specifically, the SDF metric quantifies the minimum Euclidean distance between the tool entity geometry and the nearest environmental obstacle, continuously computed in real-time throughout the trajectory execution.

Figure 15 illustrates the SDF margin variation curves for seven sub-regions generated by the planning algorithm. Statistical results (shown in

Table 4. Trajectory performance and coverage metrics.

Metric	Value
Path Point Evaluation Baseline	9283
IK Success Rate	100% (9283/9283)
Global Minimum Safety Margin	2.09 MM
Idle-Motion Path Ratio	1.98%
Global Coverage Rate	99.42%
Global Over-Polishing Rate	0.50%
Average Coverage Magnitude	9.996
Sub-Region Coverage Range	98.77–100.00%
Maximum Regional Over-Polishing	3.45%

) indicate that, in a trajectory containing 9283 path points in total length, the global minimum SDF margin is 2.09 mm. Only when the entire trajectory satisfies the safety margin constraint (Equation (37)) is it judged as valid. In our simulations, we set $d_{safe}=2.0\mathrm{mm}$. This serves as a conservative threshold, significantly larger than the robot’s repetitive positioning error of ±0.03 mm (Table 3), to accommodate potential calibration uncertainties. This demonstrates that even in regions with complex mold surface features, the planning algorithm effectively avoids collision risks. Simultaneously, the inverse kinematics (IK) success rate reached 100%, and idle-motion paths account for only 1.98% of total path length. The above data strongly suggest that the region partitioning strategy and attributed adjacency graph proposed in this paper effectively generate continuous trajectories, avoiding singularity locking and frequent jumps commonly seen in conventional methods [36].

Second, after completing the trajectory executability assessment, the process quality of the executed trajectory must be evaluated. Polishing quality depends largely on the consistency between the tool axis and the workpiece surface normal. To verify the effectiveness of this paper’s method, a comparison was made with the conventional method of PCA principal direction combined with fixed-step reciprocal motion. Figure 16 shows the normal deviation field heatmaps of trajectories generated by the two methods in the workpiece coordinate system.

As can be seen from the left side of Figure 16, the baseline method exhibits pose mismatch in regions with large curvature variations (bright yellow areas). Its mean normal deviation reaches 14.66°, with a standard deviation of 7.50°. Such a large deviation can easily lead to over-polishing or under-polishing in practical machining. In contrast, the normal deviation shown on the right side of Figure 16 is significantly reduced and more uniformly distributed. The statistical results (

Table 5. Comparative performance metrics: baseline method versus proposed method.

Metric	Baseline Method	Proposed Method
IK Success Rate	92%	100%
Min. Safety Margin	1.33 mm	2.09 mm
Mean Deviation	14.66	3.45
Median Deviation	14.96	1.68
95th Percentile	25.04	13.01
Std. Deviation	7.50	4.76
Coverage Rate	100.00%	99.42%
Avg. Coverage	7.75	9.996

Notes: Metrics are computed over N = 9283 discrete trajectory samples along the planned toolpaths in simulation.

) indicate that the mean normal deviation of our method decreases to 3.45°, and the median is only 1.68°. This improvement is mainly attributed to the high-dimensional perception capability of the deep feature fusion network proposed in Section 4.1 for complex topology, which enables the manipulator end-effector pose to closely conform to geometric variations in the curved surface. The high geometric consistency achieved in simulation provides a theoretical foundation for high-quality surface finishing in subsequent physical experiments.

Table 5 provides an explicit comparison against the conventional PCA-based planning baseline. Compared to the baseline, the proposed framework improves IK executability and increases the minimum SDF safety margin, indicating better kinematic feasibility and safer motion in the tested scenario (Table 5). Moreover, the proposed method substantially reduces TCP normal deviation (mean 14.66° → 3.45°, i.e., an ≈76% reduction), which is particularly important on high-curvature regions where pose mismatch may cause non-uniform material removal (Table 5). These results show that the contribution of our approach goes beyond achieving a low roughness value by providing a kinematically feasible and pose-consistent trajectory generation pipeline under CAD-free point-cloud inputs.

5.2. Mold Surface Polishing Experimental Verification

Building on the theoretical results from simulation-based verification, this section further validates the engineering effectiveness of the planned trajectories through experiments. The experiments were conducted on a polishing platform, as shown in Figure 17, where the manipulator and vision sensor configuration is consistent with the simulation environment. Surface roughness (Ra) was measured using a portable stylus profilometer (Mitutoyo Surftest SJ-210, Mitutoyo Corporation, Kawasaki, Japan). The instrument provides a display resolution of 0.002 µm, and measurements were conducted following the manufacturer’s specified accuracy and repeatability.

We selected one typical test point (P1–P7, see Figure 18) in each of the seven different regions of the workpiece, and measured surface roughness before and after polishing at each point three times. As shown in

Table 6. Ra changes before and after polishing at experimental points P1–P7.

Point	Before (Mean ± Std) (µm)	After (Mean ± Std) (µm)	ΔRa (µm)
P1	8.091 ± 0.529	0.669 ± 0.061	7.422
P2	8.078 ± 0.365	0.611 ± 0.086	7.467
P3	7.414 ± 0.528	0.626 ± 0.116	6.788
P4	7.575 ± 0.689	0.595 ± 0.125	6.980
P5	7.647 ± 0.653	0.529 ± 0.103	7.118
P6	7.783 ± 0.361	0.647 ± 0.135	7.137
P7	7.674 ± 0.481	0.561 ± 0.115	7.113

, the experimental data demonstrate that after polishing with the trajectory planned by our method, the average Ra value of the workpiece surface decreased from the initial 7.767 ± 0.493 µm to 0.607 ± 0.108 µm. The roughness at all seven test points was reduced to the sub-micrometer level, and the surface displayed uniform metallic luster.

The improvement trend in Ra values in the physical experiments is highly consistent with the normal deviation distribution in the simulation of Section 5.1. Regions where the normal deviation is smallest and pose alignment is best in simulation generally achieved better surface finish in the physical experiments. Notably, the standard deviation of Ra values decreased significantly, validating the effectiveness of our method in solving the problem of poor processing consistency in complex regions.

We note that a significant roughness reduction can also be observed in conventional polishing processes. Therefore, in addition to reporting the absolute Ra improvement, we emphasize the consistency of the achieved finish across different surface zones. As shown in Table 6, the post-polishing Ra values across the seven representative regions (P1–P7) fall within a narrow range of 0.529–0.669 µm, with an overall average of 0.607 ± 0.108 µm (Table 6). This zone-to-zone consistency supports the practical value of the proposed method for standardized finishing on complex mold surfaces. While manual polishing relies heavily on operator skill and is susceptible to fatigue-induced inconsistencies, especially on large-scale molds with limited reachability, the proposed robotic framework ensures deterministic quality (low standard deviation) and precise kinematic control (low normal deviation) suitable for industrial mass production. Furthermore, the proposed D-C-M strategy enables rapid foreground-extraction preprocessing (1.14 s for 237,640 points; Table 1), substantially reducing the preprocessing overhead prior to downstream partitioning and toolpath generation.

The experimental results demonstrate that, even in unstructured environments lacking CAD models and subject to perception noise, our method still achieves substantial improvements in finishing quality and consistency. This supports the fundamental advantages of the task-aware regional segmentation and deep geometric feature fusion strategy in addressing the challenging problem of point-cloud-driven polishing of complex surfaces.

6. Conclusions and Future Work

This study addresses the three key limitations identified in the Introduction for point-cloud-driven robotic polishing of complex mold surfaces: (i) the efficiency bottleneck in processing large-scale raw point clouds, (ii) task-agnostic region organization that ignores kinematic feasibility during planning, and (iii) the lack of closed-loop feasibility verification beyond purely geometric trajectories. To this end, we propose a systematic framework that bridges raw measurement data and executable robot trajectories by integrating point-cloud preprocessing, task-aware region partitioning with kinematic constraints, and data-driven trajectory generation.

Comprehensive validation via simulation and physical experiments demonstrates that the proposed framework improves efficiency, executability, and process quality. For efficiency, the D-C-M strategy achieves a 7.5× preprocessing speedup with a 98.5% mapping-back success rate, reducing the preprocessing overhead prior to downstream planning. For task organization and kinematic feasibility, incorporating reachability constraints enables 100% inverse-kinematics solvability and maintains a larger minimum safety margin compared with a PCA-based baseline. In terms of trajectory quality, the mean TCP normal deviation is reduced from 14.66° to 3.45°, mitigating orientation mismatch on complex curvature regions. Physical polishing results further confirm stable sub-micron finishing quality with low zone-to-zone variation across P1–P7.

Notwithstanding the favorable experimental outcomes achieved in mold surface polishing, the proposed method presents certain limitations. Despite employing boundary-shrinking and buffer zone strategies to manage complex edges, an over-polishing rate of approximately 3.45% is still observed in overlapping regions. Additionally, the current deep learning prediction model exhibits a dependency on specific mold geometric features.

Consequently, future research will be concentrated on two primary avenues: First, the integration of a force-feedback-driven adaptive dwell time control algorithm is planned to further improve material removal consistency at boundary regions. Second, we aim to construct a comprehensive industrial point cloud dataset encompassing diverse topological structures and material properties. By leveraging transfer learning, we seek to enhance the model’s generalization adaptability to unseen workpieces with irregular geometries, thereby facilitating the deployment of this technology in a broader spectrum of smart manufacturing applications. Furthermore, inspired by the complex interaction between surface texture and fluid dynamics, future work will also explore the integration of Moldflow analysis data into the trajectory planning stage. Specifically, aligning the robotic polishing direction with the plastic material flow direction could significantly reduce flow resistance and enhance the demolding performance of the injection molds. Establishing a data interface between the planning algorithm and Moldflow software will be a key focus of our next research phase.