精华内容
下载资源
问答
  • 自适应中值滤波算法 参考文献:Chan R H, Ho C W, Nikolova M. Salt-and-pepper noise removal by median-type noise detectors and detail-preserving regularization[J]. IEEE Trans. Image Process, 2005, 14(10)...
  • 像素点按一定的规律自适应地分组并赋予每组像素点相应的权重,最后采用加权中值滤波算法对检测出的噪声点进行滤波处理。 计算机模拟实验结果表明:该算法既能有效地滤除噪声,又能较好地保护图像细节,滤波性能比...
  • 用于图像去除噪声的自适应中值滤波算法,能够有效的去除图像中的噪声达到图像复原的效果,对于学习图像复原和图像处理有很大的帮助
  • 此处采用改进的自适应中值滤波算法进行图像恢复: 根据图像处理的空间相关性原则,采用自适应的方法选择不同的滑动窗口大小; 在算法中单滤波窗口大小达到最大值时,采用均值滤波; def get_window(res_img,noise

    完整代码可以在 我的AI学习笔记 - github 中获取

    原理

    传统的中值滤波算法在椒盐噪声的去除领域有着比较广泛的应用,其具有较强的噪点鉴别和恢复能力,也有比较低的时间复杂度:其基本思想是采用像素点周围邻接的若干像素点的中值来代替被污染的像素点;但也存在一定的缺陷,随着图像被污染程度的加深,此方法恢复的图像细节模糊、边缘损失也会越严重。

    中值滤波的思想就是比较一定领域内的像素值的大小,取出其中值作为这个领域的中心像素新的值。假设对一定领域内的所有像素从小到大进行排序,如果存在孤立的噪声点,比如椒盐噪声(椒噪声——较小的灰度值,呈现的效果是小黑点;盐噪声——较大的灰度值,呈现的效果是小白点),那么从小到大排序的这个数组中,那些孤立的噪声一定会分布在两边(要么很小,要么很大),这样子取出的中值点可以很好地保留像素信息,而滤除了噪声点的影响。
    中值滤波器受滤波窗口大小影响较大,用于消除噪声和保护图像细节,两者会存在冲突。如果窗口较小,则能较好地保护图像中的一些细节信息,但对噪声的过滤效果就会打折扣;反之,如果窗口尺寸较大则会有较好的噪声过滤效果,但也会对图像造成一定的模糊效果,从而丢失一部分细节信息。

    此处采用改进的自适应中值滤波算法进行图像恢复:

    1. 根据图像处理的空间相关性原则,采用自适应的方法选择不同的滑动窗口大小;
      在这里插入图片描述
    2. 在算法中单滤波窗口大小达到最大值时,采用均值滤波;

    代码实现

    def get_window(res_img,noise_mask,sc,i,j,k):
        listx = []
                     
        if i-sc >= 0:
            starti = i-sc 
        else:
            starti = 0
        if j+1 <= res_img.shape[1]-1 and noise_mask[0,j+1,k] !=0:
            listx.append(res_img[0,j+1,k])
        if j-1 >=0 and noise_mask[0,j-1,k] !=0:
            listx.append(res_img[0,j-1,k])
                        
        if i+sc <= res_img.shape[0]-1:
            endi = i+sc
        else:
            endi = res_img.shape[0]-1
        if j+1 <= res_img.shape[1]-1 and noise_mask[endi,j+1,k] !=0:
            listx.append(res_img[endi,j+1,k])
        if j-1 >=0 and noise_mask[endi,j-1,k] !=0:
            listx.append(res_img[endi,j-1,k])
                            
        if j+sc <= res_img.shape[1]-1:
            endj = j+sc
        else:
            endj = res_img.shape[1]-1
        if i+1 <= res_img.shape[0]-1 and noise_mask[i+1,endj,k] !=0:
            listx.append(res_img[i+1,endj,k])
        if i-1 >=0 and noise_mask[i-1,endj,k] !=0:
            listx.append(res_img[i-1,endj,k])
                        
        if j-sc >= 0:
            startj = j-sc
        else:
            startj = 0
        if i+1 <= res_img.shape[0]-1 and noise_mask[i+1,0,k] !=0:
            listx.append(res_img[i+1,0,k])
        if i-1 >=0 and noise_mask[i-1,0,k] !=0:
            listx.append(res_img[i-1,0,k])
                                            
        for m in range(starti,endi+1):
            for n in range(startj,endj+1):
                if noise_mask[m,n,k] != 0:
                    listx.append(res_img[m,n,k])
        listx.sort()
        return listx
    
    def get_window_small(res_img,noise_mask,i,j,k):
        listx = []
        sc = 1             
        if i-sc >= 0 and noise_mask[i-1,j,k]!=0:
            listx.append(res_img[i-1,j,k])
    
        if i+sc <= res_img.shape[0]-1 and noise_mask[i+1,j,k]!=0:
            listx.append(res_img[i+1,j,k])
                            
        if j+sc <= res_img.shape[1]-1 and noise_mask[i,j+1,k]!=0:
            listx.append(res_img[i,j+1,k])
                        
        if j-sc >= 0 and noise_mask[i,j-1,k]!=0:
            listx.append(res_img[i,j-1,k])
        listx.sort()
        return listx
    
    def restore_image(noise_img, size=4):
        """
        使用 你最擅长的算法模型 进行图像恢复。
        :param noise_img: 一个受损的图像
        :param size: 输入区域半径,长宽是以 size*size 方形区域获取区域, 默认是 4
        :return: res_img 恢复后的图片,图像矩阵值 0-1 之间,数据类型为 np.array,
                数据类型对象 (dtype): np.double, 图像形状:(height,width,channel), 通道(channel) 顺序为RGB
        """
        # 恢复图片初始化,首先 copy 受损图片,然后预测噪声点的坐标后作为返回值。
        res_img = np.copy(noise_img)
    
        # 获取噪声图像
        noise_mask = get_noise_mask(noise_img)
    
        for i in range(noise_mask.shape[0]):
            for j in range(noise_mask.shape[1]):
                for k in range(noise_mask.shape[2]):
                    if noise_mask[i,j,k] == 0:
                        sc = 1
                        listx = get_window_small(res_img,noise_mask,i,j,k)
                        if len(listx) != 0:
                            res_img[i,j,k] = listx[len(listx)//2]
                        else:
                            while(len(listx) == 0):
                                listx = get_window(res_img,noise_mask,sc,i,j,k)
                                sc = sc+1
                            if sc > 4:
                                res_img[i,j,k] = np.mean(listx)
                            else:
                                res_img[i,j,k] = listx[len(listx)//2]
    
        return res_img
    
    

    恢复效果:

    原始图片
    在这里插入图片描述
    添加噪点
    在这里插入图片描述
    恢复后
    在这里插入图片描述

    展开全文
  • 自适应中值滤波算法有两个处理层次: **层次A:**若zmin<zmed<zmax,则转移到层次B; 否则,增Sxy尺 寸, 若Sxy<Smax,则重复层次A;否则,输出zmed。 **层次B:**若zmin<zxy<zmax,则输出zxy;否则...


    一、实现方法

    自适应中值滤波算法有两个处理层次:
    **层次A:**若zmin<zmed<zmax,则转移到层次B;
    否则,增Sxy尺 寸,
    若Sxy<Smax,则重复层次A;否则,输出zmed。
    **层次B:**若zmin<zxy<zmax,则输出zxy;否则,输出zmed。
    既然是中值滤波,那处理椒盐这类冲激噪声肯定比较合适,自适应中值滤波能在有效去除冲激噪声的基础上,平滑其他非冲激噪声,减少失真,保留图像细节,而对于同等大小的中值滤波器,则会损失较多的细节。原理性内容书中有详细的介绍~
    运行环境:Python+anaconda
    直接上代码(因为是逐个像素操作,所以运行有点慢)


    二、代码

    # -*- coding:utf-8 -*-
    """
    作者:YJH
    日期:20211019"""
    import matplotlib.pyplot as plt
    import cv2 as cv
    import numpy as np
    # from functools import reduce               # 导入reduce,将一个函数作用在一个序列上,并且序列内容自动累计
    
    # 显示汉字
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    
    # 定义坐标数字字体及大小
    def label_def():
        plt.xticks(fontproperties='Times New Roman', size=8)
        plt.yticks(fontproperties='Times New Roman', size=8)
    
    
    # 读取图片
    img_saltpep = cv.imread('ckt_saltpep_prob_pt25.tif', 0)               # 灰度图,噪声密度50%
    
    
    def auto_median_filter(image, max_size):
        origen = 3                                                        # 初始窗口大小
        board = origen//3                                                 # 初始应扩充的边界
        # max_board = max_size//2                                         # 最大可扩充的边界
        copy = cv.copyMakeBorder(image, *[board]*4, borderType=cv.BORDER_DEFAULT)         # 扩充边界
        out_img = np.zeros(image.shape)
        for i in range(image.shape[0]):
            for j in range(image.shape[1]):
                def sub_func(src, size):                         # 两个层次的子函数
                    kernel = src[i:i+size, j:j+size]
                    # print(kernel)
                    z_med = np.median(kernel)
                    z_max = np.max(kernel)
                    z_min = np.min(kernel)
                    if z_min < z_med < z_max:                                 # 层次A
                        if z_min < image[i][j] < z_max:                       # 层次B
                            return image[i][j]
                        else:
                            return z_med
                    else:
                        next_size = cv.copyMakeBorder(src, *[1]*4, borderType=cv.BORDER_DEFAULT)   # 增尺寸
                        size = size+2                                        # 奇数的核找中值才准确
                        if size <= max_size:
                            return sub_func(next_size, size)     # 重复层次A
                        else:
                            return z_med
                out_img[i][j] = sub_func(copy, origen)
        return out_img
    
    
    if __name__ == '__main__':                                       # 运行当前函数
    
        img_auto_filter = auto_median_filter(img_saltpep, 7)
        img_median = cv.medianBlur(img_saltpep, 7)
        # img_re_median = cv.medianBlur(img_auto_filter, 3)                           # 两次3x3的中值滤波效果才能差不多
        plt.subplot(131), plt.imshow(img_saltpep, "gray"), plt.title('椒盐噪声密度50%', fontsize='small'), label_def()
        plt.subplot(132), plt.imshow(img_auto_filter, "gray"), plt.title('自适应中值滤波', fontsize='small'), label_def()
        plt.subplot(133), plt.imshow(img_median, "gray"), plt.title('中值滤波', fontsize='small'), label_def()
        # plt.subplot(144), plt.imshow(img_re_median, "gray"), plt.title('再中值滤波', fontsize='small'), label_def()
    
        plt.show()
    

    运行结果

    在这里插入图片描述
    效果还是挺好的
    目前正在学习中,欢迎大家批评指正~

    展开全文
  • 自适应中值滤波器的python实现

    千次阅读 2019-10-23 09:57:16
    自适应中值滤波器的python实现@TOC 欢迎使用Markdown编辑器 具体原理可参照https://www.cnblogs.com/wangguchangqing/p/6379646.html,下面是用python版的opencv实现的自适应中值滤波器的代码: ''' 自适应中值...

    自适应中值滤波器的python实现

    具体原理可参照https://www.cnblogs.com/wangguchangqing/p/6379646.html,下面是用python版的opencv实现的自适应中值滤波器的代码:

    '''   自适应中值滤波器的python实现   '''
    def AdaptProcess(src, i, j, minSize, maxSize):
    
        filter_size = minSize
    
        kernelSize = filter_size // 2
        rio = src[i-kernelSize:i+kernelSize+1, j-kernelSize:j+kernelSize+1]
        minPix = np.min(rio)
        maxPix = np.max(rio)
        medPix = np.median(rio)
        zxy = src[i,j]
    
        if (medPix > minPix) and (medPix < maxPix):
            if (zxy > minPix) and (zxy < maxPix):
                return zxy
            else:
                return medPix
        else:
            filter_size = filter_size + 2
            if filter_size <= maxSize:
                return AdaptProcess(src, i, j, filter_size, maxSize)
            else:
                return medPix
    
    
    def adapt_meadian_filter(img, minsize, maxsize):
    
        borderSize = maxsize // 2
    
        src = cv2.copyMakeBorder(img, borderSize, borderSize, borderSize, borderSize, cv2.BORDER_REFLECT)
    
        for m in range(borderSize, src.shape[0] - borderSize):
            for n in range(borderSize, src.shape[1] - borderSize):
                src[m,n] = AdaptProcess(src, m, n, minsize, maxsize)
    
        dst = src[borderSize:borderSize+img.shape[0], borderSize:borderSize+img.shape[1]]
        return dst
    
    
    
    
    展开全文
  • 自适应中值滤波算法

    2014-08-30 10:41:15
    基于阈值判断的自适应中值滤波算法,视频跟踪,图像处理
  • 自适应中值滤波器 对于7.3.2节所讨论的中值滤波器,只要脉冲噪声的空间密度不大,性能还是可以的(根据经验需Pa和Pb小于0.2)。本节将证明,自适应中值滤波器可以处理更大概率的脉冲噪声。自适应中值滤波器的另一个...

     7.3.3 自适应滤波器

    自适应中值滤波器

    对于7.3.2节所讨论的中值滤波器,只要脉冲噪声的空间密度不大,性能还是可以的(根据经验需Pa和Pb小于0.2)。本节将证明,自适应中值滤波器可以处理更大概率的脉冲噪声。自适应中值滤波器的另一个优点是平滑非脉冲噪声时,试图保留细节,这是传统中值滤波器所做不到的。正如前面几节中所讨论的所有滤波器一样,自适应中值滤波器也工作于矩形窗口区域Sxy然而与这些滤波器不同的是自适应中值滤波器在进行滤波处理时会根据本节列举的某些条件而改变增大或缩小)Sxy的尺寸记住滤波器的输出是一个单值该值用于替代点(x,y)处的像素值,位于(x,y)处的是Sxy的中心也是它的锚点

     

    考虑如下符号:

    Zmin=Sxy中的最小灰度值

    Zmax=Sxy中的最大灰度值

    Zmed=Sxy中的中值;

    Zxy=坐标(x,y)处的灰度值

    Smax=Sxy允许的最大尺寸(在程序中,用kernal_size表示)

    自适应中值滤波算法以两个进程工作,分别为进程AB,如下所示:

    进程A:

         如果Zmin<Zmed<Zmax,则转到进程B
         否则增大窗口尺寸;
         增大后的窗口尺寸(程序中用ks表示),
         如果ks<Smax,则重复A。(在程序中,kernal_size即Smax)
         否则输出Zmed

    进程B:

         如果Zmin<Zxy<Zmax,则输出Zxy
         否则,输出Zmed.

     

        该算法的设计意图是要实现3个目的:①去除椒盐噪声;②平滑其它非脉冲噪声;③减少物体边界细化或粗化的失真。Zmin和Zmax在算法统计上认为是类脉冲噪声分量,既使它们不是图像中的最大值或最小值。

        进程A的目的是确定中值滤波器的输出Zmed,是否是一个脉冲黑或白)。如果条件Zmin<Zmed<Zmax有效则根据前节提到的原因,Zmed不可能是脉冲这种情况下转到进程B,检验窗口Sxy的中心点Zxy(即锚点)是否是一个脉冲如果满足条件就不是脉冲原因与前同这时算法输出一个未修改的像素值Zxy通过不修改这些中间灰度级的点减少图像中的失真。如果Zmin<Zxy<Zmax为假则Zxy=Zmin或Zxy=Zmax在任何一种情况下像素值都是一个极端值且算法输出中值Zmed,从进程A可知Zmed不是脉冲噪声最后一步是执行标准的中值滤波问题是标准中值滤波器使用图像中相应邻域的中值代替图像中的每一点这会引起不必要的细节损失

        继续上面的说明,假设进程A确实找到了一个脉冲(若不是,则转到进程B),算法会增大窗口尺寸,并重复进程A。该循环会一直继续,直到算法找到一个非脉冲的中值,并转到进程B。如果循环中窗口达到了最大尺寸,则算法会返回值Zmed。注意,这并不能保证该值不是脉冲。噪声的概率Pa或Pb越小,或者在Sxy允许的范围内越大,退出条件也就越难满足。这是合理的,随着脉冲密度的增大,我们会需要更大的窗口来消除尖峰噪声。

    算法没输出一个值,窗口Sxy就被移动到图像中的下一个位置。然后,算法重新初始化并应用到新位置的像素。仅使用新像素就可以反复更新中值,因而减少了计算开销。

     

     

     

    #include <iostream>
    #include <opencv2/opencv.hpp>
    #include <vector>
    #include <algorithm>
    using namespace cv;
    using namespace std;
    //下面的宏,定义了在矩阵src的第m行、n列,ks*ks覆盖的矩形区域内的像素,并将像素压到矢量v中
    //该覆盖区域的左上角坐标为(m,n),宽为ks,高为ks,要求src必须是单通道,数据类型为CV_8UC1
    #define CV_ROI_ELEM(src,vector,m,n,ks)  \
    {                                      \
        uchar* kn;                         \
        int st0=src.step[0];\
        int st1=src.step[1];\
        for(int k=0;k<(ks);k++)            \
        {                                  \
            for(int s=0;s<(ks);s++)        \
            {                              \
                kn =src.data+(k+m)*st0+(s+n)*st1;   \
                vector.push_back(*kn);              \
            }                                       \
        }                                           \
    }
    
    #define CV_MAT_ELEM2(src,dtype,y,x) \
        (dtype*)(src.data+src.step[0]*(y)+src.step[1]*(x))
    /*********************自适应中值滤波********************************/
    void selfAdaptiveMedianBlur(Mat&src,Mat&dst,int kernal_size)
    {
        CV_Assert(src.type()==CV_8UC1||src.type()==CV_8U);
        if(dst.empty())
        {
            dst.create(src.rows,src.cols,CV_8UC1);
        }
        uchar* pdst=dst.data;
        uchar Zmin,Zmax,Zmed,Zxy;
        int step0=src.step[0];
        int step1=src.step[1];
        for(int i=kernal_size/2;i<src.rows-kernal_size/2;i++)
        {
            for(int j=kernal_size/2;j<src.cols-kernal_size/2;j++)
            {
                int ks=3;//kernal_size;
                int count=0;
                Zxy=*CV_MAT_ELEM2(src,uchar,i,j);//Sxy覆盖区域的中心点像素值,即锚点像素值
                vector<uchar> v;//将模板覆盖区域的像素,压入矢量v中
                do{
                    if(cout==0)
                    {//获取模板ks*ks覆盖区域的像素,压入矢量v中
                        CV_ROI_ELEM(src,v,i-ks/2,j-ks/2,ks);
                    }
                   else
                    {
                   /****************下面的for循环,将外扩的四个边的像素添加到v中**************/
                        uchar* p=src.data+(i-ks/2)*step0+(j-ks/2)*step1;
                        for(int u=0;u<ks;u++)
                        {
                            v.push_back(*(p+u*step1));//向外扩展的四个边的上边
                            v.push_back(*(p+(ks-1)*step0+u*step1));//向外扩展的四个边的下边
                            if(u!=0&&u!=ks-1)
                            {
                              v.push_back( *(p+u*step0));//向外扩展的四个边的左边
                              v.push_back(*(p+u*step0+(ks-1)*step1));//向外扩展的四个边的右边
                            }
                        }
                    }
    
                    //对v的元素排序
                    //排序后,Sxy覆盖区域内,最大值为Zmax=v[v.size-1],最小值为Zmin=v[0]
                    std::sort(v.begin(),v.end());
                    Zmin=v[0],Zmax=v[v.size()-1],Zmed=v[ks*ks/2];
                    pdst =CV_MAT_ELEM2(dst,uchar,i,j);
                    if(Zmin<Zmed&&Zmed<Zmax)
                    {
                        if(Zmin<Zxy&&Zxy<Zmax)
                            {*pdst=Zxy;break;}
                        else
                            {*pdst=Zmed;break;}
                    }
                    else
                    {
                        ks +=2;
                    }
                    count++;
                }while(ks<=kernal_size);
    
                *pdst=Zmed;
            }
        }
    }
    
    
    int main()
    {
        Mat src=imread("D:\\Qt\\MyImage\\3.bmp",0);
        imshow("src image",src);
    
        Mat dst;
        selfAdaptiveMedianBlur(src,dst,7);
    
        imshow("adaptive median filter",dst);
    
        waitKey();
    
        return 0;
    }

     

     

    原图像:

    自适应中值滤波后的图像:

     

    转载于:https://www.cnblogs.com/phoenixdsg/p/7011099.html

    展开全文
  • 自适应中值滤波及实现

    万次阅读 多人点赞 2018-04-01 21:04:17
    主要就是提出了一种自适应中值滤波算法,这个算法是很经典的中值滤波算法的改进版本,自动选择滤波器的大小,以追求更好的效果。原理十分简单,后面都尽量简短地进行说明。 中值滤波器(Median Filter) 中值滤波...
  • 首先椒盐噪声是很简单的一种噪声,椒噪声(黑点)灰度为0,盐噪声(白点)灰度为255,去除椒盐噪声比较有效的方法是采用中值滤波,但是,在噪声密度较大时,标准中值滤波(SMF)的效果就不太好了,因为SMF采用3*3...
  • 要求是:自适应中值滤波器和自适应均值滤波器的设计,分别使用python和matlab去实现 一.原理 1.自适应中值滤波器
  • 自适应中值滤波

    2011-11-09 20:53:18
    自己编写的matlab自适应中值滤波函数
  • 基于matlab的医学图像降噪,非常适合医学图像的处理,可以用于医学图像的预处理
  • 自适应中值滤波 1、前言 中值滤波器是一种常用的非线性滤波器,其基本原理是选择待处理像素的一个邻域中各像素值的中值来代替待处理的像素,其主要功能是像素的灰度值与周围像素比较接近,从而消除孤立的噪声点,...
  • 自适应中值滤波器(基于OpenCV实现)

    千次阅读 2018-03-06 10:03:22
    转自:http://blog.csdn.net/brookicv/article/details/54931857本文主要介绍了自适应中值滤波器,并基于OpenCV实现了该滤波器,并且将自适应中值滤波器和常规的中值滤波器对不同概率的椒盐噪声的过滤效果进行了...
  • RGB彩色图像中值滤波(非调用) 3x3矩形框中值滤波代码 // An highlighted block import cv2 import numpy as np import copy image_data = cv2.imread('noise.png') # 使用3*3的矩形框取值 for n in range(1,image...
  • 内容简介自适应滤波器自适应局部降低噪声滤波自适应中值滤波 自适应滤波器 自适应局部降低噪声滤波 自适应中值滤波
  • 按老规矩,先给简要说明,然后上MATLAB,c++和Python的代码。图像的噪声不管是模拟信号还是数字信号,都难免会产生噪声,尤其是模拟信号,噪声处理一直是比较重要的环节,数字信号相对来说噪声会少一点。图像噪声的...
  • 本文主要介绍了自适应中值滤波器,并基于OpenCV实现了该滤波器,并且将自适应中值滤波器和常规的中值滤波器对不同概率的椒盐噪声的过滤效果进行了对比。最后,对中值滤波器的优缺点了进行了总结。 空间滤波器 一...
  • 中值滤波-多通道

    2021-10-07 10:40:55
    对RGB图片进行滤波,因为RGB是三维数组,类型为HWC,所以本文仅采用numpy、PIL库对图片进行中值滤波。 首先,RGB图片转换成np.array。 #导入相应的库 from PIL import Image import numpy as np image = Image.open...
  • 标题自适应滤波器自适应局部降噪滤波器自适应中值滤波器 自适应滤波器 自适应局部降噪滤波器 均值是计算平均值的区域上的平均灰度,方差是该区域上的图像对比度 g(x,y)g(x, y)g(x,y)噪声图像在(x,y)(x, y)(x,y)处的...
  • 一.自适应局部降噪滤波器 1.原理 ...%局部均值u=(1/mn)*∑g(x,y)模板滤波,重叠区相*然后相加 localMean=filter2(ones(nhood),g)/prod(nhood); %局部方差σ^2=(1/mn)*∑g^2(x,y)-u^2 lo...
  • 本章主要分为两大内容: 第一,针对只存在噪声影响下的图像复原; 第二,针对存在退化函数和噪声的两种作用下的图像复原; 5.1图像复原的概念以及模型 1、概念 与图像增强类似,图像复原的目的也是改善给定的图像,...
  • python+OpenCV图像处理(六)图像平滑与滤波

    万次阅读 多人点赞 2018-07-29 22:29:30
    图像平滑与滤波 运用它,首先就要了解它,什么是平滑滤波?  平滑滤波是低频增强的空间域滤波技术。它的目的有两类:一类是模糊;另一类是消除噪音。空间域的平滑滤波一般采用简单平均法进行,就是求邻近像元点的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 640
精华内容 256
关键字:

自适应中值滤波python

python 订阅