中值滤波改进

已于 2022-11-17 21:09:50 修改
阅读量875 收藏 10
点赞数 4
分类专栏： 智能车视觉 文章标签： c++ 算法 数据结构
于 2021-08-20 17:45:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu58430/article/details/119828593
版权

按照：中值滤波的改进算法 - 游戏者 - 博客园的思路

取中值时半径为三，改进后比一般bfptr算法快20倍以上

以下代码模拟3e7次运算并输出时间，时间在400ms内

#include "bits/stdc++.h"
using namespace std;
#define num_type int
num_type a[9],Max1, Max2, Max3, Med1, Med2, Med3, Min1, Min2, Min3, Min_of_Max, Med_of_Med, Max_of_Min, Med_of_nine;

int find_Max(num_type Max1,num_type Max2,num_type Max3)
{
    if (Max1 <= Max2) {
        if (Max3 <= Max1)return Max3;
        else return  Max1;
    } else {
        if (Max3 <= Max2)return Max3;
        else return Max2;
    }
}
int find_Min(num_type Min1,num_type Min2,num_type Min3)
{
    if (Min1 >= Min2) {
        if (Min3 >= Min1)return  Min3;
        else return  Min1;
    } else {
        if (Min3 >= Min2)return  Min3;
        else return  Min2;
    }
}
int find_Med(num_type Med1,num_type Med2,num_type Med3)
{
    if(Med1>=Med2)
    {
        if(Med3>=Med1)return Med1;
        else if(Med3>=Med2)return Med3;
        else return Med2;
    } else{
        if(Med3>=Med2)return Med2;
        else if(Med3>=Med1)return Med3;
        else return Med1;
    }
}
void three_sort(num_type a,num_type b,num_type c,num_type *Max,num_type *Med,num_type *Min)
{
    if(a>b)
    {
        if(c>a)*Max=c,*Med=a,*Min=b;
        else if(c>b)*Max=a,*Med=c,*Min=b;
        else *Max=a,*Med=b,*Min=c;
    }
    else
        if(c>b)*Max=c,*Med=b,*Min=a;
        else if(c>a)*Max=b,*Med=c,*Min=a;
        else *Max=b,*Med=a,*Min=c;
}
int main() {

    srand((int)time(0));
    double begin,end;
    while(1){
        for (int i = 0; i < 9; i++)
            a[i] =rand()%100;
        begin = clock();

        for (int j = 0; j < 3e7; j++) {
            three_sort(a[0],a[1],a[2],&Max1,&Med1,&Min1);
            three_sort(a[3],a[4],a[5],&Max2,&Med2,&Min2);
            three_sort(a[6],a[7],a[8],&Max3,&Med3,&Min3);
           if (Max1 <= Max2) {
                if (Max3 <= Max1)Min_of_Max = Max3;
                else Min_of_Max = Max1;
            } else {
                if (Max3 <= Max2)Min_of_Max = Max3;
                else Min_of_Max = Max2;
            }
          // Min_of_Max= find_Max(Max1,Max2,Max3);
          if(Med1>=Med2)
          {
              if(Med3>=Med1)Med_of_Med=Med1;
              else if(Med3>=Med2)Med_of_Med=Med3;
              else Med_of_Med=Med2;
          } else{
              if(Med3>Med2)Med_of_Med=Med2;
              else if(Med3>=Med1)Med_of_Med=Med3;
              else Med_of_Med=Med1;
          }
      //  Med_of_Med= find_Med(Med1,Med2,Med3);

            if (Min1 >= Min2) {
                if (Min3 >= Min1)Max_of_Min = Min3;
                else Max_of_Min = Min1;
            } else {
                if (Min3 >= Min2)Max_of_Min = Min3;
                else Max_of_Min = Min2;
            }
            //Max_of_Min=find_Min(Min1,Min2,Min3);
          if(Min_of_Max>=Med_of_Med)
          {
              if(Max_of_Min>=Min_of_Max)Med_of_nine=Min_of_Max;
              else if(Max_of_Min>=Med_of_Med)Med_of_nine=Max_of_Min;
              else Med_of_nine=Med_of_Med;
          } else{
              if(Max_of_Min>Med_of_Med)Med_of_nine=Med_of_Med;
              else if(Max_of_Min>=Min_of_Max)Med_of_nine=Max_of_Min;
              else Med_of_nine=Min_of_Max;
          }
        //  Med_of_nine= find_Med(Min_of_Max,Med_of_Med,Max_of_Min);

        }
         end = clock();
        sort(a,a+9);
        cout<<Med_of_nine<<" "<<a[4]<<endl;
        cout << (end - begin) / 1000000 << endl;
    }
    return 0;
}

再改进：

现在每次最多需要比较17次才能求出中值，但

