精华内容
下载资源
问答
  • python图像处理:基于canny的动态边缘模糊效果原理canny边缘检测代码 效果 流程如下:先选择canny的两个阈值,确定好需要进行模糊的边缘,再选择模糊程度 原理 canny边缘检测 参考链接 Canny边缘检测算法可以分为...

    python图像处理:基于canny的动态边缘模糊

    效果

    流程如下:先选择canny的两个阈值,确定好需要进行模糊的边缘,再选择模糊程度
    在这里插入图片描述

    原理

    canny边缘检测

    参考链接

    Canny边缘检测算法可以分为以下5个步骤:

    1. 使用高斯滤波器,以平滑图像,滤除噪声。

    2. 计算图像中每个像素点的梯度强度和方向。

    3. 应用非极大值(Non-Maximum Suppression)抑制,以消除边缘检测带来的杂散响应。

    4. 应用双阈值(Double-Threshold)检测来确定真实的和潜在的边缘。

    5. 通过抑制孤立的弱边缘最终完成边缘检测。

    代码

    import cv2
    t1 = 0
    t2 = 0
    def Preview(img_path,ts1,ts2):
        img = cv2.imread(img_path)
        img_copy = img.copy()
    
        imgCanny = cv2.Canny(img,ts1,ts2)
    
        g = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
        g2 = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7))
        
        img_dilate = cv2.dilate(imgCanny, g)
        img_dilate2 = cv2.dilate(imgCanny, g2)
    
        shape = img_dilate.shape
        for i in range(shape[0]):
            for j in range(shape[1]):
                if img_dilate2[i,j] == 0:
                    img[i,j] = [0,0,0]
        
        cv2.namedWindow("Preview",cv2.WINDOW_NORMAL)
        cv2.createTrackbar("kerner_size","Preview",0,7,nothing)
        while(1):
            size = cv2.getTrackbarPos("kerner_size","Preview")
            dst = cv2.GaussianBlur(img,(2*size+1,2*size+1),0,0,cv2.BORDER_DEFAULT)
            
            for i in range(shape[0]):
                for j in range(shape[1]):
                    if img_dilate[i,j] != 0:
                        img_copy[i,j] =dst[i,j]
    
            cv2.imshow("Result",img_copy)
            k = cv2.waitKey(1) & 0xff
            if k == 27:
                break
        cv2.destroyAllWindows()
    
    def Choose_Thre(img_path):  
        global t1,t2
        img = cv2.imread(img_path)
        gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    
        cv2.namedWindow("Preview",cv2.WINDOW_NORMAL)
        
        def nothing(WEV):
            pass
        
        cv2.createTrackbar("Threshold1","Preview",0,255,nothing)
        cv2.createTrackbar("Threshold2","Preview",0,255,nothing)
        while(1):
            t1 = cv2.getTrackbarPos("Threshold1","Preview")
            t2 = cv2.getTrackbarPos("Threshold2","Preview")
            detected_edges = cv2.GaussianBlur(gray,(3,3),0)
            detected_edges = cv2.Canny(detected_edges,t1,t2,apertureSize = 3)
            dst = cv2.bitwise_and(img,img,mask = detected_edges) 
            cv2.imshow('Edge',dst)
            k = cv2.waitKey(1)&0xFF
            if k==27:
                break
        cv2.destroyAllWindows()
    
    def nothing(wte):
        pass
    
    #按esc退出 直接关闭无效
    img_path = '1.jpg'
    Choose_Thre(img_path)
    print(t1,t2)
    Preview(img_path,t1,t2)
    
    展开全文
  • 模糊处理算法  均值模糊--------------------------------------------------------------blur()  中值模糊-------------------------椒盐噪声处理效果非常明显--------------------medianBlur()  高斯模糊---...

    模糊处理算法

          均值模糊--------------------------------------------------------------blur()

          中值模糊-------------------------椒盐噪声处理效果非常明显--------------------medianBlur()

          高斯模糊-------------------------产生毛玻璃效果----------------------------------GaussianBlur()

          自定义模糊----------------------图像锐化有明显效果

    边缘保留的模糊处理算法

           高斯双边滤波-----------------效果类似磨皮---------------------------------- ---bilateralFilter()

           均值迁移滤波-----------------磨皮效果经常会过度模糊-------------------------pyrMeanShiftFiltering()

           局部均方差滤波均值迁移滤波(后续补充)

     

    函数参数说明

    均值模糊

    blur( src, ksize [ , dst [ , anchor [ , borderType ]]] )

            src:输入图像;图像可以有任意数量的通道,单独处理,但深度应为cv8u、cv16u、cv16s、cv32f或cv64f。

            ksize:模糊核大小(x,y分别控制不同纬度的模糊程度)

     

    中值模糊

            medianBlur( src, ksize [ , dst ] )

            src:输入1、3或4通道图像;当ksize为3或5时,图像深度应为cv8u、cv16u或cv32f,对于较大的光圈尺寸,只能为cv8u

           Ksize:必须为奇数且大于1,例如:3、5、7....

     

    高斯模糊

          GaussianBlur( src, ksize, sigmaX [ , dst [ , sigmaY [ , borderType ]]] )

          src:输入图像;图像可以有任意数量的通道,单独处理,但深度应为cv8u、cv16u、cv16s、cv32f或cv64f。

         ksize:高斯核大小。ksize.width和ksize.height可以不同,但它们都必须是正数和奇数。或者,它们可以是零,然后根据sigma*计算。

         sigmaX:X方向高斯核标准差(sigmaX和ksize和知道一个就可以推导出另外一个,也就是说设置一个就可以)

     

    自定义模糊

            cv2.filter2D( src, ddepth, kernel [ , dst [ , anchor [ , delta [ , borderType ]]]] )

            src:输入图像

            ddepth:目标图像的所需深度;如果为负,则与src.depth()相同;以下COM

                        –src.depth()=cv8u,ddepth=-1/cv16s/cv32f/cv64f

                       –src.depth()=cv_16u/cv_16s,ddepth=-1/cv_32f/cv_64f

                       –src.depth()=cv32f,ddepth=-1/cv32f/cv64f

                       –src.depth()=cv64f,ddepth=-1/cv64f

                       当ddepth=-1时,输出图像的深度将与源图像的深度相同。

             kernel:卷积核(或更确切地说是相关核),一个单通道浮点矩阵;如果要将不同的核应用于不同的通道,请使用split()将图像分割成单独的颜色平面,并分别处理它们。自定义kernel:可以每一项为奇数;或者和为0或者1,0时用来作边缘梯度,1时作增强.

    高斯双边模糊

           cv2.bilateralFilter( src, d, sigmaColor, sigmaSpace [ , dst [ , borderType ]] )函数定义

           src: 输入8位或浮点、1通道或3通道图像

          d:过滤过程中使用的每个像素邻域的直径。如果它不是正的,它是从sigmaspace计算出来的。(这个值如果打算让函数自己算则设置为0,函数会根据sigmaspace计算出来)

          sigmaColor:过滤颜色空间参数sigma。参数的较大值意味着像素邻域中的更多颜色(请参见sigmaspace)将混合在一起,从而形成较大的半等色区域。(说白了就是把差异更大的颜色看作相似进行运算,这个值可以取得大一些,这样可以把差异小的点模糊掉)

         sigmaSpace:坐标空间中过滤参数sigma。参数的较大值意味着只要像素的颜色足够接近,就有更多的像素会相互影响(颜色相近的前期下有更多的像素点参与运算,该参数影响每次参与运算像素点的个数,请参见sigmacolor)。当d>0时,它指定邻域大小,而不考虑sigmaspace(d>0时d说了算,sigmaspace不起作用)。否则,d与sigmaspace成正比。(取值技巧:取值偏小一些,降低运算量)

    均值迁移滤波

           pyrMeanShiftFiltering( src, sp, sr [ , dst [ , maxLevel [ , termcrit ]]] )

           src:输入8位3通道图像

           sp:空间窗口半径   (取值技巧:偏小降低运算)

           sr:颜色窗口半径   (取值技巧:偏大              )

    # -*- coding=GBK -*-
    #高斯双边 均值迁移 局部均方差  边缘保留滤波算法
    import cv2 as cv
    import numpy as np
    
    
    def blur_image(src1):
        src2 = cv.blur(src1, (5, 5))
        cv.namedWindow("mean blur",cv.WINDOW_AUTOSIZE)
        cv.imshow("mean blur", src2)
    
        src2 = cv.medianBlur(src1, 5)
        cv.namedWindow("median blur",cv.WINDOW_AUTOSIZE)
        cv.imshow("median blur", src2)
    
        src2 = cv.GaussianBlur(src1, (0, 0), 4)
        cv.namedWindow("gaussian blur",cv.WINDOW_AUTOSIZE)
        cv.imshow("gaussian blur", src2)
    
        src2 = cv.bilateralFilter(src1, 0, 150, 10)
        cv.namedWindow("bilatera filter",cv.WINDOW_AUTOSIZE)
        cv.imshow("bilatera filter", src2)
    
        src2 = cv.pyrMeanShiftFiltering(src1,5,10)
        cv.namedWindow("pyrMeanShiftFiltering filter",cv.WINDOW_AUTOSIZE)
        cv.imshow("pyrMeanShiftFiltering filter", src2)
    
    #自定义模糊函数
    def self_define_image(src1):
        kernel1 = np.ones((5, 5), np.float)/25#自定义矩阵,并防止数值溢出
        src2 = cv.filter2D(src1, -1, kernel1)#均值
        cv.imshow("self define mean flur", src2)
        kernel2 = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32)
        src2 = cv.filter2D(src1, -1, kernel2)#锐化
        cv.imshow("self define sharpening", src2)
    
    
    src = cv.imread("/home/xhy/PycharmProjects/materials/demo2.jpeg")
    cv.namedWindow("raw", cv.WINDOW_NORMAL)
    cv.imshow("raw", src)
    blur_image(src)
    self_define_image(src)
    cv.waitKey(0)
    cv.destroyAllWindows()

     

     

     

     

        

        

     

    展开全文
  • OpenCV for Python图像模糊操作1 图像的一些基本知识2 均值模糊、中值模糊、用户自定义模糊3 高斯模糊4 边缘保留滤波EPF5 中值、均值滤波去除高斯、椒盐噪声 Opencv4官方文档:...

    Opencv4 官方文档 : https://docs.opencv.org/4.2.0/
    Opencv4 for Python中文文档点击下载:OpenCV4 for Python 中文文档

    1 图像的一些基本知识

    1. 噪声:主要有三种:
      椒盐噪声(Salt & Pepper):含有随机出现的黑白亮度值。
      脉冲噪声:只含有随机的正脉冲和负脉冲噪声。
      高斯噪声:含有亮度服从高斯或正态分布的噪声。高斯噪声是很多传感器噪声的模型,如摄像机的电子干扰噪声。
    2. 滤波器:主要两类:线性和非线性
      线性滤波器:使用连续窗函数内像素加权和来实现滤波,同一模式的权重因子可以作用在每一个窗口内,即线性滤波器是空间不变的。
      如果图像的不同部分使用不同的滤波权重因子,线性滤波器是空间可变的。因此可以使用卷积模板来实现滤波。
      线性滤波器对去除高斯噪声有很好的效果。常用的线性滤波器有均值滤波器和高斯平滑滤波器。
      (1) 均值滤波器:最简单均值滤波器是局部均值运算,即每一个像素只用其局部邻域内所有值的平均值来置换.
      在这里插入图片描述
      (2) 高斯平滑滤波器是一类根据高斯函数的形状来选择权值的线性滤波器。 高斯平滑滤波器对去除服从正态分布的噪声是很有效的。
      非线性滤波器:
      (1) 中值滤波器:均值滤波和高斯滤波运算主要问题是有可能模糊图像中尖锐不连续的部分。
      中值滤波器的基本思想使用像素点邻域灰度值的中值来代替该像素点的灰度值,它可以去除脉冲噪声、椒盐噪声同时保留图像边缘细节。
      中值滤波不依赖于邻域内与典型值差别很大的值,处理过程不进行加权运算。
      中值滤波在一定条件下可以克服线性滤波器所造成的图像细节模糊,而对滤除脉冲干扰很有效。
      在这里插入图片描述
      (2) 边缘保持滤波器:由于均值滤波:平滑图像外还可能导致图像边缘模糊和中值滤波:去除脉冲噪声的同时可能将图像中的线条细节滤除。
      边缘保持滤波器是在综合考虑了均值滤波器和中值滤波器的优缺点后发展起来的,它的特点是:
      滤波器在除噪声脉冲的同时,又不至于使图像边缘十分模糊。
      过程:分别计算[i,j]的左上角子邻域、左下角子邻域、右上角子邻域、右下角子邻域的灰度分布均匀度V;
      然后取最小均匀度对应区域的均值作为该像素点的新灰度值。分布越均匀,均匀度V值越小。v=<(f(x, y) - f_(x, y))^2

    2 均值模糊、中值模糊、用户自定义模糊

    demo:

    #均值模糊、中值模糊、自定义模糊    模糊是卷积的一种表象
    import cv2 as cv
    import numpy as np
    
    def blur_demo(image):      #均值模糊  去随机噪声有很好的去燥效果
        dst = cv.blur(image, (1, 15))    #(1, 15)是垂直方向模糊,(15, 1)水平方向模糊
        cv.namedWindow('blur_demo', cv.WINDOW_NORMAL)
        cv.imshow("blur_demo", dst)
    
    def median_blur_demo(image):    # 中值模糊  对椒盐噪声有很好的去燥效果
        dst = cv.medianBlur(image, 5)
        cv.namedWindow('median_blur_demo', cv.WINDOW_NORMAL)
        cv.imshow("median_blur_demo", dst)
    
    def custom_blur_demo(image):    # 用户自定义模糊
        kernel = np.ones([5, 5], np.float32)/25   #除以25是防止数值溢出 
        dst = cv.filter2D(image, -1, kernel)
        cv.namedWindow('custom_blur_demo', cv.WINDOW_NORMAL)
        cv.imshow("custom_blur_demo", dst)
    

    result:
    在这里插入图片描述

    3 高斯模糊

    demo:

    #高斯模糊    轮廓还在,保留图像的主要特征  高斯模糊比均值模糊去噪效果好
    import cv2 as cv
    import numpy as np
    def clamp(pv):
        if pv > 255:
            return 255
        if pv < 0:
            return 0
        else:
            return pv
    
    def gaussian_noise(image):        #加高斯噪声
        h, w, c = image.shape
        for row in range(h):
            for col in range(w):
                s = np.random.normal(0, 20, 3)
                b = image[row, col, 0]   #blue
                g = image[row, col, 1]   #green
                r = image[row, col, 2]   #red
                image[row, col, 0] = clamp(b + s[0])
                image[row, col, 1] = clamp(g + s[1])
                image[row, col, 2] = clamp(r + s[2])
        cv.namedWindow("noise image", cv.WINDOW_NORMAL)
        cv.imshow("noise image", image)
        dst = cv.GaussianBlur(image, (15, 15), 0)  # 高斯模糊
        cv.namedWindow("Gaussian", cv.WINDOW_NORMAL)
        cv.imshow("Gaussian", dst)
    gaussian_noise(src)
    dst = cv.GaussianBlur(src, (15,15), 0)
    

    result:
    在这里插入图片描述

    4 边缘保留滤波EPF

    实现方法有高斯双边, 均值迁移,局部均方差
    demo:

    def bi_demo(image):   #双边滤波
        dst = cv.bilateralFilter(image, 0, 100, 15)
        cv.namedWindow("bi_demo", cv.WINDOW_NORMAL)
        cv.imshow("bi_demo", dst)
    
    def shift_demo(image):   #均值迁移
        dst = cv.pyrMeanShiftFiltering(image, 10, 50)
        cv.namedWindow("shift_demo", cv.WINDOW_NORMAL)
        cv.imshow("shift_demo", dst)
    

    result:
    在这里插入图片描述

    5 中值、均值滤波去除高斯、椒盐噪声

    add demo:

    import numpy as np
    from PIL import Image
    import matplotlib.pyplot as plt
    import random
    import scipy.misc
    import scipy.signal
    import scipy.ndimage
    from matplotlib.font_manager import FontProperties
    font_set = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=10)
      
    def medium_filter(im, x, y, step):
      sum_s = []
      for k in range(-int(step / 2), int(step / 2) + 1):
        for m in range(-int(step / 2), int(step / 2) + 1):
          sum_s.append(im[x + k][y + m])
      sum_s.sort()
      return sum_s[(int(step * step / 2) + 1)]
      
      
    def mean_filter(im, x, y, step):
      sum_s = 0
      for k in range(-int(step / 2), int(step / 2) + 1):
        for m in range(-int(step / 2), int(step / 2) + 1):
          sum_s += im[x + k][y + m] / (step * step)
      return sum_s
      
    def convert_2d(r):
      n = 3
      # 3*3 滤波器, 每个系数都是 1/9
      window = np.ones((n, n)) / n ** 2
      # 使用滤波器卷积图像
      # mode = same 表示输出尺寸等于输入尺寸
      # boundary 表示采用对称边界条件处理图像边缘
      s = scipy.signal.convolve2d(r, window, mode='same', boundary='symm')
      return s.astype(np.uint8)
     
    def convert_3d(r):
      s_dsplit = []
      for d in range(r.shape[2]):
        rr = r[:, :, d]
        ss = convert_2d(rr)
        s_dsplit.append(ss)
      s = np.dstack(s_dsplit)
      return s
      
      
    def add_salt_noise(img):
      rows, cols, dims = img.shape
      R = np.mat(img[:, :, 0])
      G = np.mat(img[:, :, 1])
      B = np.mat(img[:, :, 2])
      
      Grey_sp = R * 0.299 + G * 0.587 + B * 0.114
      Grey_gs = R * 0.299 + G * 0.587 + B * 0.114
      
      snr = 0.9
      
      noise_num = int((1 - snr) * rows * cols)
      
      for i in range(noise_num):
        rand_x = random.randint(0, rows - 1)
        rand_y = random.randint(0, cols - 1)
        if random.randint(0, 1) == 0:
          Grey_sp[rand_x, rand_y] = 0
        else:
          Grey_sp[rand_x, rand_y] = 255
      #给图像加入高斯噪声
      Grey_gs = Grey_gs + np.random.normal(0, 48, Grey_gs.shape)
      Grey_gs = Grey_gs - np.full(Grey_gs.shape, np.min(Grey_gs))
      Grey_gs = Grey_gs * 255 / np.max(Grey_gs)
      Grey_gs = Grey_gs.astype(np.uint8)
      
      # 中值滤波
      Grey_sp_mf = scipy.ndimage.median_filter(Grey_sp, (7, 7))
      Grey_gs_mf = scipy.ndimage.median_filter(Grey_gs, (8, 8))
      
      # 均值滤波
      Grey_sp_me = convert_2d(Grey_sp)
      Grey_gs_me = convert_2d(Grey_gs)
      
      plt.subplot(321)
      plt.title('加入椒盐噪声',fontproperties=font_set)
      plt.imshow(Grey_sp, cmap='gray')
      plt.subplot(322)
      plt.title('加入高斯噪声',fontproperties=font_set)
      plt.imshow(Grey_gs, cmap='gray')
      
      plt.subplot(323)
      plt.title('中值滤波去椒盐噪声(8*8)',fontproperties=font_set)
      plt.imshow(Grey_sp_mf, cmap='gray')
      plt.subplot(324)
      plt.title('中值滤波去高斯噪声(8*8)',fontproperties=font_set)
      plt.imshow(Grey_gs_mf, cmap='gray')
      
      plt.subplot(325)
      plt.title('均值滤波去椒盐噪声',fontproperties=font_set)
      plt.imshow(Grey_sp_me, cmap='gray')
      plt.subplot(326)
      plt.title('均值滤波去高斯噪声',fontproperties=font_set)
      plt.imshow(Grey_gs_me, cmap='gray')
      plt.show()
      
    def main():
      img = np.array(Image.open('./files/images/testthree.png'))
      add_salt_noise(img)
       
    if __name__ == '__main__':
      main()
    

    result:

    在这里插入图片描述

    转载请注明转自:https://leejason.blog.csdn.net/article/details/106442435

    展开全文
  • 欢迎关注“小白玩转Python”,发现更多 “有趣”引言在之前的文章中,我们讨论了边缘检测内核。在本文我们将讨论如何在图像上应用模糊与锐化内核,将这些内核应用到彩色图像上,同时保留核心...

    欢迎关注 “小白玩转Python”,发现更多 “有趣”

    引言

    在之前的文章中,我们讨论了边缘检测内核。在本文我们将讨论如何在图像上应用模糊与锐化内核,将这些内核应用到彩色图像上,同时保留核心图像。

    一如既往,我们从导入所需的python库开始。

    import numpy as np
    import matplotlib.pyplot as plt
    from skimage.io import imshow, imread
    from skimage.color import rgb2yuv, rgb2hsv, rgb2gray, yuv2rgb, hsv2rgb
    from scipy.signal import convolve2d
    

    读取本文将使用的图像。

    dog = imread('fire_dog.png')
    plt.figure(num=None, figsize=(8, 6), dpi=80)
    imshow(dog);
    

    现在我们应用于图像的内核是高斯模糊内核和锐化内核。

    # Sharpen
    sharpen = np.array([[0, -1, 0],
                        [-1, 5, -1],
                        [0, -1, 0]])
    # Gaussian Blur
    gaussian = (1 / 16.0) * np.array([[1., 2., 1.],
                                      [2., 4., 2.],
                                      [1., 2., 1.]])
    fig, ax = plt.subplots(1,2, figsize = (17,10))
    ax[0].imshow(sharpen, cmap='gray')
    ax[0].set_title(f'Sharpen', fontsize = 18)
        
    ax[1].imshow(gaussian, cmap='gray')
    ax[1].set_title(f'Gaussian Blur', fontsize = 18)
        
    [axi.set_axis_off() for axi in ax.ravel()];
    

    但我们如何将这些内核应用到我们的图像中呢?那么,让我们直接通过卷积来试试。

    def multi_convolver(image, kernel, iterations):
        for i in range(iterations):
            image = convolve2d(image, kernel, 'same', boundary = 'fill',
                               fillvalue = 0)
        return image
    multi_convolver(dog, gaussian, 2)
    

    很显然,我们出现了维数错误。当我们将一个矩阵与另一个矩阵卷积时,它们的维数应该是相同的。因此,我们必须先将图像转化为灰度。

    dog_grey = rgb2gray(dog)
    plt.figure(num=None, figsize=(8, 6), dpi=80)
    imshow(dog_grey);
    

    现在我们可以运行上面的卷积函数并得到预期的效果。

    convolved_image = multi_convolver(dog_grey, gaussian, 2)
    plt.figure(num=None, figsize=(8, 6), dpi=80)
    imshow(convolved_image);
    

    我们可以清楚的看到,图像已经模糊了。下面的代码将告诉我们如果继续运行高斯模糊卷积图像会发生什么。

    def convolution_plotter(image, kernel):
        iterations = [1,10,20,30]
        f_size = 20
        
        fig, ax = plt.subplots(1,4, figsize = (15,7))
        for n, ax in enumerate(ax.flatten()):
            ax.set_title(f'Iteration : {iterations[n]}', fontsize =
                         f_size)
            ax.imshow(multi_convolver(image, kernel, iterations[n]), 
                      cmap='gray')
            ax.set_axis_off()
        fig.tight_layout()
        
    convolution_plotter(dog_grey, gaussian)
    

    可以看到图像变得越来越模糊了。

    如果需要使图像模糊并保留颜色怎么办?让我们首先尝试对每个颜色通道应用卷积。

    def convolver_rgb(image, kernel, iterations = 1):
        convolved_image_r = multi_convolver(image[:,:,0], kernel,
                                            iterations)
        convolved_image_g = multi_convolver(image[:,:,1], kernel, 
                                            iterations)
        convolved_image_b  = multi_convolver(image[:,:,2], kernel, 
                                             iterations)
        
        reformed_image = np.dstack((np.rint(abs(convolved_image_r)), 
                                    np.rint(abs(convolved_image_g)), 
                                    np.rint(abs(convolved_image_b)))) / 
                                    255
       
                                   
                         
        fig, ax = plt.subplots(1,3, figsize = (17,10))
        
        ax[0].imshow(abs(convolved_image_r), cmap='Reds')
        ax[0].set_title(f'Red', fontsize = 15)
        
        ax[1].imshow(abs(convolved_image_g), cmap='Greens')
        ax[1].set_title(f'Green', fontsize = 15)
        
        ax[2].imshow(abs(convolved_image_b), cmap='Blues')
        ax[2].set_title(f'Blue', fontsize = 15)
        
        [axi.set_axis_off() for axi in ax.ravel()]
        
        return np.array(reformed_image).astype(np.uint8)
    convolved_rgb_gauss = convolver_rgb(dog, gaussian, 2)
    

    上面这个函数实际上将给我们返回重新生成的图像,我们只需要将其插入到imshow函数中即可。

    plt.figure(num=None, figsize=(8, 6), dpi=80)
    imshow(convolved_rgb_gauss);
    

    让我们看看卷积十次后图像会变成什么样。

    现在让我们尝试下更换锐化内核会发生什么。

    convolved_rgb_sharpen = convolver_rgb(dog, sharpen, 1)
    

    处理后的图像有一些轻微的扭曲,为什么会这样呢?

    请记住,RGB颜色空间隐式地将像素的光照与颜色混合。这意味着在不改变颜色的情况下对图像的光照应用卷积几乎是不可能的。那么我们如何处理这个问题呢?

    解决此问题的一种方法是更改图像的色彩空间。除了使用RGB颜色空间外,我们还可以使用YUV颜色空间。因为YUV空间中的光照通道实际上是与颜色分开的。

    现在我们编写一个函数,它首先将图像转换为YUV色彩空间,然后对图像进行卷积。

    def convolver_rgb(image, kernel, iterations = 1):
        img_yuv = rgb2yuv(image)   
        img_yuv[:,:,0] = multi_convolver(img_yuv[:,:,0], kernel, 
                                         iterations)
        final_image = yuv2rgb(img_yuv)
                                   
        fig, ax = plt.subplots(1,2, figsize = (17,10))
        
        ax[0].imshow(image)
        ax[0].set_title(f'Original', fontsize = 20)
        
        ax[1].imshow(final_image);
        ax[1].set_title(f'YUV Adjusted, Iterations = {iterations}', 
                        fontsize = 20)
        
        [axi.set_axis_off() for axi in ax.ravel()]
        
        fig.tight_layout()
        
        return final_image
    final_image = convolver_rgb(dog, sharpen, iterations = 1)
    

    现在可以看到,处理后的图像是明显锐化且没有任何颜色扭曲的。还有许多其他的方法来解决这个问题,YUV转换只是其中之一,我们还可以使用HSV来解决这个问题。

    def convolver_comparison(image, kernel, iterations = 1):
        img_yuv = rgb2yuv(image)   
        img_yuv[:,:,0] = multi_convolver(img_yuv[:,:,0], kernel, 
                          iterations)
        final_image_yuv = yuv2rgb(img_yuv)
        
        img_hsv = rgb2hsv(image)   
        img_hsv[:,:,2] = multi_convolver(img_hsv[:,:,2], kernel, 
                          iterations)
        final_image_hsv = hsv2rgb(img_hsv)
        
        
        
        convolved_image_r = multi_convolver(image[:,:,0], kernel, 
                             iterations)
        convolved_image_g = multi_convolver(image[:,:,1], kernel, 
                             iterations)
        convolved_image_b  = multi_convolver(image[:,:,2], kernel,
                             iterations)
        
        final_image_rgb = np.dstack((np.rint(abs(convolved_image_r)), 
                                     np.rint(abs(convolved_image_g)), 
                                     np.rint(abs(convolved_image_b)))) / 
                                     255
                                   
        fig, ax = plt.subplots(2,2, figsize = (17,17))
        
        ax[0][0].imshow(image)
        ax[0][0].set_title(f'Original', fontsize = 30)
        
        ax[0][1].imshow(final_image_rgb);
        ax[0][1].set_title(f'RGB Adjusted, Iterations = {iterations}', 
                           fontsize = 30)
        fig.tight_layout()
        
        ax[1][0].imshow(final_image_yuv)
        ax[1][0].set_title(f'YUV Adjusted, Iterations = {iterations}', 
                           fontsize = 30)
        
        ax[1][1].imshow(final_image_hsv)
        ax[1][1].set_title(f'HSV Adjusted, Iterations = {iterations}', 
                           fontsize = 30)
        
        [axi.set_axis_off() for axi in ax.ravel()]
        
        fig.tight_layout()
    convolver_comparison(dog, sharpen, iterations = 1)
    

    我们看到,与原始RGB方法相比,HSV和YUV有了一些改进。为了更好地说明,我们可以将迭代次数从1增加到2。

    在2次迭代后,失真变得更加明显。但是也很清楚,HSV和Y'UV调整后的图像比原始RGB调整后的图像要好得多。在选择将卷积内核应用于图像的最佳方法时,应当牢记这些特性。

    总结

    在本文中,我们已经学会了如何对图像进行模糊和锐化卷积。这些技术对于任何从事图像处理和计算机视觉领域的人员都是至关重要的。非常重要的是,我们了解到,简单地将卷积应用到各个RGB通道可能不是最好的方法。在处理图像时,我们应该始终意识到有大量不同类型的色彩空间可以使用。

    ·  END  ·

    HAPPY LIFE

    展开全文
  • 提供一种提取图像边缘的快速算法 更多提取图像边缘的方法: 最大-最小滤波器实现图像边缘提取 Prewitt滤波器和Sobel滤波器提取图像边缘 拉普拉斯滤波器提取图像边缘 差分金字塔提取图像边缘算法: 将原图像先缩小2...
  • 同样,缺点也很明显,计算均值会将图像中的边缘信息以及特征信息“模糊”掉,会丢失很多特征。 均值滤波使用简单的卷积方案来实现,既然是计算窗口区域中的像素和,即使用如下卷积核即可。图像的边界部分采用...
  • Python与opencv图像处理基础总结。1. ROI操作与泛洪填充 2. 均值模糊、中值模糊、自定义模糊 3. 高斯模糊的实现 4. 边缘保留滤波EPF,包括高斯双边滤波和均值迁移滤波。
  • 这将导致原始图像在平滑处理之后,图像边缘和图像轮廓模糊的情况出现。为了减少这类不利效果的影响,就需要利用图像锐化技术,使图像的边缘变得清晰。 一、Roberts算子 Roberts算子又称交叉微分算法,它是基于交叉...
  • 两年的研究僧图像处理经验告诉我,微分锐化,积分平滑,至于为什么,仔细想想微分和积分的曲线图就知道了。 拉普拉斯算子是二阶微分,由于图像是坐标系中离散的点,微分方程如下: 对应的算子矩阵如下: 那就...
  • Python 使用cv2.canny 进行图像边缘检测

    千次阅读 2020-12-16 10:01:41
    CV2提供了提取图像边缘的函数canny。其算法思想如下: 1. 使用高斯模糊,去除噪音点(cv2.GaussianBlur) 2. 灰度转换(cv2.cvtColor) 3. 使用sobel算子,计算出每个点的梯度大小和梯度方向 4. 使用非极大值...
  • python下openCV学习笔记(二)图像灰度转化,模糊化,边缘检测,膨胀与腐蚀一、图像的灰度化二、图像模糊化三、图像边缘检测四、图像的膨胀与腐蚀 一、图像的灰度化 很多时候我们在进行图像处理的时候,需要...
  • OpenCV-Python 图像平滑 | 十六

    千次阅读 2019-12-18 15:50:51
    目标 学会: 使用各种低通滤镜模糊图像 ...HPF滤波器有助于在图像中找到边缘。 OpenCV提供了一个函数cv.filter2D来将内核与图像进行卷积。例如,我们将尝试对图像进行平均滤波。5x5平均滤波器内核如...
  • 3.计算图像梯度 根据梯度计算 图像边缘幅值与角度 4.非最大信号压制处理 在获得梯度的方向和大小之后,应该对整幅图像做一个扫描,去除那些非边界上的点。 对每一个像素进行检查,看这个点的梯度是不是周围具有...
  • 图像平滑实际上是低通滤波,平滑过程会导致图像边缘模糊化。 图像平滑是指用于突出图像的宽大区域、低频成分、主干部分或抑制图像噪声和干扰高频成分的图像处理方法,目的是使图像亮度平缓渐变,减小突变梯度,改善...
  • HPF滤波器有助于在图像中找到边缘。 OpenCV提供了一个函数cv.filter2D来将内核与图像进行卷积。例如,我们将尝试对图像进行平均滤波。5x5平均滤波器内核如下所示: K = \frac{1}{25} \begin{bmatrix} 1 &am
  • Python Plot图片模糊解决办法

    千次阅读 2019-07-26 20:05:14
    我们日常采用Python plot出图时候可能经常出现图中文字模糊或者图像曲线边缘不清晰的问题。 解决办法: plt.savefig('fix.jpg', dpi=300) #指定分辨率保存 ...
  • 与一维信号一样,图像也可以使用各种低通滤波器(LPF),高通滤波器(HPF)等进行滤波.LPF有助于消除噪声,模糊图像等.HPF滤波器有助于找到边缘图片. cv.filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 211
精华内容 84
关键字:

python图像边缘模糊

python 订阅