Application of Nature-Inspired Algorithms to Computed Tomography with Incomplete Data

Abstract

This paper discusses and compares several computed tomography (CT) algorithms capable of dealing with incomplete data. This type of problem has been proposed for a symmetrical grid and symmetrically distributed transmitters and receivers. The use of symmetry significantly speeds up the process of constructing a system of equations that is the foundation of all CT algebraic algorithms. Classic algebraic approaches are effective in incomplete data scenarios, but suffer from low convergence speed. For this reason, we propose the use of nature-inspired algorithms which are proven to be effective in many practical optimization problems from various domains. The efficacy of nature-inspired algorithms strongly depends on the number of parameters they maintain and reproduce, and this number is usually substantial in the case of CT applications. However, taking into account the specificity of the reconstructed object allows to reduce the number of parameters and effectively use heuristic algorithms in the field of CT. This paper compares the efficacy and suitability of three nature-inspired heuristic algorithms: Artificial BeeColony (ABC), Ant Colony Optimization (ACO), and Clonal Selection Algorithm (CSA) in the CT context, showing their advantages and weaknesses. The best algorithm is identified and some ideas of how the remaining methods could be improved so as to better solve CT tasks are presented.

1. Introduction

In the classic formulation of the computed tomography (CT) reconstruction problem, the interior of the examined object is reconstructed on the basis of its X-rays (projections) with a beam of penetrating radiation. Since each type of matter has a different ability to absorb radiation energy, appropriate algorithms recreate the interior of the examined object based on the energy loss of the emitted radiation beam. However, it is required that there are enough of these projections—many X-ray angles and many rays for each of these angles (see Kotelnikov’s theorem [1]).

In the classical approach (e.g., in medical tomography), modern tomographs are perfectly capable of recreating the examined interior. They find an image (also three-dimensional) with the desired accuracy (resolution) within a satisfactory time for doctors. Therefore, most of the work in this field concerns not the reproduction process itself, but rather a later stage—the analysis of this image or obtaining similar results with a lower dose of radiation (see, e.g., [2]).

Unfortunately, in many cases, we are not able to obtain projections that meet the desired criteria. An example of such a situation is the examination of a coal seam, in which there may be stone overgrowths that are not good for economic reasons, or pressurized gas tanks that are dangerous due to the threat to the life of the working crew. Such phenomena are really dangerous. In the largest Polish catastrophe caused by rock ejection (undetected compressed gas tank), which happened in the second half of the 20th century, nearly 20 miners were killed in the Nowa Ruda mine.

When examining the coal seam, the projections obtained are highly one-sided, because they can only be made between two opposite walls. Of course, there are methods of examining coal seams (e.g., drilling is performed), but these methods are uneconomical (and sometimes also dangerous), because mining must be suspended for the duration of the test.

Meeting the assumptions about the projection quality is a guarantee of the success of the process of recreating the interior of the tested object. However, the lack of its fulfillment does not exclude the final success. CT algorithms, which on the basis of the obtained projections return the image of the examined object, can be divided into two groups: analytical algorithms [3,4,5] and algebraic algorithms [6,7,8]. The conducted research has shown that the analytical algorithms cannot cope with a too-small number of scanning angles and therefore cannot be used in the problem of an incomplete dataset (see, e.g., [9]). For this reason, we focus on algebraic algorithms.

In the literature, it is difficult to find works on the use of heuristic algorithms in the CT problem (as presented in the following paper). The overwhelming majority of works using these algorithms in this task concern not the process of reproduction itself, but the analysis of an already obtained image [10,11,12]. The lack of works similar to this one results from the difficulty of using heuristic algorithms in the CT task. The classic approach would require too many parameters to be recreated. On the other hand, the conducted research and attempts to accelerate the playback (see, e.g., [9,13]) indicated the shortcomings of the classical approach. Therefore, we have leaned towards this line of research (see, for example, in [14], its first steps).

2. Algebraic Algorithms

