A Novel Ant Colony Algorithm for Optimizing 3D Printing Paths

Abstract

The advancement of 3D printing technology has enabled the fabrication of intricate structures, yet the complexity of the print head’s motion path significantly hampers production efficiency. Addressing the challenges posed by the dataset of section points in 3D-printed workpieces, this study introduces an innovative ant colony optimization algorithm tailored to enhance the print head’s trajectory. By framing the optimization of the motion path as a Traveling Salesman Problem (TSP), the research employs a custom-designed K-means clustering algorithm to categorize the dataset into distinct clusters. This clustering algorithm partitions each printing point into different subsets based on density, optimizes these subsets through improved K-means clustering computations, and then aggregates the results to classify the entire dataset. Subsequently, the ant colony algorithm arranges the printing sequence of these clusters based on the cluster centers, followed by computing the shortest path within each cluster. To form a cohesive motion trajectory, the nearest nodes between adjacent clusters are linked, culminating in a globally optimal solution. Comparative experiments repeatedly demonstrate significant enhancements in the print head’s motion path, leading to marked improvements in printing efficiency.

1. Introduction

Three-dimensional printing is a computer-controlled process that constructs objects layer by layer and has found applications across various industries [1,2]. At the heart of this technology is the central control system of the 3D printer, which is crucial for coordinating tasks such as motion control, temperature regulation, limit sensing, and automatic leveling [3,4,5,6,7,8]. This central module processes G-Code instructions from the slicing software on a PC, directing the printer’s mechanisms to function in unison and complete the printing process [9,10,11,12,13]. Motion control plays a pivotal role in determining the manufacturing efficiency and the quality of the final product. Path planning, a critical aspect of motion control, orchestrates the movement of the print head to optimize the printing process, significantly impacting both quality and efficiency [14]. Currently, the commonly used Z-type and biased-wheel-contour path planning algorithms exhibit marked limitations, particularly in handling large parts. With the growing integration of artificial intelligence, the development of intelligent path planning algorithms for 3D printing is set to gain prominence [15].

After many years of development, the intelligent path optimization algorithm has developed rapidly. In the research of 3D printing path planning, Liu et al. [16] proposed a reciprocating parallel scanning method. This algorithm is simple to calculate, and the scanning path forms a return line to print inside the contour; however, this method has a single structure, and multiple starts and stops can easily cause surface deformation of the model, resulting in defects such as wire drawing and warping. Wang et al. [17] proposed an adaptive path optimization method on this basis. This method starts with the longest side to fill the internal contour, which can reduce the number of nozzle starts and stops, change the traditional parallel line filling method, and improve the quality of the molded material. Kamnik et al. [18] proposed a printing method of parallel offsetting of the outer contour, which improves the accuracy, especially for uniform wall thickness solid models. However, when the outer contour line is complex and the model has an inner contour, this situation increases the difficulty of the algorithm, requiring a large amount of calculation, thus increasing the printing time. To this end, Zhao et al. [19] proposed a variable offset printing path optimization, using a non-equidistant offset contour method. This filling method can change the traditional offset distance, and when encountering an inner contour, it will adaptively adjust the distance, thus reducing the calculations, optimizing the internal filling, and improving the printing efficiency. Yang et al. [20] proposed a method for optimizing the printing path using fractal curves. By dividing the outer contour into multiple curves for internal offset planning, this approach resembles a partitioned form where each small segment serves as a starting edge for inward movement. This technique ensures a more uniform movement curve within the internal area. However, the challenge lies in determining the optimal number of segments, as too many or too few can adversely affect the forming quality.

The motion path of the printing head for each layer in 3D printing bears a significant resemblance to the Traveling Salesman Problem (TSP), a classic optimization problem that seeks the shortest possible route for a traveler to visit a set of locations and return to the origin point. This analogy arises because the print head must traverse numerous discrete points (representing the geometry of the layer) in the most efficient manner to minimize travel time and enhance print quality. Despite its straightforward definition, the TSP is computationally challenging to solve, especially as the number of points increases, leading to combinatorial explosion.

With the advancement of evolutionary algorithms, heuristic methods have emerged to tackle the complexities of TSP. Among these, the ant colony optimization (ACO) algorithm is particularly noteworthy. Inspired by the foraging behavior of ants, ACO is robust and flexible, making it a favored approach in various optimization tasks. However, ACO’s efficacy diminishes when applied to large-scale TSP instances due to its propensity to become trapped in local optima.

