Metaheuristics for the Minimum Time Cut Path Problem with Different Cutting and Sliding Speeds

: The problem of efﬁciently cutting smaller two-dimensional pieces from a larger surface is recurrent in several manufacturing settings. This problem belongs to the domain of cutting and packing (C&P) problems. This study approached a category of C&P problems called the minimum time cut path (MTCP) problem, which aims to identify a sequence of cutting and sliding movements for the head device to minimize manufacturing time. Both cutting and slide speeds (just moving the head) vary according to equipment, despite their relevance in real-world scenarios. This study applied the MTCP problem on the practical scope and presents two metaheuristics for tackling more signiﬁcant instances that resemble real-world requirements. The experiments presented in this study utilized parameter values from typical laser cutting machines to assess the feasibility of the proposed methods compared to existing commercial software. The results show that metaheuristic-based solutions are competitive when addressing practical problems, achieving increased performance regarding the processing time for 94% of the instances.


Introduction
Cutting and packing (C&P) are optimization problems that concern the efficient arrangement of items within a larger space with the same dimensionality. This type of problem appears in several real-world industrial settings, including manufacturing, logistics, and 3D printing [1][2][3]. Therefore, optimization methods for C&P can represent a valuable commercial advantage [4]. This study focused on the minimum time cut path (MTCP) problem, which aims to identify a sequence of instructions (cutting or moving the head device) that minimizes the total cutting time for a packing arrangement or layout.
Prior to the solution of MTCP, a packing procedure is executed to achieve maximal surface area utilization [5,6]. In other words, all the items must be arranged within a surface of fixed width and minimal length, as illustrated in Figure 1. According to Araújo et al.'s taxonomy [4], this is a 2|Si|Oo problem, that is, two-dimensional, with a single input minimization and an open-dimensional volume. Wäscher et al. used the term strip packing problem to refer to such [7]. In addition, the literature contains several constraints that resemble more realistic settings, including the requirement for guillotined cuts [8] or irregular objects [9]. MTCP problems have a primary objective: the minimal time required for cutting the pieces represented by an input layout [5,6]. This data concerns the packing of all the items within a surface that represent the raw material, as illustrated in Figure 1. The position of pieces in the layout stage can be performed by computer-aided design (CAD) The central aspect of MTCP, proposed in this study, is the minimal cutting time, which depends on two parameters of manufacturing laser cut machines: the cutting and the moving (or sliding) speed of the head device. The first parameter depends on the machine hardware, the shapes of pieces in the input layout, and the surface material. The second parameter refers to the speed to change the position of the cutting head without cutting. Thus, we tackled a generalization type of the cut determination problem (CPD) [15] adopting the above-mentioned restrictions differently from the studies developed by Lee et al. [16] and Derwil et al. [17], respectively.
From an optimization perspective, a solution obtained to an MTCP problem is a path through the layout area considering the equipment cutting and sliding moves and the resultant manufacturing cut time. This study tackled the minimum time cut path (MTCP) problem with different cutting and sliding speeds. For simplicity of notation, the remainder of this article will refer to this particular problem simply as MTCP.
This study presented two evolutionary metaheuristic-based approaches to tackle larger instances that resemble real-world scenarios. The metaheuristics used in the conducted experiments are a standard genetic algorithm (GA) and a biased random-key genetic algorithm (BRKGA). The experiments used an extensive set of instances from the literature and allowed one to gain valuable insights into the algorithms and their performance compared to specialized commercial software.
The remainder of this article is organized as follows. Section 2 presents the most common algorithmic approaches to MTCP problems and shows the definition and terminology for MTCP. Next, Section 3 introduces two evolutionary algorithms for the MTCP problem. Section 4 presents the results of the computational experiments using an extensive set of instances. Section 5 concludes by discussing the performance of the used algorithms and future works to tackle MTCP.

