简介：围绕数字图像缩放技术展开的本科毕业设计论文，面向电子信息工程、图像处理方向的学生与自学者，可用于了解数字电视视频格式、图像分辨率变换及插值算法实现思路。压缩包共1个doc文件，约2.05MB，内容为完整论文文档，便于直接查阅与整理。已有908人学习下载。论文从数学插值基础、数字图像处理概述和MATLAB应用环境讲起，重点讨论最近邻域插值、双线性插值、双三次插值等经典算法，并给出MATLAB编程实现与实验对比思路，涉及算法性能、运算量及缩放效果分析。其任务书、摘要、目录和章节组织较完整，适合作为毕业设计选题参考、论文结构模板或图像缩放实验的入门材料，也能帮助读者梳理从理论推导到仿真验证的写作路径。

1. 一份 2006 年的本科毕设：数字图像缩放的 MATLAB 算法对比台

很多人拿到「数字图像处理毕业论文」这类资源，第一反应是翻代码、找现成函数贴进工程里。真跑起来才发现，这份毕设真正值钱的地方不是某一段代码，而是它把数字图像缩放这件事做成了一台可对比的实验台：同一批测试图、同一套指标、七种插值算法摆在一起，性能和运算量一起量。论文从数字电视的视频格式切入，先把 1080i、720p、1080p 三种分辨率摆在台面上，再落到最近邻、双线性、双三次三种经典插值，最后扩展到邻域取平均、Ferguson 曲面、自适应系数、边缘定向和共轭梯度多帧融合。全部用 MATLAB 手写实现，不依赖 imresize 这类已经调好的封装。适合两类人：一类要照着复现算法、写自己的课程设计或毕设；另一类想把这份老代码当成插值算法的字典，按需抠一块出来改成自己工程里的缩放模块。

2. 论文骨架与实验环境：从数字电视视频格式到第一条能跑的缩放脚本

2.1 为什么第一章要讲数字电视的三种视频格式

这份毕设的切入点很实在：图像缩放不是凭空研究，它有一个明确的业务驱动力——终端显示设备的分辨率和信号源的分辨率对不上。论文里把「固有分辨率」这个概念单独拎出来讲，指的是显示设备不靠行倍频、不靠内插就能做到的物理分辨率，比如等离子、液晶这类固定像素屏，固有分辨率和实际像素排列结构是同一个数。信号源可能是 1920×1080，屏幕可能是 1280×720，中间这段差就必须由缩放算法补上。

论文列出的三种格式直接决定了后面所有实验的目标分辨率：

这张表背后有个反直觉的结论，论文专门点了一句：对处理能力（带宽）的要求是 1080i < 720p。原因是 1080i 隔行传输，单位时间要处理的行数反而少。这个细节在写缩放实验时会影响你对「输入帧率」和「单帧处理预算」的估算，很多人做性能对比时忽略了这点，把 1080i 和 720p 的耗时直接横比，结论就站不住。

2.2 六章目录就是一张算法地图

把目录摊开看，这份论文的六章其实对应四层结构，每一层都能落到具体的代码产物上：

第 2 章那部分看着像凑字数，其实是后面所有 bug 的源头。论文花了不小篇幅讲采样与量化：采样把连续图像切成 M×N 个像素，量化把连续的灰度值切成离散级数，8 bit 就是 0~255 共 256 级；一幅 512×512、8 bit 灰度的图大约占 210 万个存储位。它还特意提醒了一句灰度方向的问题——0 为白 255 为黑，还是 0 为黑 255 为白，取决于输入方式和处理观点，编程时特别容易搞反。这句话我当年没当回事，后来在显示环节翻了车。

同一章还列了 MATLAB 支持的四种基本图像类型：索引图像、灰度图像、二值图像、RGB 图像。索引图像是「图像矩阵 + 颜色图数组」两件套，灰度图是一个矩阵，二值图是 0/1 矩阵，RGB 图是 M×N×3 的三维数组。这四种类型在缩放函数里的处理路径完全不同，弄混了就是第 5 章要讲的第一个坑。

