function stego=HILL_Repeatablecoverpathpayloadncover1=doubleimreadcoverpath;MN=sizecover1;wetCost = 10^8;coverLSB=modcover12;cover2=cover1-coverLSB;cost=EmbeddingCostcover2;tempcost=cost;~loc=sorttemp

该代码实现了一种可重复的隐藏信息（steganography）算法，使用HILL算法进行信息嵌入。下面是每行代码的含义：

1. function stego=HILL_Repeatable(coverpath,payload,n)：定义了一个函数 HILL_Repeatable，接受三个参数 coverpath（待隐藏信息的图像路径）、payload（隐藏信息的比特率）和 n（重复嵌入的次数），返回隐藏信息后的图像。

2. cover1=double(imread(coverpath))：从路径 coverpath 中读取待隐藏信息的图像，并将其转换为双精度的矩阵 cover1。

3. [M,N]=size(cover1)：获取图像矩阵 cover1 的尺寸，分别赋值给变量 M 和 N。

4. wetCost = 10^8：设置一个很大的嵌入代价 wetCost，用于表示无法嵌入信息的像素点。

5. coverLSB=mod(cover1,2)：计算图像矩阵 cover1 中每个像素的最低有效位（Least Significant Bit，LSB），并赋值给 coverLSB。

6. cover2=cover1-coverLSB：将图像矩阵 cover1 减去 coverLSB，得到只包含偶数值的图像矩阵 cover2。

7. cost=EmbeddingCost(cover2)：调用 EmbeddingCost 函数计算图像矩阵 cover2 的嵌入代价，并赋值给 cost。

8. tempcost=cost(:)：将 cost 矩阵展开成一维向量，并赋值给 tempcost。

9. [~,loc]=sort(tempcost)：对 tempcost 向量进行排序，并将排序后的索引赋值给 loc。

10. num=round(M*N*payload)：根据隐藏信息的比特率 payload 计算出需要隐藏的信息个数，并四舍五入为整数。

11. tempcost(loc(1:num))=1：将 tempcost 向量中前 num 个索引对应的元素置为 1，表示这些位置可以用于嵌入信息。

12. tempcost(loc(num+1:end))=wetCost：将 tempcost 向量中剩余的元素置为 wetCost，表示这些位置不可用于嵌入信息。

13. cost=reshape(tempcost,M,N)：将修改后的 tempcost 向量重新转换为与原图像矩阵 cover1 相同尺寸的矩阵，并赋值给 cost。

14. for i=1:n：重复执行下面的代码 n 次。

15. coverLSB=mod(cover1,2)：计算图像矩阵 cover1 中每个像素的最低有效位（LSB），并赋值给 coverLSB。

16. stegoLSB=EmbeddingSimulator(coverLSB,cost,round(M*N*payload),false)：调用 EmbeddingSimulator 函数将 coverLSB 和 cost 作为参数进行信息嵌入，返回嵌入信息后的图像的最低有效位（stegoLSB）。

17. stegoLSB=double(stegoLSB)：将 stegoLSB 转换为双精度矩阵。

18. stegoLSB=reshape(stegoLSB,[M,N])：将 stegoLSB 矩阵重新转换为与原图像矩阵 cover1 相同尺寸的矩阵。

19. stego=cover2+stegoLSB：将 cover2 和 stegoLSB 矩阵相加得到隐藏信息后的图像，并赋值给 stego。

20. cover1=stego：将 stego 赋值给 cover1，用于下一次循环的嵌入。

21. end：结束循环。

22. end：结束函数 HILL_Repeatable 的定义。

23. function cost=EmbeddingCost(cover)：定义了一个函数 EmbeddingCost，接受一个参数 cover（待计算嵌入代价的图像矩阵），返回每个像素的嵌入代价。

24. HF=[-1 2 -1;2 -4 2;-1 2 -1]：定义一个高通滤波器 HF。

25. H2=fspecial('average',[3 3])：创建一个 3x3 的平均滤波器 H2。

26. cover=double(cover)：将输入的图像矩阵 cover 转换为双精度矩阵。

27. sizeCover=size(cover)：获取图像矩阵 cover 的尺寸，并赋值给变量 sizeCover。

28. padsize=max(size(HF))：计算高通滤波器 HF 的尺寸，并取最大值，赋值给 padsize。

29. coverPadded=padarray(cover,[padsize padsize],'symmetric')：对图像矩阵 cover 进行边缘填充，填充大小为 padsize，填充方式为对称填充，得到填充后的矩阵 coverPadded。

30. R=conv2(coverPadded,HF,'same')：使用高通滤波器 HF 对填充后的图像矩阵 coverPadded 进行卷积操作，得到卷积结果 R。

