Optimization Algorithm for Cutting Masonry with a Robotic Saw

Featured Application

The results of this research can be applied to a robotic bricklaying process to optimize the cutting of ceramic masonry blocks. The optimal cutting scheme serves as an initial input for a robotic saw and its operations.

Abstract

The contribution of this study is in the novel application of the bin packing algorithm that is used to optimize the robotic bricklaying process with the aim of minimizing the wearing of a robotic saw used for splitting brick blocks so as to minimize brick consumption. To optimize the cutting of masonry blocks with a robotic saw, a new bin packing algorithm has been developed to enhance the design of a digital cutting plan. The algorithm is based on the principle of random search for all combinations of cutting execution with respect to the maximum number of objects (cuts) found in one container (masonry block). The new bin packing algorithm (NBPA) minimizes the number of total masonry blocks (containers) and the number of cuts made with a robotic saw, thus reducing the cutting length. The algorithm can converge to a solution rather quickly and reliably to identify optimal variants of a digital plan designed for a robotic saw to be used in different object assemblies. This article describes the optimization algorithm, including step-by-step calculations, and provides a practical example and a comparison of the results with earlier algorithms. The concept of the robotic saw is also presented in detail, including a description of a prototype. The simulation of the performance on 20 different sets of elements showed that NBPA has a similar use of space compared to the First-Fit Decreasing algorithm (FFD). Multicriteria analysis demonstrated that when the weighting criterion for saw wear was 40% of all the criteria, the use of NBPA was approximately 3.5 times more effective than FFD. The application of the new methodology to a robotic bricklaying process has the potential to reduce the wear of robotic saw, to increase the speed of the construction process and to reduce the generation of construction and demolition waste (CDW).

1. Introduction

Global efforts to reduce the consumption of raw materials obtained from non-renewable sources also apply to the materials used in the building industry [1,2]. Generally, the building industry is responsible for around 30–50% of the waste production in developed countries [3,4,5]. It is therefore necessary to advance strategies to reduce the quantity of construction and demolition waste (CDW). Furthermore, the price of building materials has increased by an average of 35–50% over the last decade, so there is also a need to develop operations supporting cost efficiency in construction processes, namely, through improved material handling [6,7,8]. Fired clay bricks (FCBs) are a dominant building material worldwide due to their low cost and ease of production, as shown by Olsson [9].

One of the most promising strategies to address environmental and economic challenges in the building industry is the digitization of building life cycles [10,11,12]. On construction sites, digitization is introduced by the utilization of robots, which is why robotic construction technologies have developed very rapidly in the last decade [13,14,15].

In the current construction industry, ceramic brick walls are laid using standardized brick blocks. The dimension of these blocks is based on the module given by the manufacturer. The most common module is 250 mm, 375 mm or 500 mm [16,17]. Brick manufacturers offer additional types of blocks for each module. This allows the walls to be connected while keeping the module intact. No extra cutting of the blocks is needed on-site. These extra blocks are usually half blocks, end blocks and corner blocks [18]. If the walls of a building are not designed with respect to the module of the brick block, it is necessary to insert custom brick sections made by cutting modular brick blocks into pieces as a supplement to the modular blocks. The production of these offcuts reduces process efficiency and generates pieces that, in many cases, cannot be further used due to their size and end up as CDW. The utilization of robots in the field of bricklaying holds considerable potential for enhancing the efficiency and safety of wall construction. The existing reference studies have primarily focused on the optimization of the bricklaying process itself, with a focus on the optimization time, cost and energy savings [19]. However, the integration of robotic saws into the robotic process is crucial for the construction of walls involving non-standard block cutoffs. To the best of our knowledge, no reference study has hitherto been found that focuses on the optimization of the bricklaying process with the aim of reducing the number of cutoffs and wear of a robotic saw. Also, no reference study has been found that describes the use of bin packing algorithms in the bricklaying process to optimise the use of bricks. The development of a novel methodology to address the optimization of robotic brick cutting, with the objective of reducing the consumption of bricks and reducing the rate of wear of the robotic saw, would enhance the efficiency of robotic bricklaying and facilitate the dissemination of this technology to construction sites.

