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);