基于增强混沌映射与改进重力扩散的图像加密算法实现与评估

1. 项目概述：当混沌遇上图像加密

最近在折腾一个图像加密的项目，核心是围绕“一维增强Log-logistic混沌映射”和“改进型重力扩散”这两个听起来有点唬人的技术。说白了，就是怎么用一套更复杂、更“乱”的数学规则，把一张普通的图片变成一堆谁也看不懂的像素点，并且还能原封不动地变回来。这玩意儿在需要保护图片内容不被窥探的场景下特别有用，比如一些涉及敏感信息的医学影像、设计图纸的云端存储，或者就是单纯想给个人相册加把锁。

整个流程可以拆解成两大块：混沌序列生成和像素值扩散。前者负责产生看似随机、实则由确定公式控制的密钥流，是加密的“随机性”来源；后者则利用这个密钥流，按照某种物理模型（这里是重力模型）去剧烈地搅乱每一个像素点的值，让原始图像的信息特征彻底消失。最后，我们还得用“信息熵”这把尺子量一量，看加密后的图像到底有多“乱”，是不是足够安全。我会用Matlab来演示整个过程，因为它的矩阵操作和可视化对于图像处理来说实在太方便了。无论你是信息安全方向的学生，还是对图像处理感兴趣的开发者，希望这篇从原理到代码的拆解都能给你带来些实实在在的参考。

2. 核心思路与算法选型背后的考量

为什么是Log-logistic混沌映射？又为什么是重力扩散？这得从图像加密的基本要求说起。一个靠谱的加密方案，必须对密钥极度敏感（密钥微变，结果巨变）、能产生高度不可预测的输出（就像真正的噪声），并且加密后的图像在统计特性上要均匀（比如直方图平坦）。传统的混沌映射如Logistic Map虽然简单，但它的混沌参数范围有限，且在某些区域内序列分布不够均匀，容易被分析破解。Log-logistic映射本身基于一个概率分布函数，其数学形式比Logistic更复杂，初始的混沌特性就更好一些。

2.1 一维增强Log-logistic混沌映射的“增强”体现在哪？

我们用的不是标准版，而是“增强版”。这个增强，通常不是随便加个参数，而是有明确目的的。标准Log-logistic混沌映射的迭代公式可能长这样：x_{n+1} = μ * x_n * (1 - x_n) / (1 + β * x_n)之类的变体（具体形式取决于文献定义）。它的混沌行为可能在某些参数区间内不够丰富，或者产生的序列值分布不够理想。

增强的思路一般有以下几种，这也是我选择它的原因：

1. 参数耦合与非线性叠加：引入更多的控制参数，并且让这些参数以非线性的方式相互作用。例如，不止一个μ，可能有α, β, γ等多个参数，迭代公式中可能包含sin,cos,mod等非线性运算，使得系统的轨迹更加难以预测。
2. 引入时变或状态依赖参数：让映射的参数μ本身也随着迭代次数n或当前状态x_n变化，而不是一个常数。这相当于一个动态的系统，其复杂性大大增加。
3. 与其它简单映射复合：将Log-logistic映射与另一个混沌映射（如Tent映射、Sine映射）的输出进行混合，作为下一次迭代的输入。这能有效扩大混沌范围并改善序列的分布特性。

在我的实现里，我主要采用了参数耦合和引入模运算以扩大值域的思路。我定义了一个增强型的迭代公式，它包含了四个可调参数（α, β, γ, r），并且通过模1运算将值域限定在[0,1)，同时确保了遍历性。这样产生的序列，不仅对初始值（即密钥）极度敏感，而且其统计特性（如自相关性）更接近白噪声，非常适合用来生成加密所需的伪随机数序列。

注意：设计或选择混沌映射时，务必通过相图、Lyapunov指数（大于0）和分岔图来验证其混沌特性。盲目“增强”可能反而会导致系统退化为周期运动，失去加密价值。

2.2 为何选择“改进型重力扩散”？

像素扩散的目的是让图像中一个像素点的改变，能影响到尽可能多的其他像素点，这称为“雪崩效应”。常见的扩散方式有Arnold变换、标准重力模型、布朗运动模型等。