2.3 环境准备与最小可跑闭环

论文成稿年代久远，但代码逻辑和现在的 MATLAB 完全兼容。我一般不去追论文里的具体版本，直接在当前 MATLAB 上跑，需要确认的只有一件事：Image Processing Toolbox 有没有装，imread、imshow、padarray、psnr这些函数都在里面。

先跑一个最小闭环，确认读图、类型转换、尺寸变换、显示、存图这条链路是通的，再去动算法：

% minimal_loop.m —— 最小可跑闭环 img = imread('test.png'); % 读入测试图，路径按自己情况改 if size(img, 3) == 3 img = rgb2gray(img); % 缩放算法先统一在单通道上验证 end f = im2double(img); % 统一转 double，灰度归一化到 0~1 fprintf('原始尺寸: %d x %d, 类型: %s\n', size(f,1), size(f,2), class(f)); sx = 2; sy = 2; % 水平/垂直缩放倍数 [H, W] = size(f); g = zeros(round(H*sy), round(W*sx)); for i = 1:size(g,1) for j = 1:size(g,2) u = min(max(round((j-0.5)/sx + 0.5), 1), W); v = min(max(round((i-0.5)/sy + 0.5), 1), H); g(i, j) = f(v, u); % 先拿最近邻占位，验证链路 end end imwrite(g, 'out_nearest.png'); figure, subplot(1,2,1), imshow(f), title('原图'); subplot(1,2,2), imshow(g), title('放大 2 倍');

这段代码里有三个约定，后面所有算法都沿用，值得先钉死。第一，输入统一im2double转成 0~1 的 double，避免 uint8 做乘加时溢出、也避免imshow因为类型不同而显示异常。第二，缩放倍数sx、sy分开传，这样后面做「只横向放大」的边缘定向插值实验时不用改函数签名。第三，目标坐标反算用(j-0.5)/sx + 0.5而不是j/sx，这个 0.5 的偏移是像素中心对齐的关键，少了它整幅图会平移半个像素，放大倍数越大偏得越明显。

坐标反算的公式值得单独说一句。目标图第 j 个像素的中心，映射回源图的位置是u = (j - 0.5) / sx + 0.5。减 0.5 是把「第 j 个像素的左边界」换成「第 j 个像素的中心」，除完倍数再 +0.5 换回源图的像素中心坐标。这一套在 OpenCV 里叫INTER_NEAREST的坐标约定，手写时最容易漏掉反算里的偏移量。

跑通之后，f是 double、范围 0~1，g同类型，imshow能正常显示。这一步稳了，再往里塞算法才不会被数据类型和显示问题干扰。

3. 三种经典插值的落地实现：最近邻、双线性、双三次的核函数与边界处理

3.1 插值核函数决定了计算量和边缘表现

三种经典算法的差别，本质上就是插值核函数的支撑域大小。最近邻只取 1 个采样点，双线性取 2×2 共 4 个，双三次取 4×4 共 16 个。运算量的差距是数量级的，效果差距也是。

论文里从数学形态上分析了插值核函数引起计算量和处理效果的不同，这个思路比单纯贴效果图有说服力。放大场景下，最近邻会产生明显的方块感，双线性把边缘抹平，双三次在强边缘两侧会出现轻微的光晕。缩小场景则反过来，最近邻会直接丢像素，产生混叠。

3.2 最近邻与双线性的手写实现

最近邻的实现上面已经给过骨架，这里补一个更完整的版本，把类型保持和边界夹取都写清楚：

