1
import cv2
2
import numpy as np
3
import os
4

5
def arnold_transform(img, steps=1, encrypt=True):
6
    """
7
    执行Arnold变换 (加密 或 解密)
8
    :param img: 输入的图像数组 (numpy array)
9
    :param steps: 迭代次数 (密钥之一)
10
    :param encrypt: True为加密(正向), False为解密(逆向)
11
    :return: 变换后的图像
12
    """
13
    h, w = img.shape[:2]
14

15
    # Arnold变换通常要求图像是正方形
16
    # 如果不是正方形，通常的做法是裁剪成正方形或只处理正方形区域
17
    # 这里为了演示简单，我们取最小边长进行裁剪
18
    N = min(h, w)
19
    img = img[:N, :N]
20

21
    # 创建一个新的图像用于存放结果
22
    new_img = np.zeros((N, N, img.shape[2]), dtype=np.uint8)
23

24
    # 生成坐标网格
25
    x, y = np.meshgrid(np.arange(N), np.arange(N))
26

27
    # 复制坐标以进行迭代
28
    new_x, new_y = x.copy(), y.copy()
29

30
    # 核心算法
31
    for _ in range(steps):
32
        if encrypt:
33
            # 正向变换 (加密)
34
            # x' = (x + y) % N
35
            # y' = (x + 2y) % N
36
            next_x = (new_x + new_y) % N
37
            next_y = (new_x + 2 * new_y) % N
38
        else:
39
            # 逆向变换 (解密)
40
            # x = (2x' - y') % N
41
            # y = (-x' + y') % N
42
            next_x = (2 * new_x - new_y) % N
43
            next_y = (-new_x + new_y) % N
44

45
        new_x, new_y = next_x, next_y
46

47
    # 这里的 new_x, new_y 是原图坐标变换后的目标坐标
48
    # 但在NumPy赋值时，我们需要反过来思考：
49
    # 我们希望 new_img[new_y, new_x] = img[y, x] (正向逻辑)
50
    # 或者用更高效的掩码赋值方式
51

52
    # 注意：为了保持向量化操作的直观性，这里直接利用映射关系
53
    # 实际上，上面的计算算出了 (x,y) 移动到了 (new_x, new_y)
54
    # 所以 img[y, x] 的像素值应该填入 new_img[new_y, new_x]
55
    new_img[new_y, new_x] = img[y, x]
56

57
    return new_img
58

59
def main():
60
    # 1. 准备测试图像
61
    # 如果你没有图片，代码会创建一个简单的测试图
62
    filename = 'test_arnold.png'
63
    if not os.path.exists(filename):
64
        print("未找到图片，生成测试图片...")
65
        test_img = np.zeros((300, 300, 3), dtype=np.uint8)
66
        cv2.putText(test_img, "HELLO CTF", (50, 150), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 255, 255), 3)
67
        cv2.imwrite(filename, test_img)
68

69
    original_img = cv2.imread(filename)
70

71
    # 2. 设置密钥 (迭代次数)
72
    KEY_STEPS = 10
73

74
    print(f"原始图像尺寸: {original_img.shape}")
75
    print(f"正在进行Arnold加密 (迭代 {KEY_STEPS} 次)...")
76

77
    # 3. 加密
78
    encrypted_img = arnold_transform(original_img, steps=KEY_STEPS, encrypt=True)
79
    cv2.imwrite('arnold_encrypted.png', encrypted_img)
80
    print("加密完成，已保存为 arnold_encrypted.png")
81

82
    # 4. 解密
83
    print(f"正在进行Arnold解密 (迭代 {KEY_STEPS} 次)...")
84
    decrypted_img = arnold_transform(encrypted_img, steps=KEY_STEPS, encrypt=False)
85
    cv2.imwrite('arnold_decrypted.png', decrypted_img)
86
    print("解密完成，已保存为 arnold_decrypted.png")
87

88
    # (可选) 显示图像
89
    # cv2.imshow("Encrypted", encrypted_img)
