hdjm.m

抽取子图像: 通过一个随机混沌标签序列从原图像中抽取 对子图像加密:小波变换 ,在高频部分加密 重构原图

function output=hdjm(inputx)
yuantu=inputx;             %读入原图像
[m,n]=size(yuantu);                         %计算图象大小

% 1 从原图中抽取一个128*128的子图像

           %% 将原图分解为1024个8*8小块
point1=zeros(1024,2);                       %point1存储各个小块的序号及首个坐标值(x,y)
s=1;                                        %s用来标记1024个小块的序号
for i=1:8:m-7                                                 
    for j=1:8:n-7                                    
        point1(s,:)=[i j];                  %将每个小块的首个坐标值存入数组
        s=s+1;
    end                                     
end    

           %% 从1024个小块中选取256个                
x=zeros(1,1024);                            %创建1*1024的数组x
y=zeros(1,256);                             %创建1*256的数组y，存放x中的前256个不同的数
x(1)=0.7;                                   %赋初值，满足0<x(1)<1
y(1)=round(x(1)*1024);
for i=2:1024                                %循环产生1024个double型数，并存入数组x中
    x(i)=3.8*x(i-1)*(1-x(i-1));             %采用Logistic映射x(i)=3.8*x(i-1)*(1-x(i-1)) 
end 
x(1)=round(x(1)*1024);                      %将x(1)*1024并四舍五入转化为整型
p=1;                                        %p用来标记数组y的下标
for i=2:1024                                %循环找出数组x(1)中的前256个不同的数
    x(i)=round(x(i)*1024);                  %将x(i)*1024并四舍五入转化为整型
    flag1=0;                                %标记当前x(i)是否重复：0-否，1-是
    for j=p:1                               %将x(i)依次与数组y中已有的数比较                             
        if x(i)==y(j)                  
            flag1=1;                        %判断当前x(i)是否重复：1-是
        end
    end
     if flag1==0                            %判断当前x(i)未重复，0-否                   
          p=p+1;                            %数组y的下标加一
          y(p)=x(i);                        %若x(i)未重复，则存入数组y
     end
     if p==256                              %如果找到了256个数，则退出循环
         break
     end
end
y=uint16(y);                                %将数组由double类型转化为int类型   

           %% 检验数组y中的256个数是否不重复
flag2=0;                                    %标记数组y中是否有重复：0-否，1-是
for i=2:256                                 % 循环检验256个数是否有重复
    for j=i-1:1                             %将y(i)依次与其前面的数比较
        if y(i)==y(j)
            flag2=1;                        %若有重复，置1
        end
    end
end
if flag2==1                                 
    disp(' 数组y is wrong');                %若有重复，显示出错信息
end
    
           %% 建立128*128的子图象   
 zitu=zeros(128,128);                       %创建128*128的二维数组zitu，存放子图象
 zitu=int16(zitu);                          %将数组由double类型转化为int类型                                    
 p=1;
 for i=1:8:121                              %将8*8的小块循环放入子图象,行循环
    for j=1:8:121                           %将8*8的小块循环放入子图象,列循环
           X1=point1(y(p),1);               %取出point1中对应的坐标值X1
           Y1=point1(y(p),2);               %取出point1中对应的坐标值Y1
           zitu(i:i+7,j:j+7)=yuantu(X1:X1+7,Y1:Y1+7);     %将原图中相应的小块放入子图像中
           p=p+1;
    end
 end
 zitu=uint8(zitu);                       
 
 

% 2 对子图像进行加密


           %% 读入水印图像并作置乱处理
sy=imread('5.bmp');                         %读入水印图像
[msy,nsy]=size(sy);                         %计算子图象大小
           % 使用混沌序列对水印置乱
point2=zeros(2,4096);                       %point2存储各个像素的序号及坐标值(x,y)
s=1;                               
for i=1:msy
    for j=1:nsy                            
        point2(:,s)=[i;j];                  %将各个像素的序号及坐标值(x,y)存入point2
        s=s+1;
    end                                     
end 
xx=zeros(1,4096);                           %创建1*4096的数组xx
xx(1)=0.7;                                  %赋初值，满足0<x(1)<1
for i=2:4096                                %循环产生4096个double型数，并存入数组x中
    xx(i)=3.8*xx(i-1)*(1-xx(i-1));          %采用Logistic映射xx(i)=3.8*xx(i-1)*(1-xx(i-1)) 
end 
for i=1:4096                                
    xx(i)=round(xx(i)*4096);                %将xx*4096并四舍五入转化为整型
end 
s=1;
for i=1:64
    for j=1:64  
        X2=point2(1,xx(s));                  %取出point1中对应的坐标值X2
        Y2=point2(2,xx(s));                  %取出point1中对应的坐标值Y2
        sy2(i,j)=sy(X2,Y2);                 %将置乱后的图象存入sy2
        s=s+1;
    end                                     
end 

          %% 小波变换加密
a=0.1;                                      %嵌入系数
[m11,m12,m13,m14]=dwt2(zitu,'db1');         %对子图像进行第一次小波变换
[m21,m22,m23,m24]=dwt2(m11,'db1');          %对子图像进行第二次小波变换
[n1,n2,n3,n4]=dwt2(sy2,'db1');        %对水印图像进行小波变换
e=(m22+m23+m24)/3;
for i=1:32                                  %加密
    for j=1:32
            m22(i,j)=e(i,j)+a*n2(i,j);     
            m23(i,j)=e(i,j)+a*n3(i,j);
            m24(i,j)=e(i,j)+a*n4(i,j);
    end
end
m11=idwt2(m21,m22,m23,m24,'db1');           %第一次小波反变换
zitu2=idwt2(m11,m12,m13,m14,'db1');         %由小波反变换重构子图像
zitu2=uint8(zitu2);
                                            %% PSNR=32.1711
                                          
                                          
% 3 将加密后的子图像放回到原图中，重建256*256的原图象      
p=1;
ff=yuantu;                                  %存放将加密后的图像                     
for i=1:8:121                               %将8*8的小块循环放入ff,行循环
   for j=1:8:121                            %将8*8的小块循环放入ff,列循环
          X1=point1(y(p),1); 
          Y1=point1(y(p),2);
          ff(X1:X1+7,Y1:Y1+7)=zitu2(i:i+7,j:j+7);   %将子图中相应的小块放入ff中
          p=p+1;
   end
end
output=ff;                                   %将加密后的图像输出


% 4 计算信噪比，检测抗噪能力

FF=0;
EE=0;
for i=1:1:256
    for j=1:1:256
        E(i,j)=double(ff(i,j))-double(yuantu(i,j));  % yuantu表示原图像，ff表示加密后的图像
        FF=FF+double(ff(i,j))^2;
        EE=EE+E(i,j)^2;
    end
end
SNR=sqrt(FF/EE);                            % SNR表示均方信噪比
MSE=EE/(256*256);
PSNR=10*log10((255^2)/MSE);                 % PSNR表示峰值信噪比
disp('峰值信噪比:');
PSNR
%显示结果
subplot(2,3,1);
subimage(yuantu);
subplot(2,3,2);
subimage(zitu);
subplot(2,3,3);
subimage(zitu2);
subplot(2,3,4);
subimage(sy);
subplot(2,3,5);
subimage(sy2);
subplot(2,3,6);
subimage(ff);