数字图像处理快速入门（python&&windows）

Goobaid

已于 2022-12-14 08:43:15 修改

阅读量750

点赞数 3

文章标签： python 开发语言 opencv

于 2022-12-14 07:50:34 首次发布

本文链接：https://blog.csdn.net/goobaid/article/details/128310125

版权

在我们正式开始之前，首先确保你已经安装了python和pycharm

一. 前期准备工作

那么闲话少叙，我们首先来安装opencv库

https://www.lfd.uci.edu/~gohlke/pythonlibs/#opencv

下拉找到OpenCV，如果你的python版本是3.8，那么就选择

http://opencv_python‑4.5.5‑cp38‑cp38‑win_amd64.whl

以此类推

然后打开你的终端，输入

pip install opencv_python

如果在安装之后提示你更新pip的版本，最好更新一下

python -m pip install --upgrade pip

打开你的pycharm，在新建一个项目之后依次点击：文件->设置->项目->Python解释器

然后点击加号，搜索opencv

选择清华源（前提是你有，一般在安装pycharm的教程里都会有提到）的python-opencv

点击左下角安装

OK，准备工作就做到这里

二. 基础函数

1. 图像的读取与存储

import cv2

image = cv2.imread("")

cv2.imwrite("", img)

双引号里是图片读取与存储的路径，如果你想直接读入灰度图，可以直接这么写

image = cv2.imread("bird.jpg",0)

需要注意的是，使用cv2.imread读进来的彩色图像是BGR型而不是RGB型

2. 图像的展示

import matplotlib.pyplot as plt


plt.imshow(image, cmap="gray")
plt.show()

plt 是一个非常好用的画图工具库，这只是它最最最基础的用法

三. 数字图像处理

1. 图像对比度变换

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


# 伽马变换
def gamma(image):
    c = 1
    g = 0.5
    img = c * np.power(image, g)
    return img


imag = cv2.imread("Duck.jpg", 0)
im = gamma(imag)
plt.imshow(im, cmap="gray")
plt.show()

2. 图像平滑

（1）空域滤波

import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import util


def smooth(image):
    # 添加椒盐噪声
    image_noise = util.random_noise(image, mode="s&p")

    # 均值滤波，逐步增大滤波核
    result1 = cv2.blur(image_noise, (3, 3))
    result2 = cv2.blur(image_noise, (7, 7))
    result3 = cv2.blur(image_noise, (11, 11))
    result4 = cv2.blur(image_noise, (15, 15))
    result5 = cv2.blur(image_noise, (19, 19))
    result6 = cv2.blur(image_noise, (23, 23))
    result7 = cv2.blur(image_noise, (27, 27))

    # 合并结果
    imag1 = np.hstack([image_noise, result1, result2, result3])
    imag2 = np.hstack([result4, result5, result6, result7])
    result = np.vstack([imag1, imag2])

    return result


img = cv2.imread("Duck.jpg")
imag = smooth(img)
cv2.imwrite("Duck_Smooth.jpg", imag * 255)

（2）低通滤波（频率滤波）

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

# 设置滤波半径
D = 20


# 傅里叶变换
def fft2(image):
    # 傅里叶变换
    result1 = np.fft.fft2(image)
    # 移动中心点
    result2 = np.fft.fftshift(result1)
    # 得到频谱图像
    return 20 * np.log(np.abs(result2))


# 傅里叶逆变换
def i_fft2(shift):
    # 移回中心点
    result1 = np.fft.ifftshift(shift)
    # 傅里叶逆变换
    result2 = np.fft.ifft2(result1)
    # 得到滤波后的图像
    return np.abs(result2)


# 理想低通滤波器
def low_pass_filter(image):
    # 傅里叶变换
    result1 = np.fft.fft2(image)
    # 移动中心点
    result2 = np.fft.fftshift(result1)

    # 设置低通滤波器
    rows, cols = img.shape
    x, y = int(rows / 2), int(cols / 2)
    mask = np.zeros((rows, cols), np.uint8)
    mask[x - D:x + D, y - D:y + D] = 1

    return result2 * mask


# 读入图像
img = cv2.imread('Duck.jpg', 0)
# 原灰度图
plt.subplot(141), plt.imshow(img, cmap="gray"), plt.axis("off")
# 离散傅里叶变换得到的频谱图像
plt.subplot(142), plt.imshow(fft2(img), cmap="gray"), plt.axis("off")
# 低通滤波得到的图像
plt.subplot(143), plt.imshow(i_fft2(low_pass_filter(img)), cmap="gray"), plt.axis("off")
# 低通滤波得到的频谱图像
plt.subplot(144), plt.imshow(fft2(i_fft2(low_pass_filter(img))), cmap="gray"), plt.axis("off")
# 图像展示
plt.show()