function g = scale_nearest(f, sx, sy) % f: 输入灰度图，double 类型 % sx/sy: 水平/垂直缩放倍数，大于 1 放大，小于 1 缩小 [H, W] = size(f); H2 = max(1, round(H * sy)); W2 = max(1, round(W * sx)); g = zeros(H2, W2, 'like', f); % 预分配，输出类型跟随输入 for i = 1:H2 v = (i - 0.5) / sy + 0.5; % 目标行中心反算到源图行坐标 v = min(max(round(v), 1), H); % 四舍五入并夹到 [1, H] for j = 1:W2 u = (j - 0.5) / sx + 0.5; u = min(max(round(u), 1), W); g(i, j) = f(v, u); % 单点采样，无权重计算 end end end

round的取整方向会影响边界像素的选择，MATLAB 的round是四舍五入远离零，和 C 的(int)(x+0.5)在小数点后正好 .5 时行为一致，问题不大。max(1, round(H*sy))这层保护是给缩小到 1 像素以下的极端情况兜底的，不写的话zeros会报维度错误。

双线性就是把 1 个点扩成 4 个点，按距离做两次一维线性插值：

function g = scale_bilinear(f, sx, sy) [H, W] = size(f); H2 = max(1, round(H * sy)); W2 = max(1, round(W * sx)); g = zeros(H2, W2); for i = 1:H2 v = (i - 0.5) / sy + 0.5; y0 = floor(v); dy = v - y0; % y0 为左上邻点行号，dy 为行方向权重 y1 = min(y0 + 1, H); % 下邻点，越界时复制边界 y0 = min(max(y0, 1), H); for j = 1:W2 u = (j - 0.5) / sx + 0.5; x0 = floor(u); dx = u - x0; x1 = min(x0 + 1, W); x0 = min(max(x0, 1), W); % 四个邻点按距离加权求和 g(i, j) = (1-dx)*(1-dy)*f(y0,x0) + dx*(1-dy)*f(y0,x1) ... + (1-dx)*dy *f(y1,x0) + dx*dy *f(y1,x1); end end end

dy和dx就是插值权重，取值范围 [0,1)。四个系数加起来恒等于 1，这是双线性能保持亮度均值的前提。y1 = min(y0+1, H)是边界复制策略，等价于padarray的replicate，比补零好——补零会在图像右下角拉出一条黑边。

这两个函数都是双循环，跑 512×512 放大 2 倍就是 100 万次迭代，MATLAB 里大概几秒到十几秒，做算法验证够用。真要提速，可以把行列索引提前向量化，或者用interp2的'nearest'、'linear'模式做对照，确认手写实现没跑偏。

3.3 双三次插值的 4×4 邻域与三次核

双三次的复杂度主要在两处：一是核函数要分段写，二是邻域取到 4×4 后边界处理麻烦。论文里提到的三次插值核，常用的形式是 Keys 提出的一类，用参数 a 控制过冲强度，a 取 -0.5 是常见选择：

function w = cubic_kernel(t) % t: 采样点到目标点的归一化距离，可以是向量 a = -0.5; % 常用取值，a=-0.75 时边缘更锐但振铃更明显 t = abs(t); w = zeros(size(t)); i1 = t <= 1; i2 = t > 1 & t < 2; w(i1) = (a+2)*t(i1).^3 - (a+3)*t(i1).^2 + 1; w(i2) = a*t(i2).^3 - 5*a*t(i2).^2 + 8*a*t(i2) - 4*a; end

核函数在 |t| > 2 时返回 0，这就是「支撑域为 4」的来源。注意权重之和不一定等于 1，双三次不像双线性那样严格保均值，这也是它在平坦区可能出现轻微亮度漂移的原因。

主体部分我习惯先padarray补两圈，把边界判断从内层循环里拿出去：

function g = scale_bicubic(f, sx, sy) [H, W] = size(f); H2 = max(1, round(H * sy)); W2 = max(1, round(W * sx)); g = zeros(H2, W2); fp = padarray(f, [2 2], 'replicate'); % 上下左右各补 2 圈边界 for i = 1:H2 v = (i - 0.5) / sy + 0.5; y0 = floor(v); dy = v - y0; for j = 1:W2 u = (j - 0.5) / sx + 0.5; x0 = floor(u); dx = u - x0; % 取源图 (y0-1..y0+2) x (x0-1..x0+2) 的 4x4 块，补边后索引整体 +2 patch = fp(y0+1 : y0+4, x0+1 : x0+4); wy = cubic_kernel((y0-1 : y0+2) - v); % 1x4 行权重 wx = cubic_kernel((x0-1 : x0+2) - u); % 1x4 列权重 g(i, j) = wy * patch * wx'; % 行列各做一次一维加权 end end end

