一、实验目的​

1. 掌握图像灰度变换（线性、对数、伽马）、代数运算（加减乘除）、直方图均衡化、自适应直方图均衡化（CLAHE）及频域滤波（低通、高通、带通）的核心原理与实现方法。​

1. 熟悉 OpenCV、NumPy 在图像处理中的应用（如图像读取、格式转换、DFT/IDFT 运算），以及 Matplotlib 在结果可视化（直方图绘制、多图对比）中的使用。​

1. 对比不同图像处理算法的效果差异（如普通均衡化与 CLAHE、低通与高通滤波），理解各算法的适用场景（如暗部增强用伽马变换、边缘提取用高通滤波）。​

1. 排查程序运行中的常见问题（如图像路径错误、图像尺寸不匹配、数据类型溢出），提升代码调试与算法优化能力。​

1. 完成 “算法实现 - 结果可视化 - 效果分析” 一体化的图像处理实验流程，为后续图像预处理、增强等应用奠定基础。​

二、实验环境​

（一）硬件环境​

计算机：CPU 为 Intel Core i5/i7 系列或同等性能处理器，内存 8GB 及以上，支持图像数据加载与矩阵运算（无特殊硬件依赖）。​

（二）软件环境​

1. 操作系统：Windows 10/11 64 位、macOS 12 及以上或 Linux（Ubuntu 20.04）。​

1. 编程语言：Python 3.8-3.11（64 位，确保数值运算效率）。​

1. 依赖库：​

• OpenCV-Python：用于图像读取、变换、滤波，版本 4.5.5 及以上。​

• NumPy：用于图像数据（矩阵）运算、数值裁剪与类型转换，版本 1.21.0 及以上。​

• Matplotlib：用于直方图绘制与多图对比显示，版本 3.5.0 及以上。​

1. 开发工具：PyCharm 2022.3、VS Code（配 Python 插件）或 Jupyter Notebook（便于分步调试）。​

三、实验原理​

（一）图像灰度变换（点运算）​

灰度变换通过对图像每个像素的灰度值进行函数映射，改变图像对比度或亮度，属于 “点运算”（仅依赖单个像素自身灰度值），代码中实现三种核心变换：​

1. 线性变换：公式为 T(x,y) = α·f(x,y) + β，其中：​

• α（对比度系数）：α>1 增强对比度，0<α<1 降低对比度；​

• β（亮度偏移量）：β>0 提升亮度，β<0 降低亮度；​

• 用np.clip(..., 0, 255)防止灰度值溢出（超出 0-255 范围），并转换为uint8类型（图像像素标准类型）。​

1. 对数变换：公式为 T(x,y) = 255·log(1+f(x,y))/log(256)，核心作用是增强暗部细节（对数函数对低灰度值拉伸、高灰度值压缩），适用于暗区域占比大的图像（如夜景）。​

1. 伽马变换：公式为 T(x,y) = 255·(f(x,y)/255)^γ，其中：​

• γ<1 时，拉伸低灰度值（暗部变亮）；​

• γ>1 时，压缩低灰度值（亮部变暗）；​

• 需先将灰度值归一化到 [0,1]（除以 255），避免指数运算后数值溢出。​

（二）图像代数运算​

代数运算对两幅图像的对应像素进行算术操作，需满足尺寸一致（代码中通过cv2.resize自动调整第二幅图像尺寸），核心运算逻辑如下：​

1. 加法运算：T(x,y) = f(x,y) + g(x,y)，用于图像叠加（如添加水印）或提升亮度（像素值累加后整体变亮），需转为float32避免溢出，再裁剪到 0-255。​

1. 减法运算：T(x,y) = f(x,y) - g(x,y)，用于突出两幅图像的差异（如运动目标检测中 “当前帧 - 背景帧”），负值用np.clip置为 0。​

1. 乘法运算：T(x,y) = (f(x,y)·g(x,y))/255，用于图像掩模（如保留特定区域），因两像素值乘积可能远超 255，需除以 255 归一化。​

1. 除法运算：T(x,y) = (f(x,y)/(g(x,y)+1e-6))·255，分母加1e-6避免除以 0 错误，用于校正图像光照不均（如阴影去除）。​

（三）图像直方图与均衡化​

1. 直方图：统计图像中各灰度值（0-255）的像素数量，反映灰度分布特征，代码中用cv2.calcHist([gray], [0], None, [256], [0,256])计算（参数分别为：图像、通道、掩模、灰度级数量、灰度范围）。​