For CT tasks, one can create any meshes, but in order to speed up the calculations, we use symmetry of engineeredmeshes and the symmetrical arrangement of transmitters and receivers of penetrating radiation. In the algebraic algorithms we are considering, it is assumed that the reproduced area can be divided into $N=n^2$ of identical squares (pixels), and this division is so dense that it can be assumed that the density distribution function $f(x,y)$ has a constant value on each of these pixels. Thanks to this assumption, the energy loss of a single ray can be presented as the sum of the energy losses of this ray on individual pixels through which this ray passes. On the other hand, the energy loss on a single pixel is proportional to the length of this ray on that pixel (knowing the discretization density n and the equations of lines containing the rays, this length can be determined) and to the value of the function $f(x,y)$ on this pixel (we have to recreate this value).

Considering all the rays in sequence, we obtain a system of linear equations of the form

$$AX=B,$$

(1)

where A is a matrix of the dimension coefficients $m\times N$ (m is the number of projections made), X is a vector of unknown lengths N (each element is an unknown value of the function $f(x,y)$ on successive pixels), and B is a vector of length m (each of its elements is the projection value, i.e., the total energy loss of the given ray).

Matrix A does not allow the use of classical methods of solving systems of linear equations. A large part of algebraic algorithms is based on Kaczmarz’s idea which is a special tag for the ART (algebraic reconstruction technique) algorithm, which is described below. In this algorithm, $a^{\left(i\right)}$ is i-th row of A, $(·,·)$ is the classically defined dot product in the space ${\mathbb{R}}^N$, $p^i$ is an i-th projection (in other words $p_i=b_i$ is an i-th element of B), $i=mod(k-1,m)+1$, $\parallel ·\parallel$ is the norm of the vector, in this case its length, and $\lambda \in \mathbb{R}$ is the relaxation parameter. Algorithm 1 presents the ART procedure.

The ART algorithm runs as long as the stop condition is satisfied. Often the stop condition is a predetermined number of iterations (we assume that one iteration is going through all the lines of the A matrix, i.e., it is executing m projections). It is also assumed that the stop condition is a measure of the change of successive solutions—if the solutions change by less than a given amount, the algorithm ends its work. A combination of both conditions is also used.    

Algorithm 1: Algorithm ART.

Input: number of rows m, number of variables N, initial solution $x^{\left(0\right)}$, parameter $\lambda$        (if $\lambda$ is not constant, we need to model the change in iterations). Output: solution x of (1).        $\mathit{Initialization}:k=0.$    1: while$stop\left(x\right)=$ true do    2:     $x^{(k+1)}:=x^{\left(k\right)}+{\lambda }_k\frac{p_i-\left(a^{\left(i\right)},x^{\left(k\right)}\right)}{\parallel a^{\left(i\right)}{\parallel }^2}{a}^{\left(i\right)}$    3:     $x^{(k+1)}:=C\left(x^{(k+1)}\right)$    4:     $k:=k+1$    5: end while    6: Solution $x^{(k+1)}$ is taken as final for (1).

3. Task Formulation and Idea

In the case of an incomplete dataset, which is represented here by the coal seam survey, projections are obtained as shown in Figure 1, where orange points indicate radiation transmitters, red—receivers, brown arrows indicate ray paths and directions, and green rectangles—objects to be detected. We are dealing with the problem of an incomplete dataset because the obtained X-rays (projections) are “one-sided”. In medical tomography, projections are obtained from any angle (for a large number of such angles). In the examination of the coal seam, we can obtain data only on the basis of projections drawn between two opposite walls. Despite the fact that we can collect a lot of such data (e.g., as much as in medical tomography), their quality (not in the sense of the accuracy of measurements, but in the sense of the data on the interior of the examined object carried by these projections) will differ significantly from the information obtained in the tomography medical. As long as we assumed the symmetry of the grid and the distribution of transmitters and receivers of penetrating radiation, at this stage, due to the heterogeneity of the studied area, we obtain projection asymmetry, and in this case it leads to a solution.

The number of radiation sources and receivers determines the number of m rows of the A matrix of the (1) equation system, while the squared discretization density $[-1,1]\times [-1,1]$ of the studied area determines the number of unknowns N. On the basis of the projections obtained in this way, the interior of the examined object should be recreated, i.e., the value of the density distribution function $f(x,y)$ for each of the pixels should be found.