90
    # cv2.imshow("Decrypted", decrypted_img)
91
    # cv2.waitKey(0)
92

93
if __name__ == "__main__":
94
    main()

1
import numpy as np
2

3
def zigzag_scan(matrix):
4
    """
5
    将 NxN 的二维矩阵进行 Zigzag 扫描，转换为一维数组
6
    """
7
    rows, cols = matrix.shape
8
    solution = [[] for i in range(rows + cols - 1)]
9

10
    for r in range(rows):
11
        for c in range(cols):
12
            sum_idx = r + c
13
            # 将同一对角线上的元素收集到同一个桶里
14
            if sum_idx % 2 == 0:
15
                # 偶数和：原本是向右上，但在遍历矩阵时，
16
                # 同一个sum_idx，r是递增的，所以直接append实际上是存的反向
17
                # 因此偶数层我们需要 insert(0) 或者后续统一反转
18
                solution[sum_idx].insert(0, matrix[r][c])
19
            else:
20
                # 奇数和：向左下
21
                solution[sum_idx].append(matrix[r][c])
22

23
    # 将所有桶合并成一个一维列表
24
    return [num for sublist in solution for num in sublist]
25

26
def inverse_zigzag(array, h, w):
27
    """
28
    Zigzag 逆变换：将一维数组还原为 h x w 矩阵
29
    (这是解密步骤必须的)
30
    """
31
    matrix = np.zeros((h, w), dtype=np.int32)
32
    rows, cols = h, w
33

34
    # 当前填充到的数组索引
35
    cur_idx = 0
36

37
    # 遍历所有对角线 (和为 0 到 h+w-2)
38
    for s in range(rows + cols - 1):
39
        if s % 2 == 0:
40
            # 偶数对角线：向右上 (r 减小, c 增加)
41
            # 确定起点的 r
42
            # 如果 s < rows, r 从 s 开始; 否则 r 从 rows-1 开始
43
            r = s if s < rows else rows - 1
44
            c = s - r
45

46
            while r >= 0 and c < cols:
47
                matrix[r][c] = array[cur_idx]
48
                cur_idx += 1
49
                r -= 1
50
                c += 1
51
        else:
52
            # 奇数对角线：向左下 (r 增加, c 减小)
53
            # 确定起点的 c
54
            c = s if s < cols else cols - 1
55
            r = s - c
56

57
            while r < rows and c >= 0:
58
                matrix[r][c] = array[cur_idx]
59
                cur_idx += 1
60
                r += 1
61
                c -= 1
62

63
    return matrix
64

65
# --- 测试 ---
66
if __name__ == "__main__":
67
    # 创建一个 4x4 测试矩阵
68
    test_mat = np.array([
69
        [1,  2,  5,  9],
70
        [3,  6,  8,  12],
71
        [4,  7,  11, 13],
72
        [10, 14, 15, 16]
73
    ])
74

75
    print("原始矩阵:")
76
    print(test_mat)
77

78
    # 1. 扫描
79
    zigzag_1d = zigzag_scan(test_mat)
80
    print(f"\nZigzag 扫描结果 (1D): {zigzag_1d}")
81
    # 预期结果: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
82
    # (如果是上面的矩阵数值设计，刚好的顺序应该是递增的，这验证了路径正确性)
83

84
    # 2. 逆变换 (还原)
85
    restored_mat = inverse_zigzag(zigzag_1d, 4, 4)
86
    print("\n还原后的矩阵:")
87
    print(restored_mat)

1
import numpy as np
2
import cv2
3
import os
4

5
def zigzag_indices(rows, cols):
6
    # 生成 Zigzag 扫描的坐标序列 [cite: 41]
7
    indices = []
8
    # 遍历所有对角线，总数为 rows + cols - 1 [cite: 42]
9
    for diag in range(rows + cols - 1):
10
        if diag % 2 == 0:
11
            # 偶数对角线：向右上方遍历 [cite: 43]
12
            # 起点 r 为该对角线允许的最大行索引 [cite: 44]