A promising potential to reduce CDW lies in the optimization algorithms that can be effectively implemented in construction processes focused on on-site material handling.

The research paper presented here describes a mathematical model determining an optimal masonry cutting plan used as an input for the operation of a robotic saw. The newly developed packing algorithm that optimizes masonry cutting and the operations of a robotic saw can determine an enhanced plan of masonry cuts and the number of necessary operations in the entire laying plan [19] of the Building Information Model (BIM). The employment of packing algorithms in the field of robotic bricklaying was previously restricted to the optimization of brick packing in order to completely fill the designed walls. Up to now, a number of research works have described effective packing algorithms [20,21], but these works were generally focused on other applications. The already existing packing algorithms [22,23] cannot work with additional parameters, such as the number of cuts or the minimal size of residual masonry. The main reason for the creation of our model is the effort to reduce, to a minimum, the amount of CDW resulting from the cutting of masonry.

During this research work, namely, owing to the global absence of a suitable mathematical method, it was necessary to develop a new packing algorithm that would take into account not only the minimization of whole masonry elements but also the minimization of the necessary number of cuts made with a robotic saw in order to reduce wear and tear on the saw cutting surface [24] and to speed up the entire construction and technological process of brickwork laying.

The structure of the following text of this paper is organized into four sections and two appendixes. In Section 2, the optimization problem is analysed, and a new bin packing algorithm is suggested. In Section 3, the results are presented, and the performance of the suggested algorithm is evaluated using multicriteria analysis. Finally, Section 4 synthesises the conclusions of this paper and outlines potential future research directions. Appendix A contains a pseudocode of the optimization algorithm for cutting masonry with a robotic saw. Appendix B presents data simulation for comparative analysis, the results of the simulation and comparison and multicriteria analysis of the new bin packing algorithm and the First-Fit Decreasing algorithm.

2. Materials and Methods

Two main objectives were addressed in this study. The first objective is to limit the wear of a cutting saw used for the splitting of brick blocks. The second objective is to minimize the number of brick blocks for the given geometry of the walls to be fully filled. The working principle of the mathematical model for the optimal design of masonry cuts is schematically illustrated by a flow chart, which can be seen in Figure 1. The diagram is divided into segments of inputs and outputs of the mathematical computational model or a digital bricklaying plan [19].

The first input involves a digital bricklaying plan of load-bearing and non-load-bearing wall blocks for different BIM objects. The plan is created with special software for bricklaying robots [19] after converting BIM objects [25] and their following export to a standard IFC format [26].

The second input is a database of masonry elements. The database provides brick specifications, such as the size and physical and mathematical parameters of masonry elements, as provided by manufacturers of building masonry systems. The digital laying plan of a building depends on the choice of specific masonry elements creating load-bearing and non-load-bearing walls. The choice of masonry can be made in the software for robotic bricklaying [19], which contains an extensive database of masonry systems and their relevant technical data and properties. If the building or facility is not modelled in a basic building module [26,27], a certain number of cuts needs to be processed according to the parameters of the third input into the model—the robotic saw module.

The mathematical core of the model is based on an algorithm, which is described in detail in the following section. The output of the model contains the lists of cuts, optimal compositions of cut assemblies, the number of masonry elements, waste pieces and the distribution of elements on a pallet for bricklaying processes (the mask on the pallet). After the cutting steps are implemented according to the output of the algorithm, the masonry elements are stacked in a specific order and at certain positions by the robotic bricklaying assembly needed for further technological bricklaying processes.

One can define a mathematical problem as an optimization problem of finding the best solution from all feasible solutions. To optimize the cutting, an optimization problem was solved with the aim of minimizing the total amount of masonry elements and reducing CDW. The number of cuts should also be minimized to reduce the operation time of the robotic saw and to limit the wear and tear of its cutting plate.

