Automatic Circle Detection on Images Based on an Evolutionary Algorithm That Reduces the Number of Function Evaluations

Abstract

This paper presents an algorithm for the automatic detection of circular shapes from complicated and noisy images with no consideration of the conventional Hough transform principles. The proposed algorithm is based on a newly developed evolutionary algorithm called the Adaptive Population with Reduced Evaluations (APRE). Our proposed algorithm reduces the number of function evaluations through the use of two mechanisms: (1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy, which decides whether the calculation or estimation of the new generated individuals is feasible. As a result, the approach can substantially reduce the number of function evaluations, yet preserving the good search capabilities of an evolutionary approach. Experimental results over several synthetic and natural images, with a varying range of complexity, validate the efficiency of the proposed technique with regard to accuracy, speed, and robustness.

1. Introduction

The problem of detecting circular features holds paramount importance in several engineering applications such as automatic inspection of manufactured products and components, aided vectorization of drawings, and target detection [1, 2]. Circle detection in digital images has been commonly solved through the Circular Hough Transform (CHT) [3]. Unfortunately, this approach requires a large storage space that augments the computational complexity and yields a low processing speed. In order to overcome this problem, several approaches which modify the original CHT have been proposed. One well-known example is the Randomized Hough Transform (RHT) [4].

As an alternative to Hough Transform-based techniques, the problem of shape recognition has also been handled through evolutionary methods. In general, they have demonstrated to deliver better results than those based on the HT considering accuracy and robustness [5]. Evolutionary methods approach the detection task as an optimization problem whose solution involves the computational expensive evaluation of objective functions. Such fact strongly restricts their use in several image processing applications; despite this, EA methods have produced several robust circle detectors which use different evolutionary algorithms like Genetic algorithms (GA) [5], Harmony Search (HSA) [6], Electromagnetism-Like (EMO) [7], Differential Evolution (DE) [8], and Bacterial Foraging Optimization (BFOA) [9].

However, one particular difficulty in applying any EA to real-world problems, such as image processing, is its demand for a large number of fitness evaluations before reaching a satisfactory result. Fitness evaluations are not always straightforward as either an explicit fitness function does not exist or the fitness evaluation is computationally expensive.

The problem of excessively long fitness function calculations has already been faced in the field of evolutionary algorithms (EA) and is better known as evolution control or as fitness estimation [10]. For such an approach, the idea is to replace the costly objective function evaluation for some individuals by alternative models which are based on an approximate model of the fitness landscape. The individuals to be evaluated and those to be estimated are determined following some fixed criteria which depend on the specific properties of the approximate model [11]. The models involved at the estimation can be dynamically built during the actual EA execution, since EA repeatedly sample the search space at different points [12]. There are several alternative models which have been used in combination with popular EAs. Some examples include polynomial functions [13], kriging schemas [14], multilayer perceptrons [15], and radial basis-function networks [16]. In the practice, the construction of successful models which can globally deal with the high dimensionality, ill distribution, and limited number of training samples is very difficult. Experimental studies [17] have demonstrated that if an alternative model is used for fitness evaluation, it is very likely that the evolutionary algorithm will converge to a false optimum. A false optimum is an optimum of the alternative model, which does not coincide with the optimum of the original fitness function. Under such conditions, the use of the alternative fitness models degrade the search effectiveness of the original EAs, producing frequently inaccurate solutions [18].

In an EA, the population size has a direct influence on the solution quality and its computational cost [19]. Traditionally, population size is set in advance to a prespecified value and remains fixed through the entire execution of the algorithm. If the population size is too small, then the EA may converge too quickly affecting severely the solution quality [20]. On the other hand, if it is too large, then the EA may present a prohibitive computational cost [19]. Therefore, an appropriate population size allows maintaining a trade-off between computational cost and effectiveness of the algorithm. In order to solve such a problem, several approaches have been proposed for dynamically adapting the population size. These methods are grouped into three categories [21]: (i) methods that increment or decrement the number of individuals according to a fixed function; (ii) methods in which the number of individuals is modified according to the performance of the average fitness value, and (iii) algorithms based on the population diversity.

In order to use either a fitness estimation strategy or an adaptive population size approach, it is necessary but not sufficient to tackle the problem of reducing the number of function evaluations. Using a fitness estimation strategy, during the evolution process with no adaptation of the population size to improve the population diversity, makes the algorithm defenseless against the convergence to a false minimum and may result in poor exploratory characteristics of the algorithm [18]. On the other hand, the adaptation of the population size omitting the fitness estimation strategy leads to increase in the computational cost [20]. Therefore, it does seem reasonable to incorporate both approaches into a single algorithm.

Since most of the EAs have been primarily designed to completely evaluate all involved individuals, techniques for reducing the evaluation number are usually incorporated into the original EAs in order to estimate fitness values or to reduce the number of individuals being evaluated [22]. However, the use of alternative fitness models degrades the search effectiveness of the original EAs, producing frequently inaccurate solutions [23].

This paper presents an algorithm for the automatic detection of circular shapes from complicated and noisy images without considering the conventional Hough transform principles. The proposed algorithm is based on a newly developed evolutionary algorithm called the Adaptive Population with Reduced Evaluations (APRE). The proposed algorithm reduces the number of function evaluations through the use of two mechanisms: (1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy which decides when it is feasible to calculate or only to estimate new generated individuals.

The APRE method begins with an initial population which is to be considered as a memory during the evolution process. To each memory element, a normalized fitness value, called quality factor is assigned to indicate the solution capacity that is provided by the element. Only a variable subset of memory elements is considered to be evolved. Like all EA-based methods, the proposed algorithm generates new individuals considering two operators: exploration and exploitation. Both operations are applied to improve the quality of the solutions by: (1) searching through the unexplored solution space to identify promising areas that contain better solutions than those found so far and (2) successive refinement of the best found solutions. Once the new individuals are generated, the memory is accordingly updated. At such stage, the new individuals compete against the memory elements to build the final memory configuration. In order to save computational time, the approach incorporates a fitness estimation strategy that decides which individuals can be estimated or actually evaluated. The proposed fitness calculation strategy estimates the fitness value of new individuals using memory elements located in neighboring positions which have been visited during the evolution process. In the strategy, new individuals, that are located near the memory element whose quality factor is high, have a great probability to be evaluated by using the true objective function. Similarly, evaluated those new particles lying in regions of the search space with no previous evaluations are also evaluated. The remaining search positions are only estimated by assigning the same fitness value that is the nearest location element on the memory. The use of such a fitness estimation method contributes to saving computational time, since the fitness value of only very few individuals is actually evaluated whereas the rest is just estimated.

Different to other approaches that use an already existent EA as framework, the APRE method has been completely designed to substantially reduce the computational cost, yet preserving good search effectiveness.

In order to detect circular shapes, the detector is implemented by encoding three pixels as candidate circles over the edge image. An objective function evaluates if such candidate circles are actually present in the edge image. Guided by the values of this objective function, the set of encoded candidate circles are evolved using the operators defined by APRE so that they can fit into the actual circles on the edge map of the image. Comparisons to several state-of-the-art evolutionary-based methods and the Randomized Hough Transform (RHT) approach on multiple images demonstrate a better performance of the proposed method in terms of accuracy, speed, and robustness.

The paper is organized as follows. In Section 2, the APRE algorithm and its characteristics are both described. Section 3 formulates the implementation of the circle detector. Section 4 shows the experimental results of applying our method to the recognition of circles in different image conditions. Finally, Section 5 discusses several conclusions.

2. The Adaptive Population with Reduced Evaluations (APRE) Algorithm

In the proposed algorithm, a population of candidate solutions to an optimization problem is evolved toward better solutions. The algorithm begins with an initial population which will be used as a memory during the evolution process. To each memory element, it is assigned a normalized fitness value called quality factor that indicates the solution capacity provided by the element.

As a search strategy, the proposed algorithm implements two operations: “exploration” and “exploitation.” Both necessary in all EAs [24]. Exploration is the operation of visiting entirely new points of a search space, whilst exploitation is the process of refining those points of a search space within the neighborhood of previously visited locations in order to improve their solution quality. Pure exploration degrades the precision of the evolutionary process but increases its capacity to find new potential solutions [25]. On the other hand, pure exploitation allows refining existent solutions but adversely drives the process to fall in local optimal solutions [26]. Therefore, the ability of an EA to find a global optimal solution depends on its capacity to find a good trade-off between the exploitation of so far found elements and the exploration of the search space.

The APRE algorithm is an iterative process in which several actions are executed. First, the number of memory elements to be evolved is computed. Such number is automatically modified at each iteration. Then, a set of new individuals is generated as a consequence of the execution of the exploration operation. For each new individual, its fitness value is estimated or evaluated according to a decision taken by a fitness estimation strategy. Afterwards, the memory is updated. In this stage, the new individuals produced by the exploration operation compete against the memory elements to build the final memory configuration. Finally, a sample of the best elements contained in the final memory configuration is undergone to the exploitation operation. Thus, the complete process can be divided in six phases: initialization, selecting the population to be evolved, exploration, fitness estimation strategy, memory updating, and exploitation.

2.1. Initialization

Like in EA, the APRE algorithm is an iterative method whose first step is to randomly initialize the population 𝐌(𝑘) which will be used as a memory during the evolution process. The algorithm begins by initializing (𝑘=0) a set of 𝑁_𝑝 elements (𝐌(𝑘)={𝐦₁,𝐦₂,…,𝐦_𝑁𝑝}). Each element 𝐦_𝑖 is an 𝑛-dimensional vector containing the parameter values to be optimized. Such values are randomly and uniformly distributed between the prespecified lower initial parameter bound 𝑝^low_𝑗 and the upper initial parameter bound 𝑝^high_𝑗, just as it described by the following expression: 𝑚_𝑖,𝑗=𝑝^low_𝑗+rand(0,1)⋅𝑝^high_𝑗−𝑝^low_𝑗,for𝑗=1,2,…,𝑛,𝑖=1,2,…,𝑁_𝑝, (1) where 𝑗 and 𝑖 are the parameter and element indexes, respectively. Hence, 𝑚_𝑖,𝑗 is the 𝑗th parameter of the 𝑖th element.

Each element 𝐦_𝑖 has two associated characteristics: a fitness value 𝐽(𝐦_𝑖) and a quality factor 𝑄(𝐦_𝑖). The fitness value 𝐽(𝐦_𝑖) assigned to each element 𝐦_𝑖 can be calculated by using the true objective function 𝑓(𝐦_𝑖) or only estimated by using the proposed fitness strategy 𝐹(𝐦_𝑖). In addition to the fitness value, it is also assigned to 𝐦_𝑖, a normalized fitness value called quality factor 𝑄(𝐦_𝑖) (𝑄(⋅)∈[0,1]), which is computed as follows: 𝑄𝐦_𝑖=𝐽𝐦_𝑖−worst_𝐌best_𝐌−worst_𝐌, (2) where 𝐽(𝐦_𝑖) is the fitness value obtained by evaluation 𝑓(⋅) or by estimation 𝐹(⋅) of the memory element 𝐦_𝑖. The values worst_𝐌 and best_𝐌 are defined as follows (considering a maximization problem): best_𝐌=max_{𝑘∈1,2,…,𝑁𝑝}𝐽𝐦_𝑘,worst_𝐌=min_{𝑘∈1,2,…,𝑁𝑝}𝐽𝐦_𝑘. (3) Since the mechanism by which an EA accumulates information regarding the objective function is an exact evaluation of the quality of each potential solution, initially, all the elements of 𝐌(𝑘) are evaluated without considering the fitness estimation strategy proposed in this paper. This fact is only allowed at this initial stage.

2.2. Selecting the Population to Be Evolved

At each 𝑘 iteration, it must be selected which and how many elements from 𝐌(𝑘) will be considered to build the population 𝐏^𝑘 in order to be evolved. Such selected elements will be undergone by the exploration and exploitation operators in order to generate a set of new individuals. Therefore, two things need to be defined: the number of elements 𝑁^𝑘_𝑒 to be selected and the strategy of selection.

2.2.1. The Number of Elements 𝑁^𝑘_𝑒 to Be Selected

One of the mechanisms used by the APRE algorithm for reducing the number of function evaluations is to modify dynamically the size of the population to be evolved. The idea is to operate with the minimal number of individuals that guarantee the correct efficiency of the algorithm. Hence, the method aims to vary the population size in an adaptive way during the execution of each iteration. At the beginning of the process, a predetermined number 𝑁⁰_𝑒 of elements are considered to build the first population; then, it will be incremented or decremented depending on the algorithm’s performance. The adaptation mechanism is based on the lifetime of the individuals and on their solution quality.

In order to compute the lifetime of each individual, it is assigned a counter 𝑐_𝑖 (𝑖∈(1,2,3,…,𝑁_𝑝)) to each element 𝐦_𝑖 of 𝐌(𝑘). When the initial population 𝐌(𝑘) is created, all the counters are set to zero. Since the memory 𝐌(𝑘) is updated at each generation, some elements prevail and others will be substituted by new individuals. Therefore, the counter of the surviving elements is incremented by one whereas the counter of new added elements is set to zero.

Another important requirement to calculate the number of elements to be evolved is the solution quality provided by each individual. The idea is to identify two classes of elements, those that provide good solutions and those that can be considered as bad solutions. In order to classify each element, the average fitness value 𝐽_𝐴 produced by all the elements of 𝐌(𝑘) is calculated as 𝐽_𝐴=1𝑁_𝑝^𝑁𝑝_𝑖=1𝐽𝐦_𝑖, (4) where 𝐽(⋅) represents the fitness value corresponding to 𝐦_𝑖. These values are evaluated either by the true objective function 𝑓(𝐦_𝑖) or by the fitness estimation strategy 𝐹(𝐦_𝑖). Considering the average fitness value, two groups are built: the set 𝐆 constituted by the elements of 𝐌(𝑘) whose fitness values are greater than 𝐽_𝐴 and the set 𝐁 which groups the elements of 𝐌(𝑘) whose fitness values are equal or lower than 𝐽_𝐴.

Therefore, the number of individuals of the current population that will be incremented or decremented at each generation is calculated by the following model: |𝐆|𝐴=floor⋅∑_𝑙∈𝐆𝑐_𝑙−|𝐁|⋅∑_𝑞∈𝐁𝑐_𝑞𝑠, (5) where the floor (⋅) function maps a real number to the previous integer. |𝐆| and |𝐁| represent the number of elements of 𝐆 and 𝐁, respectively, whereas ∑_𝑙∈𝐆𝑐_𝑙 and ∑_𝑞∈𝐁𝑐_𝑞 indicate the sum of the counters that correspond to the elements of 𝐆 and 𝐁, respectively. The factor 𝑠 is a term used for fine tuning. A small value of 𝑠 implies a better algorithm’s performance at the price of an increment in the computational cost. On the other hand, a big value of 𝑠 involves a low computational cost at the price of a decrement in the performance algorithm. Therefore, the 𝑠 value must reflex a compromise between performance and computational cost. In our experiments such compromise has been found with 𝑠=10.

Therefore, the number the elements that define the population to be evolved is computed according to the following model: 𝑁^𝑘_𝑒=𝑁_𝑒^𝑘−1+𝐴. (6) Since the value of 𝐴 can be positive or negative, the size of the population 𝐏^𝑘 may be higher or lesser than 𝐏^𝑘−1. The computational procedure that implements this method is presented in Algorithm 1, in form of pseudocode.

(1)  Input: Current population 𝐌(𝑘), counters 𝑐1,…,𝑐𝑁𝑝,   the past number of individuals 𝑁𝑒𝑘−1 and the constant factor 𝑠. (2)  𝐽𝐴←(1/𝑁𝑝)∑𝑁𝑝𝑖=1𝐽𝐦𝑖 (3)  𝐆← FindIndividualsOverJA(𝐌(𝑘),𝐽𝐴) (4)  𝐁← FindIndividualsUnderJA(𝐌(𝑘),𝐽𝐴) (5)  𝑐𝑙← FindCountersOfG(𝐆) (Where 𝑙∈𝐆) (6)  𝑐𝑞← FindCountersOfB(𝐁) (Where 𝑞∈𝐁) (7)  𝐴←floor|𝐆|⋅∑𝑙∈𝐆𝑐𝑙−|𝐁|⋅∑𝑞∈𝐁𝑐𝑞/𝑠 (8)  𝑁𝑘𝑒←𝑁𝑒𝑘−1+𝐴 (9)  Output: The number 𝑁𝑘𝑒

Algorithm 1 

Selection of the number of individuals 𝑁^𝑘_𝑒 to be evolved.

2.2.2. Selection Strategy for Building 𝐏^𝑘

Once the number of individuals has been defined, the next step is the selection of 𝑁^𝑘_𝑒 elements from 𝐌(𝑘) for building 𝐏^𝑘. A new population 𝐌𝐎 which contains the same elements that 𝐌(𝑘) is generated but sorted according to their fitness values. Thus, 𝐌𝐎 presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, 𝐌𝐎 is divided in two parts: 𝐗 and 𝐘. The section 𝐗 corresponds to the first 𝑁^𝑘_𝑒 elements of 𝐌𝐎 whereas the rest of the elements constitute the part 𝐘. Figure 1 shows this process.

Figure 1 

Necessary postprocessing implemented by the selection strategy.

In order to promote diversity, in the selection strategy, the 80% of the 𝑁^𝑘_𝑒 individuals of 𝐏^𝑘 are taken from the first elements of 𝐗 and named as Fe as shown in Figure 2, where Fe=floor (0.8∗𝑁^𝑘_𝑒). The remaining 20% of the individuals are randomly selected from section 𝐘. Hence, the last set of Se elements (where Se=𝑁^𝑘_𝑒−Fe) is chosen considering that all elements of 𝐘 have the same possibility of being selected. Figure 2 shows a description of the selection strategy. The computational procedure that implements this method is presented in Algorithm 2, in form of pseudocode.

(1)  Input: Current population 𝐌(𝑘) and the number of individuals 𝑁𝑘𝑒. (2)  𝐌𝐎← SortElementsFitness(𝐌(𝑘)) (3)  [𝐗,𝐘]← DivideMO𝐌𝐎,𝑁𝑘𝑒 (4)  Fe← floor0.8∗𝑁𝑘𝑒 (5)  Se←𝑁𝑘𝑒−Fe (6)  𝐩𝑘1,…,𝐩𝑘Fe← SelectElementsOfX(𝐗,Fe) (7)  𝐩𝑘Fe+1,…,𝐩𝑘Fe+Se← SelectRandomElementsOfY(𝐘,Se) (8)  Output: Population 𝐏𝑘 to be evolve

Algorithm 2 

Selection strategy for building 𝐏^𝑘.

Figure 2 

Employed selection strategy to build the population 𝐏𝑘, where 𝑑,𝑔∈𝐘.

2.3. Exploration Operation

The first main operation applied to the population 𝐏^𝑘 is the exploration operation. Considering 𝐏^𝑘 as the input population, APRE mutates 𝐏^𝑘 to produce a temporal population 𝐓^𝑘 of 𝑁^𝑘_𝑒 vectors. In the exploration operation two different mutation models are used: the mutation employed by the Differential Evolution algorithm (DE) [27] and the trigonometric mutation operator [28].

2.3.1. DE Mutation Operator

In this mutation, three distinct individuals 𝑟1, 𝑟2, and 𝑟3 are randomly selected from the current population 𝐏^𝑘. Then, a new value ℎ_𝑖,𝑗 considering the following model is created: ℎ_𝑖,𝑗=𝑝_𝑟1,𝑗+𝐹𝑝_𝑟2,𝑗−𝑝_𝑟3,𝑗, (7) where 𝑟1, 𝑟2, and 𝑟3 are randomly selected individuals such that they satisfy 𝑟1≠𝑟2≠𝑟3≠𝑖, 𝑖=1 to 𝑁^𝑘_𝑒 (population size), and 𝑗=1 to 𝑛 (number of decision variable). Hence, 𝑝_𝑖,𝑗 is the 𝑗th parameter of the 𝑖th individual of 𝐏^𝑘. The scale factor, 𝐹(0,1+), is a positive real number that controls the rate at which the population evolves.

2.3.2. Trigonometric Mutation Operator

The trigonometric mutation operation is performed according to the following formulation: ℎ_𝑖,𝑗=𝑝_Av𝑗+𝐹₁𝑝_𝑟1,𝑗−𝑝_𝑟2,𝑗+𝐹₂𝑝_𝑟2,𝑗−𝑝_𝑟3,𝑗+𝐹₃𝑝_𝑟3,𝑗−𝑝_𝑟1,𝑗,𝑝_Av𝑗=𝑝_𝑟1,𝑗+𝑝_𝑟2,𝑗+𝑝_𝑟3,𝑗3,𝐹₁=𝑑_𝑟2−𝑑_𝑟1,𝐹₂=𝑑_𝑟3−𝑑_𝑟2,𝐹₃=𝑑_𝑟1−𝑑_𝑟3,𝑑_𝑟1=𝐽𝐩_𝑟1𝑑_𝑇,𝑑_𝑟2=𝐽𝐩_𝑟2𝑑_𝑇,𝑑_𝑟3=𝐽𝐩_𝑟3𝑑_𝑇,𝑑_𝑇=𝐽𝐩_𝑟1+𝐽𝐩_𝑟2+𝐽𝐩_𝑟3, (8) where 𝐩_𝑟1, 𝐩_𝑟2, and 𝐩_𝑟3 represent the individuals 𝑟1, 𝑟2, and 𝑟3 randomly selected from the current population 𝐏^𝑘 whereas 𝐽(⋅) represents the fitness value (calculated or estimated) corresponding to 𝐩_𝑖. Under this formulation, the individual 𝑝_Av(𝑗) to be perturbed is the average value of three randomly selected vectors (𝑟1, 𝑟2, and 𝑟3). The perturbation to be imposed over such individual is implemented by the sum of three weighted vector differentials. 𝐹₁, 𝐹₂, and 𝐹₃ are the weights applied to these vector differentials. Notice that the trigonometric mutation is a greedy operator since it biases the 𝑝_Av(𝑗) strongly in the direction where the best one of three individuals is lying.

Computational Procedure. Considering 𝐏^𝑘 as the input population, all its 𝑁^𝑘_𝑒 individuals are sequentially processed in cycles beginning by the first individual 𝐩₁. Therefore, in the cycle 𝑖 (where it is processed the individual 𝑖), three distinct individuals 𝑟1, 𝑟2, and 𝑟3 are randomly selected from the current population considering that they satisfy the following conditions 𝑟1≠𝑟2≠𝑟3≠𝑖. Then, it is processed each dimension of 𝐩_𝑖 beginning by the first parameter 1 until the last dimension 𝑛 has been reached. At each processing cycle, the parameter 𝑝_𝑖,𝑗 considered as a parent, creates an offspring 𝑡_𝑖,𝑗 in two steps. In the first step, from the selected individuals 𝑟1, 𝑟2, and 𝑟3, a donor vector ℎ_𝑖,𝑗 is created by means of two different mutation models. In order to select which mutation model is applied, a uniform random number is generated within the range [0,1]. If such number is less than a threshold MR, the donor vector ℎ_𝑖,𝑗 is generated by the DE mutation operator; otherwise, it is produced by the trigonometric mutation operator. Such process can be modeled as follows: ℎ_𝑖,𝑗=(7)(8)().ByusingwithprobabilityMRByusingwithprobability1−MR (9) In the second step, the final value of the offspring 𝑡_𝑖,𝑗 is determined. Such decision is stochastic; hence, a second uniform random number is generated within the range [0,1]. If this random number is less than CH, 𝑡_𝑖,𝑗=ℎ_𝑖,𝑗; otherwise, 𝑡_𝑖,𝑗=𝑝_𝑖,𝑗. This operation can be formulated as follows: 𝑡_𝑖,𝑗=ℎ_𝑖,𝑗𝑝withprobabilityCH_𝑖,𝑗withprobability(1−CH). (10) The complete computational procedure is presented in Algorithm 3, in form of pseudocode.

(1)    Input: Current population 𝐏𝑘 (2)   for 𝑖=1 to 𝑁𝑘𝑒 do (3)    𝐩𝑟1,𝐩𝑟2,𝐩𝑟3← SelectElements()   % Considering that 𝑟1≠𝑟2≠𝑟3≠𝑖 (4)    for 𝑗=1 to 𝑛  do (5)    if (rand(0,1)<=MR) then (6)      ℎ𝑖,𝑗← DEMutation(𝐩𝑟1,𝐩𝑟2,𝐩𝑟3) % (7) (7)    else (8)      ℎ𝑖,𝑗← TrigonometricMutation(𝐩𝑟1,𝐩𝑟2,𝐩𝑟3) % (8) (9)    end if (10)     if (rand(0,1)<=CH) then (11)     𝑡𝑖,𝑗←ℎ𝑖,𝑗 (12)     else (13)     𝑡𝑖,𝑗←𝑝𝑖,𝑗 (14)     end if (15)    end for (16)   end for (17)   Output: Population 𝐓𝑘

Algorithm 3 

Exploration operation of APRE algorithm.

2.4. Fitness Estimation Strategy

Once the population 𝐓^𝑘 has been generated by the exploration operation, it is necessary to calculate the fitness value provided by each individual. In order to reduce the number of function evaluations, a fitness estimation strategy that decides which individuals can be estimated or actually evaluated is introduced. The idea of such a strategy is to find the global optimum of a given function considering only very few number of function evaluations.

In this paper, we explore a local approximation scheme that estimates the fitness values based on previously evaluated neighboring individuals, stored in the memory 𝐌(𝑘) during the evolution process. The strategy decides if an individual 𝐭_𝑖 is calculated or estimated based on two criteria. The first one considers the distance between 𝐭_𝑖 and the nearest element 𝐦^ne contained in 𝐌(𝑘) (where 𝐦^𝑛∈(𝐦₁,𝐦₂,…,𝐦_𝑁𝑝)) whereas the second one examines the quality factor provided by the nearest element 𝐦^ne(𝑄(𝐦^ne)).

In the model, individuals of 𝐓^𝑘 that are near the elements of 𝐌(𝑘) holding the best quality values have a high probability to be evaluated. Such individuals are important, since they will have a stronger influence on the evolution process than other individuals. In contrast, individuals of 𝐓^𝑘 that are also near the elements of 𝐌(𝑘) but with a bad quality value maintain a very low probability to be evaluated. Thus, most of such individuals will only be estimated, assigning it the same fitness value that the nearest element of 𝐌(𝑘). On the other hand, those individuals in regions of the search space with few previous evaluations (individuals of 𝐓^𝑘 located farther than a distance 𝐷) are also evaluated. The fitness values of these individuals are uncertain since there is no close reference (close points contained in 𝐌(𝑘)).

Therefore, the fitness estimation strategy follows two rules in order to evaluate or estimate the fitness values.(1)If the new individual 𝐭_𝑖 is located closer than a distance 𝐷 with respect to the nearest element 𝐦^ne stored in 𝐌, then a uniform random number is generated within the range [0,1]. If such number is less than 𝑄(𝐦^ne), 𝐭_𝑖 is evaluated by the true objective function (𝑓(𝐭_𝑖)). Otherwise, its fitness value is estimated assigning it the same fitness value that 𝐦^ne (𝐹(𝐭_𝑖)=𝐽(𝐦^ne)). Figures 3(a) and 3(b) draw the rule procedure.(2)If the new individual 𝐭_𝑖 is located longer than a distance 𝐷 with respect to the nearest individual location 𝐦^ne stored in 𝐌, then the fitness value of 𝐭_𝑖 is evaluated using the true objective function (𝑓(𝐭_𝑖)). Figure 3(c) outlines the rule procedure.

(a)

(b)

(c)

Figure 3 

The fitness estimation strategy. (a) According to the rule  1, the individual 𝐭𝑖 has a high probability to be evaluated 𝑓(𝐭1), since it is located closer than a distance 𝐷 with respect to the nearest element 𝐦ne=𝐦1 whose quality factor 𝑄(𝐦1) corresponds to the best value. (b) According to the rule  1, the individual 𝐭𝑖 has a high probability to be estimated 𝐹(𝐭1) (assigning it the same fitness value as 𝐦ne (𝐹(𝐭𝑖)=𝐽(𝐦3))), since it is located closer than a distance 𝐷 with respect to the nearest element 𝐦ne=𝐦3 whose quality factor 𝑄(𝐦3) corresponds to the worst value. (c) According to the rule  2, the individual 𝐭𝑖 is evaluated, as there is no close reference in its neighborhood.

From the rules, the distance 𝐷 controls the trade off between the evaluation and estimation of new individuals. Unsuitable values of 𝐷 result in a lower convergence rate, longer computation time, larger function evaluation number, convergence to a local maximum, or unreliability of solutions. Therefore, the 𝐷 value is computed considering the following equation: ∑𝐷=^𝑛𝑗=1𝑝^high_𝑗−𝑝^low_𝑗,50⋅𝑛 (11) where 𝑝^low_𝑗 and 𝑝^high_𝑗 represent the prespecified lower bound and the upper bound of the 𝑗-parameter, respectively, within an 𝑛-dimensional space. Both rules show that the fitness estimation strategy is simple and straightforward. Figure 3 illustrates the procedure of fitness computation for a new candidate solution 𝐭_𝑖 considering the two different rules. In the problem the objective function 𝑓 is maximized with respect to two parameters (𝑥₁,𝑥₂). In all figures (Figures 3(a), 3(b), and 3(c)) the memory 𝐌(𝑘) contains five different elements (𝐦₁,𝐦₂,𝐦₃,𝐦₄, and 𝐦₅) with their corresponding fitness values (𝐽(𝐦₁),𝐽(𝐦₂),𝐽(𝐦₃),𝐽(𝐦₄), and 𝐽(𝐦₅)) and quality factors (𝑄(𝐦₁),𝑄(𝐦₂),𝑄(𝐦₃),𝑄(𝐦₄), and 𝑄(𝐦₅)). Figures 3(a) and 3(b) show the fitness evaluation (𝑓(𝑥₁,𝑥₂)) or estimation (𝐹(𝑥₁,𝑥₂)) of the new individual 𝐭_𝑖 following the rule  1. Figure 3(a) represents the case when 𝐦^ne holds a good quality factor whereas Figure 3(b) when 𝐦^ne maintains a bad quality factor. Finally, Figure 3(c) presents the fitness evaluation of 𝐭_𝑖 considering the conditions of rule  2. The procedure that implements the fitness estimation strategy is presented in Algorithm 4, in form of pseudocode.

(1)    Input: Population 𝐓𝑘 and memory 𝐌(𝑘) (2)   for 𝑖=1 to 𝑁𝑘𝑒 do (3)    𝐦ne← FindNearestElementOfM(𝐭𝑖) (4)   distance ← FindTheDistance(𝐭𝑖,𝐦ne) (5)   if (distance < 𝐷) then (6)    if (rand(0, 1) <= 𝑄(𝐦ne)) then (7)        𝐽(𝐭𝑖)←𝑓(𝐭𝑖)  % Evaluation (8)       else              (Rule  1) (9)        𝐽(𝐭𝑖)←𝐽(𝐦ne)  % Estimation (10)     end if (11)     else (12)      𝐽(𝐭𝑖)←𝑓(𝐭𝑖)  % Evaluation  (Rule  2) (13)  end if (14)   end for (15)   Output: fitness values of  𝐓𝑘

Algorithm 4 

Fitness estimation strategy.

2.5. Memory Updating

Once the operations of exploration and fitness estimation have been applied, it is necessary to update the memory 𝐌(𝑘). In the APRE algorithm, the memory 𝐌(𝑘) is updated considering the following procedure.(1)The elements of 𝐌(𝑘) and 𝐓^𝑘 are merged into 𝐌_𝑈 (𝐌_𝑈=𝐌(𝑘)∪𝐓^𝑘).(2)From the resulting elements of 𝐌_𝑈, it is selected the 𝑁_𝑝 best elements according to their fitness values to build the new memory 𝐌(𝑘+1).(3)The counters 𝑐₁,𝑐₂,…,𝑐_𝑁𝑝 must be updated. Thus, the counter of the surviving elements is incremented by 1 whereas the counter of modified elements is set to zero.

2.6. Exploitation Operation

The second main operation applied by the APRE algorithm is the exploitation operation. Exploitation, in the context of EA, is the process of refining the solution quality of existent promising solutions within a small neighborhood. In order to implement such a process, a new memory ME is generated, which contains the same elements that 𝐌(𝑘+1) but sorted according to their fitness values. Thus, ME presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, the 10% of the 𝑁_𝑝 (𝑁_𝑒) individuals are taken from the first elements of ME to build the set 𝐄 (𝐄={𝐦𝐞₁,𝐦𝐞₂,…,𝐦𝐞_𝑁𝑒}, where 𝑁_𝑒=ceil(0.1⋅𝑁_𝑝)).

To each element 𝐦𝐞_𝑖 of 𝐄 a probability 𝑝_𝑖 which express the likelihood of the element 𝐦𝐞_𝑖 to be exploited is assigned. Such a probability is computed as follows: 𝑝_𝑖=𝑁_𝑒+1−𝑖𝑁_𝑒. (12) Therefore, the first elements of E have a better probability to be exploited than the last ones. In order to decide if the element 𝐦𝐞_𝑖 must be exploited, a uniform random number is generated within the range [0,1]. If such a number is less than 𝑝_𝑖, then the element 𝐦𝐞_𝑖 will be modified by the exploitation operation. Otherwise, it remains without changes.

If the exploitation operation over 𝐦𝐞_𝑖 is verified, the position of 𝐦𝐞_𝑖 is perturbed considering a small neighborhood. The idea is to test if it is possible to refine the solution provided by 𝐦𝐞_𝑖 modifying slightly its position. In order to improve the exploitation process, the proposed algorithm starts perturbing the original position within the interval [−𝐷,𝐷] (where 𝐷 is the distance defined in (11)) and then gradually is reduced as the process evolves. Thus, the perturbation over a generic element 𝐦𝐞_𝑖 is modeled as follows: 𝑚𝑒^new_𝑖,𝑗=𝑚𝑒_𝑖,𝑗+𝐷𝑛𝑔−𝑘()),𝑛𝑔(2⋅rand0,1−1 (13) where 𝑘 is the current iteration and 𝑛𝑔 is the total number of iterations from which consists the evolution process. Once 𝐦𝐞^new_𝑖 has been calculated, its fitness value is computed by using the true objective function (𝐽(𝐦𝐞^new_𝑖)=𝑓(𝐦𝐞^new_𝑖)). If 𝐦𝐞^new_𝑖 is better than 𝐦𝐞_𝑖 according to their fitness values, the value of 𝐦𝐞_𝑖 in the original memory 𝐌(𝑘+1) is updated with 𝐦𝐞^new_𝑖; otherwise the memory 𝐌(𝑘+1) remains without changes. The procedure that implements the exploitation operation is presented in Algorithm 5, in form of pseudocode.

(1)   Input: New memory 𝐌(𝑘+1), current iteration 𝑘 (2)   ME ← SortElementsFitness(𝐌(𝑘+1)) (3)   𝑁𝑒←ceil(0.1⋅𝑁𝑝) (4)   E ← SelectTheFirstElements(𝐌𝐄,𝑁𝑒) (5)   for 𝑖=1 to 𝑁𝑒 do (6)   𝑝𝑖←(𝑁𝑒+1−𝑖)/𝑁𝑒 (7)   if (rand(0, 1) <= 𝑝𝑖) then (8)     for 𝑗=1 to 𝑛  do (9)       𝑚𝑒new𝑖,𝑗←𝑚𝑒𝑖,𝑗+𝐷𝑛𝑔−𝑘/𝑛𝑔(2⋅rand(0,1)−1) (10)   end for (11)      𝐽(𝐦𝐞new𝑖)←𝑓(𝐦𝐞new𝑖) (12)      if (𝐽(𝐦𝐞new𝑖)>𝐽(𝐦𝐞𝑖)) then (13)       𝐌(𝑘+1)← MemoryIsUpdated(𝐦𝐞new𝑖) (14)      end if (15)   end if (16) end for (17) Output: Memory 𝐌(𝑘+1)

Algorithm 5 

Exploitation operation of APRE.

In order to demonstrate the exploitation operation, Figure 4(a) illustrates a simple example. A memory 𝐌(𝑘+1) of ten different 2-dimensional elements is assumed (𝑁_𝑝=10). Figure 4(b) shows the previous configuration of the proposed example before the exploitation operation takes place. Since only the 10% of the best elements of 𝐌(𝑘+1) will build the set E, 𝐦₅ is the single element that constitutes 𝐄 (𝐦𝐞₁=𝐦₅). Therefore, according to (12), the probability 𝑝₁ assigned to 𝐦𝐞₁ is 1. Under such circumstances, the element 𝐦𝐞₁ is perturbed considering (13), generating the new position 𝐦𝐞^new₁. As 𝐦𝐞^new₁ is better than 𝐦𝐞₁ according to their fitness values, the value of 𝐦₅ in the original memory 𝐌(𝑘+1) is updated with 𝐦𝐞^new_𝑖. Figure 4(c) shows the final configuration of 𝐌(𝑘+1) after the exploitation operation has been achieved.

(a)

(b)

(c)

Figure 4 

Example of the mating operation: (a) function example, (b) initial configuration before the exploitation operation, and (c) configuration after the operation.

2.7. Computational Procedure

The computational procedure for the proposed algorithm can be summarized in Algorithm 6.

(1)    Input: 𝑁𝑝,𝑁0𝑒,MR,CH and max𝑘 (where max𝑘 is the maximum number of iterations). (2)    𝐌(1)← InitializeM(𝑁𝑝) (3)    𝑐1,…,𝑐𝑁𝑝← ClearCounters() (4)   for 𝑘=1 to max𝑘 do (5)    Algorithm 1 (6)    Algorithm 2 (7)    Algorithm 3 (8)    Algorithm 4 (9)    𝐌(𝑘+1)← UpdateM(𝐌(𝑘)) (10)   𝑐1,…,𝑐𝑁𝑝← UpdateCounters(𝑐1,…,𝑐𝑁𝑝) (11)    𝐐← CalculateQualityFactor(M(k)) (12)   Algorithm 5 (13)   end for (14)   Solution ← FindBestElement(M(k)) (15)   Output: Solution

Algorithm 6 

Computational procedure of APRE.

The APRE algorithm is an iterative process in which several actions are executed. After initialization (lines 2-3), the number of memory elements to be evolved are computed. Such number is automatically modified at each iteration (lines 5-6). Then, a set of new individuals is generated as a consequence of the execution of the exploration operation (line 7). For each new individual, its fitness value is estimated or evaluated according to a decision taken by a fitness estimation strategy (line 8). Afterwards, the memory is updated. In this stage, the new individuals produced by the exploration operation compete against the memory elements to build the final memory configuration (lines 9–11). Finally, a sample of the best elements contained in the final memory configuration is undergone to the exploitation operation (line 12). This cycle is repeated until the maximum number of the iterations Max𝑘 has been reached.

3. Implementation of APRE-Based Circle Detector

3.1. Individual Representation

In order to detect circle shapes, candidate images must be preprocessed first by the well-known Canny algorithm which yields a single-pixel edge-only image. Then, the (𝑥_𝑖,𝑦_𝑖) coordinates for each edge pixel 𝐞_𝑖 are stored inside the edge vector 𝐄={𝐞₁,𝐞₂,…,𝐞_𝑧𝑛}, with 𝑧𝑛 being the total number of edge pixels. Each circle 𝐶 uses three edge points as individuals in the optimization algorithm. In order to construct such individuals, three indexes 𝐞_𝑖, 𝐞_𝑗, and 𝐞_𝑘, are selected from vector 𝐄, considering the circle’s contour that connects them. Therefore, the circle 𝐶={𝐞_𝑖,𝐞_𝑗,𝐞_𝑘} that crosses over such points may be considered as a potential solution for the detection problem. Considering the configuration of the edge points shown by Figure 5, the circle center (𝑥₀,𝑦₀) and the radius 𝑟 of 𝐶 can be computed as follows: 𝑥−𝑥₀²+𝑦−𝑦₀²=𝑟². (14) Considering 𝑥𝐀=^2𝑗+𝑦²_𝑗−𝑥²_𝑖+𝑦²_𝑖2⋅𝑦_𝑗−𝑦_𝑖𝑥²_𝑘+𝑦²_𝑘−𝑥²_𝑖+𝑦²_𝑖2⋅𝑦_𝑘−𝑦_𝑖,𝑥𝐁=2⋅_𝑗−𝑥_𝑖𝑥²_𝑗+𝑦²_𝑗−𝑥²_𝑖+𝑦²_𝑖2⋅𝑥_𝑘−𝑥_𝑖𝑥²_𝑘+𝑦²_𝑘−𝑥²_𝑖+𝑦²_𝑖,𝑥₀=det(𝐀)4𝑥_𝑗−𝑥_𝑖𝑦_𝑘−𝑦_𝑖−𝑥_𝑘−𝑥_𝑖𝑦_𝑗−𝑦_𝑖,𝑦₀=det(𝐁)4𝑥_𝑗−𝑥_𝑖𝑦_𝑘−𝑦_𝑖−𝑥_𝑘−𝑥_𝑖𝑦_𝑗−𝑦_𝑖,𝑟=𝑥₀−𝑥_𝑑²+𝑦₀−𝑦_𝑑², (15) where det(⋅) is the determinant and 𝑑∈{𝑖,𝑗,𝑘}. Figure 5 illustrates the parameters defined by (14) to (17).

Figure 5 

Circle candidate (individual) built from the combination of points 𝐞𝑖, 𝐞𝑗, and 𝐞𝑘.

3.2. Objective Function

In order to calculate the error produced by a candidate solution 𝐶, a set of test points is calculated as a virtual shape which, in turn, must be validated, that is, if it really exists in the edge image. The test set is represented by 𝐀={𝐚₁,𝐚₂,…,𝐚_𝑠𝑛}, where 𝑠𝑛 is the number of points over which the existence of an edge point, corresponding to 𝐶, should be validated. In our approach, the set A is generated by the Midpoint Circle Algorithm (MCA) [29]. The MCA is a searching method which seeks the required points for drawing a circle digitally. Therefore, MCA calculates the necessary number of test points 𝑠𝑛 to totally draw the complete circle. Such a method is considered the fastest because MCA avoids computing square-root calculations by comparing the pixel separation distances among them.

The objective function 𝐽(𝐶) represents the matching error produced between the pixels A of the circle candidate 𝐶 (individual) and the pixels that actually exist in the edge image, yielding 𝐽(𝐶)=∑^𝑠𝑛_𝑣=1𝐺𝐚_𝑣,𝑠𝑛 (16) where 𝐺(𝐚_𝑣) is a function that verifies the pixel existence in 𝐚_𝑣, with 𝐚_𝑣∈𝐀 and 𝑠𝑛 being the number of pixels lying on the perimeter corresponding to 𝐶 currently under testing. Hence, function 𝐺(𝐚_𝑣) is defined as 𝐺𝐚_𝑣=1,ifthepixel𝐚_𝑣isanedgepoint,0,otherwise. (17) A value of 𝐽(𝐶) near to one implies a better response from the “circularity” operator. Figure 6 shows the procedure to evaluate a candidate solution 𝐶 by using the objective function 𝐽(𝐶). Figure 6(a) shows the original edge map E, while Figure 6(b) presents the virtual shape A representing the particle 𝐶={𝐞_𝑖,𝐞_𝑗,𝐞_𝑘}. In Figure 6(c), the virtual shape A is compared to the edge image, point by point, in order to find coincidences between virtual and edge points. The particle has been built from points 𝐞_𝑖, 𝐞_𝑗, and 𝐞_𝑘 which are shown by Figure 6(a). The virtual shape A, obtained by MCA, gathers 56 points (𝑠𝑛=56) with only 17 of them existing in both images (shown as white points in Figure 6(c)) and yielding ∑^𝑠𝑛_𝑣=1𝐺(𝐚_𝑣)=17, therefore 𝐽(𝐶)≈0.30.

(a)

(b)

(c)

Figure 6 

Procedure to evaluate the objective function 𝐽(𝐶). The image (a) presents the original edge map while (b) present the virtual shape A corresponding to 𝐶. The image (c) shows the coincidences between both images by means of white pixels whereas the virtual shape is depicted in black.

3.3. The Multiple Circle Detection Procedure

In order to detect multiple circles, the APRE-detector is iteratively applied. At each iteration, two actions are developed. In the first one, a new circle is detected as a consequence of the execution of the APRE algorithm. The detected circle corresponds to the candidate solution 𝐶 with the best found 𝐽(𝐶) value. In the second one, the detected circle is removed from the original edge map. The processed edge map without the removed circle represents the input image for the next iteration. Such process is executed over the sequence of images until the 𝐽(𝐶) value would be lower than a determined threshold that is considered as permissible.

4. Results on Multicircle Detection

In order to achieve the performance analysis, the proposed approach is compared to the GA-based algorithm [5], the BFAO detector [9] and the RHT method [4] over an image set.

The GA-based algorithm follows the proposal of Ayala-Ramirez et al. [5], which considers the population size as 70, the crossover probability as 0.55, the mutation probability as 0.10, and the number of elite individuals as 2 and 200 generations. The roulette wheel selection and the 1-point crossover operator are both applied. The parameter setup and the fitness function follow the configuration suggested in [5]. The BFAO algorithm follows the implementation from [9] considering the experimental parameters as 𝑆=50, 𝑁_𝑐=350, 𝑁_𝑠=4, 𝑁_ed=1, 𝑃_ed=0.25, 𝑑_attract=0.1, 𝑤_attract=0.2, 𝑤_repellant=10, ℎ_repellant=0.1, 𝜆=400, and 𝜓=6. Such values are found to be the best configuration set according to [9]. Both, the GA-based algorithm and the BAFO method use the same objective function that is defined by (16). Likewise, the RHT method has been implemented as it is described in [4]. Finally, Table 1 presents the parameters for the APRE algorithm used in this work. They have been kept for all test images after being experimentally defined.

Table 1 

APRE detector parameters.

Images rarely contain perfectly-shaped circles. Therefore, with the purpose of testing accuracy for a single-circle, the detection is challenged by a ground-truth circle which is determined from the original edge map. The parameters (𝑥_true,  𝑦_true, and 𝑟_true) representing the testing circle are computed using the (6)–(9) for three circumference points over the manually-drawn circle. Considering the centre and the radius of the detected circle are defined as (𝑥_𝐷,𝑦_𝐷) and 𝑟_𝐷, the Error Score (Es) can be accordingly calculated as Es=𝜂⋅𝑥_true−𝑥_𝐷+𝑦_true−𝑦_𝐷+𝜇⋅𝑟_true−𝑟_𝐷. (18) The central point difference (|𝑥_true−𝑥_𝐷|+|𝑦_true−𝑦_𝐷|) represents the centre shift for the detected circle as it is compared to a benchmark circle. The radio mismatch (|𝑟_true−𝑟_𝐷|) accounts for the difference between their radii. 𝜂 and 𝜇 represent two weighting parameters which are to be applied separately to the central point difference and to the radio mismatch for the final error Es. At this work, they are chosen as 𝜂=0.05 and 𝜇=0.1. Such a choice ensures that the radius difference would be strongly weighted in comparison to the difference of central circular positions between the manually detected and the machine-detected circles. Here, we assume that if Es is found to be less than 1, then the algorithm gets a success; otherwise, we say that it has failed to detect the edge-circle. Note that for 𝜂=0.05 and 𝜇=0.1Es<1 means the maximum difference of radius tolerated is 10, while the maximum mismatch in the location of the center can be 20 (in number of pixels). In order to appropriately compare the detection results, the Detection Rate (DR) is introduced as a performance index. DR is defined as the percentage of reaching detection success after a certain number of trials. For “success” it does mean that the compared algorithm is able to detect all circles contained in the image, under the restriction that each circle must hold the condition Es<1. Therefore, if at least one circle does not fulfil the condition of Es<1, the complete detection procedure is considered as a failure.

In order to use an error metric for multiple-circle detection, the averaged Es produced from each circle in the image is considered. Such criterion, defined as the Multiple Error (ME), is calculated as follows: 1ME=⋅NC^NC_𝑅=1Es_𝑅, (19) where NC represents the number of circles within the image according to a human expert.

Figure 7 shows three synthetic images and the resulting images after applying the GA-based algorithm [5], the BFOA method [9], and the proposed approach. Figure 8 presents experimental results considering three natural images. The performance is analyzed by considering 35 different executions for each algorithm. Table 2 shows the averaged execution time, the averaged number of function evaluations, the detection rate in percentage, and the averaged multiple error (ME), considering six test images (shown by Figures 7 and 8). Close inspection reveals that the proposed method is able to achieve the highest success rate still keeping the smallest error and demanding less computational time and a lower number of function evaluations for all cases.

Table 2 

The averaged execution-time, detection rate, the averaged multiple error for the GA-based algorithm, the BFOA method, and the proposed APRE algorithm, considering six test images are shown by Figures 8 and 9.

Figure 7 

Synthetic images and their detected circles for GA-based algorithm, the BFOA method, and the proposed APRE algorithm.

Figure 8 

Real-life images and their detected circles for GA-based algorithm, the BFOA method, and the proposed APRE algorithm.

In order to statistically analyze the results in Table 2, a nonparametric significance proof known as the Wilcoxon’s rank test [30–32] for 35 independent samples has been conducted. Such proof allows assessing result differences among two related methods. The analysis is performed considering a 5% significance level over the number of function evaluations and a multiple error (ME) data. Tables 3 and 4 report the 𝑃 values produced by Wilcoxon’s test for a pairwise comparison of the number of function evaluations and the multiple error (ME), considering two groups gathered as APRE versus GA and APRE versus BFOA. As a null hypothesis, it is assumed that there is no difference between the values of the two algorithms. The alternative hypothesis considers an existent difference between the values of both approaches. All 𝑃 values reported in Tables 3 and 4 are less than 0.05 (5% significance level) which is a strong evidence against the null hypothesis, indicating that the best APRE mean values for the performance are statistically significant which has not occurred by chance.

Table 3 

𝑃 values produced by Wilcoxon’s test comparing APRE to GA and BFOA over the averaged number of function evaluations from Table 2.

Table 4 

𝑃 values produced by Wilcoxon’s test comparing APRE to GA and BFOA over the averaged ME from Table 2.

Figure 9 demonstrates the relative performance of APRE in comparison with the RHT algorithm as it is described in [4]. All images belonging to the test are complicated and contain different noise conditions. The performance analysis is achieved by considering 35 different executions for each algorithm over the three images. The results, exhibited in Figure 9, present the median-run solution (when the runs were ranked according to their final ME value) obtained throughout the 35 runs. On the other hand, Table 5 reports the corresponding averaged execution time, detection rate (in %), and average multiple error (using (10)) for APRE and RHT algorithms over the set of images. Table 5 shows a decrease in performance of the RHT algorithm as noise conditions change. Yet the APRE algorithm holds its performance under the same circumstances.

Table 5 

Average time, detection rate, and averaged error for APRE and RHT, considering three test images.

Figure 9 

Relative performance of the RHT and the APRE.

5. Conclusions

In this paper, a novel evolutionary algorithm called the Adaptive Population with Reduced Evaluations (APRE) is introduced to solve the problem of circle detection. The proposed algorithm reduces the number of function evaluations through the use of two mechanisms: (1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy which decides when it is feasible to calculate or only estimate new generated individuals.

The algorithm begins with an initial population which will be used as a memory during the evolution process. To each memory element, it is assigned a normalized fitness value called quality factor that indicates the solution capacity provided by the element. From the memory, only a variable subset of elements is considered to be evolved. Like other population-based methods, the proposed algorithm generates new individuals considering two operators: exploration and exploitation. Such operations are applied to improve the quality of the solutions by (1) searching the unexplored solution space to identify promising areas containing better solutions than those found so far and (2) successive refinement of the best found solutions. Once the new individuals are generated, the memory is updated. In such stage, the new individuals compete against the memory elements to build the final memory configuration.

In order to save computational time, the approach incorporates a fitness estimation strategy that decides which individuals can be estimated or actually evaluated. As a result, the approach can substantially reduce the number of function evaluations, yet preserving its good search capabilities. The proposed fitness calculation strategy estimates the fitness value of new individuals using memory elements located in neighboring positions that have been visited during the evolution process. In the strategy, those new individuals, close to a memory element whose quality factor is high, have a great probability to be evaluated by using the true objective function. Similarly, it is also evaluated those new particles lying in regions of the search space with no previous evaluations. The remaining search positions are estimated assigning them the same fitness value that the nearest location of the memory element. By the use of such fitness estimation method, the fitness value of only very few individuals are actually evaluated whereas the rest is just estimated.

Different to other approaches that use an already existent EA as framework, the APRE method has been completely designed to substantially reduce the computational cost but preserving good search effectiveness.

To detect the circular shapes, the detector is implemented by using the encoding of three pixels as candidate circles over the edge image. An objective function evaluates if such candidate circles are actually present in the edge image. Guided by the values of this objective function, the set of encoded candidate circles are evolved using the operators defined by APRE so that they can fit to the actual circles on the edge map of the image.

In order to test the circle detection accuracy, a score function is used (19). It can objectively evaluate the mismatch between a manually detected circle and a machine-detected shape. We demonstrated that the APRE method outperforms both the evolutionary methods (GA and BFOA) and Hough Transform-based techniques (RHT) in terms of speed and accuracy, considering a statistically significant framework (Wilconxon test). Results show that the APRE algorithm is able to significantly reduce the computational overhead as a consequence of decrementing the number of function evaluations.

Funding

The proposed algorithm is part of the vision system used by a biped robot supported under the Grant CONACYT CB 181053.