As we already mentioned, the analytical algorithms are sensitive to the quality of the projection (in this case, their number is not so important, but their unidirectional nature is), but they recreate the interior of the examined objects with a satisfactory accuracy. Although algebraic algorithms turned out to be useful in the problem of incomplete datasets, for stable, detected opaque elements, their problem is playback time—with increasing resolution (value of the N parameter), the number of rows of the equation system must increase (1), and this entails the need to perform a correspondingly larger number of iterations, which significantly extends the time (in the classic formulation of the CT reconstruction problem, a dozen or so iterations are often enough to obtain a satisfactory result, and in the presented problem of an incomplete dataset, the number of iterations can be counted in thousands).

Some attempts, most often effective, have been made to speed up the work of these algorithms. These methods include the selection of optimal values of reconstruction parameters, the introduction of chaotic algorithms, theoretical considerations on parallel computing—the introduction of block algorithms, or practical research related to the use of parallel computing in block algorithms [13,14].

These actions improved the recovery time; however, it seems that the mentioned time could be reduced much more. For this purpose, an innovative approach is used—heuristic algorithms are used to solve the CT task. Although naturally inspired algorithms were used in the problem of computed tomography [15,16,17,18,19,20], these approaches were of a different nature—these algorithms did not solve the (1) equation system, but had already reconstructed the image to improve its quality or cooperate with analytical algorithms.

In this work we compare the usefulness of three types of heuristic algorithms that have a very wide range of applications, e.g., for optimization of induction motors, continuous casting process research, to target recognition for low-altitude aircraft, to reduce noise pollution in rooms, airport traffic control, optimization of queries in a distributed database, aiding production planning, improving vehicle energy efficiency, analysis and segmentation of magnetic resonance images, prediction of wear symptoms of rubber products, solving the problem of nursing work planning, optimization of low microgrid configuration tensions, improvements in the system of granting access to data science resources, and even in viticulture and many others [21,22,23,24,25,26,27,28,29,30,31,32,33].

The first is the Artificial Bee Colony (ABC) algorithm. The ABC algorithm, similar to most nature-inspired algorithms, bases the method of its operation on the actual behavior of a certain organism. It was created on the basis of observations of bees looking for food. Bees are divided into three groups: randomly searching for food sources, searching for food in known sources, and observers waiting in the hive and making decisions about the choice of food source. The search for a solution in this algorithm is based on the information exchange system between different types of bees. The first to notice such behavior of bees was Frish, who at the end of the first half of the 20th century investigated and described this phenomenon [34]. Such behavior is based on the fact that when a new source of food is discovered (if, in the opinion of a given bee, this source is attractive), the bee informs other bees about the location of this source by appropriate movements (waggle dance). The initial bee moves in a straight line. Its direction is the angle between the sun and the food source, and its length is the distance to that source. Frish noticed that 75 ms of dancing (in a straight line) corresponded to 100 m off-road. The bee then returns in a semicircle (left or right) to its original position. The vibrations of the bee are an additional element of the dance. They determine the quality of the food. The actual bee dance can be seen (along with the description of the meaning of the dancing bee’s behavior), e.g., under the link [35]. An algorithm describing this behavior of bees was introduced by Karaboga in 2005 [36]. The equivalent of food sources are vectors from the considered space, the quality of food is interpreted by the value of the minimized functional, and the probability of selecting the source depends on the value of the functional. In general, it can be said that the area under investigation is searched twice—first the whole area is searched in general, and then the most promising areas in more detail.

Algorithm 2 presents the ABC procedure.    

Algorithm 2: Algorithm ABC.