指针每次偏移，意味着一行或是一列更新，剩余两行、两列不变，那么每次更新可以节省6次比较，理论上可在150ms内完成3e7次计算

代码：

#include "bits/stdc++.h"
#include "ctmf.h"
#include "opencv2/opencv.hpp"

using namespace cv;
using namespace std;
#define num_type unsigned char
#define    scale  0.1
#define width 128
#define high 72


void v_to_mat(Mat &image1, num_type b[][width]) {
    for (int i = 0; i < high; i++) {
        for (int j = 0; j < width; j++) {
            image1.at<uchar>(i, j) = b[i][j];
        }
    }
}
void mat_to_v(Mat &image1, num_type b[][width]) {
    for (int i = 0; i < high; i++) {
        for (int j = 0; j < width; j++) {
            b[i][j] = image1.at<uchar>(i, j);
        }
    }
}


void Binarization(num_type input[][width], num_type output[][width], num_type val) {
    for (int i = 0; i < high; i++) {
        for (int j = 0; j < width; j++) {
            output[i][j] = input[i][j] >= val ? 255 : 0;
        }
    }
}

void three_sort(num_type a, num_type b, num_type c, num_type *Max, num_type *Med, num_type *Min) {
    if (a >= b) {
        if (c >= a)*Max = c, *Med = a, *Min = b;
        else if (c >= b)*Max = a, *Med = c, *Min = b;
        else *Max = a, *Med = b, *Min = c;
    } else if (c >= b)*Max = c, *Med = b, *Min = a;
    else if (c >= a)*Max = b, *Med = c, *Min = a;
    else *Max = b, *Med = a,* Min = c;
}

void median_filtering(num_type img[][width]) {
    num_type Max1, Max2, Max3, Med1, Med2, Med3, Min1, Min2, Min3, Min_of_Max, Med_of_Med, Max_of_Min;
    int i, j;
    for (i = high-2; i ; i--) {
        three_sort(img[i - 1][0], img[i][0], img[i + 1][0], &Max1, &Med1, &Min1);
        three_sort(img[i - 1][1], img[i][1], img[i + 1][1], &Max2, &Med2, &Min2);
        three_sort(img[i - 1][2], img[i][2], img[i + 1][2], &Max3, &Med3, &Min3);
        if (Max1 <= Max2) {
            if (Max3 <= Max1)Min_of_Max = Max3;
            else Min_of_Max = Max1;
        } else {
            if (Max3 <= Max2)Min_of_Max = Max3;
            else Min_of_Max = Max2;
        }
        if (Med1 >= Med2) {
            if (Med3 >= Med1)Med_of_Med = Med1;
            else if (Med3 >= Med2)Med_of_Med = Med3;
            else Med_of_Med = Med2;
        } else {
            if (Med3 > Med2)Med_of_Med = Med2;
            else if (Med3 >= Med1)Med_of_Med = Med3;
            else Med_of_Med = Med1;
        }
        if (Min1 >= Min2) {
            if (Min3 >= Min1)Max_of_Min = Min3;
            else Max_of_Min = Min1;
        } else {
            if (Min3 >= Min2)Max_of_Min = Min3;
            else Max_of_Min = Min2;
        }
        if (Min_of_Max >= Med_of_Med) {
            if (Max_of_Min >= Min_of_Max)img[i][1] = Min_of_Max;
            else if (Max_of_Min >= Med_of_Med)img[i][1] = Max_of_Min;
            else img[i][1] = Med_of_Med;
        } else {
            if (Max_of_Min > Med_of_Med)img[i][1] = Med_of_Med;
            else if (Max_of_Min >= Min_of_Max)img[i][1] = Max_of_Min;
            else img[i][1] = Min_of_Max;
        }
        for (j = 2; j < width - 1; j++) {
            Max1=Max2,Med1=Med2,Min1=Min2;
            Max2=Max3,Med2=Med3,Min2=Min3;
            three_sort(img[i - 1][j + 1], img[i][j + 1], img[i + 1][j + 1], &Max3, &Med3, &Min3);
            if (Max1 <= Max2) {
                if (Max3 <= Max1)Min_of_Max = Max3;
                else Min_of_Max = Max1;
            } else {
                if (Max3 <= Max2)Min_of_Max = Max3;
                else Min_of_Max = Max2;
            }
            if (Med1 >= Med2) {
                if (Med3 >= Med1)Med_of_Med = Med1;
                else if (Med3 >= Med2)Med_of_Med = Med3;
                else Med_of_Med = Med2;
            } else {
                if (Med3 > Med2)Med_of_Med = Med2;
                else if (Med3 >= Med1)Med_of_Med = Med3;
                else Med_of_Med = Med1;
            }

            if (Min1 >= Min2) {
                if (Min3 >= Min1)Max_of_Min = Min3;
                else Max_of_Min = Min1;
            } else {
                if (Min3 >= Min2)Max_of_Min = Min3;
                else Max_of_Min = Min2;
            }
            if (Min_of_Max >= Med_of_Med) {
                if (Max_of_Min >= Min_of_Max)img[i][j] = Min_of_Max;
                else if (Max_of_Min >= Med_of_Med)img[i][j] = Max_of_Min;
                else img[i][j] = Med_of_Med;
            } else {
                if (Max_of_Min > Med_of_Med)img[i][j] = Med_of_Med;
                else if (Max_of_Min >= Min_of_Max)img[i][j] = Max_of_Min;
                else img[i][j] = Min_of_Max;
            }
        }
    }

}


