Repair Method and Muéganos Structure Applied to the Nesting Problem in Finite Materials

Abstract

During an optimization process which uses a metaheuristic strategy applied to the nesting problem, it is required to apply a repair method if the random solution contains overlapping items. In this paper, a repair method is proposed to avoid the overlap of pixels between items obtained by a randomly generated solution using metaheuristics. The proposed procedure runs through each one of the items. When it finds at least one overlapping pixel, it performs four moves: up, down, left, and right, and it is repeated until no more overlaps appear. In addition, a structure called muéganos is defined. It contains items that are nested more compactly to minimize waste. This structure allows the nesting of elements in a more efficient way. To complete the procedure, a sequential greedy algorithm (SGA) was implemented to nested the items in the available area of the material. A comparison was made between nesting without and with muéganos, obtaining better results using muéganos, with a material utilization of more than $70\%$. From the experimental results, it was obtained that the solutions are improved by more than $1\%$ through our proposed method, which is competitive when compared to other methods proposed in the literature.

1. Introduction

The nesting of items in finite materials is a combinatorial optimization problem to be solved in a significant number of manufacturing industries, such as metallurgical, paper, textile, footwear, and glass. Optimal nesting is essential for the best use of the materials and to minimize waste through the use of Computer Vision, Computational Intelligence and Digital Image Processing techniques [1].

Heuristic and metaheuristic methods [2,3] can be applied to complex optimization problems, such as the nesting problem, to approximate solutions. These methods guide the search process by approximating optimal solutions. Some examples of metaheuristic algorithms include greedy algorithms [4,5,6], simulated annealing (SA) [7], particle swarm optimization (PSO) [8,9], and genetic algorithms (GAs) [10,11,12,13]. Simulated annealing (SA) [7] is a probabilistic algorithm that approximates the global optimum by allowing some suboptimal moves. SA is a stochastic optimization method [14] based on the principles of statistical mechanics. It simulates the annealing process by slowly cooling a substance to obtain a strong crystalline structure. The strength of the structure depends on the cooling rate of the metals. SA can be used to approximate global solutions in an extended space search for an optimization problem.

Greedy algorithms [4,5,6] make local optimal choices at each step, which can lead to suboptimal solutions. Particle swarm optimization [8,9] is a metaheuristic optimization algorithm inspired by simulating the behavior of a swarm of particles observed in nature, such as fish, birds, and ants, among others.

GAs are one of the most popular techniques among evolutionary algorithms. They were inspired by Darwin’s theory of evolution [11] on the basis of the principle of natural selection. GAs were implemented by John Holland, a researcher at the University of Michigan, in the late 1960s [13]. GAs are stochastic search strategies based on the natural selection mechanism since they involve aspects of natural genetics, imitating biological evolution as a search strategy to solve problems [10]. GAs have three significant advantages in optimization problems: adaptability, robustness, and flexibility [15].

Related Work

Despite the methods and techniques developed to automate the nesting process, many industries still perform the procedure manually, which results in a substantial waste of material and time while performing the procedure. Some studies focused on the nesting problem are mentioned. Yi-Ping Cui et al. [16] implemented an algorithm that produces patterns from items using a sequential heuristic procedure. A pattern contains three items, which are produced from a greedy algorithm that organizes them using the left-bottom algorithm, and generates a position from the corners of the first pattern to place them in a specific orientation (vertical or horizontal). After the generation, the item values are adjusted using a value correction formula. Defu Zhang et al. [17] proposed a recursive technique to solve nesting problems by dividing the material into areas and assigning priorities to each item. These priorities depend on its size to efficiently fill the rectangle where it is placed.

Gomez and Terashima-Marín [18] used an evolutionary framework to build hyperheuristics that solve the nesting problem, which considers the minimization of two objectives: the number of items to be accommodated and the time needed for this task. It also integrates three multi-objective evolutionary algorithms that build a solution, and decides which of the three solutions is the best at each algorithm step. Leung et al. [19] presented a two-stage intelligent search algorithm for a two-dimensional strip packing problem. First, a heuristic algorithm selects a rectangular item from all items to be nested for a given space. Second, a local search and a simulated annealing algorithm are combined to enhance the solutions to the problem.