The optimization problem can be converted to the classical problem of packing algorithms (bin packing problem) [27,28]. The class of packing problems in a container is described as an NP-hard (nondeterministic polynomial time/NP-hard) combinatorics task [29]. A number of mathematical algorithms exist that are capable of approximately solving this problem for various application methods, e.g., 2D packing, line packing, packing by weight and packing by value. The whole problem is focused on packing certain objects into containers of the same size in such a way that the total number of containers is minimized. The task is NP-hard (strong NP-completeness) [29], and the use of an exact solution using a search algorithm (brute force solution) is possible only for a small number of objects. The time requirement grows exponentially with the use of limiting conditions (e.g., the maximum number of objects in a container) or even factorially. Usually, approximate heuristic algorithms are applied to solve such tasks, e.g., Next-Fit (NF), First-Fit (FF), Best-Fit (BF), First-Fit Decreasing (FFD), Harmonic-k, etc. [30], and each algorithm has its own estimate of solution accuracy and time requirements.

The specifics of employing a robotic saw to cut masonry elements assume certain simplifications and several special conditions. In modular masonry, a limited set of cut objects is used, each with several repetitions. It was necessary to add other minimization parameters (number of cuts, size of loss residues) into our model. However, none of the exploited mathematical algorithms brought a reliable and optimal solution in a reasonable amount of time [29,30,31]. Therefore, it was decided to develop an algorithm for optimizing the cutting of masonry elements in 1D space, as detailed in the following parts of this article, together with an example of application and comparison with the existing methods.

The size of a masonry element $V\left[\mathrm{m}\mathrm{m}\right]$ is expressed as:

$$V=L·W·H,$$

(1)

where $L\left[\mathrm{m}\mathrm{m}\right]$ is the length of the element, $W\left[\mathrm{m}\mathrm{m}\right]$ is the width of the element and $H\left[\mathrm{m}\mathrm{m}\right]$ is the height of the element.

The size of a masonry element is predetermined and constant, which the algorithm describes as the size of a container. The cut parts of masonry elements have the same height and width as the whole element in question. They only differ in the length of $a_1,\dots ,a_n$, where $n$ designates the number of objects. The optimization problem can be converted to a 1D space problem, where the size of the container is taken as its length $L,$ for which the following condition applies:

$$L\le {\sum }_{i\in S_k}{a}_i\forall k=1,\dots ,B,$$

(2)

where $B$ is the number of containers (the entire masonry element) and $S$ is a subset of objects (cuts). The task is to identify the splitting of a set $\left\{1,\dots ,n\right\}$ into a $B$ subset $S_1\cup \dots \cup S_B$ for which condition (2) applies. The minimum number of subsets is the optimal solution of the problem:

$$\min B=OPT,$$

(3)

Minimizing and constraining conditions for a robotic saw can be formulated as follows:

• The number of whole masonry elements is minimal: $B={\sum }_{i=1}^n{y}_i$, where $y_i=1$ for the containers used.
• The condition of the minimal number of cuttings $T$ can be formulated as minimizing the number of wasted pieces: $W={\sum }_{i=1}^n{w}_i$, where $w_i=1$ for containers with unused space. A fully filled container reduces the number of cuts by 1.
• Other constraints can be formulated as:

  $$\sum _{j=1}^n{a}_i{·x}_{ij}\le L{·y}_i,$$

  where $y_i\in \left\{0,1\right\},x_{ij}\in \left\{0,1\right\},\forall i\in \left\{1,\dots ,n\right\},\mathrm{a}\mathrm{n}\mathrm{d} \forall j\in \left\{1,\dots ,n\right\}$.

  $$\sum _{i=1}^n{x}_{ij}=1,$$

  where $x_{ij}\in \left\{0,1\right\},\forall i\in \left\{1,\dots ,n\right\},\mathrm{a}\mathrm{n}\mathrm{d} \forall j\in \left\{1,\dots ,n\right\}$.

Object $j$ is placed in container $i$ if $y_i=1$ for the used containers and $x_{ij}=1$ [32].

To optimize the number of cuttings of masonry elements, we must apply certain simplifications to our problem. The minimal possible length of the cuts defines the maximal possible number of objects in container $N$. This value is limited from above by technological processes of cutting the masonry elements, which significantly reduces the difficulty of finding the optimal solution:

$$\max N=⌈{\displaystyle \frac{L}{\min a_i}}⌉,\forall \mathrm{i}\in \left\{1,\dots ,\mathrm{n}\right\},$$

