数字图像处理三python实现-2

2020-07-01 本文已影响0人幺姨母

数字图像处理三-2（锐化空间滤波器）

拉普拉斯算子
非锐化掩蔽
罗伯特交叉梯度算子
Robel算子

openCV中的卷积计算filter2D()函数

使用自定义内核对图像进行卷积。该功能将任意线性滤波器应用于图像，支持就地操作，当光圈部分位于图像外部时，该功能会根据指定的边框模式插入异常像素值。

import cv2
import numpy as np

img = cv2.imread("cat.JPG")
kernel = np.array(([0.0625,0.125,0.0625],[0.125,0.25,0.125],[0.0625,0.125,0.0625]), dtype = "float32")
meanImg = cv2.filter2D(img, -1, kernel)

# 显示图像
cv2.imshow("img", img)
cv2.imshow("meanImg", meanImg)
cv2.waitKey(0)
cv2.destroyAllWindows()

拉普拉斯算子

二阶微分算子

四领域模板

$\begin{matrix}0&-1&0 \\ -1&4&-1 \\0&-1&0\\\end{matrix}$

八领域模板

$\begin{matrix}-1&-1&-1 \\ -1&8&-1 \\-1&-1&-1\\\end{matrix}$

当领域内像素灰度相同时，模板卷积运算结果为0
当中心像素灰度高于领域内其他像素的平均灰度时，模板的卷积运算结果为正数
当中心像素灰度低于领域内其他像素的平均灰度时，模板的卷积运算结果为负数

对卷积运算结果用适当的衰弱因子处理叠加在原中心像素，可实现图像锐化

$g(x,y) = f(x,y) + c[▽^2f(x,y)]$

dstimg = cv2.Laplacian(img, cv2.CV_16S, 3)
dstimg = cv2.convertScaleAbs(dstimg)
resimg = np.uint8(0.8 * dst) + img

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

# 读取图像
img = cv2.imread("cat.JPG")
b,g,r = cv2.split(img)

# 三通道拉普拉斯算法
dstb = cv2.Laplacian(b, cv2.CV_16S, 3)
dstg = cv2.Laplacian(g, cv2.CV_16S, 3)
dstr = cv2.Laplacian(r, cv2.CV_16S, 3)
dstb = cv2.convertScaleAbs(dstb)
dstg = cv2.convertScaleAbs(dstg)
dstr = cv2.convertScaleAbs(dstr)
b = np.uint8(0.8 * dstb) + b # 矩阵取整
g = np.uint8(0.8 * dstg) + g
r = np.uint8(0.8 * dstr) + r
laplacian = cv2.merge((dstb,dstg,dstr))
res = cv2.merge((b,g,r))

# 显示图像
cv2.imshow("original", img)
cv2.imshow("laplacianImg", laplacian)
cv2.imshow("laplacianResImg", res)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("laplacianImg.jpg", laplacian)
cv2.imwrite("laplacianResImg.jpg", res)

laplacianImg.jpg

laplacianResImg.jpg

import cv2
import numpy as np

img = cv2.imread("cat.JPG")
b,g,r = cv2.split(img)
kernel = np.array(([0,-1,0],[-1,4,-1],[0,-1,0]), dtype = "float32")
bla = cv2.filter2D(b, -1, kernel)
gla = cv2.filter2D(g, -1, kernel)
rla = cv2.filter2D(r, -1, kernel)
la = cv2.merge((bla, gla, rla))
res = np.uint8(la * 0.8) + img

cv2.imshow("myla", la)
cv2.imshow("mylares", res)
cv2.waitKey(0)
cv2.destroyAllWindows()

cv2.imwrite("myLaplacianImg.jpg", la)
cv2.imwrite("myLaplacianResImg.jpg", res)

myLaplacianImg.jpg

myLaplacianResImg.jpg

非锐化掩蔽和高提升滤波

g_mask(x,y) = f(x,y) - f_blur(x,y)

g(x,y) = f(x,y) + k * g_mask (x,y)

使用高斯blur

import cv2
import numpy as np

def func(imgPath, k):
    img = cv2.imread(imgPath)
    imgBlur = cv2.GaussianBlur(img, (3,3), 0)
    imgMask = img - imgBlur
    res = img + np.uint8(k * imgMask)
    return res

imgPath = "cat.JPG"
yanbiImg = func(imgPath, 1)
tishengImg = func(imgPath, 3)

# 显示图像
cv2.imshow("yanbi", yanbiImg)
cv2.imshow("tisheng", tishengImg)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("yanbi.jpg", yanbiImg)
cv2.imwrite("tisheng.jpg", tishengImg)

yanbi.jpg

tisheng.jpg

罗伯特交叉梯度算子

kernelx = $\begin{matrix} -1&0 \\ 0&1\\\end{matrix}$
kernely = $\begin{matrix} 0&-1 \\ 1&0\\\end{matrix}$

import cv2
import numpy

def func(imgPath):
    img = cv2.imread(imgPath)
    b,g,r = cv2.split(img)
    kernelx = np.array(([-1,0],[0,1]), dtype = "float32")
    kernely = np.array(([0,-1],[1,0]), dtype = "float32")
    xb = cv2.filter2D(b,-1,kernelx)
    yb = cv2.filter2D(b,-1,kernely)
    Robertb = cv2.addWeighted(xb,0.5,yb,0.5,0) # 加权
    xg = cv2.filter2D(g,-1,kernelx)
    yg = cv2.filter2D(g,-1,kernely)
    Robertg = cv2.addWeighted(xg,0.5,yg,0.5,0)
    xr = cv2.filter2D(r,-1,kernelx)
    yr = cv2.filter2D(r,-1,kernely)
    Robertr = cv2.addWeighted(xr,0.5,yr,0.5,0)
    res = cv2.merge((Robertb,Robertg,Robertr))
    return res

imgPath = "cat.JPG"
img = cv2.imread(imgPath)
res = func(imgPath)

# 显示图像
cv2.imshow("original", img)
cv2.imshow("Robert", res)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("Robert.jpg", res)

Robert.jpg

Robel算子

kernelx = $\begin{matrix}-1&-2&-1 \\ 0&0&0 \\1&2&1\\\end{matrix}$

kernely = $\begin{matrix}-1&0&1 \\ -2&0&2 \\-1&0&1\\\end{matrix}$

import cv2
import numpy

def func(imgPath):
    img = cv2.imread(imgPath)
    b,g,r = cv2.split(img)
    kernelx = np.array(([-1,-2,-1],[0,0,0],[1,2,1]), dtype = "float32")
    kernely = np.array(([-1,0,1],[-2,0,2],[-1,0,1]), dtype = "float32")
    xb = cv2.filter2D(b,-1,kernelx)
    yb = cv2.filter2D(b,-1,kernely)
    Robelb = cv2.addWeighted(xb,0.5,yb,0.5,0) # 加权
    xg = cv2.filter2D(g,-1,kernelx)
    yg = cv2.filter2D(g,-1,kernely)
    Robelg = cv2.addWeighted(xg,0.5,yg,0.5,0)
    xr = cv2.filter2D(r,-1,kernelx)
    yr = cv2.filter2D(r,-1,kernely)
    Robelr = cv2.addWeighted(xr,0.5,yr,0.5,0)
    res = cv2.merge((Robelb,Robelg,Robelr))
    return res

imgPath = "cat.JPG"
img = cv2.imread(imgPath)
res = func(imgPath)

# 显示图像
cv2.imshow("original", img)
cv2.imshow("Robel", res)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("Robel.jpg", res)

Robel.jpg