Neuenfeldt Júnior et al. [20] explored benchmark values (predictors) for the optimal objective function of hard combinatorial optimization problems based on mining techniques, which can be used to evaluate the quality of heuristic solutions for the 2D nesting problem. Wei et al. [6] presented a method based on the branch-and-bound best-fit ladder to solve this problem. Moreover, a greedy heuristic is used to accelerate the process and generate a complete solution from a partial one. Yin, A. H., et al. [21] proposed a Quick Heuristic-Dynamic Programming (QHDP) algorithm. At the beginning, a one-dimensional knapsack problem creates sets as a function of the height and width of small rectangular blocks, and an efficient discretization set is generated for each one. Then, each set value is used as a possible cut-off line coordinate for the subproblem division. Pinheiro et al. [22] presented a shrinking algorithm that operates within a random-key genetic algorithm (RKGA) and well-known collocation rules (e.g., bottom-left) to improve partial solutions.

Rashid, D.N.H, et al. [23] designed the Ants Nesting method (ANA), inspired by Leptothorax ants, which emulates the behavior of ants searching for positions to deposit grain while building a new nest. ANA is a continuous algorithm that updates the search agent position by adding the rate of change: step or velocity. It calculates the rate of change differently as it uses the current and previous solutions and fitness values to generate weights during the optimization process. The Pythagorean theorem is used to obtained the weights, which lead the search agents during the exploration and exploitation phases.

It is possible to consider machine learning algorithms to solve the nesting problem; for example, a neural network can be integrated into image processing as in the research of Ding et al. [24], which presented a fuzzy image-enhancement method that can be applied to image processing at the initial stage to solve the nesting problem. Zhang and Ding et al. [25] proposed to transform the extracted features using a trained self-supervised feature extractor to reduce the mis-match in the feature distribution. Poshyanonda and Dagli [26] proposed a genetic algorithm to generate a sequence of patterns and use an allocation algorithm to place the sequence using a sliding method integrated with a neural network.

In the nesting problem, it is important to address the issue of overlaps between items. To avoid overlaps, it is required to apply techniques such as the repair of unfeasible solutions or the no-fit raster concept to check overlapping between any two-dimensional generic-shaped items. Mundim et al. [27] used the no-fit raster concept, which is used to check overlaps between any two-dimensional items in a generic way. They also implement a biased random-key genetic algorithm (BRKGA) to determine the sequence in which these items are packed. Once the sequence is obtained, they propose two heuristics based on the bottom-left movements and the no-fit raster concept, which are used to sort these items in the given container by observing objective criteria.

Kierkosz and Luczak [28] proposed a one-pass heuristic, placing items at different positions in the material to avoid the overlaps using the no-fit polygon (NFP) technique, thus generating different partial solutions, until the best one was found. Details of the NFP algorithm are found in [29]. Fischetti et al. [4] used a greedy strategy by applying a Mixed-Integer Programming (MIP) model for the nesting problem. Sato et al. [30] proposed an adaptation of the no-fit polygon to consider the penetration depth of the items. It is based on an iterative compaction scheme using a separation algorithm based on a fast obstruction map local search (FOMLS).

Repair algorithms are essential to improve and avoid overlapping items in the nesting problem. These algorithms can be developed using a greedy or random repair approach or a metaheuristic strategy to find feasible solutions. However, eliminating overlapping items is not the most effective solution as it can lead to more waste material. There are several possible methods to repair an individual that is not a feasible solution. Thomas Bäck et al. [31] explained that one of these methods is to create a repaired version that is a local solution for that particular individual. This repaired version can replace the original individual in the population under some probability. The repair of an unfeasible individual is related to learning and evolution, which interact with each other to improve and find a repaired and feasible solution called the Baldwin effect [32].

The contributions and innovations of this paper are summarized as follows:

1.

A proposed repair method can be applied in a wide range of heuristic and metaheuristic techniques for solution approximation to solve the nesting problem.

2.

A calibration method to enhance the measurement and scaling of items and material for the nesting process.

3.

Enhanced efficiency and waste reduction through the use of muéganos as an innovative concept.

4.

The muégano structure facilitates nesting of elements in a more compact form and minimizing waste.

5.

Local optimization derived from the formation and optimal position of muéganos.

6.

The sequential greedy algorithm (SGA) allows filling the available areas in the material with random pattern selection.

7.

Improved application of metaheuristic algorithms when working with chromosomes or repaired solutions (e.g., genetic algorithms).

8.

Experimental results underscore that the proposed method, particularly incorporating muéganos, leads to improved waste reduction and solution quality compared to previous methodologies.

