A K-Means Clustering Approach for Accelerated Path Planning in GMA-DED: The Fast Advanced-Pixel Strategy

Abstract

The performance of Gas Metal Arc-Directed Energy Deposition (GMA-DED) strongly depends on efficient path-planning strategies that balance trajectory quality and computational cost. With the purpose of developing a computationally faster and more scalable path-planning approach, this study introduces the Fast Advanced-Pixel strategy by integrating the K-means clustering algorithm into to the Advanced Pixel strategy version to reduce the dimensionality of an optimization problem. Computational validation was conducted on four geometrically distinct parts using different clustering configurations. Statistical analysis (ANOVA) was applied to assess the significance of the results. The findings revealed that by increasing the number of clusters, computational time is substantially reduced, achieving up to a twenty-fold improvement compared with the former strategy, while maintaining consistent trajectory quality. Experimental validation using complex parts, such as a “Jaw Gripper” and a “C-frame” of a resistance spot welding gun, confirmed defect-free deposition and dimensional agreement with the CAD models. Accordingly, within the scope of GMA-DED technology and pixel-based path-planning strategies, the Fast Advanced-Pixel approach demonstrates a significant improvement in computational efficiency while preserving trajectory quality, enabling the accurate and reliable fabrication of geometrically complex metallic parts.

1. Introduction

Gas Metal Arc-Directed Energy Deposition (GMA-DED) has become a key metal additive technology, recognized for its efficiency in producing large metal components at high deposition rates. However, the overall success of GMA-DED depends not only on deposition control but also on generating optimized trajectories that ensure efficient and accurate material deposition. Path planning is a fundamental step in the GMA-DED workflow, as it determines the deposition tool’s motion path, which directly affects local heat input, interlayer bond quality, and final surface finish. Recent research highlights that poor tool-path planning can lead to excessive heat buildup, geometric deviations, and geometrical imperfections in printed parts [1,2]. Consequently, advanced trajectory generation is essential for ensuring processing stability and achieving the required deposition quality.

An effective path planning strategy must simultaneously ensure complete coverage of the part’s geometry, minimize non-productive movements, and maintain a uniform thermal profile across successive layers [3]. Conventional patterns such as zigzag, contour-parallel, or simple hybrid fills often struggle to satisfy these objectives in parallel [4]. Nevertheless, as geometries become more complex, the difficulty of trajectory generation increases, resulting in a sharp rise in computational cost [2]. In a recent review, Zhao et al. [5] highlighted that the computational burden of path planning algorithms scales with part size and feature density, suggesting the need for hybrid heuristic and AI-based strategies to maintain optimization feasibility. In this context, Li et al. [6] introduced a decomposition-based scheduling algorithm that divides complex layers into smaller subregions for parallel processing, substantially reducing the overall computational burden of path allocation and sequencing. Qvale et al. [7] proposed integrating analytical bead-shape equations into the path generator to reduce the need for dense mesh evaluation. By using a parametric bead model, the authors achieved automatic trajectory generation while cutting down geometry processing and computation time.

Recent studies increasingly employ machine learning (ML) in GMA-DED path planning to improve quality. Kunchala et al. [8] proposed an ML-driven adaptive bead modeling framework for GMA-DED with IoT-enabled monitoring; a hybrid Teaching-Learning-Based Optimization (h-TLBO) scheme combined with Support Vector Machine (SVM) models tunes deposition parameters and adaptively adjusts welding conditions from image-derived bead profiles, achieving less than 4% deviation between experiments and simulations. Leveraging reinforcement learning (RL) for trajectory design, Petrik and Bambach [9] demonstrated an adaptive path optimization for thin-walled GMA-DED components. In further work, Petrik and Bambach [10] presented RLTube to enhance deposition paths for bent tubes, which couples RL with Sequential Least Squares Programming to automate path planning and better accommodate geometric variation. Complementing these advances, Ferreira et al. [11] more recently introduced the Advanced-Pixel trajectory strategy for GMA-DED, formulating path selection as a Multi-Armed Bandit (MAB) problem to reduce computational cost while maintaining or improving trajectory quality relative to the Enhanced-Pixel baseline. Computational and experimental results demonstrated faster processing and efficient printing, with the benefits being particularly pronounced for larger and more complex geometries.

While ML has been applied to enhance part quality, particularly in path planning, further strategies are needed to reduce computational and processing time. Ferreira et al. [11] pointed out that applying clustering might help generate more complex trajectories, reduce the optimization horizon, and improve computational efficiency. Additionally, the researchers planned to explore the use of clustering techniques to further enhance the performance of the Advanced-Pixel strategy. Regarding the application of clustering in the field of DED, Pazireh et al. [12] discussed that this approach has been used to improve various tasks, such as analyzing mechanical properties influenced by toolpath patterns, geometry, and layering effects; real-time control guided by precise extraction and clustering of molten pool geometric features; and defect prediction using melt images, among others. However, applying clustering to path planning in GMA-DED remains unexplored, indicating significant potential for integration into a pixel-based strategy, which breaks down a 3D model’s layers into a grid of connected points, similar to pixels on a screen. Then it uses optimization algorithms to find a smooth and efficient tool path that visits all these “pixel” nodes, ensuring the entire layer is filled. Therefore, processing time is a drawback of this Pixel approach when complex shapes are planned. However, beyond assessing its potential to reduce computational time, it is also crucial to evaluate whether this method can ensure the quality of the generated trajectory and, consequently, the quality of the deposited part. Comprehensive comparisons between the Pixel family of path-planning strategies and traditional approaches such as raster, contour-parallel, and graph-based planners have been reported in previous publications [1]. These studies established the geometric fidelity and printing quality of pixel-based strategies relative to conventional methods.

