非线性滤波

妖狐艹你老母 2022-06-17 07:19 267阅读 0赞

非线性滤波：中值滤波，双边滤波

线性滤波：两个信号之和的响应和它们各自响应之和相等（即每个像素的输出值是一些输入像素的加权和）。

非线性滤波：

中值滤波：用像素点领域灰度值的中值来代替该像素点的灰度值，该方法在去除脉冲噪声，椒盐噪声的同时又能保留图像的边缘细节。

优点：由于噪声很难选上，所以几乎不会影响到输出，克服线性滤波器所带来的图像细节模糊，对滤波脉冲干扰即图像扫描噪声最为有效。

缺点：中值滤波花费的时间是均值滤波的5倍以上，对细节（细，尖顶）的图形不合适。

双边滤波：结合图像的空间邻近度和像素值相似度的一种折中处理，同时考虑空域信息和灰度相似性，达到保边去噪的目的。

优点：做边缘保存

缺点：保存过多的高频信息，对于彩色图像里的高频噪声，不能干净的滤掉。

相关核心API函数

中值滤波：

声明：

CV\_EXPORTS\_W void medianBlur( InputArray src, OutputArray dst, int ksize );

定义：

void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
    {
        CV_Assert( (ksize % 2 == 1) && (_src0.dims() <= 2 ));
    
        if( ksize <= 1 )
        {
            _src0.copyTo(_dst);
            return;
        }
    
        CV_OCL_RUN(_dst.isUMat(),
                   ocl_medianFilter(_src0,_dst, ksize))
    
        Mat src0 = _src0.getMat();
        _dst.create( src0.size(), src0.type() );
        Mat dst = _dst.getMat();
    
    #if IPP_VERSION_X100 >= 801
        CV_IPP_CHECK()
        {
    #define IPP_FILTER_MEDIAN_BORDER(ippType, ippDataType, flavor) \
            do \
            { \
                if (ippiFilterMedianBorderGetBufferSize(dstRoiSize, maskSize, \
                    ippDataType, CV_MAT_CN(type), &bufSize) >= 0) \
                { \
                    Ipp8u * buffer = ippsMalloc_8u(bufSize); \
                    IppStatus status = ippiFilterMedianBorder_##flavor(src.ptr<ippType>(), (int)src.step, \
                        dst.ptr<ippType>(), (int)dst.step, dstRoiSize, maskSize, \
                        ippBorderRepl, (ippType)0, buffer); \
                    ippsFree(buffer); \
                    if (status >= 0) \
                    { \
                        CV_IMPL_ADD(CV_IMPL_IPP); \
                        return; \
                    } \
                } \
                setIppErrorStatus(); \
            } \
            while ((void)0, 0)
    
            if( ksize <= 5 )
            {
                Ipp32s bufSize;
                IppiSize dstRoiSize = ippiSize(dst.cols, dst.rows), maskSize = ippiSize(ksize, ksize);
                Mat src;
                if( dst.data != src0.data )
                    src = src0;
                else
                    src0.copyTo(src);
    
                int type = src0.type();
                if (type == CV_8UC1)
                    IPP_FILTER_MEDIAN_BORDER(Ipp8u, ipp8u, 8u_C1R);
                else if (type == CV_16UC1)
                    IPP_FILTER_MEDIAN_BORDER(Ipp16u, ipp16u, 16u_C1R);
                else if (type == CV_16SC1)
                    IPP_FILTER_MEDIAN_BORDER(Ipp16s, ipp16s, 16s_C1R);
                else if (type == CV_32FC1)
                    IPP_FILTER_MEDIAN_BORDER(Ipp32f, ipp32f, 32f_C1R);
            }
    #undef IPP_FILTER_MEDIAN_BORDER
        }
    #endif
    
    #ifdef HAVE_TEGRA_OPTIMIZATION
        if (tegra::useTegra() && tegra::medianBlur(src0, dst, ksize))
            return;
    #endif
    
        bool useSortNet = ksize == 3 || (ksize == 5
    #if !(CV_SSE2 || CV_NEON)
                && src0.depth() > CV_8U
    #endif
            );
    
        Mat src;
        if( useSortNet )
        {
            if( dst.data != src0.data )
                src = src0;
            else
                src0.copyTo(src);
    
            if( src.depth() == CV_8U )
                medianBlur_SortNet<MinMax8u, MinMaxVec8u>( src, dst, ksize );
            else if( src.depth() == CV_16U )
                medianBlur_SortNet<MinMax16u, MinMaxVec16u>( src, dst, ksize );
            else if( src.depth() == CV_16S )
                medianBlur_SortNet<MinMax16s, MinMaxVec16s>( src, dst, ksize );
            else if( src.depth() == CV_32F )
                medianBlur_SortNet<MinMax32f, MinMaxVec32f>( src, dst, ksize );
            else
                CV_Error(CV_StsUnsupportedFormat, "");
    
            return;
        }
        else
        {
            cv::copyMakeBorder( src0, src, 0, 0, ksize/2, ksize/2, BORDER_REPLICATE );
    
            int cn = src0.channels();
            CV_Assert( src.depth() == CV_8U && (cn == 1 || cn == 3 || cn == 4) );
    
            double img_size_mp = (double)(src0.total())/(1 << 20);
            if( ksize <= 3 + (img_size_mp < 1 ? 12 : img_size_mp < 4 ? 6 : 2)*
                (MEDIAN_HAVE_SIMD && (checkHardwareSupport(CV_CPU_SSE2) || checkHardwareSupport(CV_CPU_NEON)) ? 1 : 3))
                medianBlur_8u_Om( src, dst, ksize );
            else
                medianBlur_8u_O1( src, dst, ksize );
        }
    }

双边滤波;

声明：

void cv::bilateralFilter( InputArray \_src, OutputArray \_dst, int d,  
Line 3416:                ocl\_bilateralFilter\_8u(\_src, \_dst, d, sigmaColor, sigmaSpace, borderType))

定义：

void cv::bilateralFilter( InputArray _src, OutputArray _dst, int d,
                          double sigmaColor, double sigmaSpace,
                          int borderType )
    {
        _dst.create( _src.size(), _src.type() );
    
        CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
                   ocl_bilateralFilter_8u(_src, _dst, d, sigmaColor, sigmaSpace, borderType))
    
        Mat src = _src.getMat(), dst = _dst.getMat();
    
        if( src.depth() == CV_8U )
            bilateralFilter_8u( src, dst, d, sigmaColor, sigmaSpace, borderType );
        else if( src.depth() == CV_32F )
            bilateralFilter_32f( src, dst, d, sigmaColor, sigmaSpace, borderType );
        else
            CV_Error( CV_StsUnsupportedFormat,
            "Bilateral filtering is only implemented for 8u and 32f images" );
    }