The paper is structured as follows:

• Methodology: The procedure used to solve the nesting problem is explained, including the repair method proposed.
• Experimental Results: The results obtained with the proposed methodology are presented.
• Conclusions and future work: The conclusions drawn from the results are discussed, and suggestions for future work are provided.

2. Methodology

This article proposes a repair method that aims to minimize material waste by removing the least amount of elements from the nesting solution. Additionally, to improve the nesting between items, a structure called muéganos is proposed. It stores elements that have a limit of adjacent neighboring pixels between items. The objective of muéganos is to obtain the items closest to each other and then repeat them in nesting. Finally, a greedy sequential algorithm (SGA) was implemented to fill the available spaces in the material. Figure 1 shows the flow diagram of the repair process described in the methodology.

Figure 1. Flow diagram of the repair process described in the methodology section. The process is a sequential flow starting with the camera calibration method to obtain the correct coordinates. Subsequently, the items are codified to apply the repair method. The muéganos are created from non-overlapping and low-waste items. Finally, the greedy algorithm optimizes the results.

2.1. Image Selection and Binarization

Firstly, the material and items are selected, and a binarization process is carried out using the OTSU method [33]. The valid area of the material and the items are binarized with values 0 and 1, respectively, and the invalid area (defects or holes) are given another value different from 0 and 1. The images stored in a data structure in conjunction with the area of each one are calculated by counting the number of valid pixels that are part of the nesting. Examples of binarized images are shown in Figure 2.

Figure 2. Binarized material and items. (a) Sample cowhide material to accommodate items. (b–d) Footwear items nesting in the sample material.

Once all the items have been binarized, a bubble sorting algorithm is applied [34], to order them from the largest to the smallest area. When arranging them, they are packed with the largest area until the smallest one is arranged.

2.2. Calculation of Waste in Metric Values

Material and item images are scaled from the original frame size using a factor scale for reducing the material and the items. The pixel coordinates are transformed into world coordinates for a real-world application. This process implies a camera calibration method [35] and direct linear transformation (DLT) [36].

Firstly, the camera is calibrated using a set of C chessboard images from different perspectives. A checkerboard image is a grid with alternating black and white squares. The grid is used to show the size of the squares in metric and pixel dimensions. The camera calibration provides the intrinsic parameters (Equation (1)), such as focal length and optical center, and distortion parameters (Equation (2)), such as the radial and tangential distortion coefficients. The camera calibration helps to reduce the distortion in the images. Table 1 shows the variables corresponding to this section.

$$K=\left[\begin{array}{ccc}{f}_x& 0& c_x\\ 0& f_y& c_y\\ 0& 0& 1\end{array}\right],$$

(1)

$$d=\left[\begin{array}{ccccc}{k}_1& k_2& p_1& p_2& k_3\end{array}\right].$$

(2)

Table 1. Calibration variables resume.

Variable	Description
C	Number of chessboard images
$f_x$, $f_y$	Focal length for axis x and y, respectively
$c_x$, $c_y$	Optical center
$k_1$, $k_2$, $k_3$	Radial distortion
$p_1$, $p_2$	Tangential distortion
K	Calibration matrix
d	Distortion vector
${\mathbf{x}}_{\mathbf{i}}$	i-th 2D coordinate (pixel)
u, v	Pixel coordinates for axis x and y, respectively
M	Projection matrix
$m_i$	i-th values from projection matrix
${\mathbf{X}}_{\mathbf{i}}$	i-th 3D coordinate (world)
$X_i$, $Y_i$, $Z_i$	World coordinates for axis x, y and z, respectively
$wast{e}_p$	Waste of the material in pixels
$wast{e}_m$	Waste of the material in m2
$are{a}_p$	Area of the rectangle around the material in pixels
$are{a}_m$	Area of the rectangle around the material in m2

Once the camera parameters and distortion coefficients are obtained, the camera is fixed to a certain distance from the material. This arrangement makes it possible to obtain the transformation from 3D coordinates to 2D coordinates. This mapping is represented as

$${\mathbf{x}}_i=M{\mathbf{X}}_i,$$

(3)

where $M\in {\mathbb{R}}^{3\times 4}$ represents the projection matrix, ${\mathbf{x}}_i=[u_i,v_i,1]$ is the i-th 2D coordinate, and ${\mathbf{X}}_i=[X_i,Y_i,Z_i,1]$ represents the i-th 3D coordinate for all $i=1,2,\cdots ,n$, and n is the number of necessary points.