标准重力扩散模型模拟了物理世界中的万有引力：每个像素点被视为一个具有“质量”（像素值）的物体，其位置会因其他所有像素点的引力而改变。这个过程计算量巨大（O(N²)），因为每个点都要和其他所有点交互。

“改进型”重力扩散，改进的核心就是效率和效果：

1. 局部化引力场：我们不需要计算全局引力。想象一下，在图像加密中，我们更关注一个像素点如何影响它的邻居。因此，改进模型通常将引力作用范围限制在一个小的邻域窗口内（比如5x5或7x7）。这样，计算复杂度从O(N²)降到了O(kN)，其中k是窗口内像素数，效率提升是数量级的。
2. 方向性扰动：标准模型可能只改变像素值。改进模型可以引入方向性的“力”，不仅改变当前像素的值，还根据其与邻域像素的“质量”差和位置关系，决定一个修改的“方向”或“强度”，这个强度由前面混沌序列生成的随机数来调制。这使得扩散过程更加非线性，更难被逆向分析。
3. 多轮迭代与混沌控制：单次扩散可能不够彻底。改进模型会进行多轮扩散，并且每一轮中用于控制扩散强度或方向的参数，都由混沌序列动态提供。这样，扩散过程本身也是随机的、密钥相关的。

我采用的模型，就是结合了局部邻域计算和混沌序列引导的扰动方向。在每一轮扩散中，对于图像中的每一个像素，我只考虑其周围8个邻居（3x3窗口）。根据混沌序列生成的随机数，决定是向“质量”更大的邻居靠拢（像素值增加），还是背离（像素值减少），以及变化的幅度。这个过程遍历整张图像多次，原始图像的空间相关性就被彻底破坏了。

3. 加密系统的详细设计与实现步骤

整个加密系统是一个流水线，下面我分步拆解，并附上关键的Matlab代码思路。

3.1 步骤一：密钥生成与混沌序列初始化

这是所有安全的基础。我们需要的密钥包括：

• x0: 混沌映射的初始值 (0 < x0 < 1)
• α, β, γ, r: 增强Log-logistic映射的控制参数。
• diffusion_key: 用于初始化扩散过程的随机种子（可以取自混沌序列的某一段）。

% 假设用户输入或系统生成密钥 keys.x0 = 0.123456789; % 初始值，需要高精度 keys.alpha = 3.789; keys.beta = 0.456; keys.gamma = 2.345; keys.r = 100; % 用于模运算的参数 keys.diffusion_seed = 0.987654321; % 生成足够长的混沌序列，长度需要大于图像像素总数的数倍 % 因为后续置乱和扩散都需要大量随机数 total_pixels = num_rows * num_cols; seq_length = total_pixels * 5; % 生成5倍像素数的序列，留足余量 chaos_seq = zeros(1, seq_length); chaos_seq(1) = keys.x0; for i = 2:seq_length % 增强型Log-logistic迭代公式示例（具体公式需根据文献调整） % 这里是一个示意性的增强公式，包含了非线性耦合和模运算 temp = keys.alpha * chaos_seq(i-1) * (1 - chaos_seq(i-1)); temp = temp / (1 + keys.beta * chaos_seq(i-1)); temp = keys.gamma * sin(pi * temp); % 引入正弦非线性 chaos_seq(i) = mod(temp, 1); % 模1运算确保值在[0,1) end % 混沌序列生成完毕，值域在[0,1)之间

实操心得：混沌序列对初始条件极其敏感。在Matlab中，使用double精度是基本要求。为了增加密钥空间，可以考虑将x0和参数设置为更高精度的形式，或者使用字符串哈希生成初始值。务必保存好这些密钥，解密时需原样输入。

3.2 步骤二：图像预处理与像素置乱

加密前，先将彩色图像转换为灰度图像（如果原是彩色，可分别对R、G、B通道加密，原理相同）。然后，我们使用混沌序列对像素的位置进行置乱，打破空间相邻性。

