空域的平滑

最新推荐文章于 2022-11-14 10:37:25 发布
最新推荐文章于 2022-11-14 10:37:25 发布
阅读量2k 收藏 3
点赞数 5
分类专栏： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44196785/article/details/115442723
版权

第1关：邻域平均法


#include "BMP.h"


BMP_Image* MeanFilter(BMP_Image* Image_In)
{

    BMP_Image* Image_MeanFilter;
  	Image_MeanFilter = (BMP_Image*)malloc(sizeof(BMP_Image));

    Image_MeanFilter->width = Image_In->width -2;
    Image_MeanFilter->height = Image_In->height -2;
	Image_MeanFilter->biBitCount = 8;
	Image_MeanFilter->imageRgbQuad = (BMP_RgbQuad*)malloc(sizeof(BMP_RgbQuad)*256);
	Image_MeanFilter->imageData = 	(unsigned char*)malloc((Image_In->height-2)*(Image_In->width-2));

    int i;
    for(i=0;i<256;i++)
	{
	 Image_MeanFilter->imageRgbQuad[i].rgbBlue =     Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MeanFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MeanFilter->imageRgbQuad[i].rgbRed = 	 Image_In->imageRgbQuad[i].rgbRed;
	 Image_MeanFilter->imageRgbQuad[i].rgbReserved = 0;

	 Image_MeanFilter->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MeanFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MeanFilter->imageRgbQuad[i].rgbRed =	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MeanFilter->imageRgbQuad[i].rgbReserved = 0;

	 Image_MeanFilter->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MeanFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MeanFilter->imageRgbQuad[i].rgbRed = 	 Image_In->imageRgbQuad[i].rgbRed;
	 Image_MeanFilter->imageRgbQuad[i].rgbReserved = 0;

	}

//Â˲¨²Ù×÷ʱ²»¿¼ÂDZßÔµ£¬3*3¾ùÖµÂ˲¨µÄ»°»áʹͼÏñ¼õÉÙ2ÐÐ2ÁÐ
//ÔÚÂ˲¨Ê±Ó¦´ÓµÚ¶þÐеڶþÁпªÊ¼µ½µ¹ÊýµÚ¶þÐеڶþÁнáÊø

    int j,index1,index2,index3,k=0,tmp;

    for (i=1; i<Image_In->height-1; i++)
    {
      for (j=1; j<Image_In->width-1; j++)
        {
		  /********* Begin *********/

            index1 = (i-1)*Image_In->width+j;
            index2 = i*Image_In->width+j;
            index3 = (i+1)*Image_In->width+j;
            tmp = (Image_In->imageData[index1-1] + Image_In->imageData[index1] + Image_In->imageData[index1+1] + Image_In->imageData[index2-1] + Image_In->imageData[index2]  +  Image_In->imageData[index2+1]  +
            Image_In->imageData[index3-1] + Image_In->imageData[index3] + Image_In->imageData[index3+1])/9;
            Image_MeanFilter->imageData[k] = tmp;
            k++;


		  /********* End *********/
	  }
	}
    return Image_MeanFilter;
}

第2关：中值滤波法(3*3)


#include "BMP.h"

int Med(int a,int b,int c)
{
int t;
if(a > b) {t = a; a=b; b=t;}
if(a > c) {t = a; a=c; c=t;}
if(b > c) {t = b; b=c; c=t;}

return b;
}