(4)

The technological processes of robotic masonry cutting are considered:

$$\min a_i\ge 50 \mathrm{m}\mathrm{m},$$

(5)

According to their length, cut objects can be classified into smaller groups. The lower and upper limits of the number of containers can be applied as constraints to our problem:

$$OPT·L\le {\sum }_{t=1}^s{m}_t{·a}_t\le n·L,$$

(6)

where $n$ is the number of objects, $m_t$ is the number of elements in group $t$, $a_t$ is the size of elements in group $t$ and $s$ is the maximum number of groups. The number of groups and elements found in each group is not limited by the algorithm. However, larger numbers of groups negatively affect the calculation time [33]. On the other hand, smaller numbers of groups negatively affect the accuracy of the algorithm. For the optimal solution, the developed algorithm must have optimal parameters:

$$m_t>5\wedge s<10$$

In the following section, several steps of the algorithm for optimizing masonry cutting with a robotic saw are described in more detail.

Step 1: Algorithm inputs and calculation of task parameters.

• ${\sum }_{t=1}^s{m}_t{·a}_t$—array of objects to pack into container ($m$ is the number of elements in a group t, $a$ is the size of an element).
• $L$—container size.
• $\max N=⌈{\displaystyle \frac{L}{\min a_i}}⌉$—maximum possible number of objects in container.

Step 2: Preparing the array of objects for first iteration.

• Listing the array of elements in the form: $A={\sum }_{i=1}^s{\sum }_{j=1}^{m_i}{a}_i$.
• Random ordering of elements in the array: $R={\sum }_{i=1}^n{r}_i$.
• Copying the first $e$ elements to the work area: $M={\sum }_{i=1}^e{r}_i$.

Note that the parameter $e$ specifies the number of first elements of a variant (each variant is a randomly serialized set). For each iteration, the elements are randomized, and the first $e$ elements at the beginning of each set are selected. The size of parameter $e$ affects the complexity and accuracy of the calculation (see

Table 1. Comparison of the time and accuracy of the algorithm for different parameters $e$.

e	Number of Containers	Number of Groups	Number of Cuts	Unused Space, [mm]	Time, [s]	Total Usage, [%]
1	50	4	50	16,500	0.003076	34.000%
2	26	8	49	4500	0.002287	65.385%
3	21	9	48	2000	0.003186	80.952%
4	19	9	42	1000	0.006804	89.474%
5	19	8	40	1000	0.023867	89.474%
6	18	6	38	500	0.077412	94.444%
7	18	6	38	500	0.214188	94.444%
8	18	6	38	500	0.530642	94.444%
9	18	6	38	500	1.135994	94.444%
10	18	6	38	500	2.128886	94.444%
11	18	5	38	500	3.856181	94.444%
12	18	5	38	500	6.596284	94.444%
13	18	5	38	500	10.123138	94.444%
14	18	5	38	500	16.274853	94.444%
15	18	5	38	500	26.315432	94.444%
16	18	5	38	500	31.709445	94.444%
17	18	5	38	500	44.169316	94.444%
18	18	5	38	500	70.867784	94.444%
19	18	5	38	500	92.810268	94.444%
20	18	5	38	500	124.552543	94.444%

).

Step 3: List of all admissible container combinations for array M.

• Each container combination $K_i$ must meet the condition:

  $${\sum }_{i=1}^k{a}_i\le L,$$

  (7)

  where $k$ is the number of objects in a container assembly.
• Used space $F_i$ and unused space $U_i$ are calculated for each container combination.
• Container combination $K_i$ is sorted into an array according to increasing unused space $U_i$.
• The combination containing a smaller number of elements $n_i$ with the same unused space receives negative penalty points and is placed lower in order.
• The best combination $K_{opt}$ is determined by the condition for the best variant:

  $$L-U_{opt}>\min (R\setminus M),$$

  (8)
• Step 2 is repeated. To converge the algorithm successfully, the iteration must be performed at most $\left(n-w\right)$ times.

Step 4: Filling container $j$ according to optimal variant $K_{opt}$.