1. 直方图均衡化：通过 “拉伸灰度分布” 让直方图更均匀，提升图像对比度，核心步骤：​

• 计算灰度直方图的累积分布函数（CDF）；​

• 将 CDF 归一化到 [0,255]，建立原灰度值到新灰度值的映射；​

• 遍历图像像素，按映射表更新灰度值（代码中用cv2.equalizeHist直接实现）。​

• 缺点：易导致局部过曝（如大面积亮区域被过度拉伸）。​

（四）自适应直方图均衡化（CLAHE）​

针对普通均衡化的过曝问题，CLAHE（Contrast Limited Adaptive Histogram Equalization）将图像分为多个子块（代码中默认 8×8），对每个子块单独均衡化，同时限制对比度（clip_limit=4.0）：​

• 当子块内某灰度值像素数量超过clip_limit时，多余像素会被分配到其他灰度级，避免局部过亮；​

• 子块间通过插值处理，减少块效应，使增强效果更自然（代码中用cv2.createCLAHE创建 CLAHE 对象，apply方法执行增强）。​

（五）图像频域变换与滤波​

频域滤波通过 “空域→频域→滤波→空域” 的流程实现图像平滑或锐化，核心原理：​

1. DFT（离散傅里叶变换）：将图像从空域（像素坐标）转换到频域（频率分量），低频分量对应图像整体轮廓，高频分量对应边缘、噪声；代码中用cv2.dft实现，np.fft.fftshift将低频分量移至图像中心。​

1. 最优尺寸 padding：因 DFT 在 2 的幂次尺寸下运算效率最高，用cv2.getOptimalDFTSize计算最优尺寸，cv2.copyMakeBorder补零扩展图像，避免边缘效应。​

1. 滤波器 mask 设计：​

• 低通滤波器（LPF）：保留低频分量，滤除高频噪声，使图像模糊；mask 中 “距离中心 < d0” 的区域设为 1（保留），其余为 0（过滤）。​

• 高通滤波器（HPF）：保留高频分量，突出边缘细节；mask 中 “距离中心> d0” 的区域设为 1，其余为 0。​

• 带通滤波器（BPF）：保留 “d0 [0]< 距离 < d0 [1]” 的中频分量，滤除低频和高频。​

1. IDFT（逆离散傅里叶变换）：用cv2.idft将滤波后的频域数据转回空域，cv2.magnitude计算复数的模（频域数据为复数），cv2.normalize归一化到 0-255，最终裁剪回原图像尺寸。​

四、实验内容与步骤​

（一）实验内容​

1. 搭建实验环境，安装 OpenCV-Python、NumPy、Matplotlib 依赖库。​

1. 分模块实现图像处理功能：​

• 灰度变换模块（gray_transform）：支持线性、对数、伽马三种变换。​

• 代数运算模块（image_arithmetic）：支持加减乘除运算，自动调整图像尺寸。​

• 直方图分析模块（histogram_analysis）：计算并显示原图与均衡化图像的直方图。​

• CLAHE 增强模块（clahe_analysis）：实现自适应直方图均衡化。​

• 频域滤波模块（frequency_domain_filter）：支持低通、高通、带通滤波。​

1. 测试程序功能：加载图像，执行各算法，观察并记录结果（如亮度变化、对比度差异、边缘清晰度）。​

1. 异常处理测试：验证图像路径错误、缺少第二幅图像时的程序响应。​

（二）实验步骤​

步骤 1：环境搭建​

打开终端，执行以下命令安装依赖库：​

​

pip install opencv-python numpy matplotlib​

​

验证安装：在 Python 交互环境中输入import cv2、import numpy、import matplotlib.pyplot as plt，无报错则安装成功。​

步骤 2：程序模块解析与开发​

1. 灰度变换模块（gray_transform）：​

• 输入：彩色图像、变换方法（linear/log/gamma）及对应参数（alpha/beta/gamma）。​

• 流程：先将彩色图像转为灰度图（cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)），再按选定方法计算变换后灰度值，返回变换图像。​

1. 代数运算模块（image_arithmetic）：​

• 输入：两幅彩色图像、运算类型（add/subtract/multiply/divide）。​

• 关键处理：若图像尺寸不同，用cv2.resize(img2, (img1.shape[1], img1.shape[0]))将第二幅图像缩放到与第一幅一致；所有运算先转为float32避免溢出，结果裁剪后转回uint8。​

1. 直方图分析模块（histogram_analysis）：​

• 输入：彩色图像。​

