图像处理与计算机视觉编程实践

table {
border-collapse: collapse;
width: 100%;
margin-bottom: 1rem;
}
th, td {
border: 1px solid #ddd;
padding: 8px;
text-align: left;
}
th {
background-color: #f2f2f2;
}
tr:nth-child(even) {
background-color: #f9f9f9;
}
pre {
background-color: #f8f8f8;
padding: 15px;
border-radius: 4px;
overflow-x: auto;
}

1、确定存储一个大小为 4000×3000 像素的未压缩二值图像所需的字节数。

二值图像每个像素通常用 1 位（bit）编码，该图像像素总数为 4000×3000 = 12000000 像素，总位数为 12000000 位。因为 1 字节（Byte） = 8 位（bit），所以所需字节数为 12000000 ÷ 8 = 1500000 字节。

2、确定使用每个颜色通道8、10、12和14位来存储一个大小为640×480像素的未压缩RGB彩色图像所需的字节数。

首先明确RGB彩色图像每个像素由红（R）、绿（G）、蓝（B）三个颜色通道组成，所以每个像素所需的位数等于每个颜色通道的位数乘以3。然后将总位数转换为字节数（1字节 = 8位）。

当每个颜色通道为8位时：

– 每个像素的位数：8位/通道×3通道 = 24位。

– 图像总像素数：640×480 = 307200像素。

– 图像总位数：24位/像素×307200像素 = 7372800位。

– 转换为字节数：7372800位÷8位/字节 = 921600字节。

当每个颜色通道为10位时：

– 每个像素的位数：10位/通道×3通道 = 30位。

– 图像总像素数：640×480 = 307200像素。

– 图像总位数：30位/像素×307200像素 = 9216000位。

– 转换为字节数：9216000位÷8位/字节 = 1152000字节。

当每个颜色通道为12位时：

– 每个像素的位数：12位/通道×3通道 = 36位。

– 图像总像素数：640×480 = 307200像素。

– 图像总位数：36位/像素×307200像素 = 11059200位。

– 转换为字节数：11059200位÷8位/字节 = 1382400字节。

当每个颜色通道为14位时：

– 每个像素的位数：14位/通道×3通道 = 42位。

– 图像总像素数：640×480 = 307200像素。

– 图像总位数：42位/像素×307200像素 = 12902400位。

– 转换为字节数：12902400位÷8位/字节 = 1612800字节。

综上，使用每个颜色通道8、10、12和14位来存储该图像所需的字节数分别为921600字节、1152000字节、1382400字节和1612800字节。

3、编写一个新的ImageJ插件，用于水平（或垂直）翻转灰度图像。使用不同大小（奇数、偶数、极小）的合适图像测试你的新插件，并仔细检查结果。

以下是基于

My_Inverter.java

模板编写的用于水平翻转灰度图像的 ImageJ 插件示例代码：

import ij.ImagePlus;
import ij.plugin.filter.PlugInFilter;
import ij.process.ImageProcessor;

public class My_HorizontalReflector implements PlugInFilter {
    public int setup(String args, ImagePlus im) {
        return DOES_8G; // 该插件接受8位灰度图像
    }

    public void run(ImageProcessor ip) {
        int M = ip.getWidth();
        int N = ip.getHeight();

        // 遍历所有图像坐标 (u,v)
        for (int v = 0; v < N; v++) {
            for (int u = 0; u < M / 2; u++) {
                int p1 = ip.getPixel(u, v);
                int p2 = ip.getPixel(M - u - 1, v);
                ip.putPixel(u, v, p2);
                ip.putPixel(M - u - 1, v, p1);
            }
        }
    }
}

代码解释：

导入必要的包

：导入

ij.ImagePlus

、

ij.plugin.filter.PlugInFilter

和

ij.process.ImageProcessor

。

实现

PlugInFilter

接口

：创建一个名为

My_HorizontalReflector

的类，实现

PlugInFilter

接口。

setup

方法

：返回

DOES_8G

，表示该插件接受 8 位灰度图像。

run

方法

：

– 获取图像的宽度

M

和高度

N

。

– 使用嵌套的

for

循环遍历图像的每一行。

– 对于每一行，交换左右两侧的像素值，实现水平翻转。

测试：

将上述代码保存为

My_HorizontalReflector.java

文件，然后在 ImageJ 中编译并运行该插件。使用不同大小（奇数、偶数、极小）的灰度图像进行测试，检查结果是否符合预期。

