我主要说的导向滤波其中的引导图选择问题.
百度百科的定义 : 导向图滤波是一种图像滤波技术 ,通过一张引导图G(导向图),对目标图像P(输入图像)进行滤波处理,使得最后的输出图像大体上与目标图像P相似,但是纹理部分与引导图G相似。其典型应用有两个:保边图像平滑,抠图。
注意这句话:纹理部分与引导图G相似,他是引导图的选择标准.可以是rgb中的某一个,也可以是灰度图,也可以是经过处理后的图.他的作用就是保留纹理.反之,如果不想保存呢?那就选没有纹理的.
当引导图G与输入图P为同一个图像的时候,导向图滤波的效果与双边滤波的效果类似,但是不同于双边滤波的是,导向图滤波可以很容易设计一个与滤波半径无关的优化算法 [4-5] 。其中窗口半径为平滑半径,参数
为平滑项参数,其值越大平滑的越明显。
当输入图P为一个初始的mask图像时,导向图滤波的效果类似于抠图算法,其中窗口半径为抠图的半径,参数
为平滑项。
https://blog.csdn.net/qq_40755643/article/details/83831071
原理可以看博主:白马负金羁 的文章导向滤波(Guided Filter)的解析与实现,对原理解释十分通俗易懂。
导向滤波:
https://blog.csdn.net/qq_40755643/article/details/83831071
导向图像(Guidance Image) I,滤波输出图像(Filtering Input Image) p,均值平滑窗口半径 r,正则化参数 e。
其中:guideFilter()函数调用opencv自带的库函数blur() 进行均值平滑。
下图采用了r=16也就是winSize=(16,16), eps=0.01的参数大小。
通过下采样减少像素点,计算mean_a & mean_b后进行上采样恢复到原有的尺寸大小。
假设缩放比例为s,那么缩小后像素点的个数为N/s^2,那么时间复杂度变为O(N/s^2)
fmean代表均值平滑,fsubsample代表图像下采样即缩小图像,fupsample代表图片上采样即放大图像,s为缩小系数。
这里使用opencv自带库函数resize()进行上下采样。
下图导向滤波采用了r=16也就是winSize=(16,16), eps=0.01的参数大小。
快速导向滤波采用了r=16也就是winSize=(16,16), eps=0.01,s=0.5的参数大小。
import cv2,math
import numpy as np
import pycuda.gpuarray as gpuarray
import pycuda.cumath as cumath
import pycuda.autoinit
def guideFilter(I, p, winSize, eps):
"""
导向图像(Guidance Image) I,滤波输出图像(Filtering Input Image) p,均值平滑窗口半径 r,正则化参数 e。
利用导向滤波进行图像平滑处理时,通常令p=I。
其中:guideFilter()函数调用opencv自带的库函数blur() 进行均值平滑。
:param I:
:param p:
:param winSize:
:param eps:
:return:
"""
# I的均值平滑
mean_I = cv2.blur(I, winSize)
# p的均值平滑
mean_p = cv2.blur(p, winSize)
# I*I和I*p的均值平滑
mean_II = cv2.blur(I * I, winSize)
mean_Ip = cv2.blur(I * p, winSize)
# 方差
var_I = mean_II - mean_I * mean_I # 方差公式
# 协方差
cov_Ip = mean_Ip - mean_I * mean_p
a = cov_Ip / (var_I + eps)
b = mean_p - a * mean_I
# 对a、b进行均值平滑
mean_a = cv2.blur(a, winSize)
mean_b = cv2.blur(b, winSize)
q = mean_a * I + mean_b
return q
def FastguideFilter(I, p, winSize, eps, s):
"""
快速导向滤波
通过下采样减少像素点,计算mean_a & mean_b后进行上采样恢复到原有的尺寸大小。
假设缩放比例为s,那么缩小后像素点的个数为N/s^2,那么时间复杂度变为O(N/s^2)
fmean代表均值平滑,fsubsample代表图像下采样即缩小图像,fupsample代表图片上采样即放大图像,s为缩小系数。
:param I:
:param p:
:param winSize:
:param eps:
:param s:
:return:
"""
# 输入图像的高、宽
h, w = I.shape[:2]
# 缩小图像
size = (int(round(w * s)), int(round(h * s)))
small_I = cv2.resize(I, size, interpolation=cv2.INTER_CUBIC)
small_p = cv2.resize(I, size, interpolation=cv2.INTER_CUBIC)
# 缩小滑动窗口
X = winSize[0]
small_winSize = (int(round(X * s)), int(round(X * s)))
# I的均值平滑
mean_small_I = cv2.blur(small_I, small_winSize)
# p的均值平滑
mean_small_p = cv2.blur(small_p, small_winSize)
# I*I和I*p的均值平滑
mean_small_II = cv2.blur(small_I * small_I, small_winSize)
mean_small_Ip = cv2.blur(small_I * small_p, small_winSize)
# 方差
var_small_I = mean_small_II - mean_small_I * mean_small_I # 方差公式
# 协方差
cov_small_Ip = mean_small_Ip - mean_small_I * mean_small_p
small_a = cov_small_Ip / (var_small_I + eps)
small_b = mean_small_p - small_a * mean_small_I
# 对a、b进行均值平滑
mean_small_a = cv2.blur(small_a, small_winSize)
mean_small_b = cv2.blur(small_b, small_winSize)
# 放大
size1 = (w, h)
mean_a = cv2.resize(mean_small_a, size1, interpolation=cv2.INTER_LINEAR)
mean_b = cv2.resize(mean_small_b, size1, interpolation=cv2.INTER_LINEAR)
q = mean_a * I + mean_b
return q
"""
下图导向滤波采用了r=16也就是winSize=(16,16), eps=0.01的参数大小。
快速导向滤波采用了r=16也就是winSize=(16,16), eps=0.01,s=0.5的参数大小。
"""
def run():
image = cv2.imread(r'/home/cheng/Documents/practice_py/cv/face03.png', cv2.IMREAD_ANYCOLOR)
#将图像归一化
image_0_1 = image/255.0
#导向滤波(三通道)
b, g, r = cv2.split(image_0_1)
# 1.753212477
# gf1 = guideFilter(b, b, (16,16), math.pow(0.1,2))
# gf2 = guideFilter(g, g, (16,16), math.pow(0.1,2))
# gf3 = guideFilter(r, r, (16,16), math.pow(0.1,2))
# 0.944390349
gf1 = FastguideFilter(b, b, (16, 16), math.pow(0.1, 2),s=0.5)
gf2 = FastguideFilter(g, g, (16, 16), math.pow(0.1, 2),s=0.5)
gf3 = FastguideFilter(r, r, (16, 16), math.pow(0.1, 2),s=0.5)
gf = cv2.merge([gf1, gf2, gf3])
#保存导向滤波结果
gf = gf*255
gf[gf>255] = 255
gf = np.round(gf)
gf = gf.astype(np.uint8)
res = np.hstack((image,gf))
cv2.imshow("res",res)
cv2.imwrite(r'/home/cheng/Documents/practice_py/cv/resface03.png.jpg', gf)
cv2.waitKey(0)
def gpu_run():
image = gpuarray.to_gpu(cv2.imread(r'/home/cheng/Documents/practice_py/cv/face03.png', cv2.IMREAD_ANYCOLOR))
#将图像归一化
image_0_1 = image/255.0
#导向滤波(三通道)
b, g, r = image_0_1[:,:,0],image_0_1[:,:,1],image_0_1[:,:,2]
# 1.753212477
# gf1 = guideFilter(b, b, (16,16), math.pow(0.1,2))
# gf2 = guideFilter(g, g, (16,16), math.pow(0.1,2))
# gf3 = guideFilter(r, r, (16,16), math.pow(0.1,2))
# 0.944390349
gf1 = FastguideFilter(b, b, (16, 16), math.pow(0.1, 2),s=0.5)
gf2 = FastguideFilter(g, g, (16, 16), math.pow(0.1, 2),s=0.5)
gf3 = FastguideFilter(r, r, (16, 16), math.pow(0.1, 2),s=0.5)
gf = cv2.merge([gf1, gf2, gf3])
#保存导向滤波结果
gf = gf*255
gf[gf>255] = 255
gf = np.round(gf)
gf = gf.astype(np.uint8)
res = np.hstack((image,gf))
cv2.imshow("res",res)
cv2.imwrite(r'/home/cheng/Documents/practice_py/cv/resface03.png.jpg', gf)
cv2.waitKey(0)
def costtime(func):
# time start
t1 = cv2.getTickCount()
func()
# time end
t2 = cv2.getTickCount()
# 计算执行秒数,利用getTickFrequency()获取时钟频率
t = (t2 - t1) / cv2.getTickFrequency()
print(t)
if __name__ == "__main__":
# costtime(gpu_run)
costtime(run)