• 流程：转灰度图→计算原图与均衡化图像的直方图→用 Matplotlib 绘制 “2×2” 子图（原图、均衡化图、原直方图、均衡化直方图），plt.tight_layout()避免子图重叠，plt.show()显示结果；返回均衡化图像。​

1. CLAHE 增强模块（clahe_analysis）：​

• 输入：彩色图像、对比度限制（clip_limit）、子块尺寸（tile_grid_size）。​

• 流程：转灰度图→创建 CLAHE 对象→执行增强→返回增强图像。​

1. 频域滤波模块（frequency_domain_filter）：​

• 输入：彩色图像、滤波器类型（low_pass/high_pass/band_pass）、截止频率（d0，带通用二元组[d1,d2]）。​

• 核心步骤：​

1. 转灰度图→计算最优 DFT 尺寸→补零扩展图像（copyMakeBorder）；​

1. 执行 DFT（cv2.dft）→将低频移至中心（np.fft.fftshift）；​

1. 生成对应滤波器 mask（如低通用 “距离 < d0” 设 1）；​

1. 频域滤波（dft_shift * mask）→逆 FFT 移位（np.fft.ifftshift）→IDFT（cv2.idft）；​

1. 计算复数模（cv2.magnitude）→归一化到 0-255→裁剪回原尺寸→返回滤波图像。​

步骤 3：程序功能测试​

1. 准备测试图像：​

• 主图像：将代码中image_path改为本地图像路径（如r"C:\test.jpg"），建议选择暗部细节丰富、边缘清晰的图像（如风景照、人像照）。​

• 代数运算辅助图：准备logo.png（无则程序跳过代数运算，打印提示）。​

1. 运行程序：执行脚本，程序依次执行以下操作：​

• 加载主图像，若路径错误则打印 “无法读取图像” 并退出；​

• 执行灰度变换（线性、对数、伽马），生成 3 幅变换图像；​

• 若存在logo.png，执行加减运算，生成 2 幅运算图像；​

• 执行直方图均衡化，弹出 Matplotlib 窗口显示 “原图 - 均衡化图 - 直方图” 对比；​

• 执行 CLAHE 增强、频域低通 / 高通滤波，生成 3 幅增强 / 滤波图像；​

• 用cv2.imshow显示所有结果窗口（共 8-10 个，取决于是否有代数运算结果）。​

1. 观察结果：​

• 灰度变换：对比线性变换的亮度变化、对数变换的暗部增强效果；​

• 直方图均衡化：观察均衡化后图像对比度提升，直方图从 “集中分布” 变为 “均匀分布”；​

• CLAHE：对比普通均衡化，CLAHE 图像无局部过曝（如天空区域）；​

• 频域滤波：低通图像模糊（边缘消失），高通图像边缘突出（如物体轮廓）。​

1. 异常测试：​

• 故意写错image_path，验证程序打印错误提示并退出；​

• 删除logo.png，验证程序打印 “未找到 logo 图像，跳过代数运算”，不崩溃。​

步骤 4：结果记录与关闭​

1. 截图保存 Matplotlib 直方图窗口及各cv2.imshow结果窗口；​

1. 按任意键关闭所有cv2窗口（cv2.waitKey(0)），程序自动销毁窗口（cv2.destroyAllWindows()）。​

五、实验结果​

（一）灰度变换结果​

1. 线性变换（α=1.5，β=30）：图像对比度显著增强，整体亮度提升，暗部细节更清晰，但过亮区域（如高光）无溢出（因np.clip处理）。​

1. 对数变换：暗部区域（如树荫、室内角落）被明显拉伸，细节可辨，亮部区域无过度提亮，适合夜景图像增强。​

1. 伽马变换（γ=0.5）：低灰度值区域（暗部）亮度提升，高灰度值区域（亮部）变化平缓，整体图像偏亮但无过曝，效果比对数变换更自然。​

（二）图像代数运算结果（需logo.png）​

1. 加法运算：主图像与 logo 叠加后，整体亮度提升（像素值累加），logo 区域因像素叠加呈亮色，可清晰看到叠加效果。​

1. 减法运算：主图像减去 logo 后，logo 区域像素值降低（呈暗色），非 logo 区域保留原图细节，突出了两图的差异。​

（三）直方图与均衡化结果​

1. 原始图像：灰度直方图集中在低灰度区间（0-100），图像整体偏暗，对比度低。​

1. 均衡化图像：直方图均匀分布在 0-255 区间，图像对比度显著提升，暗部与亮部细节均更清晰，但大面积纯色区域（如天空）出现轻微过曝。​