% 1. 读取并预处理图像 original_img = imread('secret_image.png'); if size(original_img, 3) == 3 original_img = rgb2gray(original_img); end [rows, cols] = size(original_img); img_vector = double(original_img(:)); % 将图像展平为一维向量 % 2. 位置置乱 % 从混沌序列中截取一段，生成长度为 total_pixels 的随机排列索引 perm_seq = chaos_seq(1:total_pixels); [~, scramble_index] = sort(perm_seq); % 利用排序产生随机置换索引 % scramble_index 是一个1到total_pixels的随机排列 % 3. 应用置乱 scrambled_vector = img_vector(scramble_index); scrambled_img = reshape(scrambled_vector, [rows, cols]); % 此时 scrambled_img 是位置被彻底打乱的图像，但像素值分布未变

为什么先置乱？先打乱位置，可以使后续的扩散操作作用于原本不相邻的像素，让“雪崩效应”传播得更快、更彻底。如果先扩散，局部相关性虽被破坏，但大范围的位置关系还在，安全性稍逊。

3.3 步骤三：改进型重力扩散的核心实现

这是加密算法最核心、最耗时的部分。我们将置乱后的图像scrambled_img作为输入。

% 初始化参数 diffused_img = scrambled_img; num_rounds = 3; % 扩散轮数，通常2-4轮即可达到很好效果 neighbor_offsets = [-1 -1; -1 0; -1 1; 0 -1; 0 1; 1 -1; 1 0; 1 1]; % 8邻域坐标偏移 % 从混沌序列的另一个位置开始，取数用于控制扩散 diffusion_control_seq = chaos_seq(total_pixels+1 : total_pixels + num_rounds*rows*cols*8); seq_ptr = 1; % 序列指针 for round = 1:num_rounds fprintf('正在进行第 %d 轮扩散...\n', round); for i = 2:rows-1 % 避开边界，边界可采用镜像或循环填充处理 for j = 2:cols-1 current_pixel = diffused_img(i, j); total_force = 0; % 计算8邻域对中心像素的“净力” for k = 1:8 ni = i + neighbor_offsets(k, 1); nj = j + neighbor_offsets(k, 2); neighbor_pixel = diffused_img(ni, nj); % “质量”差 mass_diff = neighbor_pixel - current_pixel; % 距离（这里用欧氏距离，但因为是固定邻域，可简化为常数或根据偏移计算） distance = sqrt(neighbor_offsets(k,1)^2 + neighbor_offsets(k,2)^2); % 固定为sqrt(1)或sqrt(2) % 模拟引力公式：力 F ~ mass_diff / (distance^2 + epsilon) % epsilon 是一个小常数，防止除零 force = mass_diff / (distance^2 + 0.1); % 从混沌序列中取一个数，决定此方向力的“有效性”和“方向” chaos_val = diffusion_control_seq(seq_ptr); seq_ptr = seq_ptr + 1; % 将chaos_val映射到[-1, 1]区间，作为力的系数 coeff = 2 * chaos_val - 1; total_force = total_force + coeff * force; end % 根据总力更新当前像素值 % delta 是变化量，需要将其限制在合理范围（如0-255） delta = total_force * 10; % 10是一个缩放因子，需要根据实验调整 new_value = current_pixel + delta; % 确保像素值在[0, 255]范围内，并进行取模运算实现非线性溢出 new_value = mod(round(new_value), 256); diffused_img(i, j) = new_value; end end % 可选：每轮结束后，对图像边界进行处理（例如，用镜像后的内部像素进行扩散） end encrypted_img = uint8(diffused_img); % encrypted_img 就是最终的加密图像

这段代码的关键点解析：

1. 局部计算：只计算8邻域，复杂度可控。
2. 混沌引导：每个邻域贡献的力都乘以一个由混沌序列生成的随机系数coeff，这个系数在[-1,1]之间。这意味着邻居像素可能对中心像素产生“拉力”（使中心像素值向其靠拢）或“推力”（使其远离），这完全随机且由密钥决定。
3. 非线性量化：mod(round(new_value), 256)这一步至关重要。它不仅仅是将值限制在0-255，mod运算引入了非线性溢出，使得微小的力变化可能导致像素值发生跳跃性改变（例如从254+3=257 mod 256 = 1），极大地增强了扩散的非线性效果。
4. 多轮迭代：一轮扩散可能不足以将扰动传播到整个图像。多轮迭代确保了雪崩效应的充分实现。