Therefore, the main objective of this work is to propose and validate a computationally efficient and scalable path-planning strategy for GMA-DED that integrates K-means clustering into the Pixel framework. By leveraging clustering to reduce problem dimensionality, the Fast Advanced-Pixel strategy aims to minimize computational resources while preserving trajectory accuracy and ensuring defect-free deposition. This study thus contributes to bridging data-driven optimization techniques with practical applications of GMA-DED.

2. The K-Means Clustering Technique

Clustering is a widely used machine learning technique that groups data based on similarities in their features. It has been successfully applied to reduce the dimensionality of optimization problems, thereby improving both quality and computational efficiency, as noted by Allaoui et al. [13]. A well-known example is the Traveling Salesman Problem (TSP), for which the computational complexity grows exponentially with the number of cities. The number of possible solutions is given by (n − 1)!/2 [14]. To overcome this challenge, the Divide-and-Conquer paradigm has been explored; large TSP instances are partitioned into smaller subproblems through clustering, which drastically reduces computational time and can improve solution accuracy [15].

The application of clustering to address TSP variants has been extensively studied. GTSP has been applied in the manufacturing context. In the Generalized Traveling Salesman Problem (GTSP), the objective is to determine the minimum-cost tour that visits exactly one city from each cluster, without requiring visits to the remaining cities within the same cluster or to clusters consecutively [16]. Hajad et al. [17], for instance, proposed an optimization approach for laser cutting operations that minimized heat accumulation. Their method combined a genetic algorithm with clustering, in which clusters represented parts of contours; only one node from each contour had to be visited to complete the task. Another variant, the Clustered Travelling Salesman Problem (CTSP), involves grouping cities into clusters, where the salesman must visit all cities within each cluster consecutively before moving to the next cluster. A manufacturing-related example is tool sequencing in drilling operations, as described by Laporte and Palekar [18]. In this case, holes requiring the same tool are grouped into clusters, and the optimization focuses on efficiently sequencing tool usage. The central idea underlying these approaches is that clustering transforms large-scale problems into smaller, more manageable ones, providing intrinsic computational advantages. Avşar and Aliabadi [19] demonstrated this principle using a parallel Divide-and-Conquer method for the TSP, in which cities were partitioned into smaller regions (“municipalities”). Optimal solutions were first computed within each region, then combined using a blend operator. Their method outperformed classical benchmarks from the TSPLIB (a standardized library of benchmark TSP instances) in both solution quality and computational time.

Among clustering techniques, K-means has demonstrated remarkable effectiveness in reducing the dimensionality of large datasets while preserving their essential structural properties [16]. Moreover, its computational efficiency enables processing large-scale data with minimal memory usage, making it especially useful for high-dimensional applications [16]. In TSP-related applications, K-means groups cities based on spatial proximity, simplifying the search for near-optimal tours. More broadly, the method is well-suited for identifying patterns and structuring data into meaningful subsets. The historical development of K-means is somewhat fragmented. According to Jain [20], the technique originated independently across several fields. It was first introduced in 1956 by Hugo Steinhaus, later applied by Stuart Lloyd in 1957 for PCM signal quantization (though published only in 1982), and subsequently rediscovered by Ball and Hall (1965) and by MacQueen (1967) in the context of clustering. Today, K-means is one of the most widely used unsupervised clustering algorithms, with applications spanning data mining, computer vision, natural language processing, market segmentation, fraud detection, image analysis, document clustering, and genetic clustering, as well as engineering [21]. In general, it can be applied to any dataset where the objective is to partition data into clusters based on similarity or distance measures.

When applied as an algorithm, K-means is an iterative clustering method that partitions a dataset into K distinct, non-overlapping groups (clusters). Each data point is assigned to exactly one cluster based on its proximity to the cluster centroid, defined as the arithmetic mean of all points within that cluster. Let the dataset consist of N points, Xi = {x1, x2, x3, …, xN}, and K as a predefined number of clusters Cj = {C1, C2, C3, …, CK}. The corresponding centroids are represented by cj = {c1, c2, c3, …, cK}, where cj denotes the centroid of cluster Cj. The goal of K-means is to minimize the sum of squared Euclidean distances between each data point (Xi) and the centroid of its assigned cluster (cj), while maximizing inter-cluster separation. The convergence criterion (CC) is expressed in Equation (1):