1. Matplotlib 显示：2×2 子图布局清晰，原图与均衡化图的视觉差异、直方图的分布差异一目了然。​

（四）CLAHE 增强结果​

CLAHE 增强图像对比度低于普通均衡化，但无局部过曝问题（如天空区域保持自然色调），子块均衡化使细节过渡更平滑，适合对过曝敏感的场景（如人像皮肤、风景天空）。​

（五）频域滤波结果​

1. 低通滤波（d0=30）：图像整体模糊，边缘（如物体轮廓、文字边缘）消失，仅保留整体轮廓（如山脉、建筑外形），验证了 “低通滤除高频，实现平滑” 的功能。​

1. 高通滤波（d0=30）：图像整体暗，边缘区域（如轮廓、纹理）呈亮色突出，背景区域（如纯色墙面）接近黑色，验证了 “高通滤除低频，提取边缘” 的功能。​

（六）异常处理结果​

1. 图像路径错误：程序打印 “无法读取图像，请检查路径是否正确” 并正常退出，无崩溃。​

1. 缺少logo.png：程序打印 “未找到 logo 图像，跳过代数运算”，继续执行其他功能，兼容性良好。​

六、实验分析与讨论​

（一）程序优点​

1. 模块化设计：各功能封装为独立函数（如gray_transform、frequency_domain_filter），参数可配置（如alpha、clip_limit），便于复用与修改。​

1. 异常处理完善：包含图像路径检查、图像尺寸自动调整、除法防零、灰度值溢出裁剪等处理，避免程序因数据异常崩溃，用户体验良好。​

1. 结果可视化清晰：用 Matplotlib 绘制直方图对比（直观展示分布变化），用cv2.imshow实时显示各算法结果，便于直观观察差异。​

1. 算法覆盖全面：涵盖灰度变换、代数运算、直方图、CLAHE、频域滤波五大核心图像处理技术，覆盖 “点运算 - 区域运算 - 频域运算” 的不同层次。​

（二）程序不足​

1. 代数运算局限性：需用户手动准备第二幅图像（logo.png），无默认备用图像，若缺失则跳过功能，灵活性不足。​

1. 频域滤波存在振铃效应：使用 “理想低通 / 高通滤波器”（mask 为 0-1 突变），逆变换后图像边缘出现明暗交替的振铃，影响视觉效果。​

1. 结果显示效率低：cv2.imshow窗口过多（最多 10 个），需手动按任意键关闭，未支持批量保存结果（如自动保存到指定文件夹）。​

1. 参数固定：核心参数（如alpha=1.5、d0=30）在代码中硬编码，用户需修改源码调整，无交互界面（如滑块）实时调节参数。​

（三）改进方向​

1. 优化代数运算：添加默认备用图像（如生成纯色图像），若缺失logo.png则用备用图执行运算，确保功能完整性；支持更多运算类型（如加权加法α·f + β·g）。​

1. 改进频域滤波器：替换理想滤波器为高斯低通 / 高通滤波器（mask 为高斯函数，渐变过渡），公式为 H(u,v) = e^(-(D²)/(2d0²))（低通），消除振铃效应。​

1. 增加结果保存功能：在main函数中添加 “保存路径选择” 逻辑（参考面部采集工具的select_save_path），自动将所有结果图像保存为 “linear_img.jpg”“high_pass_img.jpg” 等，避免窗口过多的问题。​

1. 开发交互界面：基于 PyQt6 或 Tkinter 添加 GUI 界面，用滑块调节alpha、gamma、d0等参数，实时显示调整后的结果，降低使用门槛。​

1. 扩展功能：添加其他图像处理算法（如中值滤波、边缘检测（Sobel/Canny）），支持彩色图像的通道级处理（如单独增强 R/G/B 通道）。​

（四）关键问题与解决​

1. 灰度值溢出问题：初始版本未用np.clip，线性变换α=2时灰度值超过 255，图像出现白色噪点；解决方案：所有变换后用np.clip(..., 0, 255)裁剪，并转为uint8类型，溢出问题完全解决。​

1. DFT 运算效率低：初始版本未做 padding，直接对原尺寸图像执行 DFT，运算耗时较长；解决方案：用cv2.getOptimalDFTSize计算最优尺寸（2 的幂次），补零后 DFT 运算效率提升约 30%。​