A chessboard is placed over the material, and the arrangement is captured. The arrangement is shown in Figure 3. Each corner of the physical chessboard is matched with the corresponding pixels.

Figure 3. Image (a) shows a chessboard pattern over the material. The chessboard should cover most of the material for the best calibration. In image (b), the camera captures the material for the nesting process.

The projection matrix used to transform the 2D coordinates to 3D coordinates is calculated as

$$\left[\begin{array}{cccccccccccc}{X}_1& Y_1& Z_1& 1& 0& 0& 0& 0& -u_1{X}_1& -u_1{Y}_1& -u_1{Z}_1& -u_1\\ 0& 0& 0& 0& X_1& Y_1& Z_1& 1& -v_1{X}_1& -v_1{Y}_1& -v_1{Z}_1& -v_1\\ ⋮\\ X_n& Y_n& Z_n& 1& 0& 0& 0& 0& -u_n{X}_n& -u_n{Y}_n& -u_n{Z}_n& -u_n\\ 0& 0& 0& 0& X_n& Y_n& Z_n& 1& -v_n{X}_n& -v_n{Y}_n& -v_n{Z}_n& -v_n\end{array}\right]\left[\begin{array}{c}{m}_{11}\\ m_{12}\\ ⋮\\ m_{33}\\ m_{34}\end{array}\right]=0.$$

(4)

Lastly, the $m_i$ parameters are obtained using the SVD method. Equation (4) is obtained from Equation (3).

The waste is calculated by selecting a rectangle around the material. The area of the rectangle is computed in pixels and meters. The ratio r of waste in pixels and the pixel area are equivalent to meters and metric area, as shown in Equation (5).

$$r=\frac{wast{e}_p}{are{a}_p}=\frac{wast{e}_m}{are{a}_m},$$

(5)

where $wast{e}_m$ is found as Equation (6):

$$wast{e}_m=\frac{wast{e}_p·are{a}_m}{are{a}_p}.$$

(6)

The waste of the material in meters is calculated after the arrangement of patterns over the material.

2.3. Item Coding

Item coding is arranged as a data structure where all data items are stored. It is composed of individuals that are encoded as possible solutions to the nesting problem, which in most cases have overlapping. It is necessary to establish restrictions (Section 2.3.1) that guide the search process from the beginning of the algorithm. Table 2 describes the variables contained in item coding.

Table 2. Variables for characterization of items involved in the constraints.

Variable	Description
$NestingImage$	Material with items packed
$ItemCoding$	Set of alleles by items
$Fitness$	Fitness function value
$OverlappingItems$	Items that are overlapping
$OverlappingPixels$	Pixels that are overlapping
$Outside\_of\_AreaItems$	Items that are outside of valid area
$Outside\_of\_AreaPixels$	Pixels that are outside of valid area
$AreaOccupiedbyItems$	Sum of pixels of the nested items.
$NestedItems$	Number of nested items

The item coding size defines the number of individuals or solutions generated by the algorithm, as shown in Figure 4.

Figure 4. Item coding contains all the items of the nesting. Each item is represented by five alleles: identifier ($P_k$), rotation angle ($R_k$), position in rows and columns within the material ($i_k$,$j_k$), and packing item ($B_k$).

Each item is identified by five alleles as shown in Table 3.

Table 3. Alleles identifying each item.

Variable	Description
$P_k$	Identifier item
$R_k$	Rotation angle
$i_k$	Row position within the material
$j_k$	Column position within the material
$B_k$	Packing item

Packing item ($B_k$) identifies whether the allele is packaged or unpacked. If $B_k=1$ the item is packed, then $B_k=0$ it is not packed. In our case, when generating the item coding, all $B_k$ were considered with a value of 1 per item. The structure size is n, which defines the number of items that will be packed. k is an index of the number of items placed in position ($i_k$,$j_k$), where k is in the range of $1,2,\cdots ,n$.

2.3.1. Restrictions on the Item Coding

When generating the item coding, the following restrictions are considered:

1.

The positions in rows and columns must fall within the valid area of the material.

2.

The percentage of pixels ($P\%$) outside the valid area ($Outside\_of\_AreaPixels$) must allowed between items.

