Arnold置乱变换的代码实现与置乱度分析

1. 传统Arnold置乱变换算法简介

Arnold置乱变换（又称为cat映射）是一种基于古典密码体制的图像加密算法，本质上是对长宽相等的图像进行拉伸与折叠操作以改变空间中像素点的位置，从而破坏图像相邻像素点之间的相关性，它的安全性较低，易利用像素值统计特性攻击，常用作其它加密算法的预处理。

传统的Arnold置乱变换可表示为：
[ x n + 1 y n + 1 ] = [ 1 1 1 2 ] [ x n y n ] m o d ( N ) \begin{bmatrix} x_{n+1} \\ y_{n+1} \end{bmatrix}= \begin{bmatrix} 1&1\\ 1&2 \end{bmatrix} \begin{bmatrix} x_n \\ y_n \end{bmatrix} mod(N) [xn+1​yn+1​​]=[11​12​][xn​yn​​]mod(N)

图像的恢复可表示为：
[ x n y n ] = [ 1 1 1 2 ] − 1 [ x n + 1 y n + 1 ] m o d ( N ) \begin{bmatrix} x_n \\ y_n \end{bmatrix}= \begin{bmatrix} 1&1\\ 1&2 \end{bmatrix}^{-1} \begin{bmatrix} x_{n+1} \\ y_{n+1} \end{bmatrix} mod(N) [xn​yn​​]=[11​12​]−1[xn+1​yn+1​​]mod(N)

2. 传统Arnold置乱变换的代码实现与置乱度分析

2.1 编程环境

• 编程语言：Python
• 包：cv2, matplotlib, numpy, math, time

2.2 代码实现

2.2.1 传统Arnold置乱变换

"""
function: 对图像进行r轮Arnold置乱变换，并录入每一轮变换后的图像数据信息
params: 
    img: 输入的图片
    r: 置乱轮数
    length: 图像尺寸信息
return:
    data: 置乱变换后的图像数据信息(snr/time)
"""
def arnold(img, r, length):
    cnt = 0

    ori_img = np.copy(img)
    new_img = np.copy(img)

    snr = {}
    snr[0] = 100.0
    t = {}
    t[0] = 0
    data = {}

    start = time.time()
    while cnt <= r:
        for i in range(img.shape[0]):
            for j in range(img.shape[1]):
                new_i = (i + j) % length
                new_j = (i + 2 * j) % length
                new_img[new_i][new_j] = img[i][j] 
  		# 第cnt轮置乱变换的时间信息
        end = time.time()
        t[cnt] = end - start

        cnt = cnt + 1
		# 第cnt轮置乱变换的SNR值计算
        signal = np.sum(new_img) ** 2
        # print(signal)
        noise = (ori_img - new_img) ** 2
        noise = np.sum(noise)
        if noise != 0:
            snr[cnt] = 10 * math.log10(signal * 1.0 / noise)
        else:
            snr[cnt] = 100.0
        # print(snr[cnt])
        # cv2.imshow("image", new_img)
        # cv2.waitKey(50)
        print(cnt)

        img = np.copy(new_img)
    #置乱变换的相关信息录入
    data[0] = snr
    data[1] = t
    return data

2.2.2 传统Arnold置乱变换的置乱度分析

• 基于距离
  设置乱前像素点坐标为 ( x n , y n ) (x_n, y_n) (xn​,yn​)，置乱后像素点坐标为 ( x n + 1 , y n + 1 ) (x_{n+1}, y_{n+1}) (xn+1​,yn+1​)，则：

  像素点移动的距离为：
  d e l t a ( x , y ) = ( x n + 1 − x n ) 2 + ( y n + 1 − y n ) 2 delta(x,y)=\sqrt{(x_{n+1}-x_n)^2+(y_{n+1}-y_n)^2} delta(x,y)=(xn+1​−xn​)2+(yn+1​−yn​)2 ​

  全体像素点移动距离的期望为：
  E = 1 M ∗ N ∑ x = 1 M ∑ y = 1 N d e l t a ( x , y ) E=\frac 1 {M*N}\sum_{x=1}^M\sum_{y=1}^Ndelta(x,y) E=M∗N1​x=1∑M​y=1∑N​delta(x,y)

  """
  function: 计算基于距离的置乱度
  params: 
      r: 置乱轮数
      length: 图像尺寸信息
  return:
      delta: 0~r次Arnold置乱变换后的置乱度
  """
  def calc_scrambling(r, length):
      cnt = 0
      delta = {}
      delta[0] = 0
      pos = np.ones((length, length))
      pos = init(pos, length)
      pos_r = np.copy(pos)
  
      while cnt <= r:
          s = 0.0
          # Arnold置乱变换
          for i in range(0, length):
              for j in range(0, length):
                  new_i = (i + j) % length
                  new_j = (i + 2 * j) % length
                  pos_r[new_i][new_j] = pos[i][j]
  
          cnt = cnt + 1
          # print(cnt)
          # 置乱度计算
          for i in range(1, length + 1):
              x = math.ceil(i / length * 1.0)
              y = i - length * math.floor(i / length * 1.0) - 1
  
              seq = np.where(pos == i)[0][0]
              xx = math.ceil(seq / length * 1.0)
              yy = seq - length * math.floor(seq / length * 1.0) - 1
  
              s += math.sqrt((x-xx) ** 2 + (y - yy) ** 2)
  		# 置乱度信息录入
          delta[cnt] = s / (length * length)
          # print(delta)
          pos = np.copy(pos_r)
          
      return delta
  
  """
  function: 初始化矩阵
  params: 
      matrix: 输入矩阵
      length: 矩阵尺寸
  return:
      matrix: 初始化后的矩阵
  """
  def init(matrix, length):
      n = 1
      for i in range(0, length):
          for j in range(0, length):
              matrix[i][j] = n
              n = n + 1
  
      return matrix
  
  """
  function: 绘制基于距离的置乱度折线图
  params: 
      d: 0~r次Arnold置乱变换后的置乱度
  """
  def paint_curve(d):
      plt.title("Scrambling")
      plt.ylabel("Average scrambling")
      plt.xlabel("Round")
      plt.grid(True)
      keys = d.keys()
      values = d.values()
      plt.plot(tuple(keys), tuple(values))
      plt.savefig("scrambling.png")
      plt.show()
  

• 基于均方信噪比
  信噪比（SNR）表示的是信号与噪声之比，若设原始图像为I，经Arnold置乱后的图像为I’，则均方信噪比可表示为：
  S N R = ∑ x = 1 M ∑ y = 1 N I ′ 2 ( x , y ) ∑ x = 1 M ∑ y = 1 N ( I ( x , y ) − I ′ ( x , y ) ) 2 SNR=\cfrac {\sum_{x=1}^M\sum_{y=1}^NI'^2(x,y)}{\sum_{x=1}^M\sum_{y=1}^N(I(x,y)-I'(x,y))^2} SNR=∑x=1M​∑y=1N​(I(x,y)−I′(x,y))2∑x=1M​∑y=1N​I′2(x,y)​

  """
  function: 绘制图像信噪比折线图
  params: 
      snr: 0~r次Arnold置乱变换后的信噪比
  """
  def curve2(snr):
      plt.title("SNR")
      plt.ylabel("SNR/dB")
      plt.xlabel("Round")
      plt.grid(True)
      keys = snr.keys()
      values = snr.values()
      plt.plot(tuple(keys), tuple(values))
      plt.savefig("SNR.png")
      plt.show()
  

3. 参考文献

• 方毅，Arnold置乱变换图像加密算法研究[学位论文]，2018