3.4 步骤四：解密过程

解密是加密的逆过程。重要前提：必须使用完全相同的密钥（初始值x0和参数），以生成完全相同的混沌序列。

1. 逆扩散：这是最 tricky 的部分。因为扩散过程是正向的、非线性的（有mod运算），直接求逆很困难。因此，改进型重力扩散通常设计为可逆的。这要求我们在加密时，记录下一些中间信息，或者使用一种特殊的、可逆的扩散公式。

   • 一种可行的方法：将扩散过程视为一个受混沌序列控制的、确定的像素值变换。如果我们严格按照加密时相同的顺序、使用相同的混沌序列来“反向”施加力（即系数取反，或者重新计算一个逆向的力），理论上可以还原。但这要求扩散公式在设计时就必须考虑可逆性。
   • 更常用的策略：在图像加密中，常常将“扩散”和“置乱”结合，并使用一种称为“反向序迭代”的方法。即，如果我们加密时是顺序遍历像素并进行扩散，那么解密时就逆序遍历像素，并使用相同的混沌序列和公式进行“反向”计算。这需要扩散公式满足一定的数学性质。
   • 在我的实现中的简化：为了演示的直观性，我有时会采用一种“异或扩散”的变体，即扩散公式的核心是异或运算，这自然是可逆的。但真正的重力模型逆运算更复杂。在严谨的算法设计中，需要推导出逆向公式。

2. 逆置乱：得到扩散逆变换后的图像后，我们有了位置混乱但像素值已恢复的图像。此时，我们利用加密时生成的同一个scramble_index，进行反向索引即可恢复原始位置。

   % 假设 inverse_diffused_img 是逆扩散后的图像（一维向量形式） original_vector_recovered = zeros(total_pixels, 1); original_vector_recovered(scramble_index) = inverse_diffused_img(:); original_img_recovered = reshape(original_vector_recovered, [rows, cols]);

核心难点提醒：设计一个可逆的、非线性的、密钥相关的扩散算法是图像加密研究的核心挑战之一。很多论文中的“改进型”扩散，其“改进”就包含了可逆性的设计。在复现他人算法时，务必仔细研读其逆向过程的描述。

3.5 步骤五：安全性评估 - 信息熵计算

加密效果如何，不能光靠肉眼观察。信息熵是衡量图像随机性的重要指标。对于一幅8位灰度图，其信息熵H的计算公式为：

[ H = -\sum_{i=0}^{255} p(i) \log_2 p(i) ]

其中，p(i)是灰度级i在图像中出现的概率。

理想随机图像（每个灰度级等概率出现）的信息熵为8。加密图像的信息熵越接近8，说明其像素值分布越均匀，抵抗统计攻击的能力越强。

function entropy_value = calculate_image_entropy(img) % img 是灰度图像矩阵 [counts, ~] = imhist(img); probabilities = counts / sum(counts); probabilities = probabilities(probabilities > 0); % 去掉概率为0的项，log2(0)无定义 entropy_value = -sum(probabilities .* log2(probabilities)); end % 计算原始图像和加密图像的信息熵 entropy_original = calculate_image_entropy(original_img); entropy_encrypted = calculate_image_entropy(encrypted_img); fprintf('原始图像信息熵: %.4f\n', entropy_original); fprintf('加密图像信息熵: %.4f\n', entropy_encrypted);

结果解读：典型的自然图像信息熵一般在7-7.5之间，因为像素值分布有规律。一个加密良好的图像，其信息熵应该非常接近8，比如达到7.997以上。如果加密后熵值提升不明显（比如只到7.6），说明扩散不充分，统计特征残留较多。

4. 完整Matlab代码框架与关键模块解析

下面给出一个整合了上述所有步骤的、结构清晰的Matlab脚本框架。请注意，其中增强混沌映射和可逆重力扩散的具体公式需要你根据引用的参考文献进行精确实现，这里是一个可运行的逻辑框架。