fp补了两圈之后，源图坐标k对应fp的k+2。当y0取到 0（放大倍数很大、目标行贴近上边界时会出现），y0+1 = 1仍然合法；y0最大约等于 H，y0+4 = H+4正好是fp的最后一行。这套索引关系是双三次实现里最容易写错的地方，写完后拿一张 3×3 的小矩阵手工验算一遍，比盯着效果图猜快得多。

3.4 三种算法放在一起跑：锯齿、模糊、振铃各自现形

验证阶段不要只看一张图。我一般准备三类测试图：一张带强斜边的几何图（看锯齿）、一张纹理丰富的自然图（看细节保留）、一张平滑渐变图（看亮度漂移）。放大 2 倍和缩小 0.5 倍各跑一遍，把结果拼成对比图。

耗时统计要单独做一次，把tic/toc卡在算法调用外层，别把读图和显示算进去：

methods = {@scale_nearest, @scale_bilinear, @scale_bicubic}; names = {'nearest', 'bilinear', 'bicubic'}; f = im2double(imread('test.png')); if size(f,3) == 3, f = rgb2gray(f); end for k = 1:numel(methods) tic; out = methods{k}(f, 2, 2); t = toc; fprintf('%-10s 输出 %dx%d, 耗时 %.3f s\n', names{k}, ... size(out,1), size(out,2), t); imwrite(out, sprintf('out_%s.png', names{k})); end

methods元胞数组的写法是为了后面加改进算法时不用改循环结构，只往数组里追加函数句柄就行。这套脚手架在第 4 章会一直用下去。

4. 四种改进算法的工程拆解：邻域取平均、Ferguson 曲面、自适应系数、边缘定向

4.1 缩小场景：近邻插值加邻域取平均

传统三种算法都是从「放大」角度设计的，直接拿来缩小会出问题：最近邻缩小等于等间隔抽点，被抽掉的像素信息永久丢失，遇到高频纹理就产生混叠。论文提出的第一个改进很朴素——缩小之前先在源图上做邻域取平均，把块内均值当作采样值。

function g = shrink_mean(f, k) % k: 缩小倍数，取正整数 [H, W] = size(f); H2 = floor(H / k); W2 = floor(W / k); g = zeros(H2, W2); for i = 1:H2 for j = 1:W2 block = f((i-1)*k+1 : i*k, (j-1)*k+1 : j*k); g(i, j) = mean(block(:)); % 块内均值替代单点采样 end end end

k必须取整数，这是这个算法的硬约束。如果缩小倍数是 0.4 这种非整数，得先把k设计成 2 或 3，再用双线性补足剩余比例，两段式处理。mean(block(:))是块内算术平均，等价于一个矩形窗低通滤波再抽样，能把高频噪声压下去，代价是边缘变软。

这个算法在论文里的评价是「运算量介于最近邻和双线性之间，缩小效果明显优于最近邻」。实际跑下来确实如此，尤其是纹理图缩小后，混叠条纹比纯最近邻少很多。缺点是它只能处理整数倍，且对放大场景没有帮助。

4.2 Ferguson 曲面插值：把一维三次曲线片推广到二维

Ferguson 曲线是 Hermite 形式的三次曲线，用两个端点的值和端点处的切矢来定义。推广到曲面片，就是用四个角点的值加上角点处的两个方向偏导，共 12 个参数确定一块双三次曲面片。论文的思路是：传统双三次插值只用 16 个采样点的值，没有显式利用梯度信息；Ferguson 曲面片把偏导也纳入约束，边缘过渡会更自然。