$$CC=min{\sum }_{j=1}^K{\sum }_{i=1}^N{F_{i,j}‖x_i-c_j‖}^2$$

(1)

This function is subject to Equation (2).

$$F_{i,j}=\left\{\begin{array}{l}1 if data point i belongs to cluster j\\ 0 otherwise\end{array} \right.$$

(2)

The algorithm proceeds iteratively through the following steps:

• Define the number of clusters K;
• Randomly initialize K cluster centroids;
• Assign each data point to the nearest centroid;
• Recompute centroids as the mean of all points assigned to each cluster;
• Repeat steps 3 and 4 until convergence, i.e., until cluster assignments and centroids stabilize or the variation falls below a threshold.

Figure 1 provides a visual representation of the step-by-step process of the K-means clustering algorithm, offering a clearer understanding of its functioning.

Although the K-means algorithm requires the user to specify the number of clusters K, several approaches have been developed to optimize this selection. Among the most widely adopted are the Elbow method and the Silhouette method. According to Shi et al. [22], the Elbow method consists of plotting the within-cluster sum of squared errors (SSE) for different values of K and identifying the point at which the rate of SSE reduction begins to level off, forming an “elbow” in the curve. Conversely, the Silhouette method, as described by Muca et al. [23], evaluates clustering quality by computing the average silhouette width across different values of K. The optimal number of clusters is the one that maximizes this metric, which reflects how well each data point fits within its assigned cluster compared to neighboring clusters. Beyond these two classical techniques, other approaches have been proposed, such as the Gap Statistic method, introduced by Tibshirani et al. [24], which compares the clustering performance on the given dataset against a reference null distribution to determine the most appropriate value of K.

In addition to the challenge of determining the optimal number of clusters, Xie et al. [25] highlighted several limitations of the K-means algorithm. These include its underlying assumption that clusters are spherical, equally sized, and uniformly dense, as well as its limited suitability for non-linear or non-convex structures (e.g., spiral-shaped data). Moreover, K-means is sensitive to outliers and highly dependent on initialization conditions. To address these shortcomings, numerous studies have been proposed. In particular, sensitivity to initialization has been extensively investigated. Fränti and Sieranoja [26], for example, suggested improving the initialization stage and running K-means multiple times with different initial solutions. Nevertheless, the authors emphasized that despite the variety of initialization strategies available in the literature, no consensus exists regarding a universally superior approach. In practice, initializing cluster centers with random data points (as in the original algorithm) remains a straightforward yet widely used approach. Overall, it is essential to recognize these limitations and use the K-means algorithm with caution, ensuring that its assumptions align with the dataset’s characteristics.

In Step 3 of the K-means clustering process, it is essential to account for both the dataset’s characteristics and the research objectives. As noted by Wu et al. [27], the choice of distance metric directly influences clustering outcomes, particularly when dealing with non-linear or non-convex data distributions. Selecting an appropriate metric is therefore critical for accurately capturing cluster properties. A wide range of distance measures has been proposed in the literature, including Euclidean, Manhattan, Chebyshev, cosine, and correlation-based distances. Among these, Euclidean and Manhattan distances remain the most widely applied in practice. Nonetheless, it is generally advisable to experiment with multiple metrics and compare the resulting partitions in order to make a well-informed selection.

Building on the aspects discussed above, Zhao et al. [28] characterized the K-means algorithm as computationally efficient, scalable, intuitive to understand and implement, applicable to diverse data types, and adaptable to different contexts. Owing to these advantages, K-means remains one of the most widely adopted clustering techniques in machine learning and data science and was therefore considered in this study. Nonetheless, numerous alternative clustering approaches exist. Subasi [29], for example, highlighted methods such as hierarchical clustering, density-based clustering, Bayesian clustering, and fuzzy C-means, which can serve as alternatives or complements to K-means. The choice of clustering algorithm should ultimately be guided by the characteristics of the dataset and the research objectives, as each method entails specific advantages and limitations.

3. The Fast Advanced-Pixel: An Advanced-Pixel Path Planning Algorithm Using K-Means Clustering

The Pixel strategy algorithms rely primarily on the distance between nodes as the main user input, ensuring that the layer surface is fully discretized, as illustrated in Figure 2a. In the Fast Advanced-Pixel proposal, the number of clusters (K) is also required from the user, consistent with the K-means algorithm. Based on this parameter, the algorithm partitions the nodes into clusters and displays the resulting division to the user. Figure 2b shows an example of two clusters (K = 2) in a layer. This clustering configuration is applied across all layers, regardless of whether their geometries are identical, as depicted in Figure 2c, or not. Additionally, users retain the flexibility to adjust the number of clusters on a layer-by-layer basis whenever the default result does not meet specific requirements. The K-means algorithm employed in this work relies on Euclidean distance computed in the layer plane. This choice reflects the fact that clustering is performed in a purely geometric space prior to trajectory optimization and robot execution.

Depending on the part topology, the K-means algorithm may fail to generate clusters whose nodes form a single continuous region, as shown in Figure 3 (highlighted by larger blue dots), due to islands (Figure 3a), entrances (Figure 3b), or holes (Figure 3c) in the layer geometry. It is important to note that an island is a discrete region of material within a given layer that is not directly connected to other regions in the same slice layer; therefore, the deposition process must be initiated and terminated independently for each such region. This node separation within the same cluster will be generated by non-deposition movements that interconnect them across different areas. A viable solution (though still manual) is to select another K value (an action taken by the user) to generate clusters with non-separated nodes. To illustrate this, Figure 4a,b, in turn, show non-separated nodes achieved using K = 2 and K = 4, respectively, for the problem demonstrated in Figure 3c with K = 3. It is worth noting that additional methods could be developed to avoid non-separable nodes in the same cluster in more complex geometries; such approaches lie beyond the scope of this work.

Figure 5 illustrates the potential to adjust the K value between layers. This possibility of generating different trajectories for each layer presents a promising strategy for mitigating imperfection issues, such as a lack of fusion, as highlighted by Wang et al. [30]. While acknowledging this possibility, it is important to note that this work does not explore this approach through experimental testing.

Once the clusters are defined, trajectories can be generated within each cluster independently, either sequentially or in parallel (not explored in this work), using the Advanced-Pixel strategy, described by Ferreira et al. [11]. To clarify, the term “Fast Advanced-Pixel” refers to an accelerated version of the Advanced-Pixel method that incorporates a clustering technique. Although the core principles of the Advanced-Pixel approach are retained, the inclusion of the clustering technique enables significant computational speed enhancements (as will be demonstrated in the upcoming sections). Although classical clustering validation techniques such as the Elbow, Silhouette, and Gap Statistic methods are widely used to identify an optimal number of clusters based on data compactness and separation, they are not directly applicable to the present context. In the Fast Advanced-Pixel strategy, the number of clusters K is not intended to represent intrinsic data groupings but rather to control the dimensionality of a path-planning optimization problem derived from the Traveling Salesman Problem. Therefore, the primary criterion for selecting K is computational efficiency while preserving trajectory continuity and print feasibility, rather than statistical clustering optimality.

After generating the trajectory for each cluster, interconnections between clusters are established to avoid arc start/stop events at each cluster boundary. This task is performed by the user. To illustrate this process, Figure 6a schematizes two clusters (represented in red and green) generated for a square-shaped layer. Figure 6b then shows a hypothetical trajectory planned for these two clusters. In the next step, the trajectories of each cluster are joined through a user-defined command, illustrated in Figure 6c by a blue “x” and an arrow. This command consists of selecting a reference point in the space between two consecutive clusters. Based on this reference point, the Fast Advanced-Pixel algorithm identifies the closest pair of nodes—one from each cluster. For example, Figure 6d shows that nodes 1 and 2 (belonging to the green cluster and closest to the reference point) are linked to nodes 3 and 4 (from the red cluster). The selection of reference points continues until all clusters are interconnected, thereby completing the trajectory-linking process. Finally, Figure 6e presents the complete trajectory, where node 1 is connected to node 3 and node 2 is connected to node 4. Although the manual selection of reference points may introduce minor human errors, the procedure is straightforward. Moreover, this step need not be repeated for each layer unless layers exhibit different topologies. It is important to note that the user-selected reference points do not redefine the internal trajectory optimization but only determine how independently optimized cluster trajectories are connected.

In summary, Figure 7 illustrates the 3D printing workflow, starting from the 3D model. The model is then sliced and prepared for trajectory planning through the Fast Advanced-Pixel strategy. In this strategy, the user inputs the distance between nodes (as shown in the step “Nodes on the layer surface”) and the number of clusters, K (as shown in the step “Clustering the nodes”). Clusters are generated for each layer (shown in the step “Generate a trajectory for each cluster”). The trajectories are then joined using reference points selected by the users. This process is repeated until all clusters are connected, as shown in Figure 6, resulting in the final trajectory (shown in the step “Trajectory linking”). Finally, the machine code is generated, and the part is printed. For readers who wish to understand the approach from an algorithmic perspective, the pseudocode is presented in Algorithm 1. In the current implementation, clustering and trajectory generation using the Fast Advanced-Pixel strategy are performed offline during the preprocessing stage.

It should be emphasized that the Fast Advanced-Pixel strategy is a semi-automatic path-planning approach, as it includes limited user interactions during cluster validation and trajectory linking. This manual intervention is limited to two specific steps: (i) adjusting the number of clusters K, when non-continuous clusters are detected and (ii) selecting reference points for inter-cluster trajectory linking. For each layer, this typically requires a small number of user actions (one cluster adjustment and K − 1 reference point selections). Importantly, these actions do not alter the algorithm’s internal optimization logic but only guide cluster validity and trajectory continuity. Another relevant aspect is that excessively small clusters could, in principle, result in short deposition segments, which are undesirable in GMA-based additive manufacturing technologies. In the proposed Fast Advanced-Pixel strategy, such situations are avoided through controlled selection of the number of clusters K and through validation of cluster continuity and practical feasibility. Clusters that result in impractically small regions are not intended for deposition and can be mitigated by reducing K for the affected layer.

Algorithm 1 Fast Advanced-Pixel Strategy

1: INPUT: 3D modelo M 2: INPUT: Space between layers h 3: INPUT: Node spacing d 4: INPUT: Number of clusters K 5: OUTPUT: Global deposition trajectory T 6: function Fast Advanced-Pixel(M, h, d, K) 7:            Slice M into layers {L1, L2, …, LN} 8:            T ← ∅ 9:            for each layer Li do 10:                   Ni ← GenerateNodes(Li, d) 11:                   repeat 12:                          {C1, C2, …, CK} ← KMeans(Ni, K) 13:                          valid ← not ExistsNonContinuousCluster({CK}) 14:                          if not valid then 15:                                   K ← UserAdjustK() 16:                          end if 17:                   until valid 18:                   for each cluster CK do 19:                          Tk ← AdvancedPixel(CK) 20:                   end for 21:                   Tlayer ← T1 22:                   for k = 2 to K do 23:                          pk ← UserSelectReferencePoint() 24:                   (ni, nj) ← FindClosestNodes(pk, Tlayer, Tk) 25:                   Tlayer ← LinkTrajectories(Tlayer, Tk, ni, nj) 26:                   end for 27:                   T ← T ∪ Tlayer 28:            end for 29:            return T

4. Computational Validation

This section evaluates whether the code for the Fast Advanced-Pixel strategy provides computational advantages over that of the former Advanced-Pixel strategy, in line with the objective of this work. To ensure a fair comparison, identical simulation parameters are used for both strategies across all experiments. The focus of a computational validation is not on assessing the overall efficacy of the path planning algorithm, which is the purpose of the following section, but rather on comparing its computational performance. Specifically, the analysis concentrates on computational time and the quality of the generated trajectories, using a quantitative approach.

4.1. Methodology for Evaluating the Computational Performance

To achieve the objective stated in the previous section, four different parts and their respective numbers of nodes (using a node space of 4.0 mm) presented in Figure 8 were studied, using the Fast Advanced-Pixel strategy with different numbers of clusters (K), as follows:

• Fast Advanced-Pixel strategy with a value of K = 1, which implies no clustering of nodes and therefore corresponds to the original Advanced-Pixel strategy. In this case, the Thompson Sampling policy was employed (see Ferreira et al. [11]), selected for its simplicity and the absence of required parameter tuning;
• Fast Advanced-Pixel strategy with a value of K = 2;
• Fast Advanced-Pixel strategy with a value of K = 4;
• Fast Advanced-Pixel strategy with a value of K = 8.

The values of K = 1, 2, 4, and 8 were selected heuristically to represent progressively increasing levels of problem decomposition. This user choice allows an evaluation of how clustering granularity affects computational time and trajectory quality. Rather than identifying a single optimal K, the objective is to demonstrate the scalability and robustness of the Fast Advanced-Pixel strategy across multiple clustering configurations relevant to practical GMA-DED applications. These strategies were selected to investigate the computational advantage of the Fast Advanced-Pixel strategies over the Advanced-Pixel strategy, with a particular focus on the effect of varying K on computational time and response quality (trajectory distance). The experiments were conducted using a quantitative analysis approach.

The K-means clustering algorithm employed a standard convergence criterion (Equation (1)) based on centroid displacement below a threshold of 0.0001, which was kept constant across all case studies. Cluster centroids were initialized using randomly selected data points, and no additional heuristic or adaptive initialization strategy was applied. For each cluster K, 100 iterations were performed on all parts studied. For clusters with a value greater than 1, the user performed the linking operation for the trajectories (the time required for this manual operation was not included in the calculations). For each layer, this typically requires a small number of user actions (one cluster adjustment and K − 1 reference point selections). Importantly, these actions do not alter the algorithm’s internal optimization logic but only guide cluster validity and trajectory continuity. Due to the stochastic nature of the algorithm and the potential variation in results (between different K values), 5 independent runs were conducted for each experiment, and the distribution of the data was taken into consideration in the evaluation and discussion of the results.

The experiments were conducted on a computer equipped with an Intel Core i7-12700H processor with 14 cores and 20 threads, operating at 2.30 GHz and 16 GB of RAM (with an NVIDIA Titan V graphics card with 5120 CUDA cores and 12 GB of RAM). The criteria evaluated in this article were the computational time (CPU time) for trajectory generation (response efficiency) and trajectory distance (response quality). To compare the outcomes across different clusters assigned to the same part and draw conclusive findings regarding their significance, an analysis of variance (ANOVA) was conducted at a confidence level of 0.95.

4.2. Results and Discussions

Table 1. Computational time, in seconds, and trajectory distance, in mm, for each part studied with different K clusters.

Criteria	K Values	Parts
		Binzel Logo	Tie-Shaped	Jaw Gripper	RSW Gun C-Frame
Computational time (s)	1	210.31 ± 5.54	221.75 ± 8.67	862.96 ± 30.00	3558.19 ± 708.8
	2	22.68 ± 3.24	130.09 ± 9.34	303.90 ± 13.96	967.78 ± 29.62
	4	9.64 ± 2.12	43.60 ± 3.74	80.10 ± 5.69	314.22 ± 12.64
	8	4.62 ± 1.10	11.02 ± 1.47	36.60 ± 4.28	-
	p-value	3.05649 × 10−20	2.08663 × 10−18	5.5475902 × 10−21	4.12339 × 10−6
Trajectory distance (mm)	1	2496.76 ± 10.24	2668.67 ± 12.20	2924.64 ± 8.33	6747.82 ± 68.59
	2	2472.12 ± 6.42	2642.24 ± 7.51	2921.82 ± 18.32	6610.94 ± 15.23
	4	2470.36 ± 3.16	2632.04 ± 4.11	2904.41 ± 10.44	6582.47 ± 23.85
	8	2447.42 ± 3.14	2638.57 ± 5.36	2878.30 ± 9.88	-
	p-value	2.30598 × 10−5	2.60807 × 10−5	8.25229 × 10−5	2.04609 × 10−5

presents the trajectory distance and computational time for each value of K across all studied parts. To support data interpretation, Figure 9a shows the computational time for each clustering value, while Figure 9b shows the relative computational time gain with respect to K = 1. The gain rate is calculated by dividing the computational time for K = 1 by the corresponding time for other K values. As observed in Figure 9a, the computational time decreases exponentially with increasing K. This trend arises because each clustering value corresponds to a different number of nodes, as reported in

Table 2. Number of nodes for the number of clusters in each part studied.

Part	Clusters (K)
	1	2		4				8
	1	1	2	1	2	3	4	1	2	3	4	5	6	7	8
1	757	381	376	170	171	206	210	106	70	102	109	106	82	97	85
2	896	458	438	221	221	233	221	107	81	129	108	90	132	118	131
3	1173	751	1173	306	290	312	265	108	93	242	173	121	99	192	145
4	2146	1108	1038	601	640	460	445

. The Traveling Salesman Problem (TSP) is an NP-hard problem whose theoretical computational complexity grows exponentially with the number of nodes when exact solutions are sought. However, in practical applications such as the present work, heuristic and metaheuristic solvers are employed. For these solvers, empirical computational time is strongly influenced by the number of nodes and often exhibits approximately linear or polynomial scaling. Consequently, reducing the number of nodes through clustering leads to a substantial reduction in practical computational time. It should be noted that K = 8 was not applied to the RSW gun C-frame due to the issue illustrated in Figure 3c. Consequently, trajectory distance and computational time are not reported for this case study. From Figure 9b, it can be seen that more clusters, and thus smaller clusters, produce greater computational time gains. Larger clusters require longer processing, while smaller clusters reduce this burden, amplifying the differences in computational times. However, extremely high K values may require further subdivision to sustain this behavior. In general, according to Table 1, standard deviation decreases as the number of clusters increases, since smaller node sets converge more consistently to local or even global optima. ANOVA confirmed that all p-values were below 0.05, indicating statistically significant differences among the averages. Importantly, this analysis does not aim to identify the best clustering configuration but rather to highlight that increasing k consistently reduces computational time, achieving computational speedups of up to 20-fold with eight clusters.

Figure 10a presents the trajectory distance for all parts across different clustering values, while Figure 10b illustrates the trajectory distance gain rate relative to K = 1 (calculated analogously to the computational time gain rate). At first glance, Figure 10a suggests that trajectory distance remains nearly constant across all cases. However, the p-values reported in Table 1 indicate statistically significant differences. It is important to note that this improvement is due to clustering, in which fewer nodes make it easier to find the local or even global optimum in terms of trajectory distance. Consequently, the manual steps influence only the topological connectivity of the global trajectory and do not compromise its quality with respect to path length, continuity, or printability. In Figure 10b, a notably higher gain rate is observed for the RSW gun C-frame, the part with the most significant number of nodes, whereas the behavior of the other parts does not follow a clear or consistent trend. It is worth noting that the proposed Fast Advanced-Pixel strategy does not alter the theoretical complexity class of the underlying path-planning problem, which remains NP-hard due to its formulation as a Traveling Salesman Problem solved using heuristics. As a result, while the formal asymptotic complexity remains unchanged, the practical runtime is significantly reduced through improved constant factors and reduced search spaces.

Although the ANOVA results indicate statistically significant differences in trajectory length across different values of K (p < 0.05), the practical relevance of these differences must be assessed from a GMA-DED technology perspective. As shown in Table 1 and Figure 10, the variations in trajectory distance are limited to a small percentage relative to the baseline case (K = 1). From a technological standpoint, such small differences in trajectory length are unlikely to produce measurable effects on deposition quality, thermal history, or process stability in GMA-DED.

In contrast, the reduction in computational time achieved by increasing K is substantial, reaching up to 20-fold speedups. Therefore, while the statistical analysis confirms measurable differences in trajectory length, these differences are considered technologically negligible, whereas the computational gains are highly relevant for industrial-scale path planning. This distinction highlights that statistical significance does not necessarily imply technological relevance in the context of additive manufacturing.

It is important to note that the number of nodes is not the only factor to consider. The different shapes (topologies) of the parts can also influence the results. However, it is important to emphasize that the objective of this study is to showcase the performance gain of the Fast Advanced-Pixel strategy over the Advanced-Pixel strategy in manufacturing different parts, rather than to demonstrate the influence of the number of nodes on the results at different values of K.

5. Experimental Validation

5.1. Methodology and Methods for Evaluating the Quality of the Printed Parts

The parts illustrated in Figure 8c,d were fabricated using the Fast Advanced-Pixel strategy by GMA-DED. The dimensions of the parts are detailed in Figure 11. These components were selected as functional demonstrators with previously optimized topologies. Both parts exhibit significant geometric complexity, including multiple intersections, varied hole geometries, and regions of non-uniform thickness, features clearly visible in Figure 11a,b, which display slender sections with distinct thickness transitions. Such characteristics are widely recognized as challenging for additive manufacturing, as highlighted in the review by Jafari et al. [4]. The Jaw Gripper and the C-frame of the resistance spot welding (RSW) gun exemplify components that can be produced by GMA-DED without requiring external surface machining, making the process more competitive than conventional manufacturing methods. Only a few internal surfaces require post-processing, such as localized hole trimming to accommodate fastening elements.

Trajectory generation for printing was performed by Fast Advanced-Pixel using the Thompson Sampling policy. A node spacing of 4.0 mm was selected based on values from previous exploratory beads-on-plate depositions. K = 8 for the Jaw Gripper and K = 4 for the C-Frame were selected based on satisfactory results in terms of computational time and response quality (see previous section). Six layers (pixel-planned distributed) were printed per part, with interlayer temperatures equal to or less than 80 °C. Bead overlap ratio of 0.738, as used by Ding et al. [30] under similar conditions. A total of 50 iterations were performed to generate the toolpaths for both parts. The two best trajectories obtained from these iterations were selected to fabricate the odd and even layers, respectively. The software automatically determined the start point and printing direction before generating the robot code for each layer. The printing times were measured using an internal command within the generated robot code for printing the parts.

The parts were fabricated using GMA-DED following the workflow outlined in Figure 12. The 3D models were uploaded, sliced, and processed with the Fast Advanced-Pixel strategy to generate deposition trajectories before creating the robotic code. Once the code was generated, it was transferred to the robot controller to initiate printing. Deposition parameters, including wire feed speed and travel speed, were defined through the software’s graphical interface and automatically embedded in the generated code for direct execution by the robot controller (see

Table 3. Experimental setting for printing the parts used to validate the Fast Advanced-Pixel version experimentally.

Process	Kinects (Contact Transfer Controlled by Current and Wire Feeding [31]) technology of Abicor Binzel
Arc deposition equipment	iRob 501 Pro, Buseck, Germany
Torch movement system	ABB Robot IRB 1520 ID, Zurich, Switzerland
Substrate	SAE 1020 carbon steel (300 mm × 300 mm × 12 mm)
Substrate cooling	Natural air cooling at 80 °C of interlayer temperature
Feeding wire	AWS ER70S-6—ϕ 1.2 mm
Shielding gas	Ar + 2%CO2—15 L/min
Wire feed speed	3.7 m/min
CTWD *	12.0 mm
Deposition speed	48.0 cm/min
Set Voltage	15.2 V
Set Current	136 A

(*) CTWD—contact tip-to-work distance.

).

After printing, the upper surfaces of the parts were milled to a depth of 5.0 mm, aiming at detecting internal nonconformities. The machined parts were compared to the 3D model using the 3D scanner. The 3D scanner software employs augmented-reality concepts to perform visual-quality inspections. The analysis was focused exclusively on the geometric agreement between the manufactured parts and the reference model in the in-plane directions, while deviations in the build height were intentionally disregarded, as the top surface had been uniformly removed during the machining step.

The experimental validation conducted in this study focuses on geometric compliance with the CAD model and visual inspection of the deposited parts, aiming to verify the practical feasibility of the Fast Advanced-Pixel strategy and its ability to preserve part quality while reducing computational effort. Metallurgical characterization, thermal field measurements, and detailed process stability analyses (e.g., arc fluctuation, bead width variability) were not included, as these aspects are primarily governed by process parameters and material behavior rather than by the path-planning strategy itself. The absence of such measurements does not detract from the objectives of this work, which are centered on trajectory generation efficiency and geometric accuracy. Nonetheless, future work can explore comprehensive process monitoring and microstructural evaluation to fully characterize the influence of advanced path-planning strategies on thermal behavior and material properties.

5.2. Results and Discussions

Figure 13 and Figure 14 illustrate the process workflow and the results of topology optimization, including the nodes generated in each layer. The colored nodes represent the clusters obtained. Continuous trajectories, with a single start and stop per layer, were generated for both odd and even layers.

Figure 15a presents the milled component, which exhibits no visible nonconformities, while Figure 15b compares the printed part to the original 3D CAD model, revealing dimensional agreement. The printing times for the odd and even layers were 446.77 and 445.69 s, respectively, resulting in a final part height of approximately 18 mm before machining. Figure 16a displays the machined surface of the part, showing no apparent discontinuities, while Figure 16b compares the printed component with the original 3D CAD model, demonstrating dimensional agreement, even though only the first six layers were printed. The printing times for the odd and even layers were 1001 and 1004 s, respectively, resulting in a final part height of approximately 18 mm before machining.

As stated in the paper’s objective, the case studies conducted on complex parts confirm that the Fast Advanced-Pixel strategy effectively maintains the part quality. The results demonstrate the absence of defects and a dimensional agreement between the printed components and their corresponding 3D CAD models. These results are consistent with those reported in previous studies on the Pixel family of strategies; in the present case, the main improvement lies in the reduction of computational time required for trajectory generation. Despite the presence of several turns in the generated paths, which are not optimized by the Fast Advanced Pixel, the printed parts remain defect-free, in agreement with the findings of Vishwanath and Suryakumar [32] and Singh et al. [33]. The pixel resolution (node space) used in the Advanced-Pixel and Fast Advanced-Pixel strategies directly affects both geometric fidelity and computational cost by controlling the number of discretized nodes. In the present study, pixel resolution was kept constant across all simulations and experiments to isolate the effects of clustering and algorithmic acceleration.

6. Conclusions

The main objective of this work was to propose and validate a path-planning strategy for GMA-DED that integrates K-means clustering into the Pixel framework. Therefore, the previous text presented the Fast Advanced-Pixel strategy, an enhanced evolution of the Pixel path-planning family for Gas Metal Arc-Directed Energy Deposition (GMA-DED), but not limited to this one DED technology. The performance evaluation showed that the proposed approach effectively reduces the dimensionality of the optimization problem associated with the Traveling Salesman Problem (TSP). This reduction enables a significant decrease in computational time while maintaining, or even improving, trajectory quality. Two main conclusions can be delineated as

• The computational validation confirmed that increasing the number of clusters (K) consistently decreases the time required for trajectory generation, achieving speed-ups up to 20-fold with eight clusters using the former version of the strategy, i.e., the Advanced-Pixel. Such improvement results from dividing the node set into smaller clusters, which promotes faster convergence and more stable optimization outcomes. The statistical analysis (ANOVA) further verified that these differences were significant, evidencing the robustness and reliability of the proposed method.
• The experimental validation, carried out on geometrically complex parts, demonstrated that the Fast Advanced-Pixel strategy preserves dimensional accuracy and structural integrity while producing defect-free depositions. The printed parts exhibited high geometric conformity with their CAD models, confirming that the computational gains achieved through clustering do not compromise printing quality.

Overall, the Fast Advanced-Pixel strategy provides an effective and scalable solution for accelerating trajectory generation in node-based path-planning approaches for Directed Energy Deposition.

7. Limitations and Future Work

Although the Fast Advanced-Pixel strategy demonstrates substantial computational benefits, its current implementation relies on limited user interaction for cluster validation and trajectory linking. This semi-automatic nature may restrict direct deployment in fully autonomous industrial systems. Future work will therefore focus on automating these steps, including automated trajectory linking and adaptive clustering per layer, enabling the system to self-adjust according to part topology.

While experimental validation confirmed defect-free deposition and dimensional agreement, the present study does not address metallurgical characteristics, thermal histories, arc stability metrics, or thermal accumulation effects. These aspects are recognized as important for a complete assessment of GMA-DED technology and will be investigated in future studies aimed at correlating advanced path-planning strategies with the process physics and material performance.

The results presented in this work are limited to the Gas Metal Arc–Directed Energy Deposition technology, the investigated material system, and a class of geometries discretized using pixel-based node representations. Although the underlying principle of dimensionality reduction via clustering is broadly applicable, quantitative performance gains should be interpreted within this specific context. Extension to other DED technologies, materials, or geometric representations will require additional validation.

The K-means clustering algorithm employed uses random centroid initialization. While this may lead to variations in cluster assignments across runs, such variability did not compromise trajectory feasibility, deposition continuity, or printing quality within the investigated scope. Advanced initialization strategies (e.g., K-means++) and systematic variance analyses were not adopted, as the primary objective was computational acceleration rather than clustering optimality. These aspects represent relevant directions for future work.

Finally, the proposed strategy is formulated for planar, layer-wise deposition and does not explicitly address true 3D freeform deposition or non-planar layers. This reflects current industrial practice in GMA-DED, where planar slicing remains predominant. Extension to non-planar deposition represents a promising but independent research direction.