# IMAGE PROCESSING

Lets Learn together... Happy Reading

" Two roads diverged in a wood, and I,
I took the one less traveled by,
And that has made all the difference "-Robert Frost

## Recent Posts

### Partially Colored gray scale Images

A RGB image contains three components. Namely: Red, Blue and Green.

The below figure represents various colors and their corresponding RGB (Red , Green and Blue) component values.

Gray scale value of the above RGB components:

A gray scale image can be formed from a RGB image by taking the sum of 29.89% of pixel value of Red component, 58.70% of pixel value of green component and 11.40% of pixel value of Blue component.

For instance, consider the second shade with values [150 9 22] from the color vector.
The corresponding gray scale value = (150*0.2989)+(9*.5870)+(22*.1140)
= 52.62
= 53 (approximately)

Consider the gray scale values 61 ,106 and 83 from the gray scale vector.
If the gray scale value is updated in the RGB components of the colored vector then that particular shade will be in gray scale as shown below.
The value 61 is updated in Red, Green and Blue components. Similarly, 106 and 83 are also updated.

Using this principle, we can use both RGB and gray color in a single image to obtain a partially colored gray scale image.

Let us now learn how to obtain partially colored gray scale image.

Step 1: Read the input RGB image and its corresponding RGB components
1.       Read an RGB Image
2.       Store the Red component in matrix R, Green in matrix G and Blue in matrix B.
Step 2:  Define the Grayscale Image
1.       Convert RGB Image to Grayscale Image (GS)
2.       Create a matrix R1, G1 and B1 of the same size of matrix R, G and B
3.       Update the matrices R1,G1 and B1 with the value of the matrix GS

Step 3: Create a Mask
1.       Create a matrix of size GS
2.       Update the pixel positions with one if the pixel position should be RGB else zero or vice versa.
Step 4:  Find the index of the masked positions from the Mask
Step 5:  Create partial color and gray scale
1.       Obtain the Red component (R) for the corresponding index of the mask and update it in the R1 matrix. Similarly, update the other matrices G1 and B1 with values of G and B matrices based on the index of the mask.
2.       Create a Three dimensional matrix of the same size of RGB Image
3.       Update the three dimensional matrix with the R1, G1 and B1 components. This is the required partially coloured gray scale image.
Step 6:  Display the partially colored gray scale image

MATLAB CODE:

%Read a RGB image
R = A(:,:,1); %RED component
G = A(:,:,2); %GREEN component
B = A(:,:,3); %BLUE component

%RGB to Gray scale Image
GS = rgb2gray(A);
R1 = GS;
G1 = GS;
B1 = GS;