1. 均衡化过曝问题：普通均衡化对大面积纯色区域（如天空）过度拉伸，出现过曝；解决方案：引入 CLAHE 算法，通过对比度限制与子块均衡化，完全解决过曝问题，效果更自然。​

七、实验总结​

本次实验成功实现了五种核心图像处理算法，完成了 “原理理解 - 代码实现 - 结果验证” 的完整流程，主要收获如下：​

1. 技术层面：掌握了 OpenCV 的图像读取 / 变换 / 滤波、NumPy 的矩阵运算、Matplotlib 的可视化方法，理解了灰度变换的函数映射、直方图均衡化的 CDF 原理、频域变换的 DFT/IDFT 流程，能解释各算法的适用场景（如 CLAHE 用于过曝敏感场景、高通用于边缘提取）。​

1. 问题解决层面：解决了灰度值溢出、DFT 效率低、均衡化过曝等关键问题，学会了通过 “参数调整（如clip_limit）、算法替换（如理想滤波→高斯滤波）、异常处理（如路径检查）” 优化程序。​

1. 应用层面：认识到图像处理算法的实际价值 —— 灰度变换可用于图像增强，均衡化可用于监控图像预处理，频域滤波可用于图像去噪或边缘提取，为后续计算机视觉项目（如目标检测、图像分割）的预处理环节奠定基础。​

同时，也意识到程序在交互性、滤波器性能上的不足，后续可通过开发 GUI 界面、优化滤波器类型进一步提升实用性。本次实验不仅巩固了图像处理理论知识，也提升了代码实践与问题调试能力，达到了实验目标。

程序如下

import cv2
import numpy as np
import matplotlib.pyplot as plt


# -------------------------- 1. 图像灰度变换（点运算） --------------------------
def gray_transform(image, method='linear', alpha=1.5, beta=30, gamma=0.5):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # 转为灰度图

    if method == 'linear':
        transformed = np.clip(alpha * gray + beta, 0, 255).astype(np.uint8)
    elif method == 'log':
        transformed = np.clip(255 * np.log(1 + gray) / np.log(256), 0, 255).astype(np.uint8)
    elif method == 'gamma':
        transformed = np.clip(255 * np.power(gray / 255.0, gamma), 0, 255).astype(np.uint8)
    else:
        raise ValueError("不支持的变换方法")

    return transformed


# -------------------------- 2. 图像代数运算 --------------------------
def image_arithmetic(img1, img2, operation='add'):
    if img1.shape != img2.shape:
        img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

    img1_float = img1.astype(np.float32)
    img2_float = img2.astype(np.float32)

    if operation == 'add':
        result = np.clip(img1_float + img2_float, 0, 255).astype(np.uint8)
    elif operation == 'subtract':
        result = np.clip(img1_float - img2_float, 0, 255).astype(np.uint8)
    elif operation == 'multiply':
        result = np.clip(img1_float * img2_float / 255, 0, 255).astype(np.uint8)
    elif operation == 'divide':
        result = np.clip(img1_float / (img2_float + 1e-6) * 255, 0, 255).astype(np.uint8)
    else:
        raise ValueError("不支持的运算类型")

    return result


# -------------------------- 3. 图像直方图显示与均衡化 --------------------------
def histogram_analysis(image):
    """
    显示原图、均衡化后的图像及其灰度直方图
    """
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 计算原图直方图
    hist = cv2.calcHist([gray], [0], None, [256], [0, 256])

    # 直方图均衡化
    equalized = cv2.equalizeHist(gray)
    hist_equalized = cv2.calcHist([equalized], [0], None, [256], [0, 256])

    # 显示原图和均衡化图像
    plt.figure(figsize=(12, 8))

    plt.subplot(221)
    plt.imshow(gray, cmap='gray')
    plt.title('原始灰度图')
    plt.axis('off')

    plt.subplot(222)
    plt.imshow(equalized, cmap='gray')
    plt.title('均衡化灰度图')
    plt.axis('off')

    # 显示原图直方图
    plt.subplot(223)
    plt.plot(hist, color='black')
    plt.title('原始直方图')
    plt.xlabel('灰度值')
    plt.ylabel('像素数量')
    plt.xlim([0, 256])

    # 显示均衡化后的直方图
    plt.subplot(224)
    plt.plot(hist_equalized, color='black')
    plt.title('均衡化后直方图')
    plt.xlabel('灰度值')
    plt.ylabel('像素数量')
    plt.xlim([0, 256])

    plt.tight_layout()
    plt.show()

    return equalized