Literature Review
As mentioned previously, MTCP problems consider the minimization of the total cutting time to extract the pieces from the input layout, and it is often called cutting path determination (CPD) [18]. CPD aims to determine the sequence of moves for the cutting head necessary to separate all the smaller pieces from the surface (also referred to as the stage in an industrial setting). This section focuses on approaches for CPD problems. For comprehensive surveys on C&P problems, we refer to [13,19].
Hoeft and Palekar [20] categorized CPD problems according to the flexibility to choose an initial contour entry and whether a piece is only partially cut before the head device moves to another object. The first category, according to [20], contains problems with continuous cutting, i.e., the cut is allowed to start at any point of the perimeter of pieces [21,22]. In such problems, the entry point should be the same for both entry and departure. The second category is called endpoint cutting, which contains problems in which the cut starts and ends at predefined vertices of the polygons [5,6]. The last category is intermittent cutting, in which there are no restrictions on the points that can be used for entry or exit of the cutting [23,24].
The literature contains several examples of algorithmic approaches for CPD. Dewil et al. [25] proposed grouping these methods according to the technique for traversing the vertices of the polygons. Three categories (here presented with examples of studies that employ such an approach) were identified by the authors: the touring polygons problem [26,27]), the traveling salesman problem (TSP) [28,29], the generalized TSP [30,31], and the TSP with neighborhoods [21]. Figure 2 presents a classification for CPD and the degree of generalization for this problem. The generalization level grows considering the flexibility of starting a path at any point of an item's layout. Besides, it is possible to cut only segments of a part, not necessarily starting and ending the cutting contour in the same item.  [18,20,25]. TPP: touring polygons problem; CCP: continuous cutting problem; TSP: traveling salesman problem; TSP-N: TSP with neighborhoods; ICP: intermittent cutting problem; GTSP: generalized TSP; ECP: endpoint cutting problem.
Laser cutting, as the designation suggests, applies a laser origin to cut the material. A benefit of laser cutting is that both the expanse of the cut and the heat-affected areas are tiny. Additionally, it is similar to both flame cutting and plasma cutting [32], and it is essential to highlight that the enclosed area detaches from the raw material after the cut of a complete piece contour. Depending on the supporting grid and air of the laser nozzle, it can shift its position, or if there is no supporting grid, it simply falls through. In both cases, it will be impracticable to continue cutting in this area.
The CPD problem aims to plan a path that minimizes the time required to cut all pieces regarding precedence constraints and is described in Dewil et al. [17].
Additional objectives include minimizing the cut across contours' path lengths and the effect of heat on the cutting path sequence [33]. A possible additional constraint is the requirement for a predefined cutting sequence for the items, which are to be cut without sliding movements [16]. Manber and Israni [6] tackled the problem of sequencing a torch (flame cutter machine) for cutting regular and irregular parts arranged on a surface. The main objective was to minimize the number of piercings, i.e., small holes made near each piece to improve the cutting process.
One of the approaches for CPD problems is the use of linear integer models to determine the sequence of moves that minimizes the overall time required to cut the demand of pieces [34].
Dewil et al. [17] extended [34] by assuming an additional set of constraints that resemble real-world requirements, for example, including inner-outer contours relations, resulting from holes in parts, parts allocated in holes, or elements nested in enclosed waste areas. The consideration of the inner-outer contour means that an inner contour needs to be completely cut before the outer shape is cut. In summary, all pieces of an inner contour necessitate to be cut before the end element of its outer contour is cut. Additionally, it is possible to suggest a set of constraints about basic cuts. In some layouts, each typical cut is enveloped by a contour formed of both its two contours. Hence, no typical cut is permitted to connect both of its contours.
Another kit of priority constraints appears from the evidence that when one cut the contour of two contours in common cut with one another, the separated contour can slide, making the rest of the cut process unfeasible. To correctly cut the items of the residual contour, the laser has to move into the cut kerf. It is forbidden if a high part quality is required, and a pre-cut should have been placed earlier. When cutting a part, a tiny pre-cut can be made in a nearby element if the laser head has to begin cutting from this place later on. Several non-trivial practical extensions (additional practicalities) like collisions, bridges, and thermal effects also are present in Dewil et al. [25].
A similar approach consists of reducing CPD to graph-based problems such as the capacitated node routing problem (NRP), also known as the vehicle routing or dispatch problem [35], and then optimized through mathematical models [15,36]. These techniques address CPD by utilizing a mathematical formulation based on the NRP problem and a derived model for the traveling salesman problem (TSP). This approach has been demonstrated to be suitable for achieving optimal solutions, for instance, containing approximately 2000 edges in a reasonable time. The formulation in [15] achieved optimal results for larger instances with up to 712 edges and a maximum of 560 nodes.
It is noteworthy that the studies that use mathematical models have been impractical for more realistic instances with tens of thousands of edges and nodes. A strategy to mitigate possible limitations is using heuristics and metaheuristics for solving graph-based problems, which are equivalent to the original CPD problem. For example, Moreira et al. [5] employed this approach, also considering that the surface is at an elevation (height) and that items fall as they are cut. Despite the wide variety of CPD problems in the literature, problems with different cutting and sliding speeds have not been formally described to the best of the authors' knowledge.