Input:s—number of sources, l—number of revealed sources $x_i$, $i=1,2,\dots ,s$,        $p=s·l$—number of corrections to sources, c—number of cycles        according to initial localization of l-dimensional        vectors $x_i$, $i=1,2,\dots ,s$; Output: solution $x^{*}$ to minimize functional J;    1: for$\alpha =1$ to s do    2:     for $\beta =1$ to p do    3:         Modify localization ${\mathbf{x}}_i$: $$v_i^j=x_i^j+{\varphi }_{ij}(x_i^j-x_k^j),j\in \{1,2,\dots ,l\},$$ (2)         where $\left\{\begin{array}{c}k\in \{1,2,\dots ,s\},k\ne i,\\ {\varphi }_{ij}\in [-1,1],\end{array}\right.$ are randomly selected numbers;    4:         if $J\left({\mathbf{v}}_i\right)\le J\left({\mathbf{x}}_i\right)$ then    5:             Localization ${\mathbf{v}}_i$ replaces ${\mathbf{x}}_i$, else localization ${\mathbf{x}}_i$ does not change.    6:         end if    7:     end for    8:     Calculate probability $P_i$ for localization ${\mathbf{x}}_i$ as above: $$P_i=\frac{fi{t}_i}{{\displaystyle \sum _{j=1}^s}fi{t}_j},i=1,\dots ,s,$$    where:   $fi{t}_i=\left\{\begin{array}{cc}\frac{1}{1+J\left({\mathbf{x}}_i\right)}\hfill & \mathrm{if}J\left({\mathbf{x}}_i\right)\ge 0,\\ 1+\left|J\left({\mathbf{x}}_i\right)\right|\hfill & \mathrm{if}J\left({\mathbf{x}}_i\right)<0.\end{array}\right.$;    9:     Selection of source ${\mathbf{x}}_i$, $i=1,\dots ,s$, with probability $P_i$;  10:     Explore source and modify location (2);  11:     Select ${\mathbf{x}}^{*}$ in current cycle the best located source, if current source ${\mathbf{x}}^{*}$ is better     than previous one we take it as ${\mathbf{x}}^{*}$ for the whole process;  12:     if (2) does not improve ${\mathbf{x}}_i$ (${\mathbf{x}}_i$ does not change) then  13:         source ${\mathbf{x}}_i$ we change source according to: $$x_i^j=x_{min}^j+{\varphi }_{ij}(x_{max}^j-x_{min}^j),j=1,\dots ,l,$$         where ${\varphi }_{ij}\in [0,1]$;  14:     end if  15: end for  16: Solution $x^{*}$ is taken as final.

    The second algorithm used in this work is the Ant Colony Optimization (ACO) algorithm. This is one of the best known swarm optimization algorithms. It was proposed by Dorigo in his doctoral dissertation [37], and later this method was developed; many sources mention Toksari [37] as the most important. This algorithm was created on the basis of observation of the behavior of ants searching for food and passing on knowledge about it to other ants. As in the case of bees, which conveyed information about their food source to other bees by means of appropriate dance, ants transmit information about the food place to other ants by means of scent traces (pheromone). Initially, the ants (represented by the appropriate vectors) run randomly across the field. The ant that comes back with food will take the shortest path and its pheromone trace will be the strongest, because it will have the least time to evaporate (the equivalent of the best ant is the vector for which the functional has the lowest value). The remaining ants do not have to choose the directions randomly, they make the decision to choose the path on the basis of pheromone traces left by the previous population, thus strengthening this trace (in the algorithm, the probability of choosing a direction corresponds to it). Of course, in order to not become stuck in the local minimum, the location of the ants must be modified (the values of the algorithm parameters correspond to this). Interesting applications and a slightly different approach to this algorithm can be found, among others, in the works [37,38].

Algorithm 3 presents the ACO procedure.   

Algorithm 3: Algorithm ACO.

Input:L—number of pheromone spots, n—problem dimension,       M—number of ants, I—number of iterations;       q, $\xi$—algorithm parameters; Output: solution $x^{*}$ is to minimize solution J;    1: Initial L pheromone spots is placed randomly;    2: For each pheromone spots Calculating value of goal function;    3: Sorting pheromone spots by values of goal function;    4: for$itr=1$ to I do    5:     for each pheromone spot calculating probability: $$p_l=\frac{{\omega }_l}{{\displaystyle \sum _{l=1}^L}{\omega }_l},l=1,\dots ,L$$    where the weight: $$w_l=\frac{1}{qL\sqrt{2\pi }}exp\left(\frac{-{(l-1)}^2}{2q^2{L}^2}\right).$$    6:     Each ant takes pheromone spot with probability $p_l$;    7:     Each ant modifies pheromone spot (j coordinate) with probability density     function: $$g(x,\mu ,\sigma )=\frac{1}{\sigma \sqrt{2\pi }}exp\left(\frac{-{(x-\mu )}^2}{2{\sigma }^2{L}^2}\right),$$    where $\mu =s_j^l,$$\sigma =\frac{\xi }{L-1}{\displaystyle \sum _{p=1}^L}\left|s_j^p-s_j^l\right|$    8:     For each new pheromone spots Calculating value of goal function;    9:     Reject the M worst pheromoe spots.  10: end for  11: The best pheromone spot is taken as solution $x^{*}$.

    The third algorithm used in this work is the Clonal Selection Algorithm (CSA) [39]. This algorithm is based on the functioning of the mammalian immune system. The body produces antibodies to fight harmful foreign organisms (antigens). The effectiveness of combating them depends on the measure of how similar antibodies are to antigens. In the algorithm, this antigen is the solution sought, and the antibody is the solution obtained by the algorithm.

The algorithm shows that part of the population is cloned. The number of clones produced depends on their quality. All clones undergo a maturation process. Clones undergo random hypermutation. The clones are then validated. The best clones replace the previous ones from which they were created. The remaining elements of the population that were not cloned are replaced by new random elements.

Algorithm 4 presents the CSA procedure.   

Algorithm 4: Algorithm CSA.

Input:p—population, $x_{j,lo}$, $x_{j,up}$—upper and lower       range, j-th variable of vector x in solution space of s-dimensions, $j=1,2,\dots ,s$,       I—maximum number of iterations, c, $\overline{\beta }$, $r_{max}$, $\varrho$, k—parameter; Output: solution $x^{*}$ to minimize functional J;    1: Initial population is selected randomly, each location $x_j$, $j=1,2,\dots ,s$, vecotr x is taken in the range $[x_{j,lo},x_{j,up}]$;    2: Sorting not incremental randomized population according to the functional;    3: for$\alpha =1$ to I do    4:     Copy part of population of $c·p$ locations. For locations $p_c$ is copied: $$p_c^i=⌊\frac{\overline{\beta }·p}{i_{rank}}⌋i=1,2,\dots ,\lfloor c·p\rfloor ,$$     where $\overline{\beta }$ is maximum number of copies, $i_{rank}$ is location i-th of sorted     solutions, while $\lfloor ·\rfloor$ is integer;    5:     Process of clones production – each copy has all the variables randomly     modified: $$x_j:=x_j+r\left(x_{j,up}-x_{j,lo}\right)·G(0,1),$$     where r is the range of mutation, $G(0,1)$ is the random variable of Gaussian     distribution. Range of mutation r depends on fitness: $$r=r_{max}exp\left(\varrho \frac{t}{I}\right),$$     where $r_{max}$ is maximum range of mutation, t is the number of generation, $\varrho$ is     mutation parameter. Mutation range for i-th solution in ranking $r_i$ is     according to: $$r_i=r\frac{F_i-k·F_b}{F_w-k·F_b},$$     where $F_i$, $F_b$ and $F_b$ are adaptations of solutions i-th, the best and worst-ranked     of the cloned solutions, k is coefficient of the ratio of the hypothetical     adaptation of the optimal solution and the adaptation of the best solution in     the current generation;    6:     Determining the value of the functional for the mutant functional, if better, it     replaces the original. This way $p_c^i$ solutions goes to the next generation;    7:     Rest of population $p-c·p$ is replaced with randomly selected ones.    8: end for

The idea of using heuristic algorithms in solving the CT task is as follows: in the coal seam, the density distribution is discrete and high-contrast; additionally, the resolution does not have to be very high—only tanks of considerable size are dangerous, although the possibility of reproducing elements was tested (with success) as the size of a single pixel.

For this reason, we can assume that in the area under consideration there may or may not be elements (we assume that there are no more than three) that have the shape of rectangles on which the density distribution function has a constant value. In turn, these rectangles can have at most a common segment.

Thanks to this approach, the cases in which the discussed method can be used are not limited, and the number of simultaneously recreated parameters (solution space dimension) is $5·rect$, where $rect$ is the number of rectangles to be recreated. One rectangle is characterized by two coordinates of two opposite vertices and the value of the density distribution function on that rectangle.

The aim is to recreate the interior of the tested object based on the projection. The minimized functional here is:

$$J\left(x\right)={\displaystyle \sum _{i=1}^m}{(b_i-{\overline{b}}_i)}^2,$$

(3)

where $b=\{b_1,b_2,\dots ,b_m\}$ is real project, and $\overline{b}=\{{\overline{b}}_1,{\overline{b}}_2,\dots ,{\overline{b}}_m\}$ is position for established objects.

4. Results

We start the experiments with the usability analysis of the ABC, ACO, and CSA algorithms in the case when in the searched area there is one rectangle $R=[-0.75,-0.5]\times [-0.75,-0.5]$, where the density distribution function takes the value 1. Initially, we run the programs for $N=n^2={20}^2=$ 400 pixels and $m=$ 58 of sources and receivers of rays (for this resolution it is the optimal value of m). At this point, it is important to note a certain advantage of heuristic algorithms—they are not sensitive to increasing discretization. In classical algorithms, the recovery time significantly increases with the increase of the n parameter, in these algorithms only projections should be determined, and these only require, depending on the approach to this problem, either to multiply the matrix A and the vector X (this vector can be obtained very easily on the basis of the solution generated at a given stage), or by directly determining it (also on the same basis).

Figure 2 shows, for the ABC algorithm, the relationship between the number of iterations and the value of the objective functional (3) for different numbers of s bees.

Each of the parameter sets was run 10 times and the best one was selected from the series of results. As can be seen, after 10 iterations, the reproduction errors are very small, but for 10 bees, such results are obtained from 6 iterations. For example, for 6 iterations, for 10 bees, the rectangle R was recreated as follows: $R=[-0.74997,-0.49996]\times [-0.75658,-0.49536]$, the function $f(x,y)$ assumed the value $0.96097$, and the objective function was $0.0062$. For 15 iterations and 10 bees, the values were equal to:

$$\begin{array}{cc}\hfill R& =[-0.7500007,-0.5000003]\times [-0.750000004,-0.499997],\hfill \\ \hfill f(x,y)& =0.999986,0<J\left(x^{*}\right)<{10}^{-8}.\hfill \end{array}$$

We now conduct similar tests for the ACO algorithm. In this algorithm there is an additional narrowing parameter $\epsilon$, which we take depending on the number of iterations I according to the formula $\epsilon =0.6+(I-5)·0.05$.

Figure 3 shows the relationship between the number of iterations and the value of the objective function (3) for different numbers of ants p for the ACO algorithm.

Each of the parameter sets was run 10 times and the best one was selected from the series of results. As can be seen, this algorithm behaves correctly—the value of the objective function decreases with an increase in the number of iterations and with an increase in the number of ants. We can also notice that the algorithm responds better to increasing the number of ants. For example, for 6 iterations, for 100 ants, the R rectangle was recreated as follows: $R=[-0.74999,-0.49998]\times [-0.75243,-0.49738]$, function $f(x,y)$ assumed the value $0.98044$, and the objective function was $0.00125$. For 10 iterations and for 100 bees, the values were equal to:

$$\begin{array}{cc}\hfill R& =[-0.74999,-0.500007]\times [-0.749,-0.50046],\hfill \\ \hfill f(x,y)& =1.00344,J\left(x^{*}\right)=0.000029.\hfill \end{array}$$

We now conduct similar tests for the CSA algorithm. This algorithm already has many more parameters, so it is not as intuitive as the previous two algorithms. After preliminary research and using previous experiences, we used the standard algorithm parameters. Figure 4 shows the dependence of the value of the objective function on the number of iterations for different sizes of the population.

Each of the parameter sets was run 10 times and the best one was selected from the series of results. As can be seen, this algorithm behaves correctly—the value of the objective function decreases with an increase in the number of iterations and with an increase in the size of the population. We can also notice that starting from a population of 20 individuals, the distribution of errors looks similar. For example, for 70 iterations, for a population of 70, the rectangle R was recreated as follows: $R=[-0.75006,-0.49954]\times [-0.77208,-0.47307]$, function $f(x,y)$ assumed the value $0.83987$, and the objective function took a value of $0.09626$. For 100 iterations and for 100 positions, the values were equal to:

$$\begin{array}{cc}\hfill R& =[-0.74995,-0.49979]\times [-0.75356,-0.49171],\hfill \\ \hfill f(x,y)& =0.9576,J\left(x^{*}\right)=0.0076.\hfill \end{array}$$

Figure 5, Figure 6 and Figure 7 graphically show the evolution of solutions obtained in ABC, ACO, and CSA algorithms, depending on the number of iterations. The dashed line is the exact solution. The restored value of the $f(x,y)$ function on this rectangle is also given in the middle of the approximate solution (the exact value is 1).

In subsequent tests, we increased the number of rectangles by one. This time we have two rectangles, $R_1=[-0.8,-0.6]\times [-0.7,-0.1]$ and $R_2=[0.1,0.45]\times [0.2,0.35]$, where the density distribution function takes values equal to 1 and 2, respectively.

The program is structured in such a way that if the objective function does not reach the satisfactory value while searching for one rectangle, it restarts, searching for two rectangles (likewise, it may increase the number of rectangles to three). In the ABC algorithm, it turned out that it copes with this problem. For example, for 9 bees and 15 iterations, the program returned the following recreations:

$$\begin{array}{cc}\hfill R_1& =[-0.800002,-0.59999]\times [-0.69995,-0.10006],f(x,y)=1.00015,\hfill \\ \hfill R_1& =[0.1000006,0.44999]\times [0.19993,0.35008],f(x,y)=1.9981.\hfill \end{array}$$

Unfortunately, the ACO and CSA algorithms are not able to recreate two (and therefore also three) rectangles. This is probably caused by the way of representing rectangles and solution vectors as well as the specificity of algorithms that use the measure of similarity between successive solutions. As a result, good solutions may be interpreted as seemingly different. There are already some ideas on how to overcome this problem, but this requires a lot of additional and time-consuming research to be carried out in the future.

Since the main aim of the research carried out here was to shorten the recovery time, we now compare the working times of reconstructing one rectangle for the algorithms under consideration. In

Table 1. ABC algorithm: time t (ms) to obtain a solution and maximum coefficient of variation $v_{max}(\%)$ depending on the size of the p population and the number of iterations I.

I→	7		9		11		13		15
p$\downarrow$	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]
7	516	0.091	750	0.037	1016	0.045	1094	0.082	1219	0.030
8	750	0.014	906	0.100	1094	0.094	1359	0.055	1469	0.052
9	875	0.015	1266	0.069	1375	0.324	1640	0.321	1922	0.078
10	1156	0.081	1437	0.011	1781	0.059	2062	0.108	2266	0.099

,

Table 2. ACO algorithm: time t (ms) to obtain a solution and maximum coefficient of variation $v_{max}(\%)$ depending on the size of the p population and the number of iterations I.

I→	60		70		80		90		100
p$\downarrow$	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]
7	5015	0.011	5282	0.054	6344	0.065	7140	0.044	7937	0.062
8	6578	0.074	7594	0.041	8562	0.039	9110	0.019	10,688	0.049
9	8625	0.012	10,782	0.032	11,922	0.045	13,094	0.054	16,015	0.100
10	14,016	0.096	15,828	0.087	18,281	0.055	20,375	0.094	721,109	0.076