To mitigate this issue, Li Zhen introduced a K-means clustering ant colony algorithm [21]. This algorithm first employs K-means clustering to group the data points, then applies ACO within each cluster. The algorithm enhances exploration by mutating data points with low pheromone concentrations and boosting the pheromone levels of promising paths. Despite its innovative approach, this method is computationally intensive and often exhibits low solving efficiency.

Expanding on this concept, Zheng Xufeng et al. proposed another K-means clustering ant colony algorithm tailored for TSP problems with inherent clustering characteristics [22]. This method uses K-means to partition the TSP into manageable subproblems, which are then solved and reassembled. Although this approach improves solving efficiency, it does not address the inherent limitations of ACO, such as its vulnerability to premature convergence [23].

In parallel, other researchers have focused on optimizing the motion paths of 3D printing nozzles. Thompson and Yoon developed a method to reduce filament waste by maintaining a constant nozzle velocity and adopting a rapid transition motion profile [24,25]. This approach minimizes speed fluctuations, significantly enhancing print quality by predicting and correcting velocity errors.

Ganganath et al. conceptualized the nozzle path optimization as a TSP, proposing several modified TSP algorithms evaluated through computer simulations [26]. These simulations, focusing on single-layer print segments, demonstrated considerable improvements over traditional greedy-based solvers. Building on this foundation, Fok et al. refined a Christofides-based solver and applied it to complex, real-life 3D models [26,27]. Their results indicated that this algorithm outperforms the widely used Cura(15.04) slicing software in terms of path optimization and print quality [28]. In path optimization at slicing time, in study [29], a novel slicing method has been developed that allows for slicing implicit surfaces and generating printing paths without the need for stereolithography (STL) files, thereby avoiding slicing errors introduced by meshing steps. By slicing each implicit surface separately, the corresponding G-code files are generated. The literature [30] proposes a five-axis path planning method based on spherical slicing. By leveraging an implicit expression equation based on cylinders, this approach effectively achieves efficient surface slicing and the generation of five-axis spherical paths.

These advancements illustrate the continuous evolution of optimization algorithms in 3D printing, highlighting the importance of addressing both computational efficiency and practical implementation challenges to achieve superior printing outcomes. However, the aforementioned methods perform poorly when faced with significant variations in print density and the simultaneous printing of multiple objects. Therefore, this paper develops a novel ant colony algorithm to address these issues.

In this paper, a novel ant colony algorithm is proposed to optimize the motion path of the printing head for the characteristics of the 3D printing workpiece section point dataset. The proposed method equates the optimization of the printing head motion path to a TSP problem, and uses the designed novel K-means clustering algorithm to segment the printing point dataset reached by the printing head. After the entire dataset is divided into multiple clusters, the printing order of the clusters is sorted by the ant colony algorithm and the cluster centers, and then, the shortest route of each cluster is calculated. Finally, the nearest nodes between adjacent clusters are connected to obtain a complete printing head motion path, i.e., the global optimal solution. The contributions of this paper are as follows:

(1)

A novel K-means clustering algorithm for 3D printing model section data;

(2)

By using the novel K-means clustering algorithm designed in this paper to segment the printing area of the 3D printing model section, the ant colony algorithm is optimized to obtain a better 3D printing head motion path.

The remainder of this paper is organized as follows. The TSP problem in 3D printing is introduced in Section 2 and the path planning framework is presented in Section 3. The experiment results are described and discussed in Section 4 and the paper is finally concluded in Section 5.

2. Related Work

Three-dimensional printing requires a good algorithmic control and trajectory optimization strategy to control the motion of stepper motors and improve the overall performance of 3D printing. In this section, the optimization of the print head trajectory is transformed into the Traveling Salesman Problem (TSP).

2.1. TSP Problem in 3D Printing

The motion actuator for controlling the motion trajectory in 3D printing is a precision stepper motor. The pulse signals for the stepper motor are generated by the host computer in the form of G-Code instructions. These signals are then transmitted to the controller, which executes the G-Code instructions to manipulate the stepper motor and initiate rotation. The rotation of the stepper motor drives the rotation of the lead screw, resulting in the movement of the print head. In computer systems, 3D models are mostly represented as spaces enveloped by triangular facets. These models are sliced into a series of two-dimensional cross-sections using slicing software. The control of how the print head moves within these two-dimensional planes is a key technological aspect in 3D printing process control research. When the motion trajectory of the print head is optimized, both printing efficiency and quality can be significantly improved. Typically, the motion trajectory in 3D printing is planned within the Cartesian coordinate system, with the trajectories mostly being straight lines. Although straight lines are convenient and efficient, they do not necessarily yield the highest operational efficiency. In this paper, we treat the motion trajectory of the print head as a TSP-like problem, aiming to optimize it by solving the TSP problem.

