深度學(xué)習(xí)圖像增強(qiáng)方法全總結(jié)！
作者：小喵學(xué)AI
圖像增強(qiáng)是指通過一系列技術(shù)和方法對圖像進(jìn)行處理，以改善其視覺效果和特征表現(xiàn)。
一、什么是圖像增強(qiáng)？
圖像增強(qiáng)是指通過一系列技術(shù)和方法對圖像進(jìn)行處理，以改善其視覺效果和特征表現(xiàn)。
1. 主要指標(biāo)：
(1) 亮度（Brightness）：
- 影響圖像的整體光照程度。
- 確保圖像在視覺上既不過暗也不過亮。
(2) 對比度（Contrast）：
- 增強(qiáng)圖像中亮部和暗部之間的差異。
- 使得細(xì)節(jié)更加明顯，高對比度有助于更清晰地展示圖像的紋理和特征。
(3) 清晰度（Sharpness）：
- 提高圖像邊緣的清晰度。
- 使物體輪廓更加鮮明，便于細(xì)節(jié)識別。
(4) 色彩飽和度（Color Saturation）：
- 增強(qiáng)顏色的豐富性。
- 使圖像色彩更加鮮艷，提升視覺吸引力。
(5) 紋理（Texture）：
- 突出圖像中的紋理細(xì)節(jié)。
- 增強(qiáng)表面特征，對于醫(yī)學(xué)影像和材料檢測等領(lǐng)域尤為重要。
(6) 去噪（Denoising）：
- 降低圖像中的噪聲。
- 提高信號質(zhì)量，減少噪聲對重要細(xì)節(jié)的干擾。
(7) 增強(qiáng)特征（Feature Enhancement）：
- 提高重要特征的可見性。
- 方便觀察和分析。
(8) 視覺一致性（Visual Consistency）：
- 確保圖像不同區(qū)域在亮度、對比度和色彩表現(xiàn)上的一致性。
- 便于用戶進(jìn)行全面分析。
2. 應(yīng)用領(lǐng)域：
圖像增強(qiáng)技術(shù)廣泛應(yīng)用于多個領(lǐng)域，包括：
- 醫(yī)學(xué)影像：改善X光、CT和MRI圖像，以輔助醫(yī)生診斷。
- 衛(wèi)星和遙感圖像：增強(qiáng)地理數(shù)據(jù)，支持土地利用分類和環(huán)境監(jiān)測。
- 安防監(jiān)控：提升監(jiān)控視頻質(zhì)量，促進(jìn)人臉識別和行為分析。
- 工業(yè)檢測：提高質(zhì)量控制中的產(chǎn)品檢測精度。
- 圖像搜索和檢索：改善圖像搜索結(jié)果的準(zhǔn)確性和相關(guān)性。
二、亮度和對比度調(diào)整
1. 線性方法
(1) 灰度反轉(zhuǎn)（Gray Inversion）
灰度反轉(zhuǎn)是指將圖像中的每個像素值反轉(zhuǎn)，使得圖像的亮部變暗，暗部變亮。具體來說，對于一個灰度圖像，像素值范圍通常是0到255，灰度反轉(zhuǎn)后，像素值G' = 255 - G，其中G是原始像素值，G'是反轉(zhuǎn)后的像素值。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def gray_inversion(image):
"""
灰度反轉(zhuǎn)
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
inverted_image = 255 - image
return inverted_image
def main():
# 讀取圖像
image = cv2.imread('example.jpg')
if image is None:
print("Error: Could not read image.")
return
# 灰度反轉(zhuǎn)
inverted_image = gray_inversion(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(inverted_image, cmap='gray')
plt.title('Inverted Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()import cv2
import numpy as np
import matplotlib.pyplot as plt
def gray_inversion(image):
"""
灰度反轉(zhuǎn)
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
inverted_image = 255 - image
return inverted_image
def main():
# 讀取圖像
image = cv2.imread('example.jpg')
if image is None:
print("Error: Could not read image.")
return
# 灰度反轉(zhuǎn)
inverted_image = gray_inversion(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(inverted_image, cmap='gray')
plt.title('Inverted Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 對比度拉伸（Contrast Stretching）
對比度拉伸是一種線性變換方法，通過擴(kuò)展圖像的動態(tài)范圍來增強(qiáng)對比度。具體來說，將圖像的最小像素值映射到0，最大像素值映射到255，中間的像素值按比例線性變換。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def contrast_stretching(image):
"""
對比度拉伸
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
min_val = np.min(image)
max_val = np.max(image)
stretched_image = (image - min_val) * (255 / (max_val - min_val))
stretched_image = stretched_image.astype(np.uint8)
return stretched_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 對比度拉伸
stretched_image = contrast_stretching(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(stretched_image, cmap='gray')
plt.title('Contrast Stretched Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) 對比度和亮度增強(qiáng)（Contrast and Brightness）
對比度和亮度增強(qiáng)是指同時調(diào)整圖像的對比度和亮度。具體來說，可以通過以下公式進(jìn)行調(diào)整：
其中，G是原始像素值，G'是調(diào)整后的像素值，是對比度增益因子（大于1時對比度增強(qiáng)，小于1時對比度減弱），是亮度偏移量（正值使圖像變亮，負(fù)值使圖像變暗）。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def adjust_contrast_brightness(image, alpha=1.0, beta=0):
"""
對比度和亮度增強(qiáng)
:param image: 輸入圖像
:param alpha: 對比度增益因子（大于1時對比度增強(qiáng)，小于1時對比度減弱）
:param beta: 亮度偏移量（正值使圖像變亮，負(fù)值使圖像變暗）
:return: 處理后的圖像
"""
new_image = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
return new_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 對比度和亮度增強(qiáng)
enhanced_image = adjust_contrast_brightness(image, alpha=1.5, beta=50)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(enhanced_image, cv2.COLOR_BGR2RGB))
plt.title('Contrast and Brightness Enhanced Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()2. 非線性方法
(1) 指數(shù)變換（Exponential Transformation）
通過指數(shù)函數(shù)來調(diào)整圖像的亮度和對比度。具體公式如下：
其中，G是原始像素值，G'是調(diào)整后的像素值，c和k是常數(shù)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def exponential_transformation(image, c=1.0, k=10):
"""
指數(shù)變換
:param image: 輸入圖像（灰度圖像）
:param c: 常數(shù)c
:param k: 常數(shù)k
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
exp_image = c * (np.exp(image / k) - 1)
exp_image = np.clip(exp_image, 0, 255).astype(np.uint8)
return exp_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 指數(shù)變換
exp_image = exponential_transformation(image, c=1.0, k=10)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(exp_image, cmap='gray')
plt.title('Exponential Transformed Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 伽馬變換（Gamma Transformation）
通過伽馬函數(shù)來調(diào)整圖像的亮度和對比度。具體公式如下：
其中，G是原始像素值，G'是調(diào)整后的像素值，c和是常數(shù)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def gamma_transformation(image, gamma=1.0):
"""
伽馬變換
:param image: 輸入圖像（灰度圖像）
:param gamma: 伽馬值
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
inv_gamma = 1.0 / gamma
table = np.array([((i / 255.0) ** inv_gamma) * 255 for i in np.arange(0, 256)]).astype("uint8")
gamma_image = cv2.LUT(image, table)
return gamma_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 伽馬變換
gamma_image = gamma_transformation(image, gamma=0.5)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(gamma_image, cmap='gray')
plt.title('Gamma Transformed Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) 對數(shù)變換（Logarithmic Transformation）
通過對數(shù)函數(shù)來調(diào)整圖像的亮度和對比度。具體公式如下：
其中，G是原始像素值，G'是調(diào)整后的像素值，c是常數(shù)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def logarithmic_transformation(image, c=1.0):
"""
對數(shù)變換
:param image: 輸入圖像（灰度圖像）
:param c: 常數(shù)c
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
log_image = c * np.log1p(image)
log_image = np.clip(log_image, 0, 255).astype(np.uint8)
return log_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 對數(shù)變換
log_image = logarithmic_transformation(image, c=255 / np.log1p(np.max(image)))
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(log_image, cmap='gray')
plt.title('Logarithmic Transformed Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()三、直方圖均衡化
1. 普通直方圖均衡化
直方圖均衡化的原理是將圖像的灰度直方圖展平，使得每個灰度級都有更多的像素分布，從而增強(qiáng)圖像的對比度。具體步驟如下：
- 計算灰度直方圖：統(tǒng)計圖像中每個灰度級的像素數(shù)量。
- 計算累積分布函數(shù)（CDF）：計算每個灰度級的累積概率。
- 映射灰度值：將原始圖像中的每個灰度值映射到新的灰度值，使得新的灰度分布更加均勻。
- 生成均衡化后的圖像：使用映射后的灰度值生成新的圖像。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def histogram_equalization(image):
"""
直方圖均衡化
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
equalized_image = cv2.equalizeHist(image)
return equalized_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 直方圖均衡化
equalized_image = histogram_equalization(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(equalized_image, cmap='gray')
plt.title('Histogram Equalized Image')
plt.axis('off')
plt.tight_layout()
plt.show()
# 顯示直方圖
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.hist(image.ravel(), 256, [0, 256], color='gray', alpha=0.7)
plt.title('Histogram of Original Image')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.subplot(1, 2, 2)
plt.hist(equalized_image.ravel(), 256, [0, 256], color='gray', alpha=0.7)
plt.title('Histogram of Equalized Image')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.tight_layout()
plt.show()
if __name__ == "__main__":2. 限制對比度自適應(yīng)直方圖均衡化（Contrast Limited Adaptive Histogram Equalization, CLAHE）
限制對比度自適應(yīng)直方圖均衡化在直方圖均衡化的基礎(chǔ)上進(jìn)行了改進(jìn)，通過限制對比度和局部均衡化來避免過度增強(qiáng)圖像的對比度，從而減少噪聲和不自然的效果。基本原理如下：
- 圖像分割：將圖像分割成若干個小塊（稱為“tiles”），每個小塊的大小由 tileGridSize 參數(shù)指定。
- 局部均衡化：對每個小塊分別進(jìn)行直方圖均衡化。為了限制對比度，使用 clipLimit 參數(shù)來限制每個小塊的直方圖中像素值的最大數(shù)量。
- 插值平滑：將每個小塊均衡化后的結(jié)果通過插值技術(shù)合并，以避免明顯的邊界和不連續(xù)性。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def clahe_equalization(image, clipLimit=2.0, tileGridSize=(8, 8)):
"""
CLAHE均衡化
:param image: 輸入圖像（灰度圖像）
:param clipLimit: 對比度限制閾值
:param tileGridSize: 小塊大小
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
clahe = cv2.createCLAHE(clipLimit=clipLimit, tileGridSize=tileGridSize)
clahe_image = clahe.apply(image)
return clahe_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# CLAHE均衡化
clahe_image = clahe_equalization(image, clipLimit=2.0, tileGridSize=(8, 8))
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(clahe_image, cmap='gray')
plt.title('CLAHE Equalized Image')
plt.axis('off')
plt.tight_layout()
plt.show()
# 顯示直方圖
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.hist(image.ravel(), 256, [0, 256], color='gray', alpha=0.7)
plt.title('Histogram of Original Image')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.subplot(1, 2, 2)
plt.hist(clahe_image.ravel(), 256, [0, 256], color='gray', alpha=0.7)
plt.title('Histogram of CLAHE Equalized Image')
plt.xlabel('Pixel Value')
plt.ylabel('Frequency')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()四、空間域（增強(qiáng)）
空間域增強(qiáng)方法直接操作圖像的像素值，常用于提高圖像的可視性和特征表現(xiàn)。空間域增強(qiáng)方法可以分為線性濾波和非線性濾波兩大類。此外，邊緣檢測也是一種重要的空間域增強(qiáng)技術(shù)，用于突出圖像中的邊緣和細(xì)節(jié)。
1. 線性濾波
線性濾波通過卷積操作對圖像進(jìn)行處理，常用的線性濾波器包括方框?yàn)V波、均值濾波器、高斯濾波器和銳化濾波器等。
(1) 方框?yàn)V波（Box Filtering）
方框?yàn)V波是一種簡單的均值濾波，通過計算每個像素鄰域內(nèi)的平均值來平滑圖像。具體來說，對于每個像素，取其鄰域內(nèi)的所有像素值的平均值作為該像素的新值。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def box_filter(image, kernel_size=(3, 3)):
"""
方框?yàn)V波
:param image: 輸入圖像
:param kernel_size: 濾波器大小
:return: 處理后的圖像
"""
filtered_image = cv2.boxFilter(image, -1, kernel_size)
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 方框?yàn)V波
box_filtered_image = box_filter(image, kernel_size=(5, 5))
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(box_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Box Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 均值濾波器（Mean Filter）
均值濾波器通過計算每個像素鄰域內(nèi)的平均值來平滑圖像。具體來說，對于每個像素，取其鄰域內(nèi)的所有像素值的平均值作為該像素的新值。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def mean_filter(image, kernel_size=(3, 3)):
"""
均值濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小
:return: 處理后的圖像
"""
filtered_image = cv2.blur(image, kernel_size)
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 均值濾波
mean_filtered_image = mean_filter(image, kernel_size=(5, 5))
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(mean_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Mean Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) 高斯濾波器（Gaussian Filter）
高斯濾波器通過高斯核對圖像進(jìn)行卷積操作，以平滑圖像并減少噪聲。高斯核的權(quán)重分布符合高斯分布，中心權(quán)重最大，邊緣權(quán)重逐漸減小。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def gaussian_filter(image, kernel_size=(5, 5), sigmaX=0):
"""
高斯濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小
:param sigmaX: 高斯核的標(biāo)準(zhǔn)差
:return: 處理后的圖像
"""
filtered_image = cv2.GaussianBlur(image, kernel_size, sigmaX)
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 高斯濾波
gaussian_filtered_image = gaussian_filter(image, kernel_size=(5, 5), sigmaX=0)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(gaussian_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Gaussian Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(4) 銳化濾波器（Sharpening Filter）
銳化濾波器通過增強(qiáng)圖像的邊緣和細(xì)節(jié)來提高圖像的清晰度。常用的銳化濾波器包括拉普拉斯算子和高通濾波器。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def sharpen_filter(image, kernel_size=(3, 3), alpha=1.5):
"""
銳化濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小
:param alpha: 銳化因子
:return: 處理后的圖像
"""
# 創(chuàng)建銳化濾波器
kernel = np.array([[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]])
# 應(yīng)用濾波器
sharpened_image = cv2.filter2D(image, -1, kernel)
# 確保像素值在有效范圍內(nèi)
# sharpened_image = np.clip(sharpened_image, 0, 255).astype(np.uint8)
return sharpened_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 銳化濾波
sharpened_image = sharpen_filter(image, kernel_size=(3, 3), alpha=1.5)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(sharpened_image, cv2.COLOR_BGR2RGB))
plt.title('Sharpened Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()2. 非線性濾波
非線性濾波通過非線性操作對圖像進(jìn)行處理，常用的非線性濾波器包括中值濾波器、雙邊濾波器、最小/最大濾波器、自適應(yīng)中值濾波和形態(tài)學(xué)濾波。
(1) 中值濾波器（Median Filter）
中值濾波器通過計算每個像素鄰域內(nèi)的中值來平滑圖像，特別適用于去除椒鹽噪聲和斑點(diǎn)噪聲。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def median_filter(image, kernel_size=3):
"""
中值濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小（奇數(shù)）
:return: 處理后的圖像
"""
filtered_image = cv2.medianBlur(image, kernel_size)
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 中值濾波
median_filtered_image = median_filter(image, kernel_size=5)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(median_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Median Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 雙邊濾波器（Bilateral Filter）
雙邊濾波器通過考慮像素值和空間距離來進(jìn)行濾波，能夠在去噪的同時保留圖像邊緣和細(xì)節(jié)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def bilateral_filter(image, d=9, sigmaColor=75, sigmaSpace=75):
"""
雙邊濾波
:param image: 輸入圖像
:param d: 每個像素鄰域的直徑
:param sigmaColor: 顏色空間的標(biāo)準(zhǔn)差
:param sigmaSpace: 坐標(biāo)空間的標(biāo)準(zhǔn)差
:return: 處理后的圖像
"""
filtered_image = cv2.bilateralFilter(image, d, sigmaColor, sigmaSpace)
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 雙邊濾波
bilateral_filtered_image = bilateral_filter(image, d=9, sigmaColor=75, sigmaSpace=75)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(cv2.cvtColor(bilateral_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Bilateral Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) 最小/最大濾波器（Min/Max Filter）
最小濾波器通過計算每個像素鄰域內(nèi)的最小值來處理圖像，最大濾波器通過計算每個像素鄰域內(nèi)的最大值來處理圖像。這兩種濾波器常用于形態(tài)學(xué)操作。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def min_filter(image, kernel_size=3):
"""
最小濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小（奇數(shù)）
:return: 處理后的圖像
"""
filtered_image = cv2.erode(image, np.ones((kernel_size, kernel_size), np.uint8))
return filtered_image
def max_filter(image, kernel_size=3):
"""
最大濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小（奇數(shù)）
:return: 處理后的圖像
"""
filtered_image = cv2.dilate(image, np.ones((kernel_size, kernel_size), np.uint8))
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 最小濾波
min_filtered_image = min_filter(image, kernel_size=3)
# 最大濾波
max_filtered_image = max_filter(image, kernel_size=3)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 3, 2)
plt.imshow(cv2.cvtColor(min_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Min Filtered Image')
plt.axis('off')
plt.subplot(1, 3, 3)
plt.imshow(cv2.cvtColor(max_filtered_image, cv2.COLOR_BGR2RGB))
plt.title('Max Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(4) 自適應(yīng)中值濾波（Adaptive Median Filtering）
自適應(yīng)中值濾波器通過動態(tài)調(diào)整濾波器大小來去除噪聲，同時保留圖像邊緣和細(xì)節(jié)。
import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
def auto_median_filter(image, max_size):
origen = 3 # 初始窗口大小
board = origen // 2 # 初始應(yīng)擴(kuò)充的邊界
copy = cv.copyMakeBorder(image, board, board, board, board, borderType=cv.BORDER_REFLECT) # 擴(kuò)充邊界
out_img = np.zeros_like(image, dtype=np.uint8)
def sub_func(src, i, j, size):
# 確保 i 和 j 在有效范圍內(nèi)
if i < 0 or i + size > src.shape[0] or j < 0 or j + size > src.shape[1]:
return src[i, j]
kernel = src[i:i + size, j:j + size]
z_med = np.median(kernel)
z_max = np.max(kernel)
z_min = np.min(kernel)
if z_min < z_med < z_max: # 層次A
if z_min < image[i][j] < z_max: # 層次B
return image[i][j]
else:
return z_med
else:
next_size = size + 2 # 增加尺寸
if next_size <= max_size:
return sub_func(src, i - 1, j - 1, next_size) # 遞歸調(diào)用
else:
return z_med
for i in range(image.shape[0]):
for j in range(image.shape[1]):
out_img[i][j] = sub_func(copy, i + board, j + board, origen)
return out_img
def main():
# 讀取圖像
image = cv.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
# 自適應(yīng)中值濾波
adaptive_filtered_image = auto_median_filter(gray_image, max_size=7)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv.cvtColor(image, cv.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(adaptive_filtered_image, cmap='gray')
plt.title('Adaptive Median Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(5) 形態(tài)學(xué)濾波（Morphological Filtering）
形態(tài)學(xué)濾波通過形態(tài)學(xué)操作（如腐蝕、膨脹、開運(yùn)算和閉運(yùn)算）來處理圖像，常用于去噪、邊緣檢測和形狀分析。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def morphological_filter(image, operation='opening', kernel_size=3):
"""
形態(tài)學(xué)濾波
:param image: 輸入圖像
:param operation: 操作類型（'opening', 'closing', 'erosion', 'dilation'）
:param kernel_size: 濾波器大小（奇數(shù)）
:return: 處理后的圖像
"""
kernel = np.ones((kernel_size, kernel_size), np.uint8)
if operation == 'opening':
filtered_image = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)
elif operation == 'closing':
filtered_image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
elif operation == 'erosion':
filtered_image = cv2.erode(image, kernel)
elif operation == 'dilation':
filtered_image = cv2.dilate(image, kernel)
else:
raise ValueError("Invalid operation. Choose from 'opening', 'closing', 'erosion', 'dilation'.")
return filtered_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 開運(yùn)算
opening_image = morphological_filter(image, operation='opening', kernel_size=3)
# 閉運(yùn)算
closing_image = morphological_filter(image, operation='closing', kernel_size=3)
# 腐蝕
erosion_image = morphological_filter(image, operation='erosion', kernel_size=3)
# 膨脹
dilation_image = morphological_filter(image, operation='dilation', kernel_size=3)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(12, 8))
plt.subplot(2, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(cv2.cvtColor(opening_image))
plt.title('Opening Image')
plt.axis('off')
plt.subplot(2, 2, 3)
plt.imshow(cv2.cvtColor(closing_image))
plt.title('Closing Image')
plt.axis('off')
plt.subplot(2, 2, 4)
plt.imshow(cv2.cvtColor(erosion_image))
plt.title('Erosion Image')
plt.axis('off')
plt.tight_layout()
plt.show()
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(dilation_image))
plt.title('Dilation Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()3. 邊緣檢測（Edge Enhancement）
邊緣檢測是圖像處理中的一個重要技術(shù)，用于檢測圖像中的邊緣和輪廓。
(1) Prewitt算子
Prewitt算子是一種簡單的梯度算子，用于計算圖像的梯度幅值和方向。Prewitt算子通過兩個3x3的卷積核分別計算水平和垂直方向上的梯度。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def prewitt_edge_detection(image):
"""
Prewitt邊緣檢測
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 定義Prewitt算子的水平和垂直卷積核
prewitt_x = np.array([[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1]], dtype=np.float32)
prewitt_y = np.array([[-1, -1, -1],
[0, 0, 0],
[1, 1, 1]], dtype=np.float32)
# 應(yīng)用卷積核
gradient_x = cv2.filter2D(image, -1, prewitt_x)
gradient_y = cv2.filter2D(image, -1, prewitt_y)
# 計算梯度幅值
gradient_magnitude = np.sqrt(gradient_x**2 + gradient_y**2)
gradient_magnitude = np.clip(gradient_magnitude, 0, 255).astype(np.uint8)
return gradient_magnitude
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# Prewitt邊緣檢測
prewitt_image = prewitt_edge_detection(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(prewitt_image, cmap='gray')
plt.title('Prewitt Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) Roberts算子
Roberts算子是一種簡單的梯度算子，用于計算圖像的梯度幅值和方向。Roberts算子通過兩個2x2的卷積核分別計算水平和垂直方向上的梯度。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def roberts_edge_detection(image):
"""
Roberts邊緣檢測
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 定義Roberts算子的水平和垂直卷積核
roberts_x = np.array([[1, 0],
[0, -1]], dtype=np.float32)
roberts_y = np.array([[0, 1],
[-1, 0]], dtype=np.float32)
# 應(yīng)用卷積核
gradient_x = cv2.filter2D(image, -1, roberts_x)
gradient_y = cv2.filter2D(image, -1, roberts_y)
# 計算梯度幅值
gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
gradient_magnitude = np.clip(gradient_magnitude, 0, 255).astype(np.uint8)
return gradient_magnitude
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# Roberts邊緣檢測
roberts_image = roberts_edge_detection(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(roberts_image, cmap='gray')
plt.title('Roberts Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) Sobel算子
Sobel算子是一種廣泛使用的梯度算子，用于計算圖像的梯度幅值和方向。Sobel算子通過兩個3x3的卷積核分別計算水平和垂直方向上的梯度。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def sobel_edge_detection(image):
"""
Sobel邊緣檢測
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 計算水平和垂直方向上的梯度
gradient_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
gradient_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)
# 計算梯度幅值
gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
gradient_magnitude = np.clip(gradient_magnitude, 0, 255).astype(np.uint8)
return gradient_magnitude
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# Sobel邊緣檢測
sobel_image = sobel_edge_detection(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(sobel_image, cmap='gray')
plt.title('Sobel Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(4) Scharr算子
Scharr算子是Sobel算子的一種改進(jìn)版本，提供了更高的精度。Scharr算子通過兩個3x3的卷積核分別計算水平和垂直方向上的梯度。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def scharr_edge_detection(image):
"""
Scharr邊緣檢測
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 計算水平和垂直方向上的梯度
gradient_x = cv2.Scharr(image, cv2.CV_64F, 1, 0)
gradient_y = cv2.Scharr(image, cv2.CV_64F, 0, 1)
# 計算梯度幅值
gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
gradient_magnitude = np.clip(gradient_magnitude, 0, 255).astype(np.uint8)
return gradient_magnitude
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# Scharr邊緣檢測
scharr_image = scharr_edge_detection(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(scharr_image, cmap='gray')
plt.title('Scharr Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(5) 拉普拉斯算子
拉普拉斯算子是一種二階導(dǎo)數(shù)算子，用于檢測圖像中的邊緣。拉普拉斯算子通過一個3x3的卷積核計算圖像的二階導(dǎo)數(shù)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def laplacian_edge_detection(image):
"""
拉普拉斯邊緣檢測
:param image: 輸入圖像（灰度圖像）
:return: 處理后的圖像
"""
if len(image.shape) == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 應(yīng)用拉普拉斯算子
laplacian_image = cv2.Laplacian(image, cv2.CV_64F, ksize=3)
# 將結(jié)果轉(zhuǎn)換為8位圖像
laplacian_image = np.clip(laplacian_image, 0, 255).astype(np.uint8)
return laplacian_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 拉普拉斯邊緣檢測
laplacian_image = laplacian_edge_detection(image)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(laplacian_image, cmap='gray')
plt.title('Laplacian Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(6) Canny邊緣檢測
Canny邊緣檢測是一種多階段的邊緣檢測算法，能夠檢測出圖像中的強(qiáng)邊緣。Canny邊緣檢測包括以下步驟：
- 高斯濾波：平滑圖像，減少噪聲。
- 計算梯度幅值和方向：使用Sobel算子計算圖像的梯度幅值和方向。
- 非極大值抑制：抑制非極大值像素，保留邊緣。
- 雙閾值檢測：使用高低閾值檢測和連接邊緣。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def gaussian_blur(image, kernel_size=(5, 5), sigmaX=0):
"""
高斯濾波
:param image: 輸入圖像
:param kernel_size: 濾波器大小
:param sigmaX: 高斯核的標(biāo)準(zhǔn)差
:return: 處理后的圖像
"""
return cv2.GaussianBlur(image, kernel_size, sigmaX)
def compute_gradients(image):
"""
計算圖像的梯度幅值和方向
:param image: 輸入圖像（灰度圖像）
:return: 梯度幅值和方向
"""
# 計算水平和垂直方向上的梯度
gradient_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
gradient_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)
# 計算梯度幅值
gradient_magnitude = np.sqrt(gradient_x ** 2 + gradient_y ** 2)
gradient_magnitude = np.clip(gradient_magnitude, 0, 255).astype(np.uint8)
# 計算梯度方向
gradient_angle = np.arctan2(gradient_y, gradient_x) * 180 / np.pi
gradient_angle[gradient_angle < 0] += 180
return gradient_magnitude, gradient_angle
def non_max_suppression(gradient_magnitude, gradient_angle):
"""
非極大值抑制
:param gradient_magnitude: 梯度幅值
:param gradient_angle: 梯度方向
:return: 抑制后的梯度幅值
"""
M, N = gradient_magnitude.shape
suppressed = np.zeros((M, N), dtype=np.uint8)
for i in range(1, M-1):
for j in range(1, N-1):
angle = gradient_angle[i, j]
if (0 <= angle < 22.5) or (157.5 <= angle <= 180):
q = gradient_magnitude[i, j+1]
r = gradient_magnitude[i, j-1]
elif (22.5 <= angle < 67.5):
q = gradient_magnitude[i+1, j-1]
r = gradient_magnitude[i-1, j+1]
elif (67.5 <= angle < 112.5):
q = gradient_magnitude[i+1, j]
r = gradient_magnitude[i-1, j]
elif (112.5 <= angle < 157.5):
q = gradient_magnitude[i-1, j-1]
r = gradient_magnitude[i+1, j+1]
if (gradient_magnitude[i, j] >= q) and (gradient_magnitude[i, j] >= r):
suppressed[i, j] = gradient_magnitude[i, j]
else:
suppressed[i, j] = 0
return suppressed
def double_thresholding(suppressed, low_threshold, high_threshold):
"""
雙閾值檢測
:param suppressed: 抑制后的梯度幅值
:param low_threshold: 低閾值
:param high_threshold: 高閾值
:return: 邊緣圖像
"""
M, N = suppressed.shape
strong = np.zeros((M, N), dtype=np.uint8)
weak = np.zeros((M, N), dtype=np.uint8)
strong_i, strong_j = np.where(suppressed >= high_threshold)
weak_i, weak_j = np.where((suppressed >= low_threshold) & (suppressed < high_threshold))
strong[strong_i, strong_j] = 255
weak[weak_i, weak_j] = 50
return strong, weak
def edge_tracking(strong, weak):
"""
邊緣跟蹤
:param strong: 強(qiáng)邊緣圖像
:param weak: 弱邊緣圖像
:return: 最終的邊緣圖像
"""
M, N = strong.shape
final_edges = np.zeros((M, N), dtype=np.uint8)
final_edges[np.where(strong == 255)] = 255
def dfs(i, j):
if i < 0 or i >= M or j < 0 or j >= N:
return
if weak[i, j] == 50:
final_edges[i, j] = 255
weak[i, j] = 0
dfs(i-1, j)
dfs(i+1, j)
dfs(i, j-1)
dfs(i, j+1)
dfs(i-1, j-1)
dfs(i-1, j+1)
dfs(i+1, j-1)
dfs(i+1, j+1)
for i in range(M):
for j in range(N):
if strong[i, j] == 255:
dfs(i, j)
return final_edges
def canny_edge_detection(image, low_threshold=50, high_threshold=150, kernel_size=(5, 5), sigmaX=0):
"""
Canny邊緣檢測
:param image: 輸入圖像（灰度圖像）
:param low_threshold: 低閾值
:param high_threshold: 高閾值
:param kernel_size: 高斯濾波器大小
:param sigmaX: 高斯核的標(biāo)準(zhǔn)差
:return: 邊緣圖像
"""
# 1. 高斯濾波
blurred_image = gaussian_blur(image, kernel_size, sigmaX)
# 2. 計算梯度幅值和方向
gradient_magnitude, gradient_angle = compute_gradients(blurred_image)
# 3. 非極大值抑制
suppressed = non_max_suppression(gradient_magnitude, gradient_angle)
# 4. 雙閾值檢測
strong, weak = double_thresholding(suppressed, low_threshold, high_threshold)
# 5. 邊緣跟蹤
final_edges = edge_tracking(strong, weak)
return final_edges
def main():
# 讀取圖像
image = cv2.imread('demo.jpg')
if image is None:
print("Error: Could not read image.")
return
# 轉(zhuǎn)換為灰度圖像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Canny邊緣檢測
canny_image = canny_edge_detection(gray_image, low_threshold=50, high_threshold=150)
# 顯示原始圖像和處理后的圖像
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(canny_image, cmap='gray')
plt.title('Canny Edge Detection')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()五、頻率域（增強(qiáng)）
在圖像處理中，頻率域增強(qiáng)方法通過將圖像轉(zhuǎn)換到頻率域，通過修改頻率分量來增強(qiáng)圖像中的特定特征，再將其轉(zhuǎn)換回空間域得到增強(qiáng)效果。常見的頻率域增強(qiáng)方法包括濾波和頻譜調(diào)整，如低通濾波、高通濾波、帶通濾波等。
以下是頻率域增強(qiáng)方法的主要步驟：
(1) 傅里葉變換：使用傅里葉變換將空間域圖像轉(zhuǎn)換到頻率域。
(2) 濾波器設(shè)計：根據(jù)需要增強(qiáng)的特征（如邊緣或噪聲），設(shè)計頻域?yàn)V波器。
- 低通濾波器：保留低頻成分，抑制高頻成分，用于去噪或平滑處理。
- 高通濾波器：保留高頻成分，抑制低頻成分，用于邊緣增強(qiáng)。
- 帶通濾波器：保留特定頻率區(qū)間的成分，適用于增強(qiáng)特定頻率范圍的細(xì)節(jié)。
(3) 頻譜濾波：將設(shè)計好的濾波器應(yīng)用于頻率域圖像。
(4) 逆傅里葉變換：將處理后的頻率域圖像轉(zhuǎn)換回空間域，得到增強(qiáng)后的圖像。
1. 傅里葉變換（Fourier Transform）
傅里葉變換是一種將時域信號轉(zhuǎn)換到頻域的方法。在圖像處理中，傅里葉變換將空間域圖像轉(zhuǎn)換到頻率域，使得圖像的頻率成分更加直觀。通過傅里葉變換，可以分析圖像的頻率特性，從而進(jìn)行圖像增強(qiáng)、去噪等處理。
其基本思想是將一個信號分解為多個正弦波和余弦波的組合。
對于一個連續(xù)函數(shù)f(x)，其傅里葉變換F(u)可以表示為：
其中，j是虛數(shù)單位，u是頻率變量。
對于離散信號f(x)，其離散傅里葉變換DFT可以表示為：
其中，N是信號的長度。
1. 快速傅里葉變換（Fast Fourier Transform, FFT）
快速傅里葉變換是一種高效的傅里葉變換算法，能夠快速計算離散傅里葉變換。FFT通過將DFT分解為多個小的DFT計算，從而大大減少了計算復(fù)雜度。
2. 離散傅里葉變換（Discrete Fourier Transform, DFT）
離散傅里葉變換是傅里葉變換的離散版本，適用于數(shù)字圖像處理。DFT將離散的圖像信號轉(zhuǎn)換為離散的頻率信號。
3. 傅里葉逆變換（Inverse Fourier Transform）
傅里葉逆變換將頻率域圖像轉(zhuǎn)換回空間域。對于離散傅里葉變換，其逆變換可以表示為：
import cv2
import numpy as np
import matplotlib.pyplot as plt
def fft_transform(image):
"""
傅里葉變換
:param image: 輸入圖像（灰度圖像）
:return: 頻率域圖像
"""
# 計算傅里葉變換
f = np.fft.fft2(image)
# 將零頻率分量移到頻譜中心
fshift = np.fft.fftshift(f)
return fshift
def ifft_transform(fshift):
"""
傅里葉逆變換
:param fshift: 頻率域圖像
:return: 空間域圖像
"""
# 將零頻率分量移到頻譜邊緣
f_ishift = np.fft.ifftshift(fshift)
# 計算逆傅里葉變換
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)
return img_back
def main():
# 讀取圖像
image = cv2.imread('demo.jpg', cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Could not read image.")
return
# 傅里葉變換
fshift = fft_transform(image)
# 顯示原始圖像和頻譜圖像
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(np.log(cv2.magnitude(fshift.real, fshift.imag)), cmap='gray')
plt.title('Magnitude Spectrum')
plt.axis('off')
plt.tight_layout()
plt.show()
# 傅里葉逆變換
img_back = ifft_transform(fshift)
# 顯示逆傅里葉變換后的圖像
plt.figure(figsize=(8, 4))
plt.imshow(img_back, cmap='gray')
plt.title('Inverse Fourier Transform')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()4. 濾波器設(shè)計
(1) 低通濾波
低通濾波器保留圖像的低頻成分，抑制高頻成分。低頻成分通常對應(yīng)于圖像的平滑部分，如背景和大尺度結(jié)構(gòu)，而高頻成分對應(yīng)于圖像的細(xì)節(jié)和噪聲。因此，低通濾波可以用于圖像平滑和去噪。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def fft_transform(image):
"""
傅里葉變換
:param image: 輸入圖像（灰度圖像）
:return: 頻率域圖像
"""
# 計算傅里葉變換
f = np.fft.fft2(image)
# 將零頻率分量移到頻譜中心
fshift = np.fft.fftshift(f)
return fshift
def ifft_transform(fshift):
"""
傅里葉逆變換
:param fshift: 頻率域圖像
:return: 空間域圖像
"""
# 將零頻率分量移到頻譜邊緣
f_ishift = np.fft.ifftshift(fshift)
# 計算逆傅里葉變換
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)
return img_back
def low_pass_filter(fshift, d0=30):
"""
低通濾波器
:param fshift: 頻率域圖像
:param d0: 截止頻率
:return: 濾波后的頻率域圖像
"""
rows, cols = fshift.shape
crow, ccol = rows // 2, cols // 2
mask = np.zeros((rows, cols), np.uint8)
cv2.circle(mask, (ccol, crow), d0, 1, -1)
fshift_filtered = fshift * mask
return fshift_filtered
def main():
# 讀取圖像
image = cv2.imread('demo.jpg', cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Could not read image.")
return
# 傅里葉變換
fshift = fft_transform(image)
# 低通濾波
fshift_lowpass = low_pass_filter(fshift, d0=30)
img_lowpass = ifft_transform(fshift_lowpass)
# 顯示原始圖像、頻譜圖像和低通濾波結(jié)果
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(img_lowpass, cmap='gray')
plt.title('Low-pass Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 高通濾波（High-pass Filtering）
高通濾波器保留圖像的高頻成分，抑制低頻成分。高頻成分通常對應(yīng)于圖像的細(xì)節(jié)和邊緣，而低頻成分對應(yīng)于圖像的平滑部分。因此，高通濾波可以用于邊緣檢測和細(xì)節(jié)增強(qiáng)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def fft_transform(image):
"""
傅里葉變換
:param image: 輸入圖像（灰度圖像）
:return: 頻率域圖像
"""
# 計算傅里葉變換
f = np.fft.fft2(image)
# 將零頻率分量移到頻譜中心
fshift = np.fft.fftshift(f)
return fshift
def ifft_transform(fshift):
"""
傅里葉逆變換
:param fshift: 頻率域圖像
:return: 空間域圖像
"""
# 將零頻率分量移到頻譜邊緣
f_ishift = np.fft.ifftshift(fshift)
# 計算逆傅里葉變換
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)
return img_back
def low_pass_filter(fshift, d0=30):
"""
低通濾波器
:param fshift: 頻率域圖像
:param d0: 截止頻率
:return: 濾波后的頻率域圖像
"""
rows, cols = fshift.shape
crow, ccol = rows // 2, cols // 2
mask = np.zeros((rows, cols), np.uint8)
cv2.circle(mask, (ccol, crow), d0, 1, -1)
fshift_filtered = fshift * mask
return fshift_filtered
def main():
# 讀取圖像
image = cv2.imread('demo.jpg', cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Could not read image.")
return
# 傅里葉變換
fshift = fft_transform(image)
# 低通濾波
fshift_lowpass = low_pass_filter(fshift, d0=30)
img_lowpass = ifft_transform(fshift_lowpass)
# 顯示原始圖像、頻譜圖像和低通濾波結(jié)果
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(img_lowpass, cmap='gray')
plt.title('Low-pass Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(2) 帶通濾波（Band-pass Filtering）
帶通濾波器保留圖像中特定頻率范圍內(nèi)的成分，抑制低于和高于該頻率范圍的成分。帶通濾波可以用于提取特定頻率范圍內(nèi)的細(xì)節(jié)，常用于圖像的特定特征增強(qiáng)。
import cv2
import numpy as np
import matplotlib.pyplot as plt
def fft_transform(image):
"""
傅里葉變換
:param image: 輸入圖像（灰度圖像）
:return: 頻率域圖像
"""
# 計算傅里葉變換
f = np.fft.fft2(image)
# 將零頻率分量移到頻譜中心
fshift = np.fft.fftshift(f)
return fshift
def ifft_transform(fshift):
"""
傅里葉逆變換
:param fshift: 頻率域圖像
:return: 空間域圖像
"""
# 將零頻率分量移到頻譜邊緣
f_ishift = np.fft.ifftshift(fshift)
# 計算逆傅里葉變換
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)
return img_back
def high_pass_filter(fshift, d0=30):
"""
高通濾波器
:param fshift: 頻率域圖像
:param d0: 截止頻率
:return: 濾波后的頻率域圖像
"""
rows, cols = fshift.shape
crow, ccol = rows // 2, cols // 2
mask = np.ones((rows, cols), np.uint8)
cv2.circle(mask, (ccol, crow), d0, 0, -1)
fshift_filtered = fshift * mask
return fshift_filtered
def main():
# 讀取圖像
image = cv2.imread('demo.jpg', cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Could not read image.")
return
# 傅里葉變換
fshift = fft_transform(image)
# 高通濾波
fshift_highpass = high_pass_filter(fshift, d0=30)
img_highpass = ifft_transform(fshift_highpass)
# 顯示原始圖像、頻譜圖像和高通濾波結(jié)果
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(img_highpass, cmap='gray')
plt.title('High-pass Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()(3) 小波變換（Wavelet Transform）
小波變換是一種將信號分解為不同尺度和位置的成分的方法。與傅里葉變換不同，小波變換能夠提供時間和頻率的局部化信息。
import cv2
import numpy as np
import matplotlib.pyplot as plt
import pywt
def dwt_transform(image, wavelet='haar', level=1):
"""
離散小波變換
:param image: 輸入圖像（灰度圖像）
:param wavelet: 小波類型
:param level: 分解層數(shù)
:return: 分解后的系數(shù)
"""
coeffs = pywt.wavedec2(image, wavelet, level=level)
return coeffs
def idwt_transform(coeffs, wavelet='haar'):
"""
離散小波逆變換
:param coeffs: 分解后的系數(shù)
:param wavelet: 小波類型
:return: 重構(gòu)后的圖像
"""
reconstructed_image = pywt.waverec2(coeffs, wavelet)
return reconstructed_image
def main():
# 讀取圖像
image = cv2.imread('demo.jpg', cv2.IMREAD_GRAYSCALE)
if image is None:
print("Error: Could not read image.")
return
# 離散小波變換
coeffs = dwt_transform(image, wavelet='haar', level=1)
LL, (LH, HL, HH) = coeffs
# 顯示原始圖像和分解后的系數(shù)
plt.figure(figsize=(12, 6))
plt.subplot(2, 2, 1)
plt.imshow(image, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(2, 2, 2)
plt.imshow(LL, cmap='gray')
plt.title('LL (Approximation)')
plt.axis('off')
plt.subplot(2, 2, 3)
plt.imshow(LH, cmap='gray')
plt.title('LH (Horizontal Detail)')
plt.axis('off')
plt.subplot(2, 2, 4)
plt.imshow(HL, cmap='gray')
plt.title('HL (Vertical Detail)')
plt.axis('off')
plt.tight_layout()
plt.show()
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.imshow(HH, cmap='gray')
plt.title('HH (Diagonal Detail)')
plt.axis('off')
plt.subplot(1, 2, 2)
plt.imshow(idwt_transform(coeffs, wavelet='haar'), cmap='gray')
plt.title('Reconstructed Image')
plt.axis('off')
plt.tight_layout()
plt.show()
if __name__ == "__main__":
main()責(zé)任編輯：趙寧寧
來源：
小喵學(xué)AI