To define the positions of the rows and columns of each item, it is verified that the randomly generated values are within the valid area of the material, taking into account that only a percentage ($P\%$) of pixels outside the valid area are allowed, as shown in Equations (7) and (8):

$$i_k=rows\_material-(rows\_item+rows\_item·(1-P\%)),$$

(7)

$$j_k=columns\_material-(columns\_item+columns\_item·(1-P\%)),$$

(8)

where $rows\_material$ and $columns\_material$ are the numbers of rows and columns of the material, respectively, and $rows\_item$ and $columns\_item$ are the numbers of rows and columns of the item, respectively. The restrictions allow us to guide the search within a valid space from the beginning of the algorithm.

2.4. Repair Method

The repair method works on the solutions obtained from the applied metaheuristics. It goes through each item and performs four movements (up, down, left, and right) when overlaps are found. This process is repeated until there are no overlaps between items. If the number of overlapped pixels at the beginning is equal to the number of overlapped pixels after performing the movements, then the repair process stops. If there are overlapping items at the end, they are removed. The pseudocode for this process is shown in Algorithm 1.

Algorithm 1: Repair Method

Figure 5 shows an example of how the item movements are carried out. There are 3 elements to nest, in which, item 2 is overlapped with item 3. Movements are made from left to right: down, up, right and left, and once the four movements have been made, the number of overlapped pixels is calculated. Then the left-movement-generated zero overlaps; therefore, we keep that solution. If there were overlaps in the first iteration, we would keep the smallest solution and repeat the process until the number of overlaps became zero.

Figure 5. Sample of the item movements during the repair process. The black area represents the material, the white area represents the items, and the gray area represents the overlaps.

2.5. Muéganos Detection and Structure

In Mexico, the muégano is a candy that physically looks like several pieces of pastry stuck together with honey or caramel. Once it hardens, it is very difficult to separate them. The name muégano is also used with a social connotation to name a conglomerate of two or more people united by a strong bond.

The concept of muéganos can be applied in the repair process so that the patterns can be nested as much as possible and be arranged in a structure. Each muégano represents a list of items that have adjacent neighboring pixels; this means that if two items are joined by a limited number of pixels, then a muégano has been formed.

The Flood Fill Algorithm 2 was applied to detect the muéganos.The algorithm receives an image containing the repaired solutions. When it finds a contiguous pixel between items, those are labeled with a gray level.

Algorithm 2: Flood Fill Algorithm

Once the image contains the items labeled with a gray level, the process of selecting the best muéganos is performed. Two fundamental conditions are considered for the selection of the muéganos:

1.

Two or more items have contiguous pixels.

2.

There is a limit of contiguous pixels between two items.

Contiguous pixels are adjacent pixels between neighboring item borders. If there are more adjacent pixels between items, there is less wastage.

A data structure containing the information of each muégano was implemented, in other words, the number of items contained in each muégano as shown in Figure 6.

Figure 6. Muégano structure. Each muégano is a list of the contained items. The number of items depends on the largest number of adjacent pixels between edges of neighboring items.

An example of muégano formation is shown in Figure 7.

Figure 7. Sample nesting results. Inside of the red ellipse: example of muégano formed by two items. Each item has a different gray level.

2.6. Sequential Greedy Algorithm

Once the muéganos are generated, a sequential greedy algorithm (SGA) is implemented to fill the area of the material that has not been used. Figure 8 shows the flow diagram of the SGA. Items and muéganos are randomly selected and nested avoiding overlaps between them, until there is no more space in the material.

Figure 8. Flow diagram of the greedy sequential algorithm to fill the area of the unused material. The random item is selected, and its position is generated. If the item is non-overlapped with another one, it is placed. The process is looped while there is available space in the material.

3. Experimental Results

This section shows the results obtained by applying the techniques explained above. The term $wast{e}_m$ in Equation (5) was used to obtain the wastage in square meters (m²) of the resulting images. The standard deviation was calculated to measure the precision according to the value obtained for the waste in the same image by repeatedly calculating the term $wast{e}_m$.

In this research, materials obtained from a leather-footwear factory were utilized, including cowhide leather material and boot-type footwear patterns. These materials were processed following the arrangement outlined in the “Calculation of waste in metric values” Section 2.2, to obtain their real and pixel sizes. Subsequently, the procedure described in the “Methodology” Section 2 was employed to generate the results presented in this section.