int main() {

    srand((int) time(0));
    Mat image,cc;
    double begin, end;
    int val = 180;
    image = imread("/home/rubo/2.png");
    Size dsize = Size(image.cols*scale, image.rows*scale);
    Mat img2 = Mat(dsize, CV_32S);
    resize(image, image, dsize);
    if (image.empty()) {
        cout << "no picture!" << endl;
        return 0;
    }
    num_type img[high][width];
num_type img1[high][width];
    cvtColor(image, image, COLOR_RGB2GRAY, 0);
    Mat image1;
    image.copyTo(cc);
    mat_to_v(image, img);
    begin=clock();
for(int i=0;i<1000;i++)
         median_filtering(img);
    end=clock();
    cout<<(end-begin)/1000000<<endl;
   v_to_mat(cc,img);
    begin = clock();
    medianBlur(image, image1, 3);//输入，输出，7通道
    end = clock();
    cout << (end - begin) / 1000000 << endl;
    inRange(image, 0, val, image);
    imshow("im", image);
    inRange(image1, 0, val, image1);
    imshow("im1", image1);
    inRange(cc, 0, val, cc);
    imshow("bb",cc);
    waitKey(0);
    return 0;
}

LoseHu
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【大作业】基于Matlab的中值滤波算法实现-含文档-含matlab源代码.zip
06-12
该资源可直接用于图像处理等课程的大作业。
中值滤波算法改进之C语言实现
04-30
用C语言实现的改进的中值滤波算法哦（中值算法）
中值滤波算法的研究与改进
03-08
本文对图像处理中常用的中值滤波算法的几种加速改进算法进行了研究与对比, 探讨了各种算法实现机制、处理效果及运 算复杂度, 提出一种新的基于直方图的分级查找中值滤波算法, 通过对比实验表明, 新算法提高了中值滤波的速度, 能应用于任何 中值的应用场景, 并能与以往的各种中值滤波改进算法相结合。
改进的中值滤波MATLAB程序
09-19
改进的中值滤波程序，测试后能有效滤除各种噪音，如高斯，椒盐等，比单一的中值滤波效果显著，此为中值滤波函数的M文件，用时需要自己编写主程序调用此函数即可。
基于脉冲噪声点检测的中值滤波改进算法 (2012年)
05-30
在对中值滤波及其他改进算法进行研究分析的基础上，提出了一种基于脉冲噪声点检测的中值滤波改进算法。通过设定阈值标记出可能的噪声点，再根据相邻像素的相关性对可能的噪声点进一步判断，精确确定噪声点，只对噪声点进行中值滤波。实验结果表明，相对于中值滤波及其他改进算法，新算法获得的去噪后的图像具有更好的客观评价指标和主观视觉效果。
【论文复现】中值滤波改进：Different Applied Median Filter(DAMF)
weixin_44378835的博客
02-20 1140
Different applied median filter(DAMF) 椒盐噪声：https://blog.csdn.net/u011995719/article/details/83375196 A:=[aij]m×nA:=[a_{ij}]_{m\times n}A:=[aij​]m×n​：图像矩阵 0≤aij≤2550\le a_{ij}\le 2550≤aij​≤255：如果aij=0a_{ij}=0aij​=0或aij=255a_{ij}=255aij​=255，则称它为噪声条目，否则称为正则条
数字图像处理——中值滤波及其改进算法
沧海一升的博客
08-27 6566
中值滤波器是非线性滤波器的一个例子，它在保留图像特征方面非常有效。 但是，滤波器的窗口大小直接影响中值滤波器的性能。 较小的窗口保留了特征，但会导致噪声抑制的减少。 在较大窗口的情况下，噪声抑制很高，但图像内容保留有限。 随着对标准中值滤波器的研究，提出了许多滤波器，如加权中值滤波器和许多其他高级滤波器。
【论文复现】中值滤波改进：Noise Adaptive Fuzzy Switching Median Filter（NAFSMF）
weixin_44378835的博客
02-20 1514
Noise Adaptive Fuzzy Switching Median Filter（NAFSMF） 阶段一 Initially, the detection stage will utilize the histogram of the corrupted image to identify noise pixels. These detected “noise pixels” will then be subjected to the second stage of the filtering ac
第三节--一种改进的中值滤波策略的实现
maweifei的博客
03-07 2934
 //----------------------------------------【一种改进的中值滤波策略的实现】------------------------------------ //1--传统的中值滤波器的缺点:中值滤波的效果依赖于--滤波窗口的大小，太大会使边沿模糊，太小了，则去噪效果不佳。因为 //-------噪声点和边缘点同样是灰度变化较为剧烈的像素，普通的中值滤波