# -------------------------- 4. 自适应直方图均衡化（CLAHE） --------------------------
def clahe_analysis(image, clip_limit=4.0, tile_grid_size=(8, 8)):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    clahe = cv2.createCLAHE(clipLimit=clip_limit, tileGridSize=tile_grid_size)
    enhanced = clahe.apply(gray)
    return enhanced


# -------------------------- 5. 图像频域变换与滤波 --------------------------
def frequency_domain_filter(image, filter_type='low_pass', d0=30):
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    rows, cols = gray.shape
    optimal_rows = cv2.getOptimalDFTSize(rows)
    optimal_cols = cv2.getOptimalDFTSize(cols)
    padded = cv2.copyMakeBorder(
        gray, 0, optimal_rows - rows, 0, optimal_cols - cols,
        cv2.BORDER_CONSTANT, value=0
    )

    dft = cv2.dft(np.float32(padded), flags=cv2.DFT_COMPLEX_OUTPUT)
    dft_shift = np.fft.fftshift(dft)
    crow, ccol = optimal_rows // 2, optimal_cols // 2
    mask = np.zeros((optimal_rows, optimal_cols, 2), np.float32)

    if filter_type == 'low_pass':
        for i in range(optimal_rows):
            for j in range(optimal_cols):
                distance = np.sqrt((i - crow) ** 2 + (j - ccol) ** 2)
                if distance < d0:
                    mask[i, j] = 1
    elif filter_type == 'high_pass':
        for i in range(optimal_rows):
            for j in range(optimal_cols):
                distance = np.sqrt((i - crow) ** 2 + (j - ccol) ** 2)
                if distance > d0:
                    mask[i, j] = 1
    elif filter_type == 'band_pass':
        for i in range(optimal_rows):
            for j in range(optimal_cols):
                distance = np.sqrt((i - crow) ** 2 + (j - ccol) ** 2)
                if d0[0] < distance < d0[1]:
                    mask[i, j] = 1

    dft_shift_filtered = dft_shift * mask
    f_ishift = np.fft.ifftshift(dft_shift_filtered)
    img_back = cv2.idft(f_ishift)
    img_back = cv2.magnitude(img_back[:, :, 0], img_back[:, :, 1])
    img_back = cv2.normalize(img_back, None, 0, 255, cv2.NORM_MINMAX)
    img_back = img_back.astype(np.uint8)
    img_back = img_back[:rows, :cols]

    return img_back


# -------------------------- 主函数：实验流程执行 --------------------------
def main():
    # 替换为指定图片路径（使用原始字符串避免转义问题）
    image_path = r'C:\Users\qdrdt\web\qdrdt\Pictures\Saved Pictures\screenshot_250225_201611.png'
    image = cv2.imread(image_path)
    if image is None:
        print("无法读取图像，请检查路径是否正确")
        return

    # 1. 图像灰度变换
    linear_img = gray_transform(image, method='linear')
    log_img = gray_transform(image, method='log')
    gamma_img = gray_transform(image, method='gamma')

    # 2. 图像代数运算（若需测试，需准备第二张图像，如logo.png）
    logo_path = 'logo.png'  # 若没有该文件，此部分会跳过代数运算
    logo = cv2.imread(logo_path)
    if logo is not None:
        added_img = image_arithmetic(image, logo, 'add')
        subtracted_img = image_arithmetic(image, logo, 'subtract')
    else:
        added_img = subtracted_img = image.copy()
        print("未找到logo图像，跳过代数运算")

    # 3. 直方图均衡化
    equalized_img = histogram_analysis(image)

    # 4. CLAHE增强
    clahe_img = clahe_analysis(image)

    # 5. 频域滤波
    low_pass_img = frequency_domain_filter(image, 'low_pass', d0=30)
    high_pass_img = frequency_domain_filter(image, 'high_pass', d0=30)

    # 显示结果
    cv2.imshow('Original Image', image)
    cv2.imshow('Linear Transform', linear_img)
    cv2.imshow('Log Transform', log_img)
    cv2.imshow('Gamma Transform', gamma_img)
    cv2.imshow('Equalized Image', equalized_img)
    cv2.imshow('CLAHE Enhanced', clahe_img)
    cv2.imshow('Low Pass Filter', low_pass_img)
    cv2.imshow('High Pass Filter', high_pass_img)

    if logo is not None:
        cv2.imshow('Image Addition', added_img)
        cv2.imshow('Image Subtraction', subtracted_img)

    cv2.waitKey(0)
    cv2.destroyAllWindows()


if __name__ == "__main__":
    main()