4、编写一个新的 ImageJ 插件，该插件能将 8 位灰度图像水平循环移动，直到图像恢复到原始状态。为了在每次移动后显示修改后的图像，需要一个对相应 ImagePlus 对象的引用（ImageProcessor 没有显示方法）。ImagePlus 对象只能在插件的 setup() 方法中访问，该方法会在 run() 方法自动调用之前被调用。请实现这个插件，给出完整代码。

以下是实现该功能的 Java 代码：

import ij.ImagePlus;
import ij.plugin.filter.PlugInFilter;
import ij.process.ImageProcessor;

public class XY_Plugin implements PlugInFilter {
    ImagePlus im;

    public int setup(String args, ImagePlus im) {
        this.im = im;
        return DOES_8G;
    }

    public void run(ImageProcessor ip) {
        int width = ip.getWidth();
        for (int shift = 0; shift < width; shift++) {
            ImageProcessor temp = ip.duplicate();
            for (int y = 0; y < ip.getHeight(); y++) {
                for (int x = 0; x < width; x++) {
                    int newX = (x + shift) % width;
                    ip.set(newX, y, temp.get(x, y));
                }
            }
            im.updateAndDraw();
            try {
                Thread.sleep(100); // 可调整延迟时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

此代码实现了将 8 位灰度图像水平循环移动，每次移动后显示修改后的图像，直到图像恢复到原始状态。

5、开发一个 ImageJ 插件，使用 Java 方法 Math.random() 或 Random.nextInt(int n) 创建一个像素值在 [0, 255] 范围内均匀分布的随机图像。分析该图像的直方图，以确定像素值的实际分布均匀程度。

以下是一个简单的 ImageJ 插件示例，用于创建像素值在

[0, 255]

范围内均匀分布的随机图像，并分析其直方图：

import ij.ImagePlus;
import ij.ImageProcessor;
import ij.plugin.filter.PlugInFilter;
import java.util.Random;

public class RandomImageHistogram implements PlugInFilter {
    public int setup(String arg, ImagePlus img) {
        return DOES_ALL + NO_CHANGES;
    }

    public void run(ImageProcessor ip) {
        int width = ip.getWidth();
        int height = ip.getHeight();
        Random random = new Random();
        // 生成随机像素值
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int randomValue = random.nextInt(256); // 生成 0 到 255 之间的随机整数
                ip.putPixel(x, y, randomValue);
            }
        }
        // 显示生成的随机图像
        ImagePlus randomImage = new ImagePlus("Random Image", ip.duplicate());
        randomImage.show();
        // 计算并分析直方图
        int[] histogram = ip.getHistogram();
        // 这里可以添加代码来进一步分析直方图，例如计算标准差等
        // 简单打印直方图信息
        for (int i = 0; i < histogram.length; i++) {
            System.out.println("Intensity " + i + ": " + histogram[i]);
        }
    }
}

上述代码创建了一个 ImageJ 插件，使用

Random.nextInt(int n)

方法生成在

[0, 255]

范围内的随机像素值，并将其应用到图像中。然后计算并输出图像的直方图信息。你可以根据需要进一步分析直方图，例如计算标准差等统计量，以确定像素值的实际分布均匀程度。

6、根据给定灰度图像的直方图 h 实现其算术平均值 μ 和方差 σ² 的计算。将你的计算结果与 ImageJ 的“分析 ▷ 测量”工具返回的结果进行比较（两者应完全匹配）。

可根据公式

μ=1MN∑i=0K−1h(i)⋅iμ=1MN∑i=0K−1h(i)⋅i

计算算术平均值 $mu$，根据公式

σ2=1MN∑i=0K−1(i−μ)2⋅h(i)σ2=1MN∑i=0K−1(i−μ)2⋅h(i)

计算方差 $sigma^2$。其中 $MN$ 是图像像素总数，$K$ 是直方图大小。将计算结果与 ImageJ 的“分析 ▷ 测量”工具结果比较。

7、使用查找表，实现一个ImageJ插件，以实现具有可变γ和a0值的修正伽马校正（见公式(4.34)）。注：公式(4.34)为：当像素值缩放到[0, 1]后的值aa <= a0时，bb = s * aa ；当aa > a0时，bb = (1 + d) * Math.pow(aa, GAMMA) – d 。公式(4.35)为：s = GAMMA / (Math.pow(a0, GAMMA – 1) + Math.pow(a0, 1 – GAMMA)) ，d = 1 / (Math.pow(a0, GAMMA) * (GAMMA – 1) + 1) – 1。

要实现这个需求，可对代码进行修改以支持可变的 γ 和 a0 值。以下是修改后的代码示例：

public void run(ImageProcessor ip) {
    // 仅适用于8位图像
    int K = 256;
    int aMax = K - 1;

    // 可变的γ值
    double GAMMA = 2.8;

    // 可变的a0值
    double a0 = 0.2;

    // 计算s和d
    double s = GAMMA / (Math.pow(a0, GAMMA - 1) + Math.pow(a0, 1 - GAMMA));
    double d = 1 / (Math.pow(a0, GAMMA) * (GAMMA - 1) + 1) - 1;

    // 创建并填充查找表
    int[] Fgc = new int[K];
    for (int a = 0; a < K; a++) {
        double aa = (double) a / aMax; // 缩放到[0, 1]
        double bb;
        if (aa <= a0) {
            bb = s * aa; // 线性部分
        } else {
            bb = (1 + d) * Math.pow(aa, GAMMA) - d; // 幂函数部分
        }

        // 缩放回[0, 255]
        int b = (int) Math.round(bb * aMax);
        Fgc[a] = b;
    }

    // 修改图像
    ip.applyTable(Fgc);
}

在上述代码中，定义了可变的 γ 和 a0 值，然后根据公式计算 s 和 d。在填充查找表时，根据公式，对不同范围的像素值采用不同的计算方式。最后使用

ip.applyTable(Fgc)

方法应用查找表来修改图像。

8、证明标准盒式滤波器不是各向同性的（即不会在所有方向上对图像进行相同的平滑处理）。

标准盒式滤波器的3D形状类似矩形盒子，在频率空间中，其由于边缘的急剧截止而产生强烈的“振铃”现象。在滤波器区域内，它给所有图像像素分配相同的权重，没有对靠近滤波器中心的像素给予更强的权重，与人们期望的对中心附近像素有更强强调不符。

此外，平滑滤波器应“各向同性”（即每个方向均匀）操作，而矩形盒式滤波器显然不满足这一点，所以它不是各向同性的。

9、验证冲激函数相对于线性滤波器的性质。创建一个中心有一个白色像素的黑色图像，并将此图像用作二维冲激。查看线性滤波器是否真的将滤波器矩阵 H 作为其冲激响应。

可按以下步骤操作：

创建一个黑色图像，在其中心设置一个白色像素，将此图像作为二维冲激函数。

对该二维冲激函数应用线性滤波器。

检查滤波后的结果是否与滤波器矩阵 H 相同，若相同则验证了线性滤波器会将滤波器矩阵 H 作为其冲激响应。

10、设计一个线性滤波器（内核），使其在 7 个像素的长度上产生水平模糊，从而模拟曝光期间相机移动的效果。

为了模拟 7 个像素长度的水平模糊，可设计一个 $1 imes 7$ 的线性滤波器内核。该内核应将水平方向上相邻 7 个像素的像素值进行加权求和，且为了保证图像亮度基本不变，所有权重之和应为 1。

最简单的情况是使用均匀权重，即每个像素的权重都为 $frac{1}{7}$。所以滤波器内核 $H$ 为：

H=[17,17,17,17,17,17,17]H=[17,17,17,17,17,17,17]

11、实现一个加权中值滤波器作为ImageJ插件，将权重指定为一个常量二维整数数组。在合适的图像上测试该滤波器，并将结果与标准中值滤波器的结果进行比较。解释为什么例如下面的权重矩阵没有意义：W = ⎡ ⎣ 0 1 0 1 5 1 0 1 0 ⎤ ⎦。

实现加权中值滤波器的ImageJ插件，首先定义一个二维整数数组来存储权重矩阵，在计算时，根据权重矩阵将每个像素值插入扩展像素向量多次，再对向量排序取中值。

对合适图像分别使用加权中值滤波器和标准中值滤波器处理并比较结果，通常加权中值滤波器能更好地保留结构细节。

对于权重矩阵：

W = ⎡ ⎣ 0 1 0
       1 5 1
       0 1 0 ⎤ ⎦

中心像素权重为5，其他像素权重之和为4。中心像素权重大于其他像素权重之和，会使中心像素拥有“多数票”，从而主导滤波结果，抑制了滤波器效果，因此该权重矩阵没有意义。

12、以黑塞标准（HNF）形式给出的直线无法直接绘制，因为典型的图形环境只能绘制两个指定端点之间的直线。相对于参考点$x_r = (x_r, y_r)$指定的HNF直线$L = ⟨θ, r⟩$，可以通过两种方式绘制到图像$I$中。版本1：遍历所有图像点$(u, v)$；如果位置$(u, v)$满足方程$r = (u – x_r) · cos(θ) + (v – y_r) · sin(θ)$，则标记像素$I(u, v)$。这种“暴力”方法只会显示那些位置恰好满足直线方程的直线像素。为了获得更“宽容”的绘制方法，我们将方程改写为$(u – x_r) · cos(θ) + (v – y_r) · sin(θ) – r = d$，$d$的大小等于点$(u, v)$到直线的距离，$d$本身可能为正或负，取决于点$(u, v)$位于直线的哪一侧。版本2：定义一个常数$w > 0$。遍历所有图像位置$(u, v)$；每当位置$(u, v)$满足不等式$|(u – x_r) · cos(θ) + (v – y_r) · sin(θ) – r| ≤ w$时，标记像素$I(u, v)$。例如，当$w = 1$时，所有直线点都应该显示出来。$w$的几何意义是什么？

w

表示距离直线的最大允许偏差距离，即在以直线为中心，宽度为

2w

的带状区域内的点都会被标记为直线上的点。

13、开发一种比某常规方法更“温和”的方法，用于绘制以Hessian标准形式（HNF）表示的直线L = ⟨θ, r⟩。首先，为图像的四条边界线A、B、C、D建立HNF方程。然后，确定给定直线L与每条边界线A、B、C、D的交点，并使用内置的drawLine()方法或类似例程，通过连接这些交点来绘制直线L。考虑可能出现的特殊情况以及如何处理它们。

可按以下步骤操作：

为图像的四条边界线A、B、C、D建立HNF方程；

确定直线L与四条边界线的交点；

使用内置的

drawLine()

方法或类似例程，通过连接交点来绘制直线L；

考虑可能出现的特殊情况（如直线与边界线平行、直线与边界线重合等）并思考处理办法。

14、扩展直线的霍夫变换，使得更新累加器映射时考虑当前像素的强度（边缘幅度）。

通常霍夫变换的原始数据是边缘图，被视为潜在边缘点为1的二值图像。为考虑边缘强度，可在更新累加器时，不将访问的累加器单元加1，而是加上相应边缘的强度，即：

A(i,j)←A(i,j)+E(u,v)A(i,j)←A(i,j)+E(u,v)

这样强边缘点对累加值的贡献比弱边缘点更大。

15、实现用于查找具有不同半径的圆和圆弧的霍夫变换，利用合适的快速算法在累加器数组中绘制圆。

对于查找具有不同半径的圆和圆弧的霍夫变换，与直线的霍夫变换不同，参数空间坐标之间不存在简单的函数依赖关系。

一种“暴力”方法是穷举测试参数空间的所有单元，看圆方程的关系是否成立，但这在计算上相当昂贵。

更好的办法是利用中心点坐标在霍夫空间也形成一个圆这一事实，不必为每个图像点搜索整个三维参数空间，只需增加累加器数组每个

r

平面上适当圆边缘的单元值。

可以采用任何标准的生成圆的算法，整数数学版本的 Bresenham 算法特别适合。

对于给定的图像点

pₘ = (uₘ, vₘ)

，在

r

轴的每个平面（对于

rₖ = rₘᵢₙ, …, rₘₐₓ

）上，遍历以

(uₘ, vₘ)

为中心、半径为

rₖ

的圆，最终在参数空间中创建一个三维锥形表面。

通过在累加器空间中搜索值最高的单元（即最多圆锥相交的单元），可以找到主导圆的坐标。

圆的部分（即圆弧）也可以用类似的方法找到，此时给定单元的可能最大值与弧长成正比。

16、定义一个从图像直方图估计图像最小和最大像素值的过程。使用得到的中间范围值对图像进行阈值处理。能否对得到的分区大小说些什么？

一般而言，无法对得到的背景和前景分区的相对大小做出说明。因为单个极端像素值（离群值）可能会极大地改变对比度范围，这种方法不太稳健。

17、编写一个程序（插件），在HSV颜色空间中生成一系列具有恒定色调和饱和度但不同亮度（值）的颜色。将这些颜色转换为RGB颜色，并绘制到一个新图像中。通过视觉验证色调是否真的保持恒定。

以下是一个使用Java实现该需求的示例代码：

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class HSVColorSequence {
    public static void main(String[] args) {
        // 设定恒定的色调和饱和度
        float hue = 0.5f; // 可调整为任意值，范围[0, 1]
        float saturation = 1.0f; // 可调整为任意值，范围[0, 1]
        int width = 256;
        int height = 100;
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        for (int x = 0; x < width; x++) {
            // 不同的亮度值，范围从0到1
            float value = (float) x / width;
            // 根据HSV值创建颜色
            Color color = Color.getHSBColor(hue, saturation, value);
            for (int y = 0; y < height; y++) {
                image.setRGB(x, y, color.getRGB());
            }
        }
        try {
            // 保存图像
            File output = new File("hsv_sequence.png");
            ImageIO.write(image, "png", output);
            System.out.println("图像已保存为 hsv_sequence.png");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码说明：

设定恒定的色调和饱和度

：在代码中，

hue

和

saturation

被设定为恒定值，可根据需要调整。

创建图像

：使用

BufferedImage

创建一个新图像。

生成不同亮度的颜色

：通过循环遍历图像的宽度，为每个像素生成不同的亮度值。

HSV到RGB的转换

：使用

Color.getHSBColor

方法将HSV颜色转换为RGB颜色。

绘制图像

：将生成的RGB颜色绘制到图像中。

保存图像

：使用

ImageIO.write

方法将图像保存为PNG文件。

验证：

运行代码后，会生成一个名为

hsv_sequence.png

的图像文件。打开该图像，通过视觉观察颜色条带，验证色调是否保持恒定。

18、计算角频率 ω = 5 的余弦函数 f(x) = cos(ωx) 在位置 x = -3, -2, …, 2, 3 处的值。该函数的周期长度是多少？

将 $omega = 5$ 代入函数 $f(x) = cos(omega x)$ 得 $f(x) = cos(5x)$，分别计算 $x = -3, -2, -1, 0, 1, 2, 3$ 处的值：

f(−3)=cos(−15), f(−2)=cos(−10), f(−1)=cos(−5), f(0)=cos(0)=1, f(1)=cos(5), f(2)=cos(10), f(3)=cos(15).f(−3)=cos⁡(−15), f(−2)=cos⁡(−10), f(−1)=cos⁡(−5), f(0)=cos⁡(0)=1, f(1)=cos⁡(5), f(2)=cos⁡(10), f(3)=cos⁡(15).

根据公式 $T = frac{2pi}{omega}$，可得周期 $T = frac{2pi}{5}$。

19、当A = -1且B = 2时，确定函数f(x) = A · cos(ωx) + B · sin(ωx)的相位角ϕ。

根据公式

ϕ=tan−1(BA)ϕ=tan−1⁡(BA)

将 $ A = -1 $ 和 $ B = 2 $ 代入可得，

ϕ=tan−1(2−1)=tan−1(−2)ϕ=tan−1⁡(2−1)=tan−1⁡(−2)

20、计算复数 (z = 1.5 × e^{-i 2.5}) 的实部、虚部和模。

根据欧拉公式 $ e^{i heta} = cos heta + isin heta $，则

z=1.5×e−i2.5=1.5(cos(−2.5)+isin(−2.5))z=1.5×e−i2.5=1.5(cos⁡(−2.5)+isin⁡(−2.5))

实部

为 $ 1.5cos(-2.5) approx 1.5 imes (-0.8011) = -1.20165 $

虚部

为 $ 1.5sin(-2.5) approx 1.5 imes (-0.5985) = -0.89775 $

模

为 $ |z| = 1.5 $

21、一幅尺寸为800×600的图像包含一个有效周期为12像素、方向为30°的波浪状强度图案。该图案在离散傅里叶频谱的哪些频率坐标上会显现出来？

可根据公式

[m n]=±f^⋅[M⋅cos(ψ) N⋅sin(ψ)][m n]=±f^⋅[M⋅cos⁡(ψ) N⋅sin⁡(ψ)]

计算，已知 $ M = 800 $，$ N = 600 $，$ hat{f} = frac{1}{12} $，$ psi = 30^{circ} $，代入可得

[m n]=±112⋅[800⋅cos(30∘) 600⋅sin(30∘)][m n]=±112⋅[800⋅cos⁡(30∘) 600⋅sin⁡(30∘)]

，计算出 $ m $ 和 $ n $ 的值即为频率坐标。