%% 主函数：基于增强Log-logistic混沌与改进重力扩散的图像加密 function main_image_encryption() clear; clc; close all; % ========== 1. 参数设置与密钥输入 ========== keys.x0 = 0.123456789; keys.alpha = 3.789; keys.beta = 0.456; keys.gamma = 2.345; keys.r = 100; num_diffusion_rounds = 3; % ========== 2. 读取图像 ========== img_path = 'lena_std.tif'; % 测试图像 original_img = imread(img_path); if size(original_img, 3) == 3 original_img = rgb2gray(original_img); end original_img = double(original_img); [rows, cols] = size(original_img); total_pixels = rows * cols; % ========== 3. 生成增强混沌序列 ========== fprintf('正在生成混沌序列...\n'); chaos_seq = generate_enhanced_loglogistic(keys, total_pixels*10); % 生成足够长的序列 % ========== 4. 像素置乱 ========== fprintf('正在进行像素置乱...\n'); scrambled_img = pixel_scrambling(original_img, chaos_seq, total_pixels); % ========== 5. 改进重力扩散 ========== fprintf('正在进行改进重力扩散加密...\n'); encrypted_img = improved_gravity_diffusion(scrambled_img, chaos_seq, total_pixels, num_diffusion_rounds, keys); % ========== 6. 计算信息熵 ========== entropy_orig = calculate_image_entropy(uint8(original_img)); entropy_encr = calculate_image_entropy(uint8(encrypted_img)); fprintf('\n=== 加密结果分析 ===\n'); fprintf('原始图像信息熵: %.6f\n', entropy_orig); fprintf('加密图像信息熵: %.6f\n', entropy_encr); % ========== 7. 显示结果 ========== figure; subplot(1,3,1); imshow(uint8(original_img)); title('原始图像'); subplot(1,3,2); imshow(uint8(scrambled_img)); title('置乱后图像'); subplot(1,3,3); imshow(uint8(encrypted_img)); title('最终加密图像'); % ========== 8. 解密过程 (需实现逆扩散函数) ========== % fprintf('\n开始解密...\n'); % decrypted_img = decryption_process(encrypted_img, chaos_seq, total_pixels, num_diffusion_rounds, keys); % figure; % imshow(uint8(decrypted_img)); title('解密恢复图像'); % 计算解密图像与原始图像的差异 % if isequal(uint8(original_img), uint8(decrypted_img)) % fprintf('解密成功！图像完全恢复。\n'); % else % fprintf('解密失败，存在误差。\n'); % end end %% 子函数1：生成增强型Log-logistic混沌序列 function seq = generate_enhanced_loglogistic(keys, length) seq = zeros(1, length); seq(1) = keys.x0; for i = 2:length % === 核心：在此处实现你的增强型迭代公式 === % 示例公式（需替换为文献中的精确公式）： x_prev = seq(i-1); term = keys.alpha * x_prev * (1 - x_prev); term = term / (1 + keys.beta * x_prev); term = keys.gamma * sin(pi * term); seq(i) = mod(term, 1); % 确保值在[0,1) % === 公式结束 === end end %% 子函数2：基于混沌序列的像素置乱 function scrambled = pixel_scrambling(img, chaos_seq, total_pixels) [rows, cols] = size(img); img_vec = img(:); % 使用前total_pixels个混沌数生成置乱索引 [~, idx] = sort(chaos_seq(1:total_pixels)); scrambled_vec = img_vec(idx); scrambled = reshape(scrambled_vec, [rows, cols]); end %% 子函数3：改进型重力扩散加密 function encrypted = improved_gravity_diffusion(img, chaos_seq, total_pixels, rounds, keys) % 此函数实现3.3节描述的扩散过程 % 注意：这是一个示意性函数，需要你根据可逆性要求完善扩散和逆扩散公式 [rows, cols] = size(img); current_img = img; seq_start = total_pixels + 1; % 假设从混沌序列的后面部分取数用于扩散 control_seq = chaos_seq(seq_start : seq_start + rounds*rows*cols*8 - 1); seq_ptr = 1; neighbor_offsets = [-1 -1; -1 0; -1 1; 0 -1; 0 1; 1 -1; 1 0; 1 1]; for r = 1:rounds for i = 2:rows-1 for j = 2:cols-1 % 计算当前像素受邻域的总“力”（由混沌序列调制） total_force = 0; center_val = current_img(i, j); for k = 1:8 ni = i + neighbor_offsets(k, 1); nj = j + neighbor_offsets(k, 2); neighbor_val = current_img(ni, nj); mass_diff = neighbor_val - center_val; dist_sq = neighbor_offsets(k,1)^2 + neighbor_offsets(k,2)^2; force = mass_diff / (dist_sq + 0.1); % 基础引力计算 chaos_coeff = 2 * control_seq(seq_ptr) - 1; % 映射到[-1,1] seq_ptr = seq_ptr + 1; total_force = total_force + chaos_coeff * force; end % 更新像素值，并引入非线性模运算 delta = total_force * 5; % 缩放因子需调试 new_val = center_val + delta; current_img(i, j) = mod(round(new_val), 256); end end % 处理图像边界（例如使用镜像填充） current_img = padarray(current_img(2:end-1, 2:end-1), [1 1], 'symmetric'); end encrypted = current_img; end %% 子函数4：计算信息熵（前文已给出） function entropy_value = calculate_image_entropy(img) [counts, ~] = imhist(img); probabilities = counts / sum(counts); probabilities = probabilities(probabilities > 0); entropy_value = -sum(probabilities .* log2(probabilities)); end

