导向滤波&快速导向滤波及引导图的选择

引导图的选择

我主要说的导向滤波其中的引导图选择问题.

百度百科的定义 : 导向图滤波是一种图像滤波技术 ，通过一张引导图G（导向图），对目标图像P（输入图像）进行滤波处理，使得最后的输出图像大体上与目标图像P相似，但是纹理部分与引导图G相似。其典型应用有两个：保边图像平滑，抠图。

注意这句话:纹理部分与引导图G相似,他是引导图的选择标准.可以是rgb中的某一个,也可以是灰度图,也可以是经过处理后的图.他的作用就是保留纹理.反之,如果不想保存呢?那就选没有纹理的.

作用

1. 保边图像平滑

当引导图G与输入图P为同一个图像的时候，导向图滤波的效果与双边滤波的效果类似，但是不同于双边滤波的是，导向图滤波可以很容易设计一个与滤波半径无关的优化算法 [4-5]  。其中窗口半径为平滑半径，参数

为平滑项参数，其值越大平滑的越明显。

2. 抠图

当输入图P为一个初始的mask图像时，导向图滤波的效果类似于抠图算法，其中窗口半径为抠图的半径，参数

为平滑项。

下面内容来源于

https://blog.csdn.net/qq_40755643/article/details/83831071

导向滤波算法原理

原理可以看博主：白马负金羁 的文章导向滤波(Guided Filter)的解析与实现，对原理解释十分通俗易懂。

导向滤波：

1.实现的伪代码：

https://blog.csdn.net/qq_40755643/article/details/83831071

导向图像(Guidance Image) I，滤波输出图像(Filtering Input Image) p，均值平滑窗口半径 r，正则化参数 e。

利用导向滤波进行图像平滑处理时，通常令p=I。
2.opencv库代码实现：

其中：guideFilter(）函数调用opencv自带的库函数blur() 进行均值平滑。

3.结果对比：

下图采用了r=16也就是winSize=(16,16), eps=0.01的参数大小。

---

快速导向滤波

通过下采样减少像素点，计算mean_a & mean_b后进行上采样恢复到原有的尺寸大小。

假设缩放比例为s,那么缩小后像素点的个数为N/s^2，那么时间复杂度变为O(N/s^2)

1.实现的伪代码：

fmean代表均值平滑，fsubsample代表图像下采样即缩小图像，fupsample代表图片上采样即放大图像，s为缩小系数。

2.opencv库代码实现：

这里使用opencv自带库函数resize()进行上下采样。

3.结果对比：

下图导向滤波采用了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)