实现上，核心是先估出每个网格点处的偏导，再在参数域里做双三次 Hermite 插值：

function g = scale_ferguson(f, sx, sy) f = double(f); [H, W] = size(f); [gx, gy] = gradient(f); % 中心差分估一阶偏导 H2 = round(H * sy); W2 = round(W * sx); g = zeros(H2, W2); for i = 1:H2 v = (i - 0.5) / sy + 0.5; y0 = min(max(floor(v), 1), H-1); % 取网格单元，保证 y0+1 合法 t = v - y0; % 单元内归一化参数，0~1 for j = 1:W2 u = (j - 0.5) / sx + 0.5; x0 = min(max(floor(u), 1), W-1); s = u - x0; % 四个角点的值和偏导 p00 = f(y0,x0); p10 = f(y0,x0+1); p01 = f(y0+1,x0); p11 = f(y0+1,x0+1); fx00 = gx(y0,x0); fx10 = gx(y0,x0+1); fy00 = gy(y0,x0); fy01 = gy(y0+1,x0); % Hermite 基函数 h00 = 2*s^3 - 3*s^2 + 1; h10 = s^3 - 2*s^2 + s; h01 = -2*s^3 + 3*s^2; h11 = s^3 - s^2; g00 = 2*t^3 - 3*t^2 + 1; g10 = t^3 - 2*t^2 + t; g01 = -2*t^3 + 3*t^2; g11 = t^3 - t^2; % 行方向先插值，再做列方向 row0 = h00*p00 + h10*fx00 + h01*p10 + h11*fx10; row1 = h00*p01 + h10*gx(y0+1,x0) + h01*p11 + h11*gx(y0+1,x0+1); g(i,j) = g00*row0 + g10*fy00 + g01*row1 + g11*fy01; end end end

h00~h11和g00~g11是 Hermite 三次基函数，s、t是单元内归一化参数，取值 [0,1]。这里只用了四个角点的值和部分偏导，完整版还需要角点处的混合偏导，代码会更长。论文里的评价是 Ferguson 曲面在边缘连续性上优于双三次，但运算量也上去了，因为每个像素多了一次梯度估计和更多乘法。

实际改的时候有个简化空间：如果不需要严格 C1 连续，可以把切矢用相邻点差分近似替代，省掉全局gradient调用，代价是边缘处可能出现轻微不连续。

4.3 带系数自适应插值：按局部梯度调权重

传统双线性在整幅图上用同一套权重，不管这块区域是平坦还是有边缘。自适应插值的思路是：先估局部梯度，平坦区走双线性保平滑，边缘区加大高阶分量保锐度。

function g = scale_adaptive(f, sx, sy) g1 = scale_bilinear(f, sx, sy); % 平滑基座 g2 = scale_bicubic(f, sx, sy); % 细节补充 w = stdfilt(g1, ones(3)); % 3x3 局部标准差，衡量局部活跃度 w = w ./ (max(w(:)) + eps); % 归一化到 0~1 w = min(max(w, 0), 1); g = (1 - w) .* g1 + w .* g2; % 按活跃度混合两路结果 end

stdfilt是 3×3 局部标准差滤波，值大说明这块区域纹理或边缘活跃，权重w就大，双三次的占比提高。eps是为了防止全平坦图除零。min(max(w,0),1)是保险，局部标准差归一化后理论上不会越界，但边界处理可能带来微小溢出。

这个算法有个可调参数——3×3 窗口大小。窗口放大到 5×5，平滑区的判定会更保守，边缘保护范围更宽；缩到 3×3 则更贴近像素级判断，但对噪声敏感。论文里没给具体窗口，我一般从 3×3 起调，看测试图效果再定。

4.4 边缘定向插值：先判方向再沿边插

前面几种算法都是各向同性的，插值核在水平和垂直方向一致。边缘定向插值换了个思路：先判断当前像素处在什么方向的边缘上，再沿着边缘方向做插值，避免跨边缘混合导致模糊。