wndow = uint8((gausswin(size(A,1),12)*gausswin(size(A,2),7)')*255);
wndow = ~wndow;

%Find Index
X = find(wndow==0);

R1(X) = R(X);
G1(X) = G(X);
B1(X) = B(X);

%Create a RGB matrix
C = zeros(size(A));
C(:,:,1) = R1;
C(:,:,2) = G1;
C(:,:,3) = B1;

C = uint8(C);

figure,imshow(C);

The mask can also be created manually as shown below:

Like "IMAGE PROCESSING" page

### Convert HSI Image to RGB Image

CONVERT HSI IMAGE TO RGB IMAGE:

Refer How to convert the RGB image to HSI Image

MATLAB CODE:

`````` figure,imshow(HSI);title('HSI Image');
%Obtain the Hue, Saturation and Intensity components
H1=HSI(:,:,1);
S1=HSI(:,:,2);
I1=HSI(:,:,3);

``````

`````` %Multiply Hue by 360 to represent in the range [0 360]
H1=H1*360;

%Preallocate the R,G and B components
R1=zeros(size(H1));
G1=zeros(size(H1));
B1=zeros(size(H1));
RGB1=zeros([size(H1),3]);

%RG Sector(0<=H<120)
%When H is in the above sector, the RGB components equations are

B1(H1<120)=I1(H1<120).*(1-S1(H1<120));
R1(H1<120)=I1(H1<120).*(1+((S1(H1<120).*cosd(H1(H1<120)))./cosd(60-H1(H1<120))));
G1(H1<120)=3.*I1(H1<120)-(R1(H1<120)+B1(H1<120));

%GB Sector(120<=H<240)
%When H is in the above sector, the RGB components equations are

%Subtract 120 from Hue
H2=H1-120;

R1(H1>=120&H1<240)=I1(H1>=120&H1<240).*(1-S1(H1>=120&H1<240));
G1(H1>=120&H1<240)=I1(H1>=120&H1<240).*(1+((S1(H1>=120&H1<240).*cosd(H2(H1>=120&H1<240)))./cosd(60-H2(H1>=120&H1<240))));
B1(H1>=120&H1<240)=3.*I1(H1>=120&H1<240)-(R1(H1>=120&H1<240)+G1(H1>=120&H1<240));

%BR Sector(240<=H<=360)
%When H is in the above sector, the RGB components equations are

%Subtract 240 from Hue
H2=H1-240;

G1(H1>=240&H1<=360)=I1(H1>=240&H1<=360).*(1-S1(H1>=240&H1<=360));
B1(H1>=240&H1<=360)=I1(H1>=240&H1<=360).*(1+((S1(H1>=240&H1<=360).*cosd(H2(H1>=240&H1<=360)))./cosd(60-H2(H1>=240&H1<=360))));
R1(H1>=240&H1<=360)=3.*I1(H1>=240&H1<=360)-(G1(H1>=240&H1<=360)+B1(H1>=240&H1<=360));

%Form RGB Image
RGB1(:,:,1)=R1;
RGB1(:,:,2)=G1;
RGB1(:,:,3)=B1;

%Represent the image in the range [0 255]
RGB1=im2uint8(RGB1);
figure,imshow(RGB1);title('RGB Image');

``````

Explanation

Like "IMAGE PROCESSING" page

### Converting RGB Image to HSI

Converting RGB Image to HSI

H stands for Hue, S for Saturation and I for Intensity.

MATLAB CODE:
Read a RGB Image
figure,imshow(A);title('RGB Image');

%Represent the RGB image in [0 1] range
I=double(A)/255;

R=I(:,:,1);
G=I(:,:,2);
B=I(:,:,3);

%Hue
numi=1/2*((R-G)+(R-B));
denom=((R-G).^2+((R-B).*(G-B))).^0.5;

%To avoid divide by zero exception add a small number in the denominator
H=acosd(numi./(denom+0.000001));

%If B>G then H= 360-Theta
H(B>G)=360-H(B>G);

%Normalize to the range [0 1]
H=H/360;

%Saturation
S=1- (3./(sum(I,3)+0.000001)).*min(I,[],3);

%Intensity
I=sum(I,3)./3;

%HSI
HSI=zeros(size(A));
HSI(:,:,1)=H;
HSI(:,:,2)=S;
HSI(:,:,3)=I;

figure,imshow(HSI);title('HSI Image');

Explanation:

1.    Read a RGB image using ‘imread’ function.
2.    Each RGB component will be in the range of [0 255].  Represent the image in [0 1] range by dividing the image by 255.
3.    Find the theta value. If B<=G then H= theta. If B>G then H= 360-theta
4.    Use ‘acosd’ function to find inverse cosine and obtain the result in degrees.
5.    Divide the hue component by 360 to represent in the range [0 1]
6.    Similarly, find the saturation and the intensity components.
7.    Display the image.

Like "IMAGE PROCESSING" page

### Otsu’s thresholding without using MATLAB function graythresh

To perform the thresholding I followed these steps:
a.       Reshape the 2 dimensional grayscale image to 1 dimensional.
b.      Find the histogram of the image using  ‘hist’ function.
c.       Initialize a matrix with values from 0 to 255
d.      Find the weight , mean and the variance for the foreground and background
e.      calculate weight of foreground* variance of foreground + weight of background* variance of background.
f.       Find the minimum value.
MATLAB CODE:
```
%To threshold image without using graythresh function

function mygraythresh

global H Index;

```

Here I converted the 2d matrix to 1d matrix.
```V=reshape(B,[],1);
```

The histogram of the values from 0 to 255 is stored.
For instance, G(1) contains the number of occurrence of the value zero in the image.
```
G=hist(V,0:255);

H=reshape(G,[],1);

```
'index' is a 1 dimensional matrix ranging between 0 and 255
```
Ind=0:255;

Index=reshape(Ind,[],1);

result=zeros(size([1 256]));
```

To avoid many for loops I used only 1 for loop and a function to calculate the weight, mean and variance.

Let me explain the foreground and the background for a value of ‘i’.
if ‘i’ value is 5 then the foreground values will be 0,1,2,3,4,5
and the background values will be 6 to 255.
``````

for i=0:255

[wbk,varbk]=calculate(1,i);

[wfg,varfg]=calculate(i+1,255);

``````
After calculating the weights and the variance, the final computation is stored in the array ‘result’.
```
result(i+1)=(wbk*varbk)+(wfg*varfg);

end

%Find the minimum value in the array.                   [threshold_value,val]=min(result);

tval=(val-1)/256;
```

Now convert the image to binary with the calculated threshold value.
```
bin_im=im2bw(B,tval);

figure,imshow(bin_im);

function [weight,var]=calculate(m,n)

%Weight Calculation

weight=sum(H(m:n))/sum(H);

%Mean Calculation

value=H(m:n).*Index(m:n);

total=sum(value);

mean=total/sum(H(m:n));

if(isnan(mean)==1)

mean=0;

end

%Variance calculation.

value2=(Index(m:n)-mean).^2;

numer=sum(value2.*H(m:n));

var=numer/sum(H(m:n));

if(isnan(var)==1)

var=0;

end

end

end
```
`                     `
`                   `
`                       `
`      `
```

```

 Threshold value:0.3242

Like "IMAGE PROCESSING" page

### Converting RGB image to Binary Image without using im2bw function

In the first example, image is filled with primary colors (RGB). So I am finding the sum of the values in the pixel position. If the sum is greater than zero then the value will be 1(white) otherwise zero (black).

In the second example, the following steps are needed to convert a RGB image to binary image.

1. Convert the RGB image into grayscale image.
2. Find the threshold value. If the value at the pixel position is greater than the threshold value then the value will be 1(white) else zero (black).

```
function mybinary

global GIm T1;

figure,imshow(A);

title('Original image');

B=zeros(size(A,1),size(A,2));

for l=1:size(A,1)

for m=1:size(A,2)

if(sum(A(l,m,:))>0)

B(l,m)=1;

end

end

end

B=logical(B);

figure,imshow(B);

```

```

figure,imshow(Im);

title('Original Image');

%0.2989 * R + 0.5870 * G + 0.1140 * B

GIm=uint8(zeros(size(Im,1),size(Im,2)));

for m=1:size(Im,1)

for n=1:size(Im,2)

GIm(m,n)=0.2989*Im(m,n,1)+0.5870*Im(m,n,2)+0.1140*Im(m,n,3);

end

end

```
we can perform the grayscale conversion without using the for loop:

%GIm=0.2989*Im(:,:,1)+0.5870*Im(:,:,2)+0.1140*Im(:,:,3);

```

ssz = get(0,'ScreenSize');

T.fg=figure('Visible','on','Name','IMAGE THRESHOLDING','NumberTitle','off','Position', ssz);

T.holder=axes('units','pixels','Position',[ssz(3)/35 ssz(4)/4 ssz(3)-(ssz(3)/3) ssz(4)-(ssz(4)/3)]);

imshow(GIm);

set(T.holder,'xtick',[],'ytick',[])

T.slid=uicontrol('Style','Slider','Visible','on','Value',1,'Max',255,'Min',0,'Sliderstep',[1 1],'Position',[ssz(3)/35 ssz(4)/5 ssz(3)-(ssz(3)/3) 20],'Callback', @tresher);

T.ent=uicontrol('Style','pushbutton','Visible','on','String','THRESHOLD VALUE','Position',[ssz(3)-(ssz(3)/4) ssz(4)-(ssz(4)/8) 105 30]);

T.ed=uicontrol('Style','edit','Visible','on','String','0','Value',1,'Position',[ssz(3)-(ssz(3)/4) ssz(4)-(ssz(4)/6) 90 20]);

function tresher(object,~)

val=get(object,'value');

in=GIm;

T1=Imthreshold1(in,val);

T.view1=imshow(T1);

set(T.holder,'xtick',[],'ytick',[])

set(T.ed,'String',val);

end

function Im=Imthreshold1(Image,Tvalue)

sz=size(Image);

mybin=zeros(size(Image));

for i=1:sz(1)

for j=1:sz(2)

if(Image(i,j)>Tvalue)

mybin(i,j)=1;

end

end

end

```

Instead of this for loop, the equivalent one line code is:

%mybin(find(Image>Tvalue))=1;

Explanation:
The output of find(Image>Tvalue) will be the values that are greater than Tvalue.

For instance,
consider a matrix,

>> A=[1,2,3,4;2,4,6,8;3,6,9,12];
>> A

A =

1     2     3     4
2     4     6     8
3     6     9    12

>> find(mod(A,2)==0)

ans =

2
4
5
6
8
10
11
12

``````
```
Im=logical(mybin);

end

end
```

Like "IMAGE PROCESSING" page