BMP_Image* MedFilter(BMP_Image* Image_In)
{

    BMP_Image* Image_MedFilter;
  	Image_MedFilter = (BMP_Image*)malloc(sizeof(BMP_Image));


    Image_MedFilter->width = Image_In->width -2;
    Image_MedFilter->height = Image_In->height -2;
	Image_MedFilter->biBitCount = 8;
	Image_MedFilter->imageRgbQuad = (BMP_RgbQuad*)malloc(sizeof(BMP_RgbQuad)*256);
	Image_MedFilter->imageData = 	(unsigned char*)malloc((Image_In->height-2)*(Image_In->width-2));

    int i;
    for(i=0;i<256;i++)
	{

	 Image_MedFilter->imageRgbQuad[i].rgbBlue =      Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter->imageRgbQuad[i].rgbRed = 	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter->imageRgbQuad[i].rgbReserved =  0;

	 Image_MedFilter->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter->imageRgbQuad[i].rgbRed =	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter->imageRgbQuad[i].rgbReserved =  0;

	 Image_MedFilter->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter->imageRgbQuad[i].rgbRed = 	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter->imageRgbQuad[i].rgbReserved =  0;

	}

//Â˲¨²Ù×÷ʱ²»¿¼ÂDZßÔµ£¬3*3ÖÐÖµÂ˲¨µÄ»°»áʹͼÏñ¼õÉÙ2ÐÐ2ÁÐ
//ÔÚÂ˲¨Ê±Ó¦´ÓµÚ¶þÐеڶþÁпªÊ¼µ½µ¹ÊýµÚ¶þÐеڶþÁнáÊø

    int j,index1,index2,index3,k=0;

    for (i=1; i<Image_In->height-1; i++)
    {
      for (j=1; j<Image_In->width-1; j++)
        {
		  /********* Begin *********/
            index1=(i-1)*Image_In->width+j;
            index2=i*Image_In->width+j;
            index3=(i+1)*Image_In->width+j;
            int Med1 = Med(Image_In->imageData[index1-1],Image_In->imageData[index1],Image_In->imageData[index1+1]);
            int Med2 = Med(Image_In->imageData[index2-1],Image_In->imageData[index2],Image_In->imageData[index2+1]);
            int Med3 = Med(Image_In->imageData[index3-1],Image_In->imageData[index3],Image_In->imageData[index3+1]);
            int Med4 = Med(Med1,Med2,Med3);
            Image_MedFilter->imageData[k] = Med4;
            k++;



		  /********* End *********/
	  }
	}
    return Image_MedFilter;
}

第3关：中值滤波法（5*5）


#include "BMP.h"
//Èý¸öÊýÇóÖÐÖµ
int ForMed(int a,int b,int c)
{
int t;
if(a > b) {t = a; a=b; b=t;}
if(a > c) {t = a; a=c; c=t;}
if(b > c) {t = b; b=c; c=t;}

return b;
}