• Container $j$ is filled:

  $${\sum }_{i=1}^{n_j}{a}_i=F_j,$$

  where $F_j$ is the used space of the container.
• Unused space $U_j$ of the container is calculated: $U_j=L-F_j$.
• The array of element $A$ is reduced by the elements occupied in the optimal container: $A=A\setminus a_i,i\in \left\{1,\dots ,n_j\right\}$.
• Steps 2 to 4 are repeated for $A\ne \mathrm{\varnothing }$.

Step 5: Listing containers $K_{opt}$ and calculating the parameters of the packing algorithm.

• Total used space: $F_t={\sum }_{i=1}^{OPT}{F}_i$, where $OPT$ is the optimal number of containers (maximization problem).
• Unused total space (CDW): $U_t={\sum }_{i=1}^{OPT}{U}_i$, where $OPT$ is the optimal number of containers (minimization problems).
• The total number of cuts $T_t$ for the entire set of elements (minimization problems).
• The container combination $K_t$ (minimization problems).

Step 6: Multi-objective optimization (multiple-criteria decision making).

• The multi-objective optimization problem can be formulated as:

  $$\min ({-F}_t,U_t,T_t,\mathrm{K})$$

  (9)
• Multicriteria analysis is performed by assigning a weight to each criterion.
• List optimal containers K_opt.

Appendix A contains a pseudocode of the optimization algorithm for cutting masonry with a robotic saw. The core of the new bin packing algorithm is programmed in the language PHP 8.3.15 [34]. PHP is a general-purpose scripting language for web development. However, it can also be used to solve mathematical problems for better implementation in online forms with a powerful modern math library [35]. The source code is available in [36]. The following section provides a practical example of the algorithm and comparison of the results with other algorithms.

3. Results

The experimental results of the suggested bin packing algorithm were applied on an example task for robotic bricklaying in the robotic saw module. According to the digital bricklaying plan [19], it was necessary to prepare additional sets of cuts: 300 mm × 10 pieces, 250 mm × 5 pieces, 150 mm × 15 pieces and 100 mm × 20 pieces. The length of the masonry element is 500 mm. The visualization of the construction can be seen in Figure 2.

The robotic saw is designed to cut given masonry elements according to a building layout plan and a mathematical calculation model. The saw used to test the robotic system (see Figure 3) consists of a CCE400 construction saw [37] (1) and accessories for automatic saw operation. Pneumatic valves (2) are applied to control table movements and the pressure of the masonry element exerted on the table. The table movements (3) are driven by a pneumatic cylinder, which is attached to the saw frame. The pressure is ensured by a set of pressure arms with hard rubber (4) for better contact with masonry elements. The pressure arms are on a linear rail and the force is exerted by a pneumatic valve. The robotic saw is able to cut all standard masonry elements.

The total number of cuts is $n=50,$ and the cuts fulfil condition (5). The maximum possible number of cuts from one masonry element is $\max N=5.$ For $e=11$, the optimal set of containers according to the iteration steps can be found (see

Table 2. Optimal masonry cutting for parameter $e=11$.

Iteration	Combination	Number of Cuts	Used Part, [mm]	Unused Snippet, [mm]	Container Usage, [%]	Time, [s]
1	300 + 150	2	450	50	90%	0.287428
2	250 + 150 + 100	2	500	0	100%	0.246005
3	300 + 100 + 100	2	500	0	100%	0.269982
4	300 + 100 + 100	2	500	0	100%	0.264411
5	250 + 150 + 100	2	500	0	100%	0.254247
6	250 + 150 + 100	2	500	0	100%	0.265522
7	300 + 100 + 100	2	500	0	100%	0.255779
8	250 + 150 + 100	2	500	0	100%	0.260728
9	300 + 100 + 100	2	500	0	100%	0.266978
10	300 + 100 + 100	2	500	0	100%	0.258111
11	250 + 150 + 100	2	500	0	100%	0.276104
12	300 + 100 + 100	2	500	0	100%	0.259949
13	300 + 100 + 100	2	500	0	100%	0.257400
14	300 + 150	2	450	50	90%	0.257507
15	300 + 150	2	450	50	90%	0.141309
16	150 + 150 + 150	3	450	50	90%	0.033435
17	150 + 150 + 150	3	450	50	90%	0.000960
18	150 + 100	2	250	250	50%	0.000041
w = 18	Combinations: 5	38	8500	500	94.444%	3.856181

). At the end of Table 2, a summary of the algorithm is shown. As can be seen there, the algorithm identified the optimal set of cuttings with the total usage of construction masonry materials of 94.444%.

