catalog
3.2 Otsu method with multiple thresholds
3.3 multi threshold Otsu method 2
4.2.1 single location and single point crossing
4.2.2 multi position and single point crossing
8.1 test script ga_muti_thresholding.m
8.2 population initialization init_pop.m
8.6 calculation of fitness function_ fit.m
1. Summary
Image segmentation is an important problem in image processing and computer vision, and it is the key step of image processing and analysis. Image segmentation is to divide a digital image into multiple regions or sets. In order to solve the problem of time-consuming in traditional image thresholding segmentation method and make full use of the high efficiency of genetic algorithm, a multi thresholding image segmentation method based on genetic algorithm is proposed, which takes the maximum between class variance or the minimum within class variance as an important reference standard. Experimental results show that the genetic algorithm can not only achieve image threshold segmentation, but also reduce the segmentation time significantly.
Keywords: image segmentation genetic algorithm multi threshold segmentation
2. Introduction
In a broad sense, image segmentation is to divide image into sub regions or objects according to image components, and the way of image segmentation depends on the problem we want to solve; the ultimate goal of segmentation is to extract the part we are concerned about from the image, so as to further research, analysis and processing, and the accuracy of image segmentation stage will be for the image in the next stage The management effect has a great influence. For many applications that rely on computer vision, such as medical imaging, target location in satellite images, machine vision, fingerprint and face recognition, agricultural imaging, etc., it is an essential preprocessing task.
Therefore, image segmentation has been studied for many years. At present, the commonly used image segmentation methods are: Based on threshold segmentation, edge segmentation, region segmentation, based on wavelet, genetic algorithm, artificial neural network, active contour model, clustering segmentation and so on [1]. Among them, because of the simplicity of threshold segmentation technology, and threshold method is the most common parallel direct detection area segmentation method. The key step is how to select threshold, which has been widely concerned in recent years. Many threshold selection methods have been proposed. For example, Otsu algorithm, minimum error threshold method and best histogram entropy method. On the other hand, because genetic algorithm can provide near optimal solutions for many practical applications, the problem of finding the optimal threshold is transformed into an optimization problem in a finite field.
In this paper, the threshold segmentation method is combined with genetic algorithm. Based on the threshold segmentation method to maximize the variance between different regions or objects, this method is called Otsu algorithm. This standard is used as the fitness standard of genetic algorithm to search the best threshold.
3 Otsu threshold segmentation
Otsu algorithm, also known as Otsu method, is an algorithm to determine the threshold value of image binary segmentation, which was proposed by Japanese scholar Otsu in 1979. In terms of the principle of Dajin method, it is also called the method of maximum inter class variance. This method is considered to be the best algorithm for threshold selection in image segmentation. It is simple to calculate and not affected by image brightness and contrast, so it has been widely used in digital image processing. Its basic principle is to use the best threshold to divide the gray histogram into two parts, so that the variance between the two parts is the maximum, that is, the maximum separation. The classical Otsu method can only be used for single threshold segmentation. In the process of thresholding segmentation, the information hist(x) of gray histogram is mainly used to calculate.
3.1 classical Otsu method
3.2 Otsu method with multiple thresholds
3.3 multi threshold Otsu method 2
4 genetic algorithm design
Genetic algorithm (GA) is a heuristic search algorithm which simulates the genetic and evolutionary process of organisms in the natural environment to form an adaptive global optimization probability [4]. Genetic algorithm is a population-based algorithm, which generates multiple solutions each iteration. When there is no deterministic method or the computational complexity of deterministic method, genetic algorithm is used to search the optimal solution. It has two significant advantages: implicit parallelism and effective use of global information, which is helpful to improve the search speed and robustness of the algorithm. Combined with image segmentation based on multi threshold, the genetic algorithm is designed as follows:
4.1 individual code
In genetic algorithm, the population evolves through continuous iterations. We may think that an individual has only one chromosome, that is, the individual is equal to the chromosome, in which each chromosome corresponds to a solution of the problem, and the individual evolution is equal to the final result of chromosome crossing, mutation and survival of the fittest. Because the common threshold segmentation will preprocess the image. Color image, each pixel has three values (RGB), each value range is 0 ~ 255. Gray image, each pixel has only one value, called gray value. Because processing gray image is simpler and more efficient than processing color image. Therefore, the preprocessing is to convert the color image to the gray image, and each pixel value is in [0255]. Because each threshold is a gray value, each threshold is defined as a binary bit vector with a length of L, and each binary bit is called a gene, where l = log (gray value series); for n threshold, each chromosome contains n*L binary bits, where each L bit represents a threshold, and the chromosome structure is shown in Figure 1 below.
Figure 1: chromosome structure
4.2 mating operation
Mating can also be understood as the crossing between chromosomes. The chromosomes perform the crossing operation at random points. The following introduction will use the single point crossing method:
4.2.1 single location and single point crossing
Take the whole chromosome as a unit, randomly generate a random number in the range of 1~L*n, take this point as the beginning of chromosome crossing operation, and successively exchange the following bits (genes). The specific operation is shown in Figure 2.
Figure 2: single point chromosome crossing at crossing position 14
4.2.2 multi position and single point crossing
The L-bit binary encoding of each threshold within the chromosome is taken as the unit. If a chromosome contains n thresholds, then n cross random values are randomly generated, and the random values range from 1 to log (gray scale Series). The thresholds of the corresponding positions of the two chromosomes were crossed at one point. The specific operation is shown in Figure 3.
Figure 3: Multipoint chromosome crossing at 4 and 14, respectively
4.3 variation operation
Variation is the change (reversal) of a gene's position, which is used to overcome the possible local optimum caused by crossing. The specific method of a mutation is to randomly generate a random number, the random number range is 1~n*L, and flip the binary bit on the position.
4.4 selection operation
The selection operation is very important in genetic algorithm. According to the fitness of each individual, the most suitable individual is selected to keep to the next generation. At the same time, the individual with low fitness is also selected. Therefore, the roulette method is used for selection. Through the fitness value of each individual, the probability = individual fitness value / population overall fitness sum is calculated, and then the cumulative probability is calculated according to the above. The probability of each individual being selected = individual cumulative probability / total group cumulative probability. This is a normalization process, and each individual is allocated to the roulette with probability of 1 in proportion. In order to improve the convergence speed and increase elite retention, the superior individuals of the parents will replace the inferior individuals of the newly selected offspring.
Select n individuals to form the next generation population, and the specific operation is as follows:
(a) Calculate the individuals with the best adaptability of their parents.
(b) Calculate the cumulative probability of each individual in the parent generation.
(c) Generate n random numbers between 0 and 1.
(c) According to the cumulative probability, the first individual larger than the random number is selected.
(e) The superior individuals of the parents will replace the inferior individuals of the new offspring.
3.5 fitness function setting
For the fitness evaluation of threshold segmentation, that is, what kind of threshold segmentation can separate the object and what kind of segmentation is good. In this paper, Otsu's maximum inter class variance or minimum intra class variance is used as the threshold segmentation criteria. For different thresholds, the larger the variance between classes and the smaller the intra class variance, the better the segmentation effect.
5 Analysis of test results
The test is implemented in Matlab environment. The parameter settings are as follows:
Population size: 20
Cross probability: 0.8
Probability of variation: 0.1
Maximum iterations: 100
5.1 test one
(a) (b)
(c ) (d)
Figure 4: (a) original cell picture [5]; (b) effect picture after threshold segmentation; (c) gray histogram of original picture; (d) segmentation red line with threshold value of 210 divides gray value histogram into two parts
5.2 test II
(a) (b)
(c) (d)
Figure 5: (a) the original building block picture; (b) the grayed image; (c) an effect picture with a segmentation threshold of 123 gray value segmentation; (d) an effect picture with two segmentation thresholds of 119 and 207 gray value segmentation, respectively
Because the threshold used for segmentation is less than the object type, some object objects will be defined as the background, only the object with the largest gray difference will be used as the distinguishing object, which is suitable for highlighting some of the most important objects in the multi object image. When the number of segmentation thresholds is equal to or greater than the object type, all different object objects in the image can be distinguished as well as possible.
Table 1: comparison between traditional Otsu method and genetic algorithm (see Figure 5 for effect object)
It can be seen from table 1 that in the case of single threshold, traditional Otsu traverses all pixels (256), and calculates the class variance corresponding to each pixel value respectively, which is very fast, faster than genetic algorithm. However, when multi threshold segmentation is implemented, the number of iterations will increase exponentially due to the number of thresholds, which makes the running time of the program too long and reduces the efficiency.
5.3 test three
(a) (b)
(c)
(d)
Figure 6: (a) the original bird map; (b) the bird map segmented by the threshold value of 97 gray level; (c) the best adaptability and average adaptability of each generation of single point crossing; (d) the best adaptability and average adaptability of each generation of multi point crossing
Table 2: comparison of two different cross methods mentioned in the paper (the effect of the object is shown in Figure 6)
|
Cross mode |
Optimal threshold |
Achieve the best Threshold algebra |
Reach the best threshold Time taken by value |
Complete operation Line time |
|
Single point crossing |
97 |
12 |
0.122s |
0.2190s |
|
Multipoint crossing |
97 |
22 |
0.125s |
0.2860s |
From table 2, it can be seen that single point intersection can converge earlier and take less time overall. As each threshold in the multi-point cross operation increases the cross operation and time consumption, it can be seen from the average fitness of each generation in the right figures (c) and (d) of Figure 6 that the multi-point cross jitter is more obvious. It is to spend more time to expand the search space to reduce the possibility of falling into local optimum.
5.4 test four
(a) (b)
Figure 7: (a) the original license plate image; (b) the license plate image segmented by the threshold value of 123
Table 3: comparison of two calculation methods of fitness mentioned in the paper (see Figure 7 for effect object)
|
Fitness criteria |
Optimal threshold |
Reach optimal threshold algebra |
Reach the best threshold Time taken by value |
Complete operation Line time |
|
Maximize between classes |
123 |
11 |
0.0320s |
0.2600s |
|
Maximizing between classes & minimizing within classes |
124 |
10 |
0.0270s |
0.2220s |
From table 3, it can be seen that the effect of the two segmentation methods is similar, and the fitness strategy of maximizing combination within classes and minimizing between classes runs faster.
6 Conclusion
Thresholding based segmentation is a deterministic but very complex problem. Compared with the traditional Otsu method, genetic algorithm is used to search for the optimal solution through the heuristic information between populations, so as to quickly approach the optimal solution, which can greatly improve the efficiency of finding the optimal solution, and the efficiency is considerable. At the same time, for different scenes, using different threshold number, we can effectively extract the important object individuals in the image.
7. Reference
[1] Ding Liang, Zhang Yongping, Zhang Xueying. Overview of image segmentation methods and pre performance evaluation [J]. Software. 2010 (12): 78-83
[2] Liu Jianzhuang, Xie Weixin, Gao Xinbo. Genetic algorithm for multi threshold image segmentation [J]. Pattern recognition and artificial intelligence. 1995.12:126-132
[3]Omar B, Yahya A Y.Multi-Thresholding Image Segmentation Using Genertic Algorithm[J].Computer Vision.,59(2),2004:167-181.
[4] Ma Wen, Zhou Shaoguang, Ding Huizhen. Application of Otsu method based on Genetic Algorithm in image segmentation [J]. Coastal enterprises and technology. 2005 (8): 160-162
[5]CSDN blog. Application of Ostu method based on Genetic Algorithm in image segmentation [OL] https://blog.csdn.net/u010945683/article/details/41780491
8 code part
8.1 test script ga_muti_thresholding.m
%
% Muti-Thresholding Image Segemention Using Genetic Algonithm
% Multi threshold image segmentation based on genetic algorithm
% Author:
% data : 2020/06/03
% Objective: to maximize the inter class variance between the target and the background or to minimize the inter class variance within the target pixel
% Encoding: binary encoding determines the number of bits according to the range of gray value thsld_len According to the number of preset thresholds thsld_mount
% The length of each chromosome is determined as: thsld_len*thsld_mount
% Fitness function:
% Choice: Roulette
% Variation: single point variation
%%
%(0) empty
clc;
clear;
close all;
%%
%(1) Determine parameters
pop_size = 20; %Population size
pc = 0.8; %Crossover probability
pm = 0.1; %Mutation probability
iter_max = 100; %Maximum number of iterations
thsld_mount = 3; %Number of thresholds
thsld_len = log2(256); %Bits per threshold
image_path = '14.jpg'; %Image path
compression_ratio = 0.4; %Image compression ratio
elite_pro = 0.1; %Proportion of parents in elite retention
%%
%(2)Image preprocessing
init_image = imread(image_path); %Read in picture
subplot(3,3,1);
imshow(init_image);
title('Init Image');
%Reduce the number of pixels, reduce the amount of calculation and improve the efficiency of calculation
compress_image = imresize(init_image,compression_ratio); %Reduce the picture to 0% of the original picture.2 times
subplot(3,3,2);
imshow(compress_image);
title('Compress Image');
%The quality of segmentation is affected by the uniformity of gray value of each target pixel, and graying is helpful to reduce the influence
gray_image = rgb2gray(compress_image); %Color image graying
subplot(3,3,3);
imshow(gray_image);
title('Gray Image');
hist = imhist(gray_image); %Generating histogram data from gray image
subplot(3,3,4);
imhist(gray_image);
title('Gray value histogram');
%%
t_start = clock;
%Code logic part
%Initial population
pop = init_pop(pop_size,thsld_mount);
%Keep records
history = zeros(iter_max,2); %Best fitness value of each generation average fitness value of each generation
history_pop = zeros(iter_max,thsld_mount); %The best fit threshold of each generation the average value of each threshold segment of each generation
%Maximum iteration within algebra
flag = ceil(iter_max * (1-0.4));
tim = zeros(iter_max,6)
for iter = 1:iter_max
%overlapping
cross_pop = crossing(pop,pc,thsld_len);
%variation
muta_pop = mutation(cross_pop,pm,thsld_len);
%choice
[pop best_fit_aver_fit cur_best_pop ] = selection(pop,muta_pop,thsld_mount,hist,elite_pro);
history(iter,:) = best_fit_aver_fit;
history_pop(iter,:)= cur_best_pop;
tim(iter,:) = clock;
fprintf("%d:best fitness:%f\n",iter,history(iter,1));
fprintf("%d:best pop answer:%s\n\n",iter,num2str(history_pop(iter,:)));
%Adjust selection and compilation probability
if iter == flag
pc = pc * 0.4;
pm = pm * 0.4;
end
end
t_end = clock;
%% Graph output results
subplot(3,3,5);
plot(history(:,1));
title('Best fitness');
xlabel('Generation');
ylabel('Fitness');
text(1,history(1,1),num2str(history(1,1)));
text(20,history(20,1),num2str(history(20,1)));
text(iter_max,history(iter_max,1),num2str(history(iter_max,1)));
subplot(3,3,6);
plot(history(:,2));
title('Average fitness');
xlabel('Generation');
ylabel('Fitness');
text(1,history(1,2),num2str(history(1,2)));
text(20,history(20,2),num2str(history(20,2)));
text(iter_max,history(iter_max,2),num2str(history(iter_max,2)));
subplot(3,3,7);
plot(history_pop);
title('Thlsd value');
xlabel('Generation');
ylabel('Thlsd value');
for t = 1:thsld_mount
text(iter_max-10,history_pop(iter_max-10,t),num2str(history_pop(iter_max-10,t)));
end
subplot(3,3,8);
plot(hist);
title('Cut-off Rule');
hold on
y = max(hist);
color = ['r','g','b','c','y','m','b'];
for t = 1:thsld_mount
pos = rem(t,7);
if pos == 0
pos = 7;
end
plot([history_pop(iter_max,t),history_pop(iter_max,t)],[0,y],color(pos));
text(history_pop(iter_max,t),y-(t*100),num2str(history_pop(iter_max,t)));
end
%Redraw
last_thsld = history_pop(iter_max,:);
[row list ]= size(gray_image);
%Determine the color value of each interval segment
color = zeros(1,thsld_mount+1);
for i=1:thsld_mount+1
if i == 1
color(1) = uint8(fix((1 + last_thsld(1)-1)/2));
elseif i < thsld_mount+1
color(i) = uint8(fix((last_thsld(i-1) + last_thsld(i)-1)/2));
else
color(i) = uint8(fix((last_thsld(i-1) + 256)/2));
end
end
new_image = zeros(size(gray_image));
for i = 1:row
for j = 1:list
for k = 1:thsld_mount+1
if k == thsld_mount+1
new_image(i,j) = color(k);
elseif gray_image(i,j) < last_thsld(k)
new_image(i,j) = color(k);
break;
end
end
end
end
subplot(3,3,9);
imshow(uint8(new_image));
title('Result Image');
run_time = etime(t_end,t_start);
disp(run_time);8.2 population initialization init_pop.m
function pop = init_pop(pop_size,thsld_mount)
%Random generation[0 255]Decimal threshold between
pop = zeros(pop_size,thsld_mount);
for i = 1:pop_size
pop(i,:) = randperm(256,thsld_mount);
end
end8.3 cross operation
function cross_pop = crossing(pop,pc,thsld_len)
[row list] = size(pop);
%Single point intersection of multiple intersections
%Calculate how many individuals need to cross
cross_mount = fix( row * pc ) ; %Round down
if rem( cross_mount,2) ~= 0 %Make even numbers convenient for crossing
cross_mount = cross_mount + 1; %Since it starts to round down, plus 1 doesn't worry about crossing the border
end
%Random sampling from population cross_mount Individuals mating
cross_num = randperm(row,cross_mount); %From 1~row Medium, select cross_mount Do not repeat random arrangement
% fprintf('cross_num:%s\n',num2str(cross_num));
%Make a twofold crossing
for i = 1:2:cross_mount
%Single point crossing for each threshold
while 1
%Each threshold component has different degree of single point crossing
cross_pos = randi(thsld_len,1,list);
%Encode decimal to binary
x = dec2base(pop(cross_num(i),:),2,thsld_len); %8 String array represented by bit 2
y = dec2base(pop(cross_num(i+1),:),2,thsld_len);
for j = 1:list
for k=cross_pos(j):thsld_len
temp = x(j,k);
x(j,k) = y(j,k);
y(j,k) = temp;
end
end
%Convert binary to decimal
pop(cross_num(i),:) = base2dec(x,2)';
pop(cross_num(i+1),:) = base2dec(y,2)';
%Check whether the same threshold value is generated in a descendant
ux = length(pop(cross_num(i),:))-length(unique(pop(cross_num(i),:)));
uy = length(pop(cross_num(i+1),:))-length(unique(pop(cross_num(i+1),:)));
if ux == 0 && uy == 0 && sum(pop(cross_num(i),:)>256)==0 ...
&& sum(pop(cross_num(i+1),:)>256)==0
break;
end
end
%Single point crossing with only one intersection
% while 1
% r = randi(list * thsld_len,1);
% %Encode decimal to binary
% x = dec2base(pop(cross_num(i),:),2,thsld_len); %8 String array represented by bit 2
% y = dec2base(pop(cross_num(i+1),:),2,thsld_len);
%
% cross_row = ceil(r/(thsld_len));
% if rem(r,thsld_len) == 0
% cross_list = thsld_len;
% else
% cross_list = rem(r,thsld_len);
% end
%
% for j = cross_row:list
% if j == cross_row %Cross the data of the current row first
% for k = cross_list:thsld_len
% temp = x(j,k);
% x(j,k) = y(j,k);
% y(j,k) = temp ;
% end
% else
% for k = 1:thsld_len %Cross other row data
% temp = x(j,k);
% x(j,k) = y(j,k);
% y(j,k) = temp;
% end
% end
% end
%
% %Convert binary to decimal
% %Check whether the same threshold value is generated in a descendant
% ux = length(pop(cross_num(i),:))-length(unique(pop(cross_num(i),:)));
% uy = length(pop(cross_num(i+1),:))-length(unique(pop(cross_num(i+1),:)));
% if ux == 0 && uy == 0 && sum(pop(cross_num(i),:)>256)==0 ...
% && sum(pop(cross_num(i+1),:)>256)==0
% break;
% end
% end
% end
cross_pop = pop;
end8.4 mutation.m
function muta_pop = mutation(pop,pm,thsld_len)
[row list] = size(pop);
muta_mount = ceil(row * list * thsld_len * pm); %Calculate the total number of binary digits to be varied
muta_num = randperm(row * list * thsld_len,muta_mount);
for i = 1:muta_mount
% muta_num(i)
muta_row = ceil(muta_num(i) / (list * thsld_len));
if rem(muta_num(i),list * thsld_len) == 0
muta_list = list;
else
muta_list = ceil(rem(muta_num(i),list * thsld_len) / thsld_len);
end
%
%Encode decimal to binary
z = dec2base(pop(muta_row,muta_list),2,thsld_len); %8 String array represented by bit 2
if rem(muta_num(i),list * thsld_len) == 0
muta_bit = thsld_len;
else
muta_bit = rem(muta_num(i),list * thsld_len) - (muta_list-1) * thsld_len;
end
while 1
if z(muta_bit) == '0'
z(muta_bit) = '1';
else
z(muta_bit) = '0';
end
pop(muta_row,muta_list) = base2dec(z,2);
%Check whether there is the same threshold in an individual after mutation
uz = length(pop(muta_row,:))-length(unique(pop(muta_row,:)));
if uz == 0 && sum(pop(muta_row,:)>256)==0
break;
else
muta_bit = randi(thsld_len,1);
end
end
end
muta_pop = pop;
end8.5 selection.m
function [select_pop best_fit_aver_fit cur_best_pop] = selection(pop,new_pop,thsld_mount,hist,elite_pro)
[row list] = size(pop);
%Check threshold changed to 0 by mutation or crossover
new_pop(new_pop==0)=1;
f_num = ceil(elite_pro * row) ;
temp_pop = zeros(size(pop));
select_fit = zeros(1,row);
%30%Keep the excellent individuals of the parents
f_fitness = compute_fit(pop,hist);
[a b] = sort(f_fitness,'descend');
temp_pop = pop(b(1:f_num),:);
select_fit = f_fitness(b(1:f_num));
%Calculate offspring fitness
s_fitness = compute_fit(new_pop,hist);
%Calculate the cumulative probability according to the fitness value
cumulat_fit = zeros(row,1); %Cumulative fitness
pro = zeros(row,1); %Cumulative probability
c_sum = 0;
for i = 1:row
c_sum = c_sum + s_fitness(i);
cumulat_fit(i) = c_sum;
end
por = cumulat_fit/c_sum;
%roulette wheel selection row - f_num Individuals
s_num = row - f_num;
[a b] = sort(s_fitness,'descend');
temp_pop(f_num+1:row,:) = new_pop(b(1:s_num),:);
history_j = zeros(1,row);
for i=1:s_num
r = rand;
for j=1:row
if por(j) >= r
history_j(i) = j;
temp_pop(f_num+i,:) = new_pop(j,:);
select_fit(f_num+i)= s_fitness(j);
break;
end
end
end
%Best and average fitness of each generation after selection
best_fit = max(select_fit);
aver_fit = mean(select_fit);
best_fit_aver_fit = [best_fit aver_fit];
%The solution space of the best fitness after selection
[a b] = sort(select_fit,'descend');
cur_best_pop = temp_pop(b(1),:);
select_pop =temp_pop;
end
8.6 calculation of fitness function_ fit.m
%% (4)Calculation of fitness
%Fitness 2
% function fitness = compute_fit(pop,hist)
% [row list] = size(pop);
%
% %Sort each individual and then adjust it back
% [sort_pop order] = sort(pop,2);
%
% %(4.1)Calculate variance between classes
% %(4.1.1)Calculate the average value of pixels in the threshold segment
% m = zeros([row list+1]);
% %(4.1.2)Calculate the probability within the threshold segment
% p = zeros([row list+1]);
% %(4.1.3)Calculate global pixel average
% mg = zeros(row,1);
% sum_i = zeros([row list+1]);
% for k = 1:row %row Individuals
% for i=1:list+1
% %Determine threshold segment start
% if i == 1
% m_start = 1;
% else
% m_start = pop(k,i-1);
% end
% %Determine threshold segment start
% if i == list+1
% m_end = 256;
% else
% m_end = pop(k,i)-1;
% end
%
% for j = m_start:m_end
% m(k,i) = m(k,i) + j * hist(j); %Common understanding: total gray level in threshold segment
% sum_i(k,i) = sum_i(k,i) + hist(j); %General understanding: the total number of pixels in the threshold segment
% end
% end
% sum_i(k,sum_i(k,:)==0) = 0.0001;
% m(k,:) = m(k,:)./sum_i(k,:); %Average gray level of pixels in threshold segment
% p(k,:) = sum_i(k,:)./sum(sum_i(k,:)); %Probability of pixel number of each threshold segment in total pixel number
% end
% mg = sum(m.*p,2); %Expectation of overall gray value of each individual row * 1
% S_bo = sum(p .* ((m - mg) .^ 2),2); %Between objects variance row*1
%
% %(4.2)Calculate intra class variance
% %(4.2.1)Calculate variance within threshold segment Si
% si = zeros([row list+1]);
% for k = 1:row %row Individuals
% for i=1:list+1
% %Determine threshold segment start
% if i == 1
% m_start = 1;
% else
% m_start = pop(k,i-1);
% end
% %Determine threshold segment start
% if i == list+1
% m_end = 256;
% else
% m_end = pop(k,i)-1;
% end
% for j = m_start:m_end
% si(k,i) = si(k,i) + (hist(j) - m(k,i)).^2; %row * list+1
% end
% end
% end
% %Global variance of image
% sg = zeros(row,1);
% for j=1:256
% sg = sg + hist(j) .* (j - mg).^2; %row*1
% end
%
% S_wo = sum(si./sg,2); %row*1
% S_wo(S_wo==0) = 0.001;
% % S_bo
% % S_wo
% fitness = S_bo ./ S_wo;
% end
%Fitness 1
function fitness = compute_fit(pop,hist)
[row list] = size(pop);
%Sort each individual and then adjust it back
[sort_pop order] = sort(pop,2);
%Calculate the total pixels in the image
image_sum = sum(hist);
%Calculate the probability of each pixel component pi Represent gray value i Probability of
p = hist ./ image_sum;
%Gray level expectation of the whole image
gray = 1:256;
gray = gray'; %Matrix transpose
mg = sum(gray .* p);
pk = zeros(row,list+1); %Total probability of each threshold segment
mk = zeros(row,list+1); %Gray value expectation of each threshold segment
for i = 1:row
for j = 1:list+1
%Determine start position
if j == 1
m_start = 1;
else
m_start = sort_pop(i,j-1)+1;
if m_start > 256
m_start = 256;
end
end
%Determine end position
if j == list+1
m_end = 256;
else
m_end = sort_pop(i,j);
end
%Calculate the total probability that pixels are divided into each threshold segment
pk(i,j) = sum(p(m_start:m_end));
%prevent pk Become denominator for 0
if pk(i,j)==0
pk(i,j)= 0.0001;
end
%Calculate the gray value expectation of each threshold segment
mk(i,j) = sum((gray(m_start:m_end) .* p(m_start:m_end))/pk(i,j));
end
end
%Calculate variance between classes
H = pk.*((mk - mg).^2);
S = sum(H,2);
fitness = S;
endThank you. Welcome to talk!