13
            r = min(diag, rows - 1)
14
            c = diag - r
15

16
            # 当 r 未越下界且 c 未越右界时循环 [cite: 47]
17
            while r >= 0 and c < cols:
18
                indices.append((r, c)) # [cite: 50]
19
                r -= 1 # [cite: 51]
20
                c += 1 # [cite: 52]
21
        else:
22
            # 奇数对角线：向左下方遍历 [cite: 48]
23
            # 起点 c 为该对角线允许的最大列索引 [cite: 53]
24
            c = min(diag, cols - 1)
25
            r = diag - c
26

27
            # 当 c 未越左界且 r 未越下界时循环 [cite: 55]
28
            while c >= 0 and r < rows:
29
                indices.append((r, c)) # [cite: 56]
30
                r += 1 # [cite: 57]
31
                c -= 1 # [cite: 58]
32
    return indices # [cite: 59]
33

34
def zigzag_unscramble_2d(matrix_2d):
35
    # 针对二维矩阵进行 Zigzag 逆变换 [cite: 60]
36
    rows, cols = matrix_2d.shape # [cite: 61]
37
    indices = zigzag_indices(rows, cols) # [cite: 63]
38

39
    # 将矩阵展平，因为加密过程是按 Zigzag 顺序读取后的一维流 [cite: 64, 65]
40
    flattened = matrix_2d.flatten()
41

42
    # 创建全零矩阵用于存放还原后的数据 [cite: 66]
43
    unscrambled = np.zeros_like(matrix_2d)
44

45
    # 将展平的数据按 Zigzag 路径填回原位 [cite: 67]
46
    for idx, (r, c) in enumerate(indices):
47
        unscrambled[r, c] = flattened[idx]
48

49
    return unscrambled # [cite: 68]
50

51
def zigzag_unscramble_image(img):
52
    # 判断图像维度并处理 [cite: 69]
53
    if img.ndim == 2:
54
        # 灰度图直接处理 [cite: 70]
55
        return zigzag_unscramble_2d(img)
56
    elif img.ndim == 3 and img.shape[2] == 3:
57
        # RGB 彩色图对每个通道分别处理 [cite: 71, 72]
58
        unscrambled = np.zeros_like(img)
59
        for ch in range(3):
60
            unscrambled[:, :, ch] = zigzag_unscramble_2d(img[:, :, ch]) # [cite: 73]
61
        return unscrambled # [cite: 74]
62
    else:
63
        raise ValueError("仅支持灰度图或标准 RGB 彩色图") # [cite: 76]
64

65
if __name__ == "__main__":
66
    # 设置加密图片路径 (根据题目描述文件名为 enc.png) [cite: 78]
67
    encrypted_image_path = "enc.png"
68

69
    # 检查文件是否存在 [cite: 80]
70
    if not os.path.exists(encrypted_image_path):
71
        print(f"错误: 找不到加密图像文件 '{encrypted_image_path}'")
72
        exit(1)
73

74
    # 读取图像 [cite: 83]
75
    img_bgr = cv2.imread(encrypted_image_path)
76
    if img_bgr is None:
77
        print("无法读取加密图像,请检查路径或格式是否支持")
78
        exit(1)
79

80
    # OpenCV 默认读取为 BGR，需转换为 RGB 进行处理 [cite: 85]
81
    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
82
    print(f"成功读取加密图像, 尺寸: {img_rgb.shape}") # [cite: 86]
83

84
    # 执行解密 [cite: 87]
85
    decrypted_img = zigzag_unscramble_image(img_rgb)
86

87
    # 转回 BGR 以便保存 [cite: 88]
88
    decrypted_bgr = cv2.cvtColor(decrypted_img, cv2.COLOR_RGB2BGR)
89

90
    # 保存结果 [cite: 89, 90]
91
    output_path = "decrypted_zigzag.png"
92
    cv2.imwrite(output_path, decrypted_bgr)
93
    print(f"图像已解密并保存为: {output_path}") # [cite: 91]