The algorithm shows very fast convergence and reliable results for $e=6$. The computational time increases exponentially, as demonstrated in Figure 4.

The computation time corresponds to the amount of variants for the decomposition of an integer number into up to N smaller numbers [38]:

$$C_n^m={\displaystyle \frac{n!}{m!\left(n-m\right)!}},$$

(10)

where $n$ is the number of all objects and $m=\max N$ is the maximum number of objects in one container. For the example provided, the number of variants is equal to $C_n^m={\displaystyle \frac{50!}{5!\left(50-5\right)!}}=\mathrm{2,118,760}$ combinations. After applying the constraints and conditions, the number of acceptable combinations is reduced to 144.

Figure 5 shows charts of the dependence of other algorithm outputs on random selection parameter $e$.

Table 3. Comparison of the efficiency of developed algorithm with other packing algorithms.

Parameters	New Bin Packing Algorithm	Next-Fit Decreasing	First-Fit Decreasing	Worst-Fit Decreasing	Best-Fit Decreasing
Total usage, [%]	94.44%	77.27%	89.474%	89.474%	89.474%
Number of containers, [-]	18	22	19	19	19
Number of cuts, [-]	38	44	43	44	44
Unused space, [mm]	500	2500	1000	1000	1000

compares the results of packing methods for the identical example. Several algorithms, often used in practical instances of packing objects into containers, are included in the analysis [39]. The quality of the bin packing algorithms was tested online with [40].

