lsb algorithm.m

利用LSB算法去实现了电子水印技术。代码完全实现了嵌入以及提取

close all
clear all;

% save start time
start_time=cputime;

% read in the cover object
file_name='E:\Phd\My Paper\Second paper -- Experiment\Experiment\Cover and Secret Image\lena.bmp';
[cover_object,map]=imread(file_name);


% read in the secret image
file_name='E:\Phd\My Paper\Second paper -- Experiment\Experiment\Cover and Secret Image\hat.bmp';
[secret,map1]=imread(file_name);
secret1=secret;

% convert to double for normalization, then back again
secret=double(secret);
secret=fix(secret./2);    %rounds the elements of A toward zero, resulting in an array of integers
secret=uint8(secret);

% determine size of cover object
Mc=size(cover_object,1);    %Height
Nc=size(cover_object,2);    %Width

% determine size of secret object
Mm=size(secret,1);            %Height
Nm=size(secret,2);            %Width

% title the secret object out to cover object size to generate watermark
for ii = 1:Mc
    for jj = 1:Nc
        if (secret(ii,jj)>75)
            watermark(ii,jj)=255;
        else
            watermark(ii,jj)=0;
        end
    end
end

% now we set the lsb of cover_object(ii,jj) to the value of watermark(ii,jj)
watermarked_image=cover_object;
for ii = 1:Mc
    for jj = 1:Nc
        if (watermark(ii,jj)==0)
            watermarked_image(ii,jj)=bitset(watermarked_image(ii,jj),1,0);  %Set bit at certain position
        else
            watermarked_image(ii,jj)=bitset(watermarked_image(ii,jj),1,1);  %Set bit at certain position
        end
    end
end

% write the watermarked image out to a file
imwrite(watermarked_image,'lsb_watermarked.bmp','bmp');



%==================================Extraction=================================================== 
% determine size of watermarked image 
Mw=size(watermarked_image,1);	%Height 
Nw=size(watermarked_image,2);	%Width 
 
% use lsb of watermarked image to recover watermark 
for ii = 1:Mw 
    for jj = 1:Nw 
        RecoveryWatermark(ii,jj)=bitget(watermarked_image(ii,jj),1); 
    end 
end 
 
% scale the recovered watermark 
RecoveryWatermark=2*double(RecoveryWatermark); 
%===================================================================================================


%===========================SharpAttack=================
SharpedWatermarkImage = watermarked_image;
H = fspecial('unsharp',0.001);          %the alpha from 0.005 to 0.1 20 numbers
sharpImage = imfilter(SharpedWatermarkImage,H,'replicate');
figure(6);
colormap(gray(256));
imshow(sharpImage);
title('sharp Image');
imwrite(sharpImage, gray(256), 'sharpImage.bmp');

% determine size of watermarked image 
MSw=size(sharpImage,1);	%Height 
NSw=size(sharpImage,2);	%Width 
 
% use lsb of watermarked image to recover watermark 
for ii = 1:MSw 
    for jj = 1:NSw 
        RecoverySharpWatermark(ii,jj)=bitget(abs(sharpImage(ii,jj)),1); 
    end 
end 
 
% scale the recovered watermark 
RecoverySharpWatermark=2*double(RecoverySharpWatermark); 
psnrSharp = psnr(RecoveryWatermark, RecoverySharpWatermark)

figure(7);
colormap(gray(256));
imshow(RecoverySharpWatermark,[])
title('RecoverySharpWatermark');

%====================================================================
% 
% 
%===========================Gaussian Blur=================
GaussianBlurWatermarkedImage = watermarked_image;
H = fspecial('gaussian',size(GaussianBlurWatermarkedImage),0.035); %the alpha from 0.005 to 0.1 20 numbers 
GaussianBlurImage = imfilter(GaussianBlurWatermarkedImage,H,'replicate');
figure(8);
colormap(gray(256));
imshow(GaussianBlurImage,[])
title('Gaussian Blur Image');
imwrite(GaussianBlurImage, gray(256), 'GaussianBlurImage.bmp');

% determine size of watermarked image 
MSw=size(GaussianBlurImage,1);	%Height 
NSw=size(GaussianBlurImage,2);	%Width 
 
% use lsb of watermarked image to recover watermark 
for ii = 1:MSw 
    for jj = 1:NSw 
        RecoveryGaussianBlurWatermark(ii,jj)=bitget(GaussianBlurImage(ii,jj),1); 
    end 
end 
 
% scale the recovered watermark 
RecoveryGaussianBlurWatermark=2*double(RecoveryGaussianBlurWatermark); 
psnrBlur = psnr(RecoveryWatermark, RecoveryGaussianBlurWatermark)

figure(9);
colormap(gray(256));
imshow(RecoveryGaussianBlurWatermark,[])
title('RecoveryGaussianWatermark');
% % 
% %===========================================================
% % 
% % %==========================================Histogram=======================
histogramWatermarkedImage = watermarked_image;
histogramImage = histeq(watermarked_image,10); % from 10 to 200
figure(10);
colormap(gray(256));
image(histogramImage); 
title('histogramImage Image');
imwrite(histogramImage, gray(256), 'histogramImage.bmp');

MSw=size(histogramImage,1);	%Height 
NSw=size(histogramImage,2);	%Width 
 
% use lsb of watermarked image to recover watermark 
for ii = 1:MSw 
    for jj = 1:NSw 
        RecoveryHistogramWatermarked(ii,jj)=bitget(histogramImage(ii,jj),1); 
    end 
end 

 
% scale the recovered watermark 
RecoveryHistogramWatermarked=2*double(RecoveryHistogramWatermarked); 
psnrHistorgram = psnr(RecoveryWatermark, RecoveryHistogramWatermarked)

figure(11);
colormap(gray(256));
imshow(RecoveryHistogramWatermarked,[])
title('RecoveryHistogramWatermarked');
% 
% %==========================================================================
% 
% 
% %==========================Noise=============================
NoiseWatermarked = watermarked_image;
NoiseImage = imnoise(NoiseWatermarked,'gaussian',0.001);
figure(12);
colormap(gray(256));
imshow(NoiseImage);
title('noiseImage');
imwrite(NoiseImage, gray(256), 'noiseImage.bmp');

MSw=size(NoiseImage,1);	%Height 
NSw=size(NoiseImage,2);	%Width 
 
% use lsb of watermarked image to recover watermark 
for ii = 1:MSw 
    for jj = 1:NSw 
        RecoveryNoiseWatermarked(ii,jj)=bitget(NoiseImage(ii,jj),1); 
    end 
end 

 
% scale the recovered watermark 
RecoveryNoiseWatermarked=2*double(RecoveryNoiseWatermarked); 
psnrNoise = psnr(RecoveryWatermark, RecoveryNoiseWatermarked)

figure(13);
colormap(gray(256));
imshow(RecoveryNoiseWatermarked,[])
title('RecoveryNoiseWatermarked');
%%=====================================================================



% display processing time
elapsed_time=cputime-start_time,