and

Table 3. CSA algorithm: time (ms) to obtain a solution and maximum coefficient of variation $v_{max}(\%)$ depending on the size of the p population and the number of iterations I.

I→	60		70		80		90		100
p$\downarrow$	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]	t [ms]	${\mathit{v}}_{\mathit{max}}$ [%]
20	2938	0.133	3094	0.121	4125	0.129	4229	0.107	4531	0.095
30	4250	0.076	5609	0.092	5891	0.101	6797	0.066	6828	0.055
40	6781	0.084	6844	0.098	7812	0.093	9500	0.109	9797	0.069
50	7960	0.056	9282	0.078	10,422	0.089	10,953	0.126	11,828	0.034

, the working times of the algorithms for different sizes of the population and the number of iterations are collected. After selecting the best pairs of these parameters,

Table 4. ABC algorithm: value of the goal function to solve the best $J\left(x^{*}\right)$, the average of the value of the goal function $\overline{J}$, the standard deviation of these results $\sigma$, and the average time to obtain them, t, for $I=$ 8, $p=$ 9, and 10 runs.

$\mathit{J}\left({\mathit{x}}^{*}\right)$	$\overline{\mathit{J}}$	$\mathit{\sigma }$	t [ms]
0.00014298	0.0504308	0.071	963.9