一种改进的中值滤波方法—内附MATLAB源码
qq_33668060的博客
08-29 3251
一种改进的中值滤波方法 标准中值滤波器会根据窗口大小对噪声图像的每个像素点进行处理，这样会导致处理结果受到滤波窗口大小的影响比较严重，而且，对于纹理性较强的图像处理效果不理想会存在模糊现象，故在文章《小样本情况下基于深度学习的水下目标识别》一文中，作者提出了一种改进的中值滤波处理算法。本文是对该文...
中值滤波改进算法在图像处理中应用
11-26
针对图像处理中一些噪声干扰，现提出一种中值滤波改进算法来滤波噪声干扰。
中值滤波的改进算法
aoamca84802的博客
08-25 1383
中值滤波的算法很多，但通常数据排序量较大。需要消耗大量时间，不利于图像处理的实时性。 （1）窗口大小为3*3的快速排序算法 为了便于说明。将3*3窗口内的各个像素分别定义为M11，M12，M13，M21，M22，M23，M31，M32，M33。首先分别对窗口中的每一行计算最大值、中值、最小值，这样一共可以得到9个数值，分别包括3个最大值、3个中值、3个最小值： 第一行的最大值：Max1=...
中值滤波(Median filtering)
热门推荐
半濠春水的博客
11-25 5万+
1.概念介绍  中值滤波法是一种非线性平滑技术，它将每一像素点的灰度值设置为该点某邻域窗口内的所有像素点灰度值的中值。  中值滤波的方法是用某种结构的二维滑动模板，将板内像素按照像素值的大小进行排序，生成单调上升（或下降）的为二维数据序列。 2.基本原理  中值滤波会选取数字图像或数字序列中像素点及其周围临近像素点（一共有奇数个像素点）的像素值，将这些像素值排序，然后将位于中间位置的像素值作为当前像素点的像素值，让周围的像素值接近真实值，从而消除孤立的噪声点。  例如，针对图2-1中第4行第4列的像素点，.
改进的自适应中值滤波算法 去除椒盐噪声 python 代码实现
云微的blog
06-10 5630
传统的中值滤波算法在椒盐噪声的去除领域有着比较广泛的应用，其具有较强的噪点鉴别和恢复能力，也有比较低的时间复杂度：其基本思想是采用像素点周围邻接的若干像素点的中值来代替被污染的像素点；但也存在一定的缺陷，随着图像被污染程度的加深，此方法恢复的图像细节模糊、边缘损失也会越严重。 此处采用改进的自适应中值滤波算法进行图像恢复： 根据图像处理的空间相关性原则，采用自适应的方法选择不同的滑动窗口大小； 在算法中单滤波窗口大小达到最大值时，采用均值滤波； def get_window(res_img,noise
中值滤波与图像锐化
weixin_30511039的博客
12-24 1082
本文主要包括以下内容 中值滤波及其改进算法 图像锐化， 包括梯度算子、拉普拉斯算子、高提升滤波和高斯-拉普拉斯变换 本章的典型囊例分析 对椒盐噪声的平滑效果比较 Laplacian与LoG算子的锐化效果比较 中值滤波 中值滤波本质上是一种统计排序滤波器． 对于原图像中某点（i,j)， 中值滤波以该点为中 心的邻域内的所有像素的统计排序中值作为（i, ...
改进的中值滤波函数
dowhathowtodo
08-10 686
void CSDIELSView::OnMedianFilterImprove() { //程序编制：李立宗 //[email protected] //2012-8-10 if(myImage1.IsNull()) OnOpenResourceFile(); if(!myImage2.IsNull()) myImage2.Destroy(); if(myIma...
msmpi 高性能并行计算 移植并行细胞自动机报错
最新发布
a1309602336的博客
05-02 79
稍微修改，因为相对路径在 msmpi 10.1.1 中失效。
MATLAB中改进中值滤波
05-22
因此，需要进行改进，提高中值滤波的去噪效果。 以下是一些MATLAB中改进中值滤波的方法： 1. 自适应中值滤波：根据像素值的分布情况动态调整窗口大小和中值滤波器的参数，以增强去噪效果。 2. 双边滤波：在中值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LoseHu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值