# Column Sorting Code with Best Result in Matlab(2-D)

clc, clear, close all;
tic

a=imread(‘cameraman.tif’); imshow(a);
nf=.5;
ws=3;
ll=floor(ws/2);

b=imnoise(a,’salt & pepper’,nf); % Generation of noisey input to algorithm
figure,imshow(b);

[m1 n1]=size(a);
b1=zeros(m1+ws-1);
b1=uint8(b1);
[m n]=size(b1);
b1(ll+1:m-ll,ll+1:n-ll)=b;
for i = 2:m-1
for j = 2:n-1
if(b1(i,j)<=0||b1(i,j)>=255)
y=b1(i-ll:i+ll,j-ll:j+ll);
p = sort(y(:,1:1));
q = sort(y(:,2:2));
r = sort(y(:,3:3));
b = [p,q,r];
S = sort(b(:));
flg = 1;
if S(1) < b1(i,j) && b1(i,j) < S(5) && 0 < S(1) && S(9) < 255
b1(i,j) = y(i,j);

else
b1(i,j) = S(5);
end
end
end
end

b2=b1(ll+1:m-ll,ll+1:n-ll);
figure,imshow(b2)
[psnr,mse]=psnr_mse_maxerr(a,b2);
display(psnr)
display(mse)
toc Advertisements

# Bubble Sort in MATLAB

clc, clear, close all;
tic
a=imread(‘lena_gray.tif’);
nf=.5;
ws=3;

b=imnoise(a,’salt & pepper’,nf);
figure,imshow(b);

[m1 n1]=size(b);
ll=floor(ws/2);
b1=zeros(m1+ws-1); % b1 is zero matrix of 514*514
b1=uint8(b1); % b1 is a unsign 8 bit
[m n]=size(b1);

b1(ll+1:m-ll,ll+1:n-ll)=b;

for i=ll+1:m1-ll
for j=ll+1:n1-ll
f1=b1(i-ll:i+ll,j-ll:j+ll);
f=f1;
n=length(f);
g=size(f);
for k=1:g
for l=g-1:-1:k+1
if(f(l)<f(l+1))
tmp=f(l);
f(l)=f(l+1);
f(l+1)=tmp;
end
end
end
if (0<b1(i,j)&&b1(i,j)<255) %(0<t1(2,2)&&t1(2,2)<255)
else
for i1=9:-1:1 % for i1= (start= 5 : step= -1 : end=1)
if (0<f(i1)&&f(i1)<255) % if
b1(i,j)=f(i1);
break;
end
if (i1==1)
b1(i,j)=f(5);
end
end
end
end
end
[m n]=size(b1);
b2=b1(ll+1:m-ll,ll+1:n-ll); % Size of b2 is 512*512
figure,imshow(b2);
toc

# Ascending Sort Code With Effective Result in MATLAB – M. Ganesh Sai

tic
clc
clear all
a=imread(‘lena_gray.tif’);
imshow(a)
nf=.4;
ws=3;
b=imnoise(a,’salt & pepper’,nf);
figure,imshow(b)

[m1 n1]=size(a);
r=floor(ws/2);
b1=zeros(m1+ws-1);
b1=uint8(b1);
[m n]=size(b1);
b1(r+1:m-r,r+1:n-r)=b;
for i=r+1:m-r
for j=r+1:n-r
t1=b1(i-r:i+r,j-r:j+r);
t2=sort(t1(:));
le=length(t2);
len=ceil(le/2);
if (0<t1(r+1,r+1)&&t1(r+1,r+1)<255)
else
if t1(r+1,r+1)==255
for i1=len:-1:1
if (0<t2(i1)&&t2(i1)<255)
b1(i,j)=t2(i1);
break;
end
if (i1==1)
b1(i,j)=t2(len);
end
end
elseif t1(r+1,r+1)==0
for i1=len:le
if (0<t2(i1)&&t2(i1)<255)
b1(i,j)=t2(i1);
break;
end
if (i1==le)
b1(i,j)=t2(len);
end
end
end
end
end
end
b2=b1(r+1:m-r,r+1:n-r);
figure,imshow(b2)
toc