presents a statement for the best of these algorithms: the value of the goal function $J\left(x^{*}\right)$, the average of the goal function values, the standard deviation of these results, and the average time needed to obtain these plays.

As a measure of algorithm convergence, we use the maximum coefficient of variation, the size of which represents the repeatability of the obtained results in many samples. Assuming that ${\mathbf{x}}^k=[x_1^k,x_2^k,\dots ,x_d^k]$, for $k=1,2,\dots n$ are n independent solutions of the same problem obtained in n independent trials, the maximum coefficient of variation $v_{max}$ is given by the formula:

$$v_{max}=100·max\left\{\frac{\sqrt{\frac{1}{n}{\displaystyle \sum _{k=1}^n}{\left({\overline{x}}_i-x_i^k\right)}^2}}{{\overline{x}}_i},i=1,2,\dots ,d\right\}\%$$

(4)

where ${\overline{x}}_i$ is the average restore value of i-th parameter, and d is the number of parameters restored.

Comparing the obtained results, it can be easily noticed that even the most time-consuming set of parameters in the ABC algorithm generates a time shorter than the least time-consuming pair of parameters in the other algorithms. In addition, $p=15$ and $I=10$ in the ABC algorithm are definitely exaggerated values, and in the other algorithms, the set of parameter pairs for the shortest times is too small. In conjunction with the fact that the ABC algorithm can also deal with a larger number of reconstructed rectangles, it becomes the clear winner among the algorithms compared here. In addition, it should be mentioned that the time needed to recreate the interior of the object is incomparably shorter than the time needed by the classic CT algorithms (in the case of an incomplete dataset).