Evolutionary Metaheuristics for MTCP
This section introduces the steps for building two evolutionary-based approaches for tackling MTCP, considering different moving and cutting speeds: a genetic algorithm (GA) and a biased random-key genetic algorithm (BRKGA).

A GA-Based Approach
As mentioned previously, the MTCP with different moving and cutting speeds can be seen as a generalization of the CPD problem [5,15]. The input data for the MTCP problem is a packing layout, i.e., a set of non-overlapping polygons, which are defined as a set of two-dimensional points and edges, as illustrated in Figure 3. It also includes, in our approach, the moving (µ) and cutting speeds (π), which are numerical parameters that vary according to the machinery and the raw material. Let d(A, B) be the distance between the points A and B using a metric that respects the triangle inequality. This study adopted the Chebyshev metric (see Figure 4) since it abstracts aspects that are ignored: deceleration, acceleration, and effects from the cutting process, such as surface bending. The solution for the MTCP problem is a sequence of actions (being either moving or cutting) for the cutting head device.   , and Chebyshev (c). The continuous lines represents the layout, and the points in red and blue represent the two points considered in our example of the three distances used. The dashed lines represent the value of the distance between these two points. The Euclidean distance is the usual shortest line that connect both points; the Manhattan distance is the horizontal euclidean distance plus the vertical Euclidean distance between them; and, finally, the Chebyshev distance is the maximum value between horizontal and vertical Euclidean distances.
The first step is to build an equivalent undirected graph G = (V, E) containing the union of all the polygons' vertices and edges in the layout (see Figure 3). We applied the same strategy suggested by Silva et al. [15]. Figure 5 illustrates two possible paths in which cutting moves are represented as black edges, and simple moves are shown in red. The nodes and edges of the resultant graph portray the polygon points in surface space and the lines resulting from the meeting of two faces, respectively. In the final step, the solution is associated with a sequence of (cut or move) instructions processed by the cutting machine until the separation of the entire layout of pieces is finished. In addition, this section presents a packing approach that uses a traditional genetic algorithm (GA) to tackle practical instances that exact models cannot address in a reasonable time. GAs are computational algorithms based on the principle of natural selection and survival through the fittest individuals in a similar way to the evolutionary processes in nature [37]. GA-based methods are among the prevalent approaches to cutting and packing problems [38,39] and cutting path problems [16,40].
The GA starts by generating a random group of individuals, which are represented by chromosomes or typically binary arrays. These structures are evaluated using a fitness function that measures the candidate solution's quality. A small percentage of the individuals with the highest fitness is copied into the next generation (elitism). The selection operator then chooses two individuals of the current generation to be combined with probability txCross (crossover rate). Similarly, the mutation operator is applied to the offspring with probability txMut (mutation rate) [41]. After the new population is generated, the stop condition (e.g., number of generations or genetic convergence) of the algorithm is tested. If it is not satisfied, the process is repeated.
In the proposed GA implementation, each individual is encoded by a chromosome represented by a vector chrom(i) = (i = 1, 2, . . . , n, n + 1, . . . , 2n), where n corresponds to the number of edges that must be cut from the input layout. The n's first positions represent the cutting order of each edge, and the remaining elements have binary values (0 or 1) expressing the direction of the process. Figure 6a illustrates an input layout. We emphasize that the entire cutting process tends to start from the original system of each device (Source) and return with the movement head at the end (Regress). In this work, we considered the point (0,0), because the machine where we applied the tests follows the same idea. Note that in Figure 6b, the coding process for each individual describes that the input layout has four edges and, therefore, the individuals' representation vector contains eight positions. Moreover, the order (i = 1, 2, 3, 4) and direction (i = 5, 6, 7, 8) determine the plan of the complete cut. Therefore, when treating each element of the representation vector, we applied an offset assuming the shortest distance (Chebyshev) possible for cases in which the target node of one edge i does not match the origin node of the next i + 1. We assumed that 0 represents "left-to-right" or "bottom-to-up," in other words, for edge (u, v), we considered the initial point to visit u and the final point v, and 1 depicts the directions back.
The initial population was generated by shuffling a list of each cutting edge, while the rest of the positions with values 0s or 1s were drawn randomly under equal probabilities. The fitness of each individual was calculated by adding the time needed to cut, i.e., the time to cut the required edges (T cut ) and the motion of the head from the origin to the initial node of the layout and back from the head to the end of the complete cut (t o f f sets ). It was necessary to consider the speed π (cutting) and the other times µ (without cutting) to calculate the value of T cut . Figure 7 illustrates the (i , i + 1)-step of the fitness function. Note that (i) typifies each position of chrom, and the two squares represent the required cut edges (n), in other words, the input layout.
. Fitness representation to t(i) and t(i+1). (a) illustrates the i-step to compute the fitness value for each individual. (b) supposed that the chrom(i + 1) was the edge (z,w) and that its direction position (chrom(2n + (i + 1))) had value 1. Figure 7a illustrates the i-step to compute the fitness value for each individual. The chrom(i) is (x,y) edge and its position in the second part of the chromosome (chrom(2n + i)) contained value 0. The movement occured from node x to y (direction represented by 0), and, in this case, the edge (x,y) belonged to the set of required cutting edges. Thereby, to compute the time, t(i) was divided by the Chebyshev distance for (x,y) to π (cut speed). The next stage, (i + 1-step), supposed that the chrom(i + 1) was the edge (z,w) and that its direction position (chrom(2n + (i + 1))) had value 1-see Figure 7b. In this condition, to account for the time t(i + 1), we needed to add the displacement time of the cutting device head from node y to z; for this, we applied the displacement speed (1) with the cutting time of the edge (z,w), and we used the cutting speed (2). Therefore, Equation (1) formalizes the fitness function.
The method for individual selection applied was q-Tournament [42]. In this procedure, a group of q individuals was randomly selected with population replacement. This group became part of a dispute in which the winner was determined according to the best fitness. The crossover operator, in general, recombines aspects of chromosomes and benefits the search for the solution space, directing the evolution process. The method applied to the proposed GA was partially matched crossover (PMX) [43]. The goal is to generate two children by combining pairs of values in a given range of the two parents and exchanging these indexes' values. This strategy was applied only to the n's first elements of the vector.
On the other hand, the remaining positions of the representation were recombined through the two-point crossover. This adaptation facilitates the manipulation of each part of the applied model's scopes, sequencing edges, and direction choices, respectively.
The mutation operator was verified to ensure an expansive scan of the state space and to contain the premature convergence (optimal locations) of the GA. Similar to the idea conceived for the crossover, we applied the Shuffle Indexes method to the first part of the chromosome and the flip bit mutation strategy for the directions portion.
Finally, we detailed all values for GA parameters like population size, crossover and mutation rate, stop criteria, and others in the results Section 4.