The results were obtained using 60 muéganos in the solutions. The quantity of muéganos is equivalent to 120 items, which were used to form the solutions in the results obtained without muéganos. Table 4 and Table 5 show the results of twenty runs with and without muéganos, respectively. Each run represents a solution obtained by nesting the items on the material. The columns specify the percentage of wastage and its equivalent in m², the execution time, and the admissible orientations for each item.

Table 4. Results obtained without Muéganos.

Runs	Waste (%)	Waste in m2	Time	Admissible Orientations
1	$31.2$	$0.4919$	$303.44$	$0°,120°,240°$
2	$30.77$	$0.4850$	$256.16$	$0°,120°,240°$
3	$30.58$	$0.4819$	$319.21$	$0°,120°,240°$
4	$30.58$	$0.4822$	$273.84$	$0°,120°,240°$
5	$30.98$	$0.4883$	$250.34$	$0°,120°,240°$
6	$31.29$	$0.4932$	$250.85$	$0°,120°,240°$
7	$30.62$	$0.4825$	$277.82$	$0°,120°,240°$
8	$30.87$	$0.4866$	$260.68$	$0°,120°,240°$
9	$31.1$	$0.4902$	$278.54$	$0°,120°,240°$
10	$30.27$	$0.4771$	$270.62$	$0°,120°,240°$
11	$31.14$	$0.4911$	$258.51$	$0°,120°,240°$
12	$30.64$	$0.4832$	$250.64$	$0°,120°,240°$
13	$30.94$	$0.4878$	$295.93$	$0°,120°,240°$
14	$30.4$	$0.4794$	$261.95$	$0°,120°,240°$
15	$30.65$	$0.4833$	$285.84$	$0°,120°,240°$
16	$31.58$	$0.4978$	$252.58$	$0°,120°,240°$
17	$30.74$	$0.4847$	$294.69$	$0°,120°,240°$
18	$30.93$	$0.4875$	$280.09$	$0°,120°,240°$
19	$31.1$	$0.4904$	$319.71$	$0°,120°,240°$
20	$30.69$	$0.4835$	$329.71$	$0°,120°,240°$
Average	$30.85$	$0.4863$	$278.55$

Table 5. Results obtained with Muéganos.

Runs	Waste (%)	Waste in m2	Time	Admissible Orientations
1	28.64	0.4513	339.52	$0°,120°,240°$
2	28.73	0.4528	380.47	$0°,120°,240°$
3	29.36	0.4628	290	$0°,120°,240°$
4	29.52	0.4654	275.48	$0°,120°,240°$
5	29.21	0.4605	264.16	$0°,120°,240°$
6	28.82	0.4593	315.52	$0°,120°,240°$
7	28.4	0.4480	321.24	$0°,120°,240°$
8	28.76	0.4536	306.85	$0°,120°,240°$
9	28.63	0.4515	282.33	$0°,120°,240°$
10	28.49	0.4494	359.65	$0°,120°,240°$
11	28.89	0.4556	290.64	$0°,120°,240°$
12	28.9	0.4554	303.83	$0°,120°,240°$
13	28.99	0.4567	268.73	$0°,120°,240°$
14	29.23	0.4607	274.65	$0°,120°,240°$
15	29.2	0.4602	318.56	$0°,120°,240°$
16	28.5	0.4492	291.57	$0°,120°,240°$
17	28.79	0.4537	282.16	$0°,120°,240°$
18	29.11	0.4588	305.44	$0°,120°,240°$
19	29.21	0.4605	308.56	$0°,120°,240°$
20	28.8	0.4539	324.28	$0°,120°,240°$
Average	$28.909$	$0.4559$	$305.82$

Figure 9 represents a comparison for the waste value between the solutions with and without muéganos. It is essential to mention that the worst solution with muéganos achieves a lower wastage than the best solution without them. This proposed method improves the solution and reduces waste.

Figure 9. Comparison of waste between the results obtained with and without muéganos. The blue box-and-whisker plot shows a better improvement of the waste over the non-muéganos box-and-whisker plot. The mean of the results using muéganos is around $28.9\%$.

Figure 10 illustrates the execution time, comparing the solutions with and without muéganos. Since they are formed by more compact items, it takes longer to place them in the material as it seeks for a larger area to perform the arrangement. However, this compensates for the fact that the waste is reduced.