5. 常见问题、调试技巧与性能优化

在实际实现和复现这类算法时，你肯定会遇到不少坑。下面是我在多次尝试中总结的一些典型问题和解决方法。

5.1 加密后图像出现规律性纹理或块效应

• 问题描述：加密后的图像看起来不是均匀噪声，而是有模糊的轮廓、条纹或块状区域。
• 原因分析：
  1. 混沌序列质量差：增强映射的参数没设对，系统没有处于强混沌状态，产生的序列自相关性高，随机性不足。这会导致置乱和扩散用的“随机数”不够随机。
  2. 扩散不充分：扩散的轮数不够，或者邻域窗口太小、作用力计算公式太弱，导致像素值的改变没有传播开来。
  3. 边界处理不当：图像边界的像素在扩散时邻居不足，如果处理不好（比如简单置零或不变），就会形成明显的边界效应。
• 解决方案：
  1. 绘制混沌序列的相图（x_n vs x_{n+1}）和分岔图。一个良好的混沌序列相图应该充满整个[0,1]x[0,1]空间，没有明显的空白带或规律结构。分岔图应显示参数在一定范围内系统都处于混沌态。
  2. 增加扩散轮数：从2轮增加到3轮或4轮。观察每轮扩散后图像信息熵的变化，如果熵值不再显著增加，说明扩散已饱和。
  3. 改进边界处理：不要忽略边界。可以采用“循环边界”（将图像上下左右连接成环面）或“镜像边界”（将边界外的像素值用镜像位置的像素值填充）策略。在代码中，可以在每轮扩散开始前，用padarray函数扩展图像边界。

     % 在每轮扩散循环开始前，对current_img进行镜像填充 padded_img = padarray(current_img, [1 1], 'symmetric'); % 然后对padded_img(2:end-1, 2:end-1)的区域进行计算 % 计算完成后，更新current_img为处理后的中心区域

5.2 解密图像无法完全恢复，存在误差

• 问题描述：使用完全相同的密钥解密，得到的图像和原始图像在像素级对比有差异。
• 原因分析：
  1. 数据类型的精度损失：这是最常见的原因。在加密过程中，像素值经过了大量的浮点数运算（如引力计算），最后通过round和mod取整到0-255的整数。如果解密过程的计算顺序、取整时机与加密过程有丝毫偏差，就会累积误差。
  2. 扩散过程不可逆：你实现的扩散公式在数学上不是严格可逆的。特别是当公式中包含mod、round或其它非线性、非单射函数时，逆向计算可能得不到唯一解。
  3. 混沌序列不同步：加密和解密时生成的混沌序列哪怕有一个比特的差异，结果就会天差地别。确保用于置乱的索引序列和用于扩散控制的随机数序列在加密和解密时是完全相同的，包括使用的起始位置和长度。