3. 图像锐化

（1）空域滤波

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


# sobel算子
def sharp(image):
    # sobel算子
    kernel_x = np.array([[-1, 0, 1],
                         [-2, 0, 2],
                         [-1, 0, 1]])

    kernel_y = np.array([[1, 2, 1],
                         [0, 0, 0],
                         [-1, -2, -1]])

    # 分别在两个方向上对图像做卷积
    result_x = cv2.filter2D(image, -1, kernel_x, borderType=cv2.BORDER_REFLECT)
    result_y = cv2.filter2D(image, -1, kernel_y, borderType=cv2.BORDER_REFLECT)

    # 合并结果
    result = cv2.addWeighted(result_x, 0.5, result_y, 0.5, 0)

    return result


image = cv2.imread("Duck.jpg", 0)
imag = sharp(image)
im = cv2.cvtColor(imag, cv2.COLOR_BGR2RGB)
plt.imshow(im, "gray")
plt.show()

（2）高通滤波（频率滤波）

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

# 设置滤波半径
D = 20


# 傅里叶变换
def fft2(image):
    # 傅里叶变换
    result1 = np.fft.fft2(image)
    # 移动中心点
    result2 = np.fft.fftshift(result1)
    # 得到频谱图像
    return 20 * np.log(np.abs(result2))


# 傅里叶逆变换
def i_fft2(shift):
    # 移回中心点
    result1 = np.fft.ifftshift(shift)
    # 傅里叶逆变换
    result2 = np.fft.ifft2(result1)
    # 得到滤波后的图像
    return np.abs(result2)


# 理想高通滤波器
def high_pass_filter(image):
    # 傅里叶变换
    result1 = np.fft.fft2(image)
    # 移动中心点
    result2 = np.fft.fftshift(result1)

    # 设置高通滤波器
    rows, cols = img.shape
    x, y = int(rows / 2), int(cols / 2)
    mask = np.ones((rows, cols), np.uint8)
    mask[x - D:x + D, y - D:y + D] = 0

    return result2 * mask


# 读入图像
img = cv2.imread('Duck.jpg', 0)
# 原灰度图
plt.subplot(141), plt.imshow(img, cmap="gray"), plt.axis("off")
# 离散傅里叶变换得到的频谱图像
plt.subplot(142), plt.imshow(fft2(img), cmap="gray"), plt.axis("off")
# 高通滤波得到的图像
plt.subplot(143), plt.imshow(i_fft2(high_pass_filter(img)), cmap="gray"), plt.axis("off")
# 高通滤波得到的频谱图像
plt.subplot(144), plt.imshow(fft2(i_fft2(high_pass_filter(img))), cmap="gray"), plt.axis("off")
# 图像展示
plt.show()

4. 图像边缘检测

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


class EdgeDetect:
    def __init__(self, img) -> None:
        self.src = cv2.imread(img)
        self.gray = cv2.cvtColor(self.src, cv2.COLOR_BGR2GRAY)

    # 图像锐化（空域滤波，prewitt算子）
    def prewitt(self):
        kernelX = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=int)
        kernelY = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=int)
        x = cv2.filter2D(self.gray, -1, kernelX)
        y = cv2.filter2D(self.gray, -1, kernelY)
        return cv2.addWeighted(x, 0.5, y, 0.5, 0)

    # 概率Hough线检测
    def houghlinesp(self):
        lines = cv2.HoughLinesP(self.gray, 1, np.pi / 180, 100, 100, 10)
        result = self.gray
        for line in lines:
            x1, y1, x2, y2 = line[0]
            cv2.line(result, (x1, y1), (x2, y2), (0, 255, 0), 2)
        return result


Detector = EdgeDetect('Duck.jpg')
plt.imshow(Detector.houghlinesp(), "gray")
plt.show()

5. 图像二值分割

import cv2
from matplotlib import pyplot as plt

image = cv2.imread("Duck.jpg")
original = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 原图
plt.subplot(131), plt.imshow(original, "gray")
plt.title("original"), plt.xticks([]), plt.yticks([])

# 灰度直方图
plt.subplot(132), plt.hist(original.ravel(), 256)
plt.title("histogram"), plt.xticks([]), plt.yticks([])

# 二值分割
ret1, result = cv2.threshold(gray, 210, 255, cv2.THRESH_BINARY)
plt.subplot(133), plt.imshow(result, "gray")
plt.title("result"), plt.xticks([]), plt.yticks([])

plt.show()