Figure 10. Comparison of time between the results obtained with and without muéganos. The blue box-and-whisker plot shows a greater spread of computational time cost, and the mean of the results is around 305 s due to the size of the muéganos structure. However, it is compensated by reduced waste.

Figure 11 shows the obtained results without and with muéganos, respectively. Figure 11a shows the items placed randomly, which results in less compactness between them when nesting. The execution time of the solution was 260.68 s. Figure 11b illustrates a higher compaction between two items contained in the muégano, with an execution time of $306.85$ s.

Figure 11. Nesting results obtained (a) without muéganos, and (b) with muéganos. The result obtained from muéganos and item nesting generates less waste than the non-muéganos solution due to the minimum separation between items inside the muéganos structure.

Comparisons with Other Research

Some comparisons were made with other methods proposed in the literature. In [4], they used a greedy algorithm with a bottom-left strategy to placed the items obtaining an efficiency of $81.54\%$. In this work the concept of muéganos was applied to find the solution obtained with an efficiency of $82.11\%$ as shown in Figure 12a. In [30], a separation and compaction algorithm using a fast obstruction map local search (FOMLS) was developed to solve a rectangular packing problem (RPP) using fixed-ratio compaction. They obtained an efficiency of $68.31\%$, which, compared to the result of this research using the muéganos, obtained an improvement with $69.09\%$ efficiency. Figure 12b shows our result. In [27], calculating with BRKGA70 for the instances with circles obtained an efficiency of $73.32\%$. In our case, we performed some runs with the same patterns on a finite material obtaining $74.65\%$ efficiency, as shown in Figure 12c.

Figure 12. Results obtained by our method using state-of-the-art patterns. We used (a) the items from [4], (b) from [30], and (c) from [27] to compare the waste and efficiency.

Table 6 displays the comparative results of our work against other methods. The three initial columns present references and values of efficiency and waste obtained from the reported methods. The final two columns exhibit outcomes from the proposed method in this study, derived through item utilization from the compared methods.

Table 6. Comparative results with the state-of-the-art.

Method and Reference	Waste (%)	Efficiency (%)	Waste (%) Repair Method (Ours)	Efficiency (%) Repair Method (Ours)
MIP [4]	$18.46$	$81.54$	$17.89$	$\mathbf{82}.\mathbf{11}$
BRKGA70 [27]	$26.68$	$73.32$	$25.35$	$\mathbf{74}.\mathbf{65}$
FOMLS|RPP [30]	$31.68$	$68.31$	$30.91$	$\mathbf{69}.\mathbf{09}$

4. Discussion and Future Work

This paper proposes a strategy to repair solutions obtained with overlaps using metaheuristics, which provides an excellent alternative to solve the nesting problem and allows an improved matching process. The muéganos structure aims to compact the items to reduce waste, and this work demonstrates that feasible solutions are obtained to compete with the results achieved in previous research. It is important to mention that the repair process and the muéganos can be applied to any solution to solve the nesting problem, as long as there is an overlap in any solution.

The method proposed in this research is applied to real problems in industries such as the leather-footwear industry, where waste reduction is crucial for optimal material utilization. Many companies still manually conduct nesting processes, relying on operator expertise, impacting time and material waste. Automation of the nesting process is vital for efficiency. Specialized companies have provided us with the required materials (including leather material and footwear patterns) to conduct real-size testing. Additionally, we established an arrangement within the factory to capture images of the materials, facilitating the subsequent calibration and image digitization processes.

The proposed method offers a significant advantage in automating the nesting process within these industries, leading to decreased material waste and increased efficiency. Although this method has advantages over other reported ones, it has certain limitations, but working on these can lead to even better results. For example, time production is a important factor in the industry when working in real-time, and this improvement could make the algorithm more efficient. In future work, the time factor will be improved by using parallel programming with threads in the implementation of the algorithm. Additionally, it is convenient to keep a count of all the items needed to complete the manufacturing process depending on the type of industry in which the algorithm is applied.

To further improve results, it is necessary to work on determining the quality of the skin to give an adequate positioning to each item. The skin segmentation is by type of cut, since each item must have a certain elasticity, and therefore must be placed in a suitable orientation angle. Another future work is to calculate the efficiency of wastage by muéganos to provide solutions with the least possible waste. Finally, a further improvement will be to achieve the formation of muéganos per production unit; for example, if a shoe needs five items for its manufacture, then the muéganos should contain these five items.