As can be seen, the ABC algorithm is not only effective but is also stable. The mean value of the objective function is as low as $0.05$ and the standard deviation is $0.071$. The average time also does not differ from the corresponding (see Table 1) previously obtained time.

Finally, underlining the usefulness of the ABC algorithm, in Figure 8 we show how it recreates the three rectangles shown in Figure 1:

$$\begin{array}{cc}\hfill R_1& =[-0.75,0.15]\times [0.15,0.45],\hfill \\ \hfill R_2& =[-0.15,0.05]\times [-0.35,-0.15],\hfill \\ \hfill R_3& =[0.45,0.65]\times [-0.65,0.05],\hfill \end{array}$$

and the density distribution function on these rectangles is equal to 1, 2, and $1.38$, respectively.

5. Conclusions

The tested algorithms turned out to be useful in solving the task of computed tomography with an incomplete dataset. All of the considered algorithms are characterized by significantly shorter recovery times than the classic CT algorithms with an incomplete dataset. Among the heuristic algorithms discussed in this paper, the ABC algorithm turned out to be the best in many respects. It had the best play times, was the most intuitive to use (no extra parameters), and was good at handling multiple rectangles.

A further direction of research will be the modification of approaches to the ACO and CSA algorithms, so that they also correctly reproduce the tested objects with more than one rectangle. The next step will be to modify the idea by recreating other types of objects.