Appendix B contains the data (

Table A1. Simulate data for comparative analysis.

ID	Elements	Container, [mm]	Min Cut, [mm]	Total Combs	Set of Elements (Size [mm], Number)
1	426	500	100	121	(480, 70), (360, 20), (320, 72), (290, 95), (250, 9), (150, 73), (130, 34), (120, 1), (110, 27), (100, 25)
2	529	500	100	65	(450, 76), (440, 82), (380, 85), (300, 13), (260, 24), (210, 16), (170, 94), (160, 36), (140, 4), (110, 99)
3	616	500	100	15	(470, 78), (450, 70), (380, 33), (370, 60), (350, 23), (330, 85), (300, 11), (270, 89), (240, 92), (180, 75)
4	455	500	100	34	(470, 52), (460, 9), (430, 70), (390, 83), (350, 38), (320, 26), (280, 12), (270, 33), (130, 90), (100, 42)
5	556	500	100	39	(420, 23), (390, 69), (370, 77), (320, 7), (290, 79), (260, 94), (220, 56), (180, 83), (160, 51), (140, 17)
6	591	500	100	46	(480, 61), (360, 2), (310, 63), (280, 91), (270, 54), (250, 75), (240, 63), (190, 20), (180, 75), (110, 87)
7	582	500	100	24	(400, 35), (390, 88), (360, 69), (340, 79), (300, 80), (270, 44), (260, 64), (230, 1), (210, 95), (150, 27)
8	621	500	100	48	(480, 97), (460, 80), (430, 34), (300, 76), (290, 80), (250, 86), (200, 30), (180, 98), (150, 25), (110, 15)
9	291	500	100	25	(490, 33), (470, 42), (460, 43), (330, 13), (320, 35), (280, 35), (270, 48), (190, 25), (180, 15), (170, 2)
10	533	500	100	62	(480, 59), (470, 70), (430, 43), (400, 10), (310, 19), (250, 79), (180, 45), (160, 100), (120, 64), (100, 44)
11	536	600	200	26	(560, 25), (520, 64), (440, 75), (420, 32), (350, 43), (340, 76), (270, 72), (250, 74), (230, 43), (210, 32)
12	575	600	200	21	(580, 94), (480, 14), (400, 87), (370, 47), (360, 85), (350, 73), (330, 4), (300, 23), (250, 98), (240, 50)
13	529	600	200	13	(560, 26), (550, 72), (540, 54), (510, 48), (490, 53), (480, 33), (430, 65), (390, 40), (270, 65), (250, 73)
14	548	600	100	84	(540, 8), (460, 89), (440, 32), (350, 19), (300, 99), (270, 63), (250, 90), (190, 76), (140, 9), (100, 63)
15	483	600	100	71	(590, 34), (580, 47), (540, 38), (510, 13), (420, 18), (350, 100), (220, 52), (160, 85), (140, 17), (100, 79)
16	352	400	50	186	(360, 22), (330, 26), (320, 39), (230, 1), (190, 24), (160, 100), (120, 53), (110, 27), (60, 35), (50, 25)
17	380	400	50	130	(390, 14), (370, 76), (330, 29), (300, 25), (260, 37), (180, 33), (130, 8), (110, 20), (70, 40), (50, 98)
18	446	400	50	49	(380, 87), (350, 99), (310, 37), (270, 1), (260, 44), (250, 62), (220, 21), (140, 58), (110, 14), (70, 23)
19	387	400	100	25	(340, 53), (310, 20), (300, 48), (290, 9), (270, 18), (250, 28), (240, 30), (230, 40), (130, 51), (120, 90)
20	612	400	100	13	(370, 63), (330, 86), (310, 92), (280, 57), (270, 51), (260, 76), (250, 96), (240, 15), (200, 8), (190, 68)

) and the results of the simulation and comparison (

Table A2. The results of the simulation and comparison.

ID	New Bin Packing Algorithm					First-Fit Decreasing Algorithm
	Containers	Cuts	Combs	Usage	Unused Space, [mm]	Containers	Cuts	Combs	Usage	Unused Space, [mm]
1	273	393	12	83.96%	21,900	262	397	11	87.48%	16,400
2	340	469	10	87.81%	20,730	321	492	10	93.00%	11,230
3	495	616	10	81.58%	45,590	495	616	10	81.58%	45,590
4	324	421	11	86.94%	21,160	323	455	10	87.21%	20,660
5	383	515	12	79.61%	39,050	358	549	11	85.17%	26,550
6	340	491	12	88.43%	19,670	340	492	12	88.43%	19,670
7	459	581	10	77.02%	52,730	459	581	10	77.02%	52,730
8	425	548	11	91.54%	17,980	413	548	10	94.20%	11,980
9	249	274	10	81.71%	22,770	249	274	10	81.71%	22,770
10	311	423	13	93.59%	9970	307	477	15	94.81%	7970
11	366	493	10	86.14%	30,440	366	493	10	86.14%	30,440
12	426	441	11	83.84%	41,300	426	441	11	83.84%	41,300
13	460	529	11	82.95%	47,040	460	529	11	82.95%	47,040
14	295	431	14	88.81%	19,800	290	471	12	90.34%	16,800
15	295	438	11	86.07%	24,650	273	472	13	93.01%	11,450
16	177	300	17	88.21%	8350	176	351	11	88.71%	7950
17	212	309	14	90.98%	7650	204	331	11	94.54%	4450
18	352	389	11	86.85%	18,520	351	402	10	87.09%	18,120
19	267	369	11	81.39%	19,880	255	369	11	85.22%	15,080
20	501	535	9	76.71%	46,680	574	608	10	74.83%	57,780

and

Table A3. Multicriteria analysis of the new bin packing algorithm and the First-Fit Decreasing algorithm.

ID	Weight Set 1			Weight Set 2
	Score NBPA	Score FFD	Diff	Score NBPA	Score FFD	Diff
1	54.43	55.92	−1.50	46.64	47.46	−0.82
2	54.87	55.98	−1.11	48.44	47.58	0.85
3	33.64	33.64	0.00	26.91	26.91	0.00
4	47.71	46.70	1.01	41.16	37.36	3.80
5	46.83	48.46	−1.63	40.42	39.27	1.15
6	55.43	55.39	0.04	51.11	51.01	0.10
7	39.17	39.17	0.00	31.40	31.40	0.00
8	52.98	54.65	−1.67	47.09	48.42	−1.33
9	40.50	40.50	0.00	34.73	34.73	0.00
10	58.73	55.88	2.85	55.24	48.91	6.33
11	46.85	46.85	0.00	40.69	40.69	0.00
12	45.17	45.17	0.00	45.46	45.46	0.00
13	27.84	27.84	0.00	22.28	22.28	0.00
14	59.92	59.30	0.62	56.47	53.06	3.41
15	54.71	55.11	−0.41	47.49	45.00	2.49
16	60.89	58.27	2.62	54.62	46.73	7.89
17	60.78	61.32	−0.55	56.09	54.22	1.88
18	49.56	49.46	0.10	44.76	43.52	1.25
19	43.26	44.99	−1.73	36.47	37.86	−1.39
20	34.55	26.19	8.36	32.67	21.22	11.46
	7	7		11	3

¹ Weights: containers (25%), combinations (25%), cuts (25%), unused space (25%). ² Weights: containers (20%), combinations (20%), cuts (40%), unused space (20%).

) of the new bin packing algorithm (NBPA) with the First-Fit Decreasing algorithm (FFD). The data and a comparative analysis can be found in [36]. The experiment was based on 20 random simulations for different hyperparameters of the algorithms (such as container size, minimum allowable cut size, parameter $e$) and for random sets of elements (size and number of brick elements) (Table A1). Each simulation was processed with the new bin packing algorithm (NBPA) [36] and checked with [40] for the FFD algorithm (Table A2). For each simulation, the number of containers, the number of combinations, the number of cuts and the unused space were calculated.