31. W=conv2(abs(R),H2,'same')：对卷积结果 R 取绝对值，然后使用平均滤波器 H2 进行滤波操作，得到滤波结果 W。

32. if mod(size(HF,1),2)==0,W=circshift(W,[1,0])：如果高通滤波器 HF 的行数是偶数，则将滤波结果 W 向下平移一行。

33. if mod(size(HF,2),2)==0,W=circshift(W,[0,1])：如果高通滤波器 HF 的列数是偶数，则将滤波结果 W 向右平移一列。

34. W=W(((size(W,1)-sizeCover(1))/2)+1:end-((size(W,1)-sizeCover(1))/2),((size(W,2)-sizeCover(2))/2)+1:end-((size(W,2)-sizeCover(2))/2))：根据原始图像的尺寸裁剪滤波结果 W，得到与原始图像尺寸相同的矩阵。

35. cost=1./(W+10^(-10))：将滤波结果 W 取倒数，并加上一个很小的数，得到嵌入代价矩阵 cost。

36. wetCost=10^10：设置一个很大的嵌入代价 wetCost，用于表示无法嵌入信息的像素点。

37. rhoA=cost：将嵌入代价矩阵 cost 赋值给 rhoA。

38. rhoA(rhoA>wetCost)=wetCost：将 rhoA 中大于 wetCost 的元素置为 wetCost。

39. rhoA(isnan(rhoA))=wetCost：将 rhoA 中的NaN值置为 wetCost。

40. HW=fspecial('average',[15,15])：创建一个 15x15 的平均滤波器 HW。

41. cost=imfilter(rhoA,HW,'symmetric','same')：使用平均滤波器 HW 对 rhoA 进行滤波操作，得到最终的嵌入代价矩阵 cost。

42. end：结束函数 EmbeddingCost 的定义。

43. function y=EmbeddingSimulator(x,cost,m,fixEmbeddingChanges)：定义了一个函数 EmbeddingSimulator，接受四个参数 x（待嵌入信息的最低有效位矩阵）、cost（嵌入代价矩阵）、m（待嵌入信息的个数）和 fixEmbeddingChanges（是否固定嵌入变化），返回嵌入信息后的最低有效位矩阵 y。

44. n=numel(x)：计算最低有效位矩阵 x 的元素个数，并赋值给变量 n。

45. lambda=calc_lambda(cost,m,n)：调用 calc_lambda 函数计算参数 cost、m 和 n，得到嵌入强度 lambda。

46. pChange=(exp(-lambda.* cost))./(1+exp(-lambda.* cost))：根据嵌入强度 lambda 和嵌入代价 cost 计算每个像素发生嵌入变化的概率 pChange。

47. if fixEmbeddingChanges==1：如果 fixEmbeddingChanges 等于 1，则固定嵌入变化。

48. RandStream.setGlobalStream(RandStream('mt19937ar','seed',139187))：设置随机数生成器的全局种子为 139187。

49. else：否则，使用当前时间作为种子生成随机数。

50. RandStream.setGlobalStream(RandStream('mt19937ar','Seed',sum(100*clock)))：设置随机数生成器的全局种子为当前时间的和乘以 100。

51. randChange=rand(size(x))：生成一个与最低有效位矩阵 x 相同尺寸的随机数矩阵 randChange。

52. y=x：将最低有效位矩阵 x 赋值给 y。

53. y(randChange<pChange)=mod(y(randChange<pChange)+1,2)：根据随机数矩阵 randChange 和嵌入概率 pChange，对 y 矩阵中满足条件的元素进行信息嵌入，即将这些元素加1并取模2。

54. end：结束函数 EmbeddingSimulator 的定义。

55. function lambda=calc_lambda(cost,message_length,n)：定义了一个函数 calc_lambda，接受三个参数 cost（嵌入代价矩阵）、message_length（待嵌入信息的长度）和 n（图像像素的总数），返回嵌入强度 lambda。

56. l3=1e+3：设置初始的嵌入强度 l3 为 1000。

57. m3=double(message_length + 1)：将待嵌入信息的长度加1，并转换为双精度，赋值给 m3。

58. iterations=0：初始化迭代次数为 0。

59. while m3>message_length：循环执行下面的代码，直到 m3 小于等于待嵌入信息的长度。

60. l3=l3*2：将嵌入强度 l3 乘以 2。

61. p=(exp(-l3.*cost))./(1+exp(-l3.*cost))：根据嵌入强度 l3 和嵌入代价 cost 计算每个像素发生嵌入变化的概率 p。

62. m3=binary_entropyf(p)：调用 binary_entropyf 函数计算 p 的二进制熵，