BMP_Image* MedFilter1(BMP_Image* Image_In)
{

    BMP_Image* Image_MedFilter1;
  	Image_MedFilter1 = (BMP_Image*)malloc(sizeof(BMP_Image));

    Image_MedFilter1->width = Image_In->width -4;
    Image_MedFilter1->height = Image_In->height -4;
	Image_MedFilter1->biBitCount = 8;
	Image_MedFilter1->imageRgbQuad = (BMP_RgbQuad*)malloc(sizeof(BMP_RgbQuad)*256);
	Image_MedFilter1->imageData = 	(unsigned char*)malloc((Image_In->height-4)*(Image_In->width-4));

    int i;
    for(i=0;i<256;i++)
	{

	 Image_MedFilter1->imageRgbQuad[i].rgbBlue =      Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter1->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter1->imageRgbQuad[i].rgbRed = 	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter1->imageRgbQuad[i].rgbReserved =  0;

	 Image_MedFilter1->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter1->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter1->imageRgbQuad[i].rgbRed =	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter1->imageRgbQuad[i].rgbReserved =  0;

	 Image_MedFilter1->imageRgbQuad[i].rgbBlue = 	 Image_In->imageRgbQuad[i].rgbBlue;
	 Image_MedFilter1->imageRgbQuad[i].rgbGreen = 	 Image_In->imageRgbQuad[i].rgbGreen;
	 Image_MedFilter1->imageRgbQuad[i].rgbRed = 	     Image_In->imageRgbQuad[i].rgbRed;
	 Image_MedFilter1->imageRgbQuad[i].rgbReserved =  0;

	}

    int j,index1,index2,index3,index4,index5,k=0;
//Â˲¨²Ù×÷ʱ²»¿¼ÂDZßÔµ£¬5*5ÖÐÖµÂ˲¨µÄ»°»áʹͼÏñ¼õÉÙ4ÐÐ4ÁÐ
//ÔÚÂ˲¨Ê±Ó¦´ÓµÚÈýÐеÚÈýÁпªÊ¼µ½µ¹ÊýµÚÈýÐеÚÈýÁнáÊø
    for (i=2; i<Image_In->height-2; i++)
    {
      for (j=2; j<Image_In->width-2; j++)
        {
		  /********* Begin *********/
            index1=(i-2)*Image_In->width+j;
            index2=(i-1)*Image_In->width+j;
            index3=i*Image_In->width+j;
            index4=(i+1)*Image_In->width+j;
            index5=(i+2)*Image_In->width+j;
            int Med1 = ForMed(Image_In->imageData[index1-1],Image_In->imageData[index1],Image_In->imageData[index1+1]);
            int Med2 = ForMed(Image_In->imageData[index2-1],Image_In->imageData[index2],Image_In->imageData[index2+1]);
            int Med3 = ForMed(Image_In->imageData[index3-1],Image_In->imageData[index3],Image_In->imageData[index3+1]);
            int Med4 = ForMed(Image_In->imageData[index4-1],Image_In->imageData[index4],Image_In->imageData[index4+1]);
            int Med5 = ForMed(Image_In->imageData[index5-1],Image_In->imageData[index5],Image_In->imageData[index5+1]);
            int Med6= ForMed(Med1,Med2,Med3);
            int Med7= ForMed(Med4,Med5,Med6);
            Image_MedFilter1->imageData[k] = Med7;
            k++;



		  /********* End *********/
	  }
	}
    return Image_MedFilter1;
}
川师_King
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Intel‘s oneAPI实现bmp图像的5*5中值滤波
weixin_51800631的博客
06-18 86
DPC++ 结合了 C++ 的灵活性和并行计算的能力，使开发人员能够利用多核 CPU、强大的 GPU 和可重构的 FPGA 进行高性能计算。​使用oneAPI实现时，需要使用oneAPI的编程模型Data Parallel C++ (DPC++)，该模型结合了传统的 C++ 编程和并行计算的能力，使开发人员能够在多种硬件平台上进行并行计算，如 CPU、GPU 和 FPGA。例如，它包括用于向量化和优化计算的高性能数学库、用于加速图像处理和机器学习的库，以及用于构建和优化 FPGA 加速器的工具。
Opencv_13 图像滤波(低通滤波图像平滑去噪)
Fioman_GYM的博客
05-19 7736
文章目录一. 图像滤波简介① 为什么图像是波?② 图像的频率③ 滤波器二. 低通滤波之线性滤波① 方框滤波② 均值滤波③ 高斯滤波 一. 图像滤波简介 ① 为什么图像是波? 我们都知道,图像由像素组成.下图是一张400 * 400的图片,一共包含了16万个像素点. 每个像素的颜色,可以用红绿蓝表示,大小范围是0~255. 如果把每一行所有像素(上例是400个)的红,绿,蓝的值,依次画成三条曲线,六得到下面的图形: 可以看到每条曲线都在不停地上下波动.有些区域波动比较小,有些区域波动不叫大,比如54,和3
空域的锐化
weixin_44196785的博客
04-05 1123
第1关：Roberts梯度算子 #include "BMP.h" BMP_Image* Roberts(BMP_Image* Image_In) { BMP_Image* Roberts; Roberts = (BMP_Image*)malloc(sizeof(BMP_Image)); Roberts->width = Image_In->width -1; Roberts->height = Image_In->height -1; Ro
Python 图像处理 OpenCV （7）：图像平滑（滤波）处理
极客挖掘机
06-06 5975
前文传送门： 「Python 图像处理 OpenCV （1）：入门」 「Python 图像处理 OpenCV （2）：像素处理与 Numpy 操作以及 Matplotlib 显示图像」 「Python 图像处理 OpenCV （3）：图像属性、图像感兴趣 ROI 区域及通道处理」 「Python 图像处理 OpenCV （4）：图像算数运算以及修改颜色空间」 「Python 图像处理 OpenCV （5）：图像的几何变换」 「Python 图像处理 OpenCV （6）：图像的阈值处理」 1. 引言 第一.
图像在空域上的平滑处理
lllfor的博客
06-19 2141
平滑处理（smoothing） 平滑处理（smoothing）也称模糊处理（bluring）。作用就是减少图像上的噪声或者失真。 图像滤波，即在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像预处理中不可缺少的操作，其处理效果的好坏将直接影响到后续图像处理和分析的有效性和可靠性。 平滑滤波是低频增强的空间域滤波技术。它的目的有两类：一类是模糊；另一类是消除噪音。 空间域的平滑滤波一般采用均值滤波、中值滤波和加权平滑滤波进行处理。 均值滤波 3*3窗口的均值滤波如下图所示，点(x,y)的滤波值由其
空域平滑滤波
01-09
基于matlab的空域平滑滤波程序 对于图像处理有很大的作用，有相关研究的人可以下载下来共同研究
空域平滑滤波消噪处理程序.pdf
12-06
本资源主要是MATLAB中对图像的相关处理，包括椒盐噪声等各种噪声的平滑滤波处理，图像的边缘检测及锐化处理
数字图像处理（空域平滑）
09-16
在数字图像处理领域，空域平滑是一种基本且重要的技术，用于减少图像噪声，提高图像质量。本主题主要探讨四种常见的空域平滑方法：四邻域平滑法、中值滤波法、阈值平均法和加权平均法。 **四邻域平滑法**： 这是一...
图像的空域平滑
10-09
代码很全，两种方法实现对图像的空域进行平滑。
空域平滑 中值滤波代码
06-09
数字图像处理基本代码空域平滑 中值滤波 自己编写
图像平滑处理的空域算法和频域分析
12-30
数字图像处理包括时域和频域的方法。图像平滑通有空域模板和频域滤波器。本文档包含了时域和频域的处理方法，希望对你有帮助！
图像增强---空域滤波之平滑
luran的博客
11-28 6718
一.空域滤波基础 1.定义 空域滤波增强采用模板处理方法对图像进行滤波，去除图像噪声或增强图像的细节。 2.卷积理论 ①卷积的离散表达式，基本上可以理解为模板运算的数学表达方式： ②由此，卷积的冲击相应函数h(x,y)，称为空域卷积模板。 3.空域滤波及滤波器的定义 使用空域模板进行的图像处理，被称为空域滤波。 模板本身被称为空域滤波器。 ①滤波器的分类 · 数学形态分类 · 处理效果分类 平滑滤波器； 锐化滤波器。 4.线性滤波器 ①定义 线性滤波器是线性系统和频域滤波概念在空域的自然延伸。其特征
图像增强—空域平滑
白水的博客
08-02 2096
图像噪声图像噪声是指图像在摄取或传输过程中所受到的随机干扰信号，通常分为内部噪声和外部噪声在图像处理过程中通常会接触到三类噪声：椒盐噪声：含有随机出现的黑白强度值，通常呈点状，不形成大的连通域脉冲噪声：只含有随机的白强度(正脉冲)噪声或黑强度(负脉冲)噪声高斯噪声：含有强度服从高斯分布的噪声图像平滑图像平滑的目的是改善图像质量，尽量消除噪声对图像带来的影响...
Airspace smoothing
长夜漫漫，无心睡眠
03-12 1805
加性噪声：可加性噪声，一般易于消除 乘性噪声：非线性引入的噪声，往往与信号密切相关 量化噪声：模拟信号转化到数字信号时取整变化产生的误差 注意template左上角的1后面有个黑点，代表运算的结果后赋给这个对应点。 一般噪声的像素与周围的像素都明显不同。 ...
图像的阈值分割技术
weixin_44196785的博客
04-13 1010
全局阈值分割 #include "BMP.h" BMP_Image* GlobalSegmentation(BMP_Image* Image_In) { BMP_Image* Image_GlobalSegmentation; Image_GlobalSegmentation = (BMP_Image*)malloc(sizeof(BMP_Image)); Image_GlobalSegmentation->width = Image_In->width;
图像空域平滑算法
huibailingyu的专栏
04-02 5190
基于空间相领像素点的平滑算法是图像处理里面经常用到的去噪算法。 它的核心思想是：选择当前像素点c和其周围的一些像素{c, n1, n2, ..., nN}（共N+1个像素点），根据他们与c的距离和/或与c的像素差值，赋予他们不同的权重{w0, w1, w2, ..., wn}（要求0 空域平滑算法就是不同权重值的卷积运算，卷积运算需要注意的问题1是计算量，2是数据搬移量。3x3的卷积运算，一个
数字图像处理与分析（matlab实现）——实现空域线性及非线性低通平滑滤波
帅才的博客
10-13 4439
空域低通滤波 将空间域模板用于图像处理，通常称为空间滤波，而空间域模板称为空间滤波器。 空间域滤波按线性和非线性特点有：线性、非线性平滑滤波器。线性滤波在消除图像噪声的同时也会模糊图像的细节，利用非线性平滑滤波可在消除图像中噪声的同时较好的保持图像的细节。 线性平滑滤波器包括邻近域平均法。非线性平滑滤波器有中值滤波器。 平滑滤波:平滑...
Python图像处理六：图像空域平滑
小柒的博客
11-14 1552
图像空域平滑、图像加噪、random_noise 、filters.median中值滤波、skimage.filters.gaussian
图像空域平滑mtalab代码
最新发布
05-19
以下是Matlab实现图像空域平滑的代码示例： ```matlab % 读入图像 img = imread('lena.png'); % 定义平滑半径 r = 3; % 构造平滑模板 h = fspecial('average', [2*r+1, 2*r+1]); % 应用平滑模板 img_smooth = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值