A BRKGA-Based Approach
Genetic algorithms with random keys (RKGA) were introduced by [44] to deal with combinatorial optimization problems involving representation adapted to sequencing. In an RKGA, each chromosome is represented as a vector of real numbers in the range [0, 1[ n , where n is the problem's dimension. A decoder receives a chromosome and maps it into a feasible problem solution. Resende [45] proposed the Biased Random-Key Genetic Algorithm (BRKGA), in which the individuals are selected in the recombination process, and it also contains the highlighted function of the probability of inheriting information from the parents (p a ).
This study used the BRKGA due to its tolerance to several optimization problems, assuming that two elements of its framework must be represented [46]: a compatible decoder, featured in this section, and a representative fitness function, trying to minimize Equation (1), for this problem. Figure 8 illustrates the BRKGA heuristic and its parameters: the size of the population (P), the proportion of the population in the elite (P e ), and the number of new random individuals that will be included in the new population (P m ). An important characteristic of BRKGA is the parameterized uniform crossover [47]. In this crossover type, one of the parents is extracted from the elite group, while the second parent is extracted from the non-elite set. This enables the BRKGA heuristic to mitigate a premature genetic convergence. On the other hand, it requires the calibration of the p a parameter that can affect the overall performance. This peculiar parameter of the BRKGA ensures that the child individual inherits more characteristics of an elite parent. One parent is always selected (with replacement) from the elite solutions group, and the probability that the child inherits the key of the elite parent >0.5. According to Resende [45], this is a differentiating factor in favor of faster convergence when compared to RKGA [44].
Each gene in the chromosome representation for individuals in the BRKGA contains a real value in the range [0.1). For example, Figure 9 illustrates how random keys represent alleles for each chromosome. In our proposed strategy, the value of each gene chrom(i) was used by the decoder to determine the order and the cuts and movements' directions.
Therefore, the decoder operated as follows: first, the initial n genes for each chromosome are sorted upwards, corresponding to the cut order. Then, for each of the remaining genes (n + 1, . . . , 2n), the following function is used to determine the cuts' direction.
f (chrom(i)) = 0, if chrom(i) < 0.5 1, otherwise Figure 9 presents the encoding process from random keys to process an individual. Note that this process depends on problem specifications. For this reason, we illustrated this process separately from Figure 8. The input module saves the SVG file (layout) information like the edges for a cut. The dimension of the array depends on such a value. It is noteworthy that the part of the vector representing the directions does not participate in the keys' ordering, being decoded only by the function f(chrom). In this way, sorting random keys (ascending order of keys) results in the sequencing of edges visits. After that, the decoder presents a solution containing a sequence of movements for the input layout and the fitness function defined by Equation (1), which can calculate the time required for each individual. In this context, we use Section 4 to present our GA and BRKGA approaches' parameters and the cutting(π) and moving speeds(µ), inherent in MTCP, for all computational tests applied.

Results and Discussion
The computational experiments were conducted in an Intel Xeon 3.80 GHz machine with eight cores, 8GB RAM, and an Ubuntu 18.08 operational system. The GA and the BRKGA algorithm were implemented in Python 3.7. As input data, all dataset instances were layouts extracted through the algorithm applied by Amaro et al. [12]. The result was a file in SVG format. The following sub-sections present the characteristics of the benchmark instances (Section 4.1), a comparison between GA and BRKGA (Section 4.2), and a comparison between BRKGA (best approach considered) and a commercial laser cut software in practical situations (Section 4.3).The reader can access the complete information of the data used and constructed in this section through the link presented in the Data Availability Statement.

Instances
A set of 50 problem instances was used to evaluate the presented approaches. These instances can be categorized according to the possible presence of empty space between the pieces in the input layout, being either connected (C) (Figures A1 and A2 in the Appendix A.1) or separated (S) (Figures A3-A5 in the Appendix A.2). The presence of space between items in the latter group aimed to enable the use of support, which is quite common in some material cutting applications. The dataset was generated by the nesting approach presented in [12].

GA and BRKGA Hyper-Parameter Configuration
GA and BRKGA hyper-parameter configurations used in the experiments were selected after preliminary tests: population of 10,000, 5000, and 1000 individuals; crossover of 70%, 75%, and 80%; and mutation of 10%, 15%, and 20%. For the elite group in BRKGA, values of 30%, 20%, and 10%; mutated population of 10%, 15%, and 20%; p a of 70%. The stopping criteria wre met when there was no improvement in the best solution found for 100 generations or when the execution time exceeded 300 s. Tables A1 (see Appendix B.1) and A2 (see Appendix B.2) summarize the computational results. For every connect and separate instance, the results include the objective function value (FO), the elapsed time for the best execution, the average objective values, and the elapsed computational time. It is possible to observe that the BRKGA is more suitable than the standard GA for addressing the tested instances. Every hyper-parameter setting was tested for both GA and BRKGA, and each type of layout, connected (C) and separated (S). Figure 11 presents the number of times that a BRKGA hyper-parameter setting achieved the best solution found. For connected layouts (C), the best GA configuration addressing relation-1 (instances/executions) was obtained using the following hyperparameters after 49 times: P = 10,000, txCross = 0.8, and txMut = 0.1. In the separated instances group (S), the best solution was obtained after 20 executions, and the configuration was the following: P = 5000, txCross = 0.75, and txMut = 0.2.  Figure 12 presents the minimum time required to reach the best value in each execution. It is possible to observe that, for each instance, the objective function value was above the average best. A consideration of the results exposes that it is not suitable to define the best configuration for relation-1. While it achieves the best result in all executions for some instances, it led to the below-average value for the remaining.   Next, we defined relation-2 considering the number of instances each configuration achieved the best FO value for at least one execution. Figure 13 presents the best hyperparameter configuration according to the highest average value for connected and separate layouts. Therefore, the best parameters to connected instances were P = 5000, P e = 0.30, P m = 0.1; P = 10,000, P e = 0.10, P m = 0.1; P = 10,000, P e = 0.10, and P m = 0.2. For separate instances, the best hyper-parameters were P = 10,000, P e = 0.20, and P m = 0.2. Figure 14 presents the progression of the BRKGA optimal value at each generation.    Lastly, we defined relation-3 setting the configuration using each parameter option that occurred more frequently in the best solutions (modal value): P = 10,000, P e = 0.3, and P m = 0.10. A comparison between vertex numbers (V) and population size (P) exposed that the configuration that hyper-parameter settings with population equal to 10,000 failed to achieve the best results for instances with V ≥ 70. For example, for the instances inst_01_26pol (V = 210) and trousers (V = 350), the value of P in the configuration that presented the best solution was 1000 for both cases. Therefore, the following hyperparameter was selected for further experiments: P = 5000, P e = 0.30, and P m = 0.1. The progression of the BRKGA is shown in Figure 15 and Table A3 (see Appendix C.1) and Table A4 (see Appendix C.2). Since the configuration failed to reach the average result for both connected and separate instances, it is possible to affirm that increasing the timeout would enable better solutions.

Comparing BRKGA and a Commercial Laser Cut Machine Software
This section presents a practical case from industry comparing BRKGA using the best hyper-parameter setting (see Section 4.2) and commercial software for laser cutting machines. The characteristics of the device are shown as follows. PRISMA machine (https://www.automatisa.com.br/en/ (accessed on 8 October 2021)) produced Automatisa Laser Solutions, was 60 W, and had a maximum working area of 900 × 600 mm. The speeds π (cut) and µ (displacement) were 16.67 mm/s and 400 mm/s, respectively. Then, BRKGA was executed for all the instances, and the generated outputs (sequence of edges for cutting) were exported as SVG files. After, a similar process was repeated using the commercial software. Finally, we used the proposed instances and assigned them as input for execution to compute the machine's software (LaserCut). Table A5 (see Appendix D.1) presents a comparison between the introduced BRKGA approach with parameters P = 5000, P e = 0.30, and P m = 0.1, and LaserCut. For 50 instances analyzed, BRKGA achieved a gained time in 47 s, i.e., an improvement of 94%. It is noteworthy that for instances with separated items, the improvement was inferior to those for instances with connected items.
It is possible to notice that the BRKGA approach achieved a time of 256.56 s for the connected group and 258.76 s for the separated group-see Tables A1 and A2. The respective settings applied to these results were: P = 1000, P e = 0.30, and P m = 0.1 and P = 1000, P e = 0.30, and P m = 0.15. It is noteworthy that, for several instances, BRKGA performed better than LaserCut. Interestingly, the results indicate an apparent relationship between the population size and the number of vertices (Table 1) in the input layout.

Conclusions
This study introduced a case of the MTCP problem, which more closely resembles real-world scenarios by distinguishing cutting and moving speeds. The cutting and the sliding rates for the equipment are essential parameters and, despite their relevance in realworld machinery, such features are often ignored in the literature. This study presented the minimum time cut path problem, including two presented evolutionary approaches, i.e., the genetic algorithm (GA) and biased random-key genetic algorithm (BRKGA) methods, which are suitable for addressing larger instances.
Computational tests presented extensive hyper-parameter tuning using a large set of instances extracted from the literature, which can be leveraged in future research. For all instances analyzed, the proposed methodology achieved a gain in time of 47 s and an improvement in 94% of the tests performed.
However, we noticed a decrease in performance when the input layouts had a relatively large number of vertices. This fact indicates a correlation between this parameter and the population size. Moreover, a suitable approach would consist of splitting the layout into parts, considering cutoff distances, so that the individual's representation can also be segmented. Hence, we would build N subgroups of edges, and the evaluation would be limited in finding the best sequence for each N. Lastly, we would add the endpoint times to the beginning of all predefined N by finding a feasible solution and enabling parallel processing.
Future work will investigate how clustering methods such as K-Means can be integrated into the current approach to find feasible and quality solutions when addressing instances with a more significant number of parts positioned in a layout. This strategy will be integrated into the mathematical model. Another research direction is the investigation of an alternative representation for candidate solutions in the BRKGA algorithm. In the recent literature, there have been examples of methodology that allow the use of a purely discrete representation and the possibility of combining the discrete solutions using vector-like operations, similar to what is usually done for continuous solutions as in the random-key encoding [48][49][50].

Informed Consent Statement: Not applicable.
Data Availability Statement: Publicly available datasets were analyzed in this study. This data can be found here: https://github.com/GUIKAR741/metaheuristics-minimun-path (accessed on 8 October 2021). The folder "algorithms" includes the codes of the two approaches developed for this study. The folder "instances" holds all input SVG layouts. The folder "results" presents the numerical experimental data. The folder "result-evolution process" contains the evolution graph of the best solution (Y) with the number of generations (X), and the folder "results-final draw" shows the ten images of the path sequence found (each instance × execution), just for the BRKGA approach with hyper-parameters [P = 5000, P e = 0.30, and P m = 0.1].

Conflicts of Interest:
The authors declare no conflict of interest.

Abbreviations
The following abbreviations are used in this manuscript: