Merge pull request #24 from navkiran/master

Added Image Processing Algorithms for Matlab

Author: cozek

algorithms/ImageProcessing/LSB based Image Steganography/decrypt.m

@@ -0,0 +1,32 @@
+clc;
+clear variables;
+len=str2double(input('Enter the length (character count) of the message you are looking for: ','s'));
+len = len*8;
+image_hide = imread('output.png');
+[rows,columns,channels] = size(image_hide);
+if channels > 1
+    image_hide = rgb2gray(image_hide);
+end
+count=1;
+bitseq='';
+for i=1:rows
+    for j=1:columns
+        %For all the characters in the message
+        if count<=len
+            
+            %Retrieve the LSB of the intensity level of the pixel
+            LSB=mod(image_hide(i,j),2);
+            bitseq(count,1) = LSB;
+            count=count+1;
+        end
+    end
+end
+
+%Converting the bit sequence into the original message
+weights = [ 128 64 32 16 8 4 2 1 ]; 
+
+% elements are taken column wise from bitseq, each char has 8 bits so 8
+% rows
+message_matrix = reshape(bitseq,8,len/8);
+original_message = char(weights*message_matrix);
+disp(['The original message is: ',original_message]);

algorithms/ImageProcessing/LSB based Image Steganography/imgst1.png

@@ -0,0 +1,42 @@
+Image Steganography means hiding data in an image. 
+
+This is possible because images are constituted of pixels. Each pixel can be represented as bits. The lower bits don't hold a lot of detail so they can be used to hide our data (by replacing them with corresponding bits of data). 
+
+Since most of the information is contained in MSBs (due to their higher weights; bits are multiplied by 2^n for the nth bit and added during binary to decimal conversion), the resulting image is very similar to the human eye if we modify the LSBs only (Least Significant Bits).
+
+The encoding is done using the following steps:
+
+    1. Convert the image to greyscale
+    2. Resize the image if needed
+    3. Convert the message to its binary format
+    4. Initialize output image same as input image
+    5. Traverse through each pixel of the image and do the following:
+       - Convert the pixel value to binary
+       - Get the next bit of the message to be embedded
+       - Create a variable temp
+        If the message bit and the LSB of the pixel are same, set temp = 0
+        If the message bit and the LSB of the pixel are different, set temp = 1
+        This setting of temp can be done by taking XOR of message bit and the LSB of the pixel
+        Update the pixel of output image to input image pixel value + temp
+        
+    Keep updating the output image till all the bits in the message are embedded
+    Finally, write the input as well as the output image to local system.
+
+The decoding/decryption is done using the following steps:
+
+    1. Get the output image which was encoded earlier.
+    2. Input the length of the encoded message (character count).
+    3. Retrieve the LSBs of each pixel
+    4. Form a bit sequence from these LSBs
+    5. Arrange the bit sequence into a matrix of 8 rows and total_message_bits/8 columns 
+        (each column will represent a character of 8 bits, hence 8 rows)
+       - Convert the binary value to decimal
+       - Get the corresponding char from ascii
+  
+        
+    Finally, display the original message.
+    
+References:
+[Concept, TDS article](https://towardsdatascience.com/steganography-hiding-an-image-inside-another-77ca66b2acb1), 
+[GFG article on LSB based Image Steganography](https://www.geeksforgeeks.org/lsb-based-image-steganography-using-matlab/), 
+[GFG article on text extraction from image](https://www.geeksforgeeks.org/text-extraction-from-image-using-lsb-based-steganography/)

algorithms/ImageProcessing/LSB based Image Steganography/imgst2.png

@@ -0,0 +1,58 @@
+clc;
+clear variables;
+% Load the image and convert to grayscale if it is RGB
+I=imread('input.png');
+[rows, columns, numberOfColorChannels] = size(I);
+if numberOfColorChannels > 1
+    I = rgb2gray(I);
+end
+L=256;
+image_hide=I;
+
+message=input('Please enter the message you want to hide: ','s');
+% Each character occupies a byte, so total bits can be found by multiplying
+% string length by 8
+len=strlength(message)*8; 
+ascii_values=uint8(message);   
+ascii2binary=dec2bin(ascii_values,8);
+
+% Append all binary equivalents of ascii values into one string
+binary_sequence='';  
+for i=1:strlength(message)
+    binary_sequence=append(binary_sequence,ascii2binary(i,:));
+end
+
+% To track how many bits of message have been hidden
+bitCount=1;
+
+for i=1:rows
+    for j=1:columns
+        
+        if bitCount<=len
+            %Obtain the LSB of the grey level of the pixel
+            LSB=mod(I(i,j),2);
+            
+            %Convert the bit from the message to numeric form
+            a=str2double(binary_sequence(bitCount));
+
+            %Perform XOR operation between the bit and the LSB
+            temp=double(xor(LSB,a));
+            
+            %Change the bit of the image_hide accordingly
+            image_hide(i,j)=I(i,j)+temp;
+            
+            bitCount=bitCount+1;
+        end
+    end
+end
+
+subplot(1,2,1);
+imshow(I);
+title('Input Image');
+
+subplot(1,2,2);
+imshow(image_hide);
+title('Image with Hidden Data');
+
+imwrite(image_hide,'output.png')
+

algorithms/ImageProcessing/LSB based Image Steganography/input.png

@@ -0,0 +1,6 @@
+Used for resizing images. It assigns to each location the intensity of its nearest neighbor in original image. Refer [Gonzalez DIP Book](https://www.pearson.com/us/higher-education/program/Gonzalez-Digital-Image-Processing-4th-Edition/PGM241219.html) chapter 1.
+
+Basic algorithm is as follows:
+
+*For every pixel in resized image, we find the coordinate mapping in original image and copy over the pixel intensity from         there to pixel in output image.*
+

algorithms/ImageProcessing/LSB based Image Steganography/output.png

@@ -0,0 +1,27 @@
+clc;
+clear variables;
+image=imread('lena_color.bmp');
+[r,c,d] = size(image);
+zoom = 1.5;
+zr=zoom*r;
+zc=zoom*c;
+
+for i=1:1:zr
+     for j=1:1:zc
+         x=i/zoom;
+         mapi=round(x);
+         y=j/zoom;
+         mapj=round(y);
+          if mapi==0
+            mapi=1;
+         end
+         if mapj==0
+             mapj=1;
+         end
+         res(i,j)=image(mapi,mapj);
+     end
+end
+figure
+imshow(image);
+figure
+imshow(res);