As a classic problem in combinatorial optimization, the TSP can be conceptually described as follows: A traveling salesman needs to visit n cities, starting from one city and then traversing all the remaining cities. Each city can only be visited once, and the salesman must return to the starting city. The core of this problem lies in how to plan the route to minimize the distance traveled by the salesman while completing the task. The significance of TSP can be more intuitively described by the concept of a Hamiltonian cycle in graph theory. A Hamiltonian cycle refers to a cycle that includes all nodes without any branches. Therefore, the TSP is also known as the minimum Hamiltonian cycle problem.

2.2. Mathematical Model of TSP Problem

The optimization of the 3D printing trajectory primarily involves optimizing the path of the print head as it passes through a large number of coordinate points. For a given weighted undirected graph $G=\left(V,W\right)$, where V is the set of vertices and W is the set of edges, we aim to find a Hamiltonian cycle C in G. The total weight of C is defined as follows:

$$w(C)={\displaystyle \sum _{\left(v_i,v_j\right)\in C}w\left(v_i,v_j\right)}$$

(1)

such that the total power of C is minimized. If the paths passing between the nodes are denoted by $x_{ij}$, i.e., the decision variables are as follows:

$$x=\left\{\begin{array}{l}0 \left(v_i,v_j\right)\notin C\\ 1 \left(v_i,v_j\right)\in C\end{array}\right.$$

(2)

Then, the TSP problem’s objective function is expressed as follows, requiring the minimum total distance of the print head through the path:

$$\min Z={\displaystyle \sum _{i\in V}{\displaystyle \sum _{j\in V}{d}_{ij}{x}_{ij}}}$$

(3)

where $d_{ij}$ denotes the Euclidean distance between data points $i$ and $j$.

$$\begin{array}{l}\mathrm{s}.\mathrm{t}. {\displaystyle \sum _{j\in V}{x}_{ij}}=1, i=1,\cdots ,n\\ {\displaystyle \sum _{i\in V}{x}_{ij}}=1, j=1,\cdots ,n\end{array}$$

(4)

The print head of a printer can be seen as the traveling salesman in the TSP problem, with the points to be printed representing the cities. For complex-shaped printing objects, the size of the city set can be very large, reaching hundreds of thousands or even millions of coordinate points. Therefore, for such complex print jobs, the path planning of the print head is of great importance.

2.3. Summary of Previous Works

To provide a clearer understanding of previous works in the field of 3D printing technology and TSP optimization, we have summarized the key approaches and findings in

Table 1. Summary of relevant research results.

Study	Focus	Methodology	Key Findings
Lechowicz et al. [31]	Path optimization in 3D printing	Hybrid algorithms (greedy and annealing algorithms)	Reduced total length of print paths, lowering print time.
Fok et al. [23]	ACO-based tool-path optimizer	Ant colony optimization	Improved computation time, print time, and visual quality of printed objects.
Merzah et al. [32]	Tool-path optimization in FFF 3D printing	Linear greedy algorithm and linear two-opt algorithm	Proposed a hybrid algorithm that shows promise in path optimization.
Iori et al. [33]	Optimizing nozzle path in 3D printing	Heuristic algorithms	Achieved significant reductions in print time and proposed future research directions.
Liu et al. [34]	Minimizing transitions of print nozzles	Genetic algorithm	Generated paths with fewer transitions, improving print quality.
Pinochet et al. [35]	Path optimization for multi-material 3D printing	Self-organizing maps	Generated optimized print paths based on material behavior, improving G-code generation.
Riabko et al. [36]	3D TSP optimization	Ant colony optimization	Achieved execution times similar to 2D TSP for 3D TSP problems.

.

3. Algorithm

In this section, we first discuss the ant colony algorithm and its corresponding main state formulation, secondly, we discuss the related clustering methods, and finally propose a new ant colony algorithm in this paper based on the discussed ant colony algorithm and clustering methods.

3.1. Principle of Ant Colony Algorithm

The ant colony algorithm is a type of optimization algorithm that simulates the foraging behavior of ants. Its basic principle originates from the shortest path problem encountered by ants in nature. Based on observations by entomologists, it has been found that ants in nature, despite having underdeveloped vision, can find the shortest path from a food source to their nest without any explicit cues. They can also adaptively search for new optimal paths when the environment changes, such as the presence of obstacles on the original path.

When ants search for food sources, they release a specific secretion known as pheromones along the path they have traveled. These pheromones can be detected by other ants within a certain range, influencing their future behavior. As more ants pass through certain paths, they deposit more pheromones, leading to an increase in pheromone intensity (which gradually weakens over time). Consequently, the probability of ants choosing that path also increases, further enhancing the intensity of pheromones on that path. This selection process is referred to as the self-stimulatory behavior of ants. Due to its principle of positive feedback, the ant colony algorithm can also be understood as a form of reinforcement learning system, often referred to as an enhanced learning system or “ant colony”.

3.2. Main State Calculation

For the TSP problem, without loss of generality, let us assume the total number of ants in the ant colony is $m$, and the number of cities is n. The distance between city $i$ to city $j$ is denoted as $d_{ij}$ for $i,j=1,2,\cdots ,n$. The concentration of pheromones on the connection path between city $i$ and city $j$ at time t is denoted as ${\tau }_{ij}\left(t\right)$. At the initial time, ants are placed in different cities, and the concentration of pheromones on the connection paths between cities is the same, denoted as ${\tau }_{ij}\left(0\right)=\tau \left(0\right)$. Then, ants will choose routes according to certain probabilities. Let $P_{ij}^k\left(t\right)$ denote the random probability of ant k at time t transitioning from city $i$ to city $j$. We know that the “Ant TSP” strategy is influenced by two factors: the expectation of visiting a certain city and the concentration of pheromones released by other ants. Therefore, the random probability $P_{ij}^k\left(t\right)$ is defined as follows:

$$P_{ij}^k\left(t\right)=\left\{\begin{array}{l}{\displaystyle \frac{{\left[{\tau }_{ij}\left(t\right)\right]}^{\alpha }\cdot {\left[{\eta }_{ij}\left(t\right)\right]}^{\beta }}{{\displaystyle \sum _{\mu \in J_k\left(i\right)}{\left[{\tau }_{ij}\left(t\right)\right]}^{\alpha }\cdot {\left[{\eta }_{ij}\left(t\right)\right]}^{\beta }}}}, j\in J_k\left(i\right)\\ 0, \mathrm{Otherwise}\end{array}\right.$$

(5)

where $J_k\left(i\right)$ is the set of cities that ants have not yet traversed; ${\tau }_{ij}\left(t\right)$ represents the concentration of pheromones on the edge $\left(i,j\right)$ at time t; ${\eta }_{ij}\left(t\right)$ represents the heuristic expectation of transitioning from city $i$ to city $j$, given by ${\eta }_{ij}\left(t\right)=1/d_{ij}$; and parameter $\alpha$ represents the importance factor of pheromones, where a larger value increases the likelihood of ants following the path of previous ants, reducing randomness. When this value is small, although the randomness of the search is increased, the convergence speed of the algorithm may become slower. Parameter $\beta$ represents the importance factor of the heuristic function. If it is too large, the randomness of the algorithm decreases, leading to a higher chance of becoming trapped in local optima. When $\beta$ is small, although the randomness of the algorithm increases, the difficulty of optimization also increases.

During the process of ants traversing cities, a characteristic similar to the actual scenario is that while ants release pheromones, the strength of pheromones on the connection paths between cities gradually diminishes through evaporation and other means. To describe this feature, let $\rho \left(0<\rho <1\right)$ represent the evaporation factor of pheromones. Thus, after all ants have completed a full traversal of all cities, the concentration of pheromones on the connection paths between cities can be expressed as follows:

$$\left\{\begin{array}{l}{\tau }_{ij}\left(t+n\right)=\left(1-\rho \right)\cdot {\tau }_{ij}\left(t\right)+\Delta {\tau }_{ij}\\ \Delta {\tau }_{ij}={\displaystyle \sum _{k=1}^m\Delta {\tau }_{ij}^k}\end{array}\right.$$

(6)

where $\Delta {\tau }_{ij}$ represents the increment in pheromones after one iteration; the $\rho$ directly affects the pheromone content on the path, which in turn affects the global search ability and convergence speed of the algorithm. The pheromones left on the path $\left(i,j\right)$ by the k-th ant in a certain iteration is the following equation:

$$\Delta {\tau }_{ij}^k=\left\{\begin{array}{l}{\displaystyle \frac{Q}{L_k}}, \mathrm{Ant} k \mathrm{passes} \mathrm{through} \left(i,j\right) \mathrm{on} \mathrm{this} \mathrm{tour}\\ 0, \mathrm{Otherwise}\end{array}\right.$$

(7)

where $Q$ is the normal number; $L_k$ denotes the length of the path taken by ant k.

3.3. Clustering Algorithm

The K-means clustering algorithm is characterized by its clear semantics, simple structure, and fast computation speed. For solving large-scale TSP problems, the introduction of the K-means algorithm allows for dividing unevenly distributed city locations into a specified number of clusters [37]. Since the ant colony algorithm is more suitable for solving small-scale TSP problems, incorporating this idea can effectively address the drawbacks of slow computation speed and unstable results in the ant colony algorithm.

3.3.1. K-Means Clustering

The K-means clustering algorithm divides the original dataset into k disjointed clusters. First, k initial cluster centers are randomly selected, and the Euclidean distance between the remaining data points and the initial cluster centers is computed. According to the nearest neighbor principle, the data points with the smallest distance are assigned to the cluster corresponding to the closest cluster center. After the assignment is completed, the new cluster centers are recalculated. Finally, the new Euclidean distances between each cluster center and each data point are computed, and the process is iterated until a predetermined threshold is reached to stop the computation. When using the K-means clustering algorithm for image segmentation, clustering is performed based on the features of image pixels. Let $x\times y$ be the resolution of an image and k be the number of clusters. Given an input pixel $P\left(x,y\right)$ and a cluster center $C_k$, the computation principle is as follows:

(1)

Select a reasonable k initial clustering centers $C_k^{(0)}$;

(2)

Calculate the Euclidean distance $d$ between the image center and each pixel according to Equation (1):

$$d=‖p\left(x,y\right)-C_k‖$$

(8)

(3)

Assign all pixels to the nearest center based on the distance $d$;

(4)

Recalculate new clustering centers according to Equation (2) after all pixels have been assigned:

$$C_k={\displaystyle \frac{1}{k}}{\displaystyle {\sum }_{y\in C_k}{\displaystyle {\sum }_{x\in C_k}P\left(x,y\right)}}$$

(9)

(5)

Repeat the iterative calculation until the determined threshold value is satisfied and then stop the calculation.

The bulleted list of the K-means algorithm is shown below:

• Initialization: randomly select k data points as initial centroids;
• Assignment: assign each data point to the cluster of the nearest centroid;
• Update: recalculate the centroid of each cluster as the mean of all data points in the cluster;
• Convergence: repeat the assignment and update the steps until the centroids no longer change or a preset number of iterations is reached.

Although it has some advantages, such as simplicity and efficiency, the K-means clustering algorithm also has some disadvantages. Here are some of the drawbacks of the K-means clustering algorithm:

(1)

The initial selection of cluster centers has a significant impact on the results: The K-means algorithm requires the selection of initial cluster centers at the beginning, and this choice can greatly influence the final clustering results. Improper initial center selection may lead to inaccurate or unstable clustering results;

(2)

Sensitivity to initial cluster centers: The K-means algorithm is highly sensitive to the choice of initial cluster centers. Different initial center selections may result in different clustering outcomes. This means that when applying the K-means algorithm, it is necessary to try different initial centers multiple times to obtain better clustering results;

(3)

Sensitivity to cluster shapes and sizes: The K-means algorithm assumes that each cluster has a convex shape, and the size differences between clusters are not significant. This implies that if there are clusters with non-convex shapes or clusters with large differences in sizes in the dataset, the K-means algorithm may not accurately capture the structure of these clusters;

(4)

Sensitivity to noise and outliers: The K-means algorithm is highly sensitive to noise and outliers. Individual noise points or outliers can affect the entire clustering result, leading to inaccurate clustering results;

(5)

Requires pre-specification of the number of clusters: The K-means algorithm requires the pre-specification of the number of clusters, denoted as K. However, in practical applications, we often do not know the optimal number of clusters. Choosing an inappropriate number of clusters can result in inaccurate clustering results;

(6)

Not suitable for handling nonlinear data: The K-means algorithm is based on the Euclidean distance, which makes it perform well on linearly separable data; however, for nonlinearly separable data, the K-means algorithm may not produce reasonable clustering results.

Therefore, it is clear from the above-mentioned disadvantages that the method cannot be applied to various point sets of 3D-printed cut surfaces, and improvements are needed for the related disadvantages.

3.3.2. Novel K-Means Clustering

Due to the absence of “noise” points in the printing points of all the sections in 3D printing, there is no interference from “noise” points. However, the printing points in the sections of printed objects with uneven internal filling are sparse, which means that the density of the printing points varies greatly due to different filling ratios. Therefore, the classical K-means algorithm is not suitable for this type of dataset. In addition, the algorithm heavily relies on the selection of initial cluster centers and requires prior knowledge of the number of clusters, which limits the application of the K-means clustering algorithm in the segmentation of 3D printing section point sets.

To address the shortcomings of the K-means clustering algorithm mentioned above, this paper proposes a new type of K-means clustering algorithm. The idea of this algorithm is as follows: First, calculate the density of each printing point, and based on the density, divide the printing points into multiple groups of datasets where the printing points in each group have similar density values. Then, analyze the number of cluster centers based on each group of datasets, evaluate the clustering results with different numbers of cluster centers using the silhouette coefficient, and obtain a reasonable number of cluster centers. Next, use the corresponding point with the highest density as the initial point for each cluster center, and recompute the K-means clustering for the datasets. Perform the aforementioned clustering calculation for each group of datasets to obtain the classification of each group. Finally, merge all the clustering clusters together to form the final classification result. The calculation principle of this new clustering algorithm is as follows:

(1)

Calculate the density ${\rho }_i$ of each data point i:

$${\rho }_i={\displaystyle \sum _{i\ne j,j=1}^n\chi \left(d_{ij}-{\epsilon }_0\right)}$$

(10)

where $\chi \left(·\right)$ is a logical judgment function, when $\left(·\right)<0$, $\chi \left(·\right)=1$ otherwise $\chi \left(·\right)=0$; ${\epsilon }_0$ is the neighborhood truncation distance of data point i, and can be calculated as ${\epsilon }_0={\displaystyle \frac{\alpha }{N}}{\displaystyle {\sum }_{i=1}^N{d}_{i(k)}}$; $\alpha$ is a scaling factor typically chosen between 1 and 2; N is the total number of data points; $d_{i(k)}$ represents the distance between data point $i$ and its k-th nearest neighbor [38];

(2)

Based on the density values calculated in the previous step, the density point set is divided. The division method first calculates the number of points within each unit range for each density value ${\epsilon }_{\rho }$, and then divides the dataset into $\lambda$ datasets $\left\{H_1,H_2,\cdots ,H_{\lambda }\right\}$ based on the density value where the number of points in the unit range is less than the number of points in two adjacent unit ranges. ${\epsilon }_{\rho }$ is a unit scale of $\rho$ in the partition Formula (10), which can be optimized through the backpropagation algorithm;

(3)

For the dataset $H_i$ in the previous step, K-means cluster analysis is performed while the cluster centers are calculated from 2 to m to obtain the classification results for the corresponding pairs, and then their contour coefficients are calculated separately; the corresponding contour coefficients are calculated as follows:

$$s\left(i\right)={\displaystyle \frac{b\left(i\right)-a\left(i\right)}{\max \left\{a\left(i\right),b\left(i\right)\right\}}}$$

(11)

where $a\left(i\right)$ is equal to the average of the dissimilarity of data point i to other points in the same cluster; and $b\left(i\right)$ is equal to the minimum of the average dissimilarity of data point i to other clusters. The optimal number of clusters is selected by the contour coefficients, and the final result of the selected optimal number of clusters $o_i$ is the classification result $H_i\Rightarrow \left[c_1^i,c_2^i,\cdots ,c_{o_i}^i\right]$ of the dataset $H_i$;

(4)

Finally, the classification results of all datasets $\left\{H_1,H_2,\cdots ,H_{\lambda }\right\}$ are aggregated to obtain the final clustering results:

$$\left\{\left[c_1^1,c_2^1,\cdots ,c_{o_1}^1\right],\left[c_1^2,c_2^2,\cdots ,c_{o_2}^2\right],\cdots \right.,\left.\left[c_1^i,c_2^i,\cdots ,c_{o_i}^i\right],\cdots ,\left[c_1^{\lambda },c_2^{\lambda },\cdots ,c_{o_{\lambda }}^{\lambda }\right]\right\}$$

(12)

The flowchart of the new K-means clustering algorithm is shown in the Figure 1 below:

3.4. Novel Ant Colony Algorithm

The novel ant colony algorithm utilizes the Novel K-means clustering algorithm to partition and split large-scale TSP (Traveling Salesman Problem) instances into K small regions. Then, the TSP problem is solved once for each of these K regions to obtain the printing sequence for each region. After that, the ACA (ant colony algorithm) is applied to each region to obtain the movement trajectory of the printing heads. The computational principle of this new ant colony algorithm is as shown in Algorithm 1:

Algorithm 1 Novel ant colony algorithm

1: Select a collection of large-scale 3D printing data points;

2: Use Equation (10) to calculate the density ${\rho }_i$ for each data point i;

3: Based on the density values calculated in the previous step, the density point set is divided;

4: K-means clustering analysis is performed for the dataset in the previous step, while the cluster centers are calculated from 2 to m to obtain the classification results for the corresponding;

5: The contour coefficients are calculated using Equation (11), and the optimal number of clusters is selected by the contour coefficients to obtain the classification result $H_i\Rightarrow \left[c_1^i,c_2^i,\cdots ,c_{o_i}^i\right]$ of the dataset $H_i$;

6: Aggregate the classification results of all datasets to obtain the final clustering segmentation results;

7: The ant colony algorithm solves the paths for all the clustering centers and obtains the printing order between the regions;

8: Based on the printing order, the path is solved for each of the K regions of each cut separately using the ant colony algorithm;

9: Aggregate the print head motion paths for all areas.

4. Results

In this section, we carry out experimental studies based on the number of prints printed simultaneously. In order to verify the timeliness of the proposed algorithm, simulations are conducted to compare the proposed algorithm with the simple linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, and the Hilbert curve path planning algorithm. The experiments are divided into two groups: the first group of experiments in which 10 prints are selected to be printed together; the second group of experiments uses 20 prints to be printed together. Each group of experiments compares the printing time after path planning for several algorithms.

4.1. Test Platform

The 3D printer system employed in this paper is a desktop-level control system comprising a general PC, MCU (Microcontroller Unit), and hardware control card. This system performs complex path planning calculations on the computer, using a decoupled approach between the computer and the printer. This allows the printer to operate independently from the computer, enhancing the performance of the entire printer control system. The printer’s logic control unit utilizes an ARM AT32F403, and the software environment is Marlin 2.0. The motherboard and printer platform are shown in Figure 2. Additionally, we used Python 3.12 to develop our algorithms and conduct experiments, generating our own slicing results.

4.2. Experiment I

In this part of the experiment, a scene with 10 different regular parts printed together is selected, as shown in Figure 3 (a 60° view from the front). The linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, the Hilbert curve path planning algorithm, and the algorithm proposed in this paper are used to path plan the printed parts in this scene, and the print head motion path of its single layer is shown in Figure 4.

The linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, the Hilbert curve path planning algorithm, and the single-layer print path planned by the algorithm proposed in this paper are shown in Figure 4 and Figure 5. Through observation, it is evident that the proposed algorithm in this paper results in shorter inter-region connecting lines, allowing for a direct visual comparison that demonstrates the superiority of our algorithm over several others. Furthermore, regarding the time consumption of various trajectory planning algorithms, the performance test parameters for printing one layer are presented in the

Table 2. Performance comparison of each algorithm for planning print paths with 10 components.

Name of the Algorithm	Circumference		Exterior Profile		Internal Padding		Total Time (s)
	Time (s)	Percentage (%)	Time (s)	Percentage (%)	Time (s)	Percentage (%)
Linear	28	7.0	46	11.7	320	81.3	394
Loopback algorithm	28	7.5	43	11.4	316	81.1	387
Archimedean spiral	26	6.8	41	10.6	319	82.6	386
Hilbert curve	28	4.6	41	6.7	589	88.7	658
Proposed algorithm	26	7.2	36	10.5	294	82.3	356

below.

4.3. Experiment II

This section of the experiment selected a scenario where 20 different rule parts are printed together, as shown in Figure 6 (a 45° view from the front). The linear path planning algorithm, the loop algorithm, the Archimedean spiral path planning algorithm, the Hilbert curve path planning algorithm, and the algorithm proposed in this paper were used to plan the paths of the printed parts in this scenario. The movement path of the print head for each layer is shown in Figure 7.

The linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, the Hilbert curve path planning algorithm, and the single-layer print path planned by the algorithm proposed in this paper are shown in Figure 7 and Figure 8. Similarly, through observation, it was found that the proposed algorithm in this paper features shorter connecting lines between regional blocks, allowing for a direct visual comparison that demonstrates the superior path efficiency of our algorithm compared to others. Additionally, calculations using the ant colony algorithm indicate that the overall printing sequence between modules is superior to that of the other algorithms. The performance test parameters for printing a single layer, focusing on the time consumption of each trajectory planning algorithm, are presented in the

Table 3. Performance comparison of each algorithm for planning print paths with 20 components.

Name of the Algorithm	Circumference		Exterior Profile		Internal Padding		Total Time (s)
	Time (s)	Percentage (%)	Time (s)	Percentage (%)	Time (s)	Percentage (%)
Linear	82	7.3	151	11.2	758	81.5	991
Loopback algorithm	89	7.8	173	12.0	714	80.2	976
Archimedean spiral	80	7.4	149	10.6	760	82.0	989
Hilbert curve	82	4.8	156	6.9	1244	88.3	1482
Proposed algorithm	79	7.4	127	10.8	681	81.8	887

below.

4.4. Discussion

According to the data in the above table, the proposed method optimizes the time consumption of printing due to the path optimization, which results in a shorter path of the print head. Based on Experiment I and Experiment II, the total time consumption of the proposed algorithm is improved by 9.6 and 10.5% compared to the linear path planning method, respectively; 8.0% and 9.1% compared to the loopback path planning algorithm, respectively; 7.8% and 10.3% compared to the Archimedean spiral path planning algorithm, respectively; and 45.9% and 40.1% compared to the Hilbert curve algorithm. In addition, we test another 100 sets of models to obtain the experimental results in Figure 9. Our proposed algorithm consumes less time than several other methods. Therefore, it can be proven that the proposed algorithm in this paper has better timing performance for the case of simultaneous printing of multiple parts, and the more parts are printed, the better the timing performance is. However, it should be noted that the method proposed in this paper does not have much advantage if a simple part is printed alone.

The 3D printing process consists of three main steps: 3D modeling, slicing, and printing with a 3D printer. The algorithm we proposed is utilized during the slicing stage, which is executed on a computer. It is important to note that our proposed algorithm has a higher slicing time consumption compared to other algorithms. Specifically, in Experiment I, the slicing time for our proposed algorithm was 471 s, while the slicing times for the linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, and Hilbert curve path planning algorithm were 253 s, 198 s, 292 s, and 337 s, respectively. In Experiment II, the slicing time for our proposed algorithm was 788 s, whereas the slicing times for the linear path planning algorithm, loopback algorithm, Archimedean spiral path planning algorithm, and Hilbert curve path planning algorithm were 361 s, 308 s, 411 s, and 485 s, respectively. Although our proposed algorithm increases the slicing time, it optimizes the printing path planning for large-scale industrial device production, where slicing is only performed once. This optimization can significantly reduce the overall 3D printing time during subsequent large-scale production, thereby greatly saving production time.

In addition, the proposed algorithm is primarily designed for 3D printers using thread-based materials. Meanwhile, the proposed algorithm is implemented using Python programming language and generates G-code. The basic processing workflow includes the following: reading the 3D model, slicing along the Z-axis, generating paths (with our proposed algorithm), generating the G-code, and outputting the G-code.

5. Conclusions

This paper proposes a new ant colony algorithm to optimize the motion path of the print head. The proposed method equates the optimization of the print head motion path to a TSP problem and uses a newly designed K-means clustering algorithm to divide the print point dataset reached by the print head. After the whole dataset is divided into multiple clusters, the printing order of the clusters is sorted by the ant colony algorithm and the cluster center, and then the shortest route of each cluster is calculated. Finally, the nearest nodes between adjacent clusters are connected to obtain a complete motion path of the print head, that is, the global optimal solution.

The key findings from our study are as follows:

Optimization efficiency: the ant colony algorithm significantly optimized the motion path of the print head, resulting in reduced transition times and improved overall printing efficiency;

Clustering effectiveness: the application of the K-means clustering algorithm effectively divided the print points, facilitating a more manageable and efficient path optimization process;

Comparison results: repeated comparison experiments demonstrate that the optimized motion path consistently outperformed traditional methods in terms of both path length and printing speed.

These findings provide a robust basis for further research in the field of 3D printing optimization. The methodologies and algorithms presented in this study can be adapted and expanded upon for various 3D printing scenarios, potentially leading to even greater efficiencies and advancements in the technology.

In the future, we would like to work on 3D printing optimization techniques and further explore our path optimization technique for a wider range of multiple 3D manufacturing. Additionally, the integration of machine learning techniques with the proposed algorithms could provide further improvements and new insights into the optimization of complex 3D printing processes.

6. Recommendations for Future Research

Given the promising results of our study, we recommend the following directions for future research:

• Integration with machine learning: exploring the integration of machine learning techniques with our proposed algorithms to enhance the adaptability and efficiency of the optimization process;
• Real-time path optimization: developing real-time path optimization algorithms that can dynamically adjust to changes during the printing process, ensuring continuous optimization;
• Multi-material printing: investigating the application of our optimization techniques in multi-material 3D printing scenarios to address the unique challenges posed by different material properties.
• Scalability: testing the scalability of our algorithms with larger and more complex datasets to ensure they can handle industrial-scale 3D printing tasks.

These research directions aim to build on the foundation laid by our current study and contribute to the ongoing advancement of 3D printing technologies.