According to the multicriteria analysis (Table A3), for the same weight of criteria (number of containers, number of combinations, number of cuts and unused space), NBPA and FFD show the same result score (7 for NBPA, 7 for FFD). For the second set of weights (number of containers (20%), number of combinations (20%), number of cuts (40%) and unused space (20%)), NBPA shows better results with a score of 11 vs. FFD with a score of 3. Six simulations show the same result for both algorithms.

The research reports for each simulation can be found in [36].

4. Conclusions

A new bin packing algorithm was designed to be used for the optimal planning of masonry cutting with a robotic saw. The algorithm is based on the principle of random search for all combinations of cuts executed with respect to the maximum number of objects (cuts) located in one container (masonry element). The new bin packing algorithm minimizes the number of entire masonry elements (containers) and the number of cuts made by the robotic saw to reduce the wear and tear of the cutting plate. The algorithm converges very quickly and reliably finds optimal variants of a digital plan for the robotic saw and various construction objects. Already existing packing algorithms were compared with the newly developed algorithm intended to optimize cuts using a robotic saw. The performed analysis showed its faster convergence and better achievable results for masonry element assemblies.

When comparing the usage of space, the simulation comparing the performance on 20 different sets of elements showed that NBPA is comparable to FFD. Multicriteria analysis demonstrated that when the weighting criterion for saw wear was 40% of all the criteria, the use of NBPA was approximately 3.5 times more effective than FFD.

The presented work successfully introduced an effective methodology for the implementation of building object modelling as well as a connecting bridge between the BIM environment and the environment of industrial robots. The new algorithm enables us to significantly simplify the implementation of robotic assembly units (robotic masonry and robotic saw) in construction processes and achieve better solutions. The robotic saw module, after deploying the algorithm developed, can save time when performing technological construction processes and can also reduce the wear and tear of the technical equipment of robotic assemblies. The application of this methodology to the construction process has the potential to reduce the generation of CDW and to speed up the construction period of brick buildings.

However, scientific work on the development of the algorithm cannot end here. It is necessary to carry out more diverse tests, eliminate possible algorithm errors, accelerate its convergence and reduce time requirements. It is also necessary to analyse the use of the new packing algorithm for deployment in other applications and expand it from 1D to 2D and 3D spaces.

To test the algorithm, an online calculator with limited parameters $e$ and the maximum number of elements $n$ is available at [41].

The source code of the algorithm, written in PHP v.8.3.15, can be found at [36] or can be provided upon request to the main author of the contribution.