function g = scale_edge_directed(f, s) f = double(f); imgH = scale_bilinear(scale_bilinear(f, s, 1), 1, s); % 先横后纵 imgV = scale_bilinear(scale_bilinear(f, 1, s), s, 1); % 先纵后横 [gx, gy] = gradient(f); % 源图上的水平/竖直梯度 Gx = scale_bilinear(gx, s, s); % 梯度场同步放大到目标尺寸 Gy = scale_bilinear(gy, s, s); wH = abs(Gy) + eps; % 竖直梯度大 → 沿水平方向插值 wV = abs(Gx) + eps; % 水平梯度大 → 沿竖直方向插值 g = (wH .* imgH + wV .* imgV) ./ (wH + wV); end

这里的权重逻辑是：Gy大说明上下方向灰度变化剧烈，属于水平边缘，插值应该沿水平方向走，所以给imgH（先横后纵的结果）更大权重。eps保证分母不为零，abs取梯度幅值，符号不影响方向判断。

论文里还提了一个简化算法：不做完整的梯度场估计，只在 3×3 窗口内比较四个方向的差分绝对值，取最小的方向做一维插值。运算量能降一个量级，效果在中等放大倍数下和完整版差距不大。这个简化版本适合嵌入式或实时场景，代价是方向判断的粒度变粗，遇到弯曲边缘容易判错方向。

这个算法有个前提——输入图得相对干净。梯度估计对噪声非常敏感，噪声图上梯度幅值被噪声主导，方向判断基本随机，效果反而比双线性还差。我一般会在前面加一道轻度平滑，或者用 Sobel 核代替简单的中心差分。

4.5 多帧融合提高分辨率：共轭梯度那一路

论文最后一节跳出了单帧插值的框架，讲多帧融合超分。核心思想是：同一场景的多帧低分辨率图像之间存在亚像素位移，这些位移提供了额外的采样信息，融合起来能重建出超过单帧插值极限的高分辨率图像。

模型写成y = Hx + n，y是观测到的低分辨率帧堆叠成的列向量，x是待求的高分辨率图像，H是降采样加模糊的观测矩阵，n是噪声。直接求逆不现实，H是超大稀疏矩阵，所以用共轭梯度迭代解最小二乘：