# Column Sorting Technique In 2D MATLAB – M. Ganesh Sai

Column sort is a simple sorting algorithm that works by repeatedly stepping through the list to be sorted through the columns in the matrix  swapping each column if they are in the wrong order. The pass through the matrix is repeated until no swaps are needed, which indicates that the matrix is sorted. The algorithm gets its name from the way that the each column is sorted in the matrix.

Illustrative Example

Let us take the matrix form , and sort the each column step by step from lowest number to greatest number using row sort. In each step, elements written in bold are being sorted. Five steps will be required.

95       45       92       41       13

73       89       20       74       52

05       19     44       20       73

40       35     60       93       67

81       27     46       83       93

First step:

First sort the column 1 elements in the matrix form.

95     45     92   41     13                                                       05   45   92   41   13

73     89     20   74     52                                                       40   89   20   74   52

05     19     44   20     73                           →                        73   19   44   20   73

40     35     60   93     67                                                       81   35   60   93   67

81     27   46   83     93                                                         95     27   46   83   93

Second step:

Sort the column 2 elements in the matrix form.

95     45     92   41     13                                                       95   19   92   41   13

73     89     20   74     52                                                       73   27   20   74  52

05     19     44   20     73                           →                        05   35   44   20   73

40     35     60   93     67                                                       40   45   60   93   67

81     27   46   83     93                                                         81     89   46   83   93

Third step:

Sort the column 3 elements in the matrix form.

95     45     92   41     13                                                      95   45   20   41   13

73     89     20   74     52                                                      73   89   44   74   52

05     19     44   20     73                           →                        05   19   46   20   73

40     35     60   93     67                                                      40   35   60   93   67

81     27   46   83     93                                                        81     27   92    83   93

Fourth step:

Sort the column 4 elements in the matrix form.

95     45     92   41     13                                                       95   45   92   20   13

73     89     20   74     52                                                       73   89   20   41   52

05     19     44   20     73                           →                         05   19   44   74   73

40     35     60   93     67                                                        40   35   60   83   67

81     27   46   83     93                                                          81     27   46   93   93

Fifth step:

Sort the column 5 elements in the matrix form.

95     45     92   41     13                                                       95   45   92   41   13

73     89     20   74     52                                                      73   89   20   74   52

05     19     44   20     73                           →                       05   19   44   20   67

40     35     60   93     67                                                     40   35   60   93   73

81     27   46   83     93                                                       81     27   46   83   93

Finally sorted columns in the matrix is shown below:

95     45     92   41     13                                                       05   19   20   20   13

73     89     20   74     52                                                       40   27   44   41   52

05     19     44   20     73                           →                        73   35   46   74   67

40     35     60   93     67                                                       81   45   60   83   73

81     27   46   83     93                                                         95   89   92   93   93

Column Sort Output Table are given bellow:

 Selection 3X3 5X5 7X7 9X9 Noise Density psnr Time Psnr Time psnr time psnr time 10% 32.05 3.15 32.02 3.35 32.34 3.32 31.98 3.42 20% 28.40 3.18 28.52 3.12 28.10 3.21 28.38 3.13 30% 25.99 3.05 26.17 3.01 26.17 3.19 25.92 3.11 40% 23.83 2.95 24.08 2.93 24.06 2.99 23.98 3.06 50% 22.14 2.79 22.03 2.97 22.20 2.88 22.12 2.93 60% 20.41 2.67 20.58 2.74 20.36 2.80 20.29 2.72 70% 18.65 2.54 18.54 2.54 18.71 2.62 18.58 2.62 80% 16.58 2.41 16.71 2.40 16.78 2.52 16.76 2.49 90% 13.94 2.33 14.05 2.49 14.24 2.54 13.98 2.36

//