• 解决方案：
  1. 全程使用高精度浮点数：在Matlab中，double类型是基础。在加密和解密的所有中间计算步骤，都保持为double类型。只在最终显示或输出为图像时，才转换为uint8。
  2. 设计或采用可逆扩散公式：这是算法的核心。一个技巧是使用“前向-后向”可逆的运算。例如，一种常见的可逆扩散是：C(i) = mod(P(i) + f(C(i-1), key) + key_stream(i), 256)，其中C是密文像素，P是明文像素，f是一个函数。其逆运算是：P(i) = mod(C(i) - f(C(i-1), key) - key_stream(i), 256)。你需要将重力模型改造成这种形式。
  3. 严格同步混沌序列：在代码中，将生成混沌序列、截取用于置乱和扩散的子序列的过程，封装成独立的、可复用的函数。在加密和解密的主函数中，用相同的密钥调用这些函数，确保得到的序列一模一样。可以在调试时，打印出加密和解密过程前几个混沌数的值进行比对。

5.3 算法运行速度太慢

• 问题描述：尤其是对于大图像（如1024x1024），加密/解密需要数十秒甚至几分钟。
• 原因分析：主要瓶颈在于扩散过程的多重嵌套循环（轮数 x 行数 x 列数 x 邻域数）。如果使用8邻域和3轮扩散，对于百万像素的图像，核心操作次数接近2500万次。
• 优化策略：
  1. 向量化计算（最重要）：Matlab的强项是矩阵运算，应尽量避免多层for循环。可以尝试将邻域计算向量化。例如，使用im2col函数将图像转换为列块，然后一次性计算所有像素与邻域的相互作用。但这对于自定义的非线性重力公式可能较难实现。
  2. 减少扩散轮数或邻域大小：在安全性和效率之间权衡。通过实验确定一个最小的、能达到安全阈值的轮数（如信息熵>7.99）。也可以考虑使用4邻域（上、下、左、右）代替8邻域。
  3. 使用MEX函数或并行计算：将最耗时的扩散循环用C/C++写成MEX文件在Matlab中调用。或者，如果扩散各轮之间、同行像素之间依赖性不强，可以考虑使用parfor进行并行循环（注意混沌序列的访问需要线程安全）。
  4. 预计算引力权重：由于邻域相对位置固定，每个方向的距离和基础权重是常数，可以预先计算好一个权重向量，在循环中直接调用，避免重复计算sqrt和除法。

5.4 信息熵提升不明显，达不到7.99以上

• 问题描述：加密后图像的信息熵只在7.6到7.8之间徘徊。
• 原因分析：统计特性没有完全均匀化。说明当前的置乱和扩散组合，没有彻底破坏原始图像的统计特征。
• 排查与改进：
  1. 检查置乱效果：单独显示scrambled_img。它应该看起来像完全随机的静态噪声。如果还能看出原图的轮廓，说明混沌序列生成的随机排列索引质量不高，或者图像展平/重构的逻辑有误。
  2. 强化扩散非线性：检查你的扩散公式。mod(..., 256)是产生非线性的关键。尝试调整缩放因子（代码中的delta = total_force * 5的5），让像素值的变化幅度更大，更容易触发模运算的“翻转”效应。
  3. 引入像素值置乱：在位置置乱之后、重力扩散之前，可以增加一步“像素值置乱”（或称“混淆”）。即用另一个混沌序列生成的随机数，与当前像素值进行按位的异或（XOR）或模加运算。这能快速破坏像素值的统计关系。公式如：C(i) = bitxor(P(i), floor(chaos_seq(i)*256))。
  4. 尝试不同的混沌系统：如果Log-logistic增强版效果不佳，可以尝试更复杂的系统，如二维混沌映射（Henon, Logistic-Sine耦合）或超混沌系统。它们通常能产生随机性更好的序列。

最后，图像加密算法的评估是一个系统工程，除了信息熵，还应考虑直方图分析（是否平坦）、相邻像素相关性（水平、垂直、对角方向应接近0）、密钥空间（是否足够大以抵抗暴力破解）、差分攻击（明文微小改变导致密文巨大改变的程度）等。将这些测试模块化，集成到你的代码中，才能全面评估自己实现的算法强度。