function x = cg_superresolve(y, H, iters, lambda) % y: 低分辨率观测，列向量 % H: 观测矩阵（降采样 + 模糊），稀疏存储 % iters: 迭代上限；lambda: 正则项权重 N = size(H, 2); x = H' * y; % 用伴随作为初值，比全零收敛快 r = H' * (y - H * x) - lambda * x; p = r; rsold = r' * r; for k = 1:iters Ap = H' * (H * p) + lambda * p; % 正则化最小二乘的法方程 alpha = rsold / (p' * Ap); x = x + alpha * p; % 沿共轭方向更新 r = r - alpha * Ap; rsnew = r' * r; if sqrt(rsnew) < 1e-6, break; end % 残差足够小就提前退出 p = r + (rsnew / rsold) * p; % 构造下一个共轭方向 rsold = rsnew; end end

lambda是正则项权重，控制解的平滑程度，取大了图像糊，取小了噪声放大。iters一般几十到上百次就收敛，靠sqrt(rsnew) < 1e-6提前退出能省不少时间。H'是观测矩阵的转置，实际实现里不会真的构造这个大矩阵，而是用「模糊 + 降采样」和「上采样 + 反模糊」两个函数代替矩阵乘，这也是论文里没细说、但工程上必须处理的一步。

这一节在毕设里更多是方向性的，没做到完整可复现的程度。想复现的话，得自己补帧间配准（估亚像素位移）和H的具体形式，工作量比前面四个算法大一个量级。

4.6 统一实验脚手架：同一批图、同一套指标

五种算法写完后，如果没有统一的跑法，对比表根本做不出来。我习惯把算法函数句柄、名称、参数打包成一个结构体，用一个循环跑完：

cfg = struct( ... 'nearest', {{@scale_nearest, 2, 2}}, ... 'bilinear', {{@scale_bilinear, 2, 2}}, ... 'bicubic', {{@scale_bicubic, 2, 2}}, ... 'adaptive', {{@scale_adaptive, 2, 2}}, ... 'edge', {{@scale_edge_directed, 2}}); f = im2double(imread('test.png')); if size(f,3) == 3, f = rgb2gray(f); end names = fieldnames(cfg); for k = 1:numel(names) fn = cfg.(names{k}){1}; args = cfg.(names{k})(2:end); tic; out = fn(f, args{:}); t = toc; imwrite(out, sprintf('cmp_%s.png', names{k})); fprintf('%-10s 耗时 %.3f s, 输出 %dx%d\n', ... names{k}, t, size(out,1), size(out,2)); end

args{:}这个展开写法让不同参数个数的算法可以共用同一个循环，scale_edge_directed只接一个倍数参数也能跑。这套脚手架最大的价值是可复现——换个测试图、换个放大倍数，只改配置不改循环，对比表的数字才有可比性。

5. 避坑与排查：跑这份缩放代码最容易翻车的五个地方

5.1 缩放后图像一片白或一片黑

现象：算法跑完imshow出来全白或全黑，max(g(:))看着也正常，就是显示不对。

原因：imshow对 double 类型默认按 [0,1] 映射，对 uint8 按 [0,255] 映射。如果输入是 uint8、中间某一步转成了 double 但没除 255，imshow会把 0~255 的值当 0~1 处理，超过 1 的全截成白色；反过来 double 乘了 255 再当 uint8 显示，就是全黑。

解决：在函数入口处统一im2double，出口处保持 double，显示前不再做类型转换。如果必须输出 uint8，用im2uint8而不是uint8(g*255)，前者会自动做饱和截断，后者在 g 略大于 1 时会回绕。

g = scale_bilinear(f, 2, 2); % 输出 double，范围约 0~1 imwrite(im2uint8(g), 'out.png'); % 存盘才转 uint8，用 im2uint8 不用 uint8

5.2 放大后整幅图平移了半个像素

现象：放大 2 倍的图和原图叠在一起看，边缘错位，偏移量随放大倍数增大而增大。

原因：坐标反算写成了u = j / sx，少了像素中心的 0.5 偏移。j/sx把目标图的像素边界当成了像素中心，等价于整体平移了半像素。

解决：统一用u = (j - 0.5) / sx + 0.5。验证方法很简单，放大倍数为 1 时输出必须和输入完全一致，max(abs(g(:) - f(:)))应该接近 0，不是 0 就说明坐标映射有问题。

提示：这条验证我每次都跑，sx=sy=1 时三种算法的输出都该和原图逐像素相等，不等的地方就是坐标偏移的藏身之处。

5.3 彩色图缩放后颜色错乱或直接变灰度

现象：输入是 RGB 图，输出颜色明显不对，或者干脆成了灰度图。

原因：缩放函数是按二维矩阵写的，size(f)返回三个维度但代码只取了前两个，zeros(H2,W2)直接丢掉了通道维。另一种情况是输入其实是索引图像，imread读出来是二维索引矩阵加一个 colormap，直接当灰度图处理，灰度值被误当成了颜色索引。

解决：RGB 图分通道处理，或者用三维索引一次算完；索引图先ind2rgb转成 RGB 再进缩放。判断方法看imfinfo返回的ColorType字段。

[img, map] = imread('test.png'); if ~isempty(map) img = ind2rgb(img, map); % 索引图先转 RGB end if size(img, 3) == 3 g = zeros(size(img,1)*2, size(img,2)*2, 3); for c = 1:3 g(:,:,c) = scale_bilinear(img(:,:,c), 2, 2); % 逐通道缩放 end else g = scale_bilinear(img, 2, 2); end

5.4 运算量统计出来不可比

现象：同一张图跑两遍，第一次耗时明显比第二次长，或者几个算法之间的耗时差异大得离谱。

原因：第一次调用会把函数文件加载进内存，这段开销算在了tic/toc里；另一个常见问题是把imread、imshow、imwrite都圈进了计时区间，这些 I/O 操作的波动比算法本身还大。

解决：计时区间只包住算法调用的那一行，跑之前先预热一遍，取三次的中位数。对比不同算法时，确保输入尺寸、输出尺寸、数据类型完全一致。

out = scale_bilinear(f, 2, 2); % 预热，不计时 times = zeros(1, 3); for r = 1:3 tic; scale_bilinear(f, 2, 2); times(r) = toc; end fprintf('中位耗时 %.4f s\n', median(times));

5.5 边缘定向插值在噪声图上反而更差

现象：加了一点高斯噪声之后，边缘定向插值的结果比双线性还糊，边缘方向看起来是随机的。

原因：方向判断依赖梯度估计，噪声会让梯度幅值整体抬升，真实边缘的梯度淹没在噪声里，权重wH、wV基本变成随机数，融合结果就是两路噪声的平均。

解决：在梯度估计前加一道轻度平滑，或者改用 Sobel、Prewitt 这类带平滑效果的卷积核代替gradient的中心差分。平滑强度别太大，否则边缘本身也被抹掉了。

f_s = imgaussfilt(f, 0.5); % 轻度高斯平滑，sigma 取 0.5 左右 [gx, gy] = gradient(f_s); % 在平滑后的图上估梯度

注意：边缘类算法的适用前提是信噪比别太差。真实场景里如果输入本身噪声大，先降噪再插值，别指望插值算法顺便把噪声也处理了。

6. 二次开发：把它改成一个能加算法、能出对比表的实验台

这份代码放到今天，最有价值的改造方向不是把某个算法调到极致，而是把实验台搭稳，让新增算法能即插即用。

第一件事是把函数签名统一。现在几个函数参数个数不一致，scale_edge_directed只接一个倍数，scale_adaptive接两个，进循环时得写分支判断。统一成g = scaler(f, sx, sy, opts)之后，多出来的参数塞进opts结构体，循环里只认一个签名。这一步看着笨，但能省掉后面每次加算法都要改脚手架的麻烦。

function g = scaler(f, sx, sy, method, opts) % 统一入口：method 为算法名字符串，opts 为可选项结构体 if nargin < 5, opts = struct(); end switch lower(method) case 'nearest', g = scale_nearest(f, sx, sy); case 'bilinear', g = scale_bilinear(f, sx, sy); case 'bicubic', g = scale_bicubic(f, sx, sy); case 'adaptive', g = scale_adaptive(f, sx, sy); case 'edge', g = scale_edge_directed(f, sx); otherwise, error('未知算法: %s', method); end end

第二件事是把评价指标补齐。论文只做了主观效果对比和运算量统计，缺客观指标。放大实验的客观评价不能直接拿放大结果和原图算 PSNR，尺寸都不一样。标准做法是：原图先缩小再放大回原尺寸，和原图比，这个叫循环一致性；或者直接拿高分辨率原图作为参考，先把算法降采样到低分辨率，再放大回来比 PSNR 和 SSIM。两种口径不能混用，混用出来的数字没有可比性。

第三件事是给边缘类算法留一个预处理钩子。现在的实现假设输入干净，实际拿去处理手机拍的图会翻车。在scaler里加一个opts.presmooth字段，非零时先做一次轻度平滑，默认关闭，需要时打开。这样既保留了论文原始算法的行为，又给了工程化的出口。

从那以后我每次拿到这类算法对比型的老代码，都先做两件事：把输入输出的数据类型和坐标映射这两个约定用一句话写死，再用 sx=sy=1 跑一遍自检。这两关过了，剩下的调试才有意义；过不了，后面所有效果对比都是在错的基础上比较。希望帮到你。

本文还有配套的精品资源，点击获取