均值滤波和中值滤波的java代码

最新推荐文章于 2024-07-23 08:52:32 发布
最新推荐文章于 2024-07-23 08:52:32 发布
阅读量6k 收藏 9
点赞数 2


均值滤波和中值滤波的内容非常基础，均值滤波相当于低通滤波，有将图像模糊化的趋势，对椒盐噪声基本无能为力。中值滤波的优点是可以很好的过滤掉椒盐噪声，缺点是易造成图像的不连续性。在下面的代码中，中值滤波主要通过冒泡算法来实现。 
含有椒盐噪声的lena彩色图像： 
 


均值滤波的效果如下，可以看出，椒盐噪声被处理成了小的气泡，同时图像变模糊： 
 


中值滤波的效果如下，可以看到，几乎完全去除了椒盐噪声。 
 


Java代码   收藏代码
  1. package p01;  
  2.   
  3. import java.awt.*;  
  4. import java.awt.event.*;  
  5. import java.awt.image.*;  
  6. import java.io.File;  
  7. import java.io.IOException;  
  8.   
  9. import javax.imageio.ImageIO;  
  10. import javax.swing.*;  
  11.   
  12. public class colorfilter extends Frame{  
  13.     Image im, tmp;  
  14.     int i, iw, ih;  
  15.     int[] pixels;  
  16.     boolean flag_load = false;  
  17.       
  18.     public colorfilter(){      
  19.         this.setTitle("彩色图像均值中值滤波3*3");  
  20.         Panel pdown;  
  21.         Button load, mean, median, save, quit;   
  22.         addWindowListener(new WindowAdapter(){  
  23.             public void windowClosing(WindowEvent e){  
  24.                 System.exit(0);  
  25.             }  
  26.         });  
  27.           
  28.         pdown = new Panel();  
  29.         pdown.setBackground(Color.lightGray);  
  30.         //定义按钮  
  31.         load = new Button("装载图像");      
  32.         mean = new Button("均值滤波3*3");  
  33.         median = new Button("中值滤波3*3");  
  34.         save = new Button("保存");  
  35.         quit = new Button("退出");  
  36.           
  37.         this.add(pdown, BorderLayout.SOUTH);  
  38.         //添加按钮  
  39.         pdown.add(load);      
  40.         pdown.add(mean);  
  41.         pdown.add(median);  
  42.         pdown.add(save);  
  43.         pdown.add(quit);  
  44.         //按钮的动作程序  装载图像  
  45.         load.addActionListener(new ActionListener(){      
  46.             public void actionPerformed(ActionEvent e){  
  47.                 try {  
  48.                 jLoad_ActionPerformed(e);  
  49.                 } catch (IOException e1) {  
  50.                     e1.printStackTrace();  
  51.                 }  
  52.             }  
  53.         });  
  54.         //按钮的动作程序  均值滤波  
  55.         mean.addActionListener(new ActionListener(){      
  56.             public void actionPerformed(ActionEvent e){  
  57.                 jMean_ActionPerformed(e);  
  58.             }  
  59.         });  
  60.         //按钮的动作程序  中值滤波  
  61.         median.addActionListener(new ActionListener(){      
  62.             public void actionPerformed(ActionEvent e){  
  63.                 jMedian_ActionPerformed(e);  
  64.             }  
  65.         });  
  66.         //按钮的动作程序  保存  
  67.         save.addActionListener(new ActionListener(){      
  68.             public void actionPerformed(ActionEvent e){  
  69.                 try {  
  70.                 jSave_ActionPerformed(e);  
  71.                 } catch (IOException e1) {  
  72.                     e1.printStackTrace();  
  73.                 }  
  74.             }  
  75.         });  
  76.         //按钮的动作程序  退出  
  77.         quit.addActionListener(new ActionListener(){      
  78.             public void actionPerformed(ActionEvent e){  
  79.                 jQuit_ActionPerformed(e);  
  80.             }  
  81.         });  
  82.     }  
  83.   //按钮动作的实现  加载图像  
  84.     public void jLoad_ActionPerformed(ActionEvent e) throws IOException{      
  85.         File inputFile = new File("E:\\f2\\sc\\lena_zaosheng08.jpg");  
  86.         BufferedImage input = ImageIO.read(inputFile);  
  87.         iw = input.getWidth(this);  
  88.         ih = input.getHeight(this);  
  89.     pixels = new int[iw*ih];  
  90.     im = input;  
  91.     tmp = input;  
  92.         flag_load = true;  
  93.         repaint();  
  94.     }  
  95.   //按钮动作的实现 均值滤波    
  96.     public void jMean_ActionPerformed(ActionEvent e) {      
  97.         if(flag_load){  
  98.             try{  
  99.                   PixelGrabber pg = new PixelGrabber(im,0,0,iw,ih,pixels,0,iw);  
  100.                   pg.grabPixels();  
  101.               }catch(InterruptedException e3){  
  102.                 e3.printStackTrace();  
  103.               }  
  104.             BufferedImage grayImage = new BufferedImage(iw, ih,   
  105.                       BufferedImage.TYPE_INT_RGB);  
  106.               
  107.             ColorModel cm = ColorModel.getRGBdefault();  
  108.               
  109.             for(int i=1;i<ih-1;i++){  
  110.                 for(int j=1;j<iw-1;j++){  
  111.                       
  112.                     int red1 = cm.getRed(pixels[(i-1)*iw+j-1]);  
  113.                     int red2 = cm.getRed(pixels[(i-1)*iw+j]);  
  114.                     int red3 = cm.getRed(pixels[(i-1)*iw+j+1]);  
  115.                     int red4 = cm.getRed(pixels[i*iw+j-1]);  
  116.                     int red6 = cm.getRed(pixels[i*iw+j+1]);  
  117.                     int red7 = cm.getRed(pixels[(i+1)*iw+j-1]);  
  118.                     int red8 = cm.getRed(pixels[(i+1)*iw+j]);  
  119.                     int red9 = cm.getRed(pixels[(i+1)*iw+j+1]);  
  120.                     int meanRed = (red1+red2+red3+red4+red6+red7+red8+red9)/8;  
  121.                       
  122.                     int green1 = cm.getGreen(pixels[(i-1)*iw+j-1]);  
  123.                     int green2 = cm.getGreen(pixels[(i-1)*iw+j]);  
  124.                     int green3 = cm.getGreen(pixels[(i-1)*iw+j+1]);  
  125.                     int green4 = cm.getGreen(pixels[i*iw+j-1]);  
  126.                     int green6 = cm.getGreen(pixels[i*iw+j+1]);  
  127.                     int green7 = cm.getGreen(pixels[(i+1)*iw+j-1]);  
  128.                     int green8 = cm.getGreen(pixels[(i+1)*iw+j]);  
  129.                     int green9 = cm.getGreen(pixels[(i+1)*iw+j+1]);  
  130.                     int meanGreen = (green1+green2+green3+green4+green6+green7+green8+green9)/8;  
  131.                       
  132.                    int blue1 = cm.getBlue(pixels[(i-1)*iw+j-1]);  
  133.                     int blue2 = cm.getBlue(pixels[(i-1)*iw+j]);  
  134.                     int blue3 = cm.getBlue(pixels[(i-1)*iw+j+1]);  
  135.                     int blue4 = cm.getBlue(pixels[i*iw+j-1]);  
  136.                     int blue6 = cm.getBlue(pixels[i*iw+j+1]);  
  137.                     int blue7 = cm.getBlue(pixels[(i+1)*iw+j-1]);  
  138.                     int blue8 = cm.getBlue(pixels[(i+1)*iw+j]);  
  139.                     int blue9 = cm.getBlue(pixels[(i+1)*iw+j+1]);  
  140.                     int meanBlue = (blue1+blue2+blue3+blue4+blue6+blue7+blue8+blue9)/8;  
  141.                       
  142.                     int rgb = 255<<24|meanRed<<16|meanGreen<<8|meanBlue;   
  143.                     grayImage.setRGB(j, i, rgb);  
  144.                 }     
  145.             }  
  146.             tmp = grayImage;  
  147.             repaint();  
  148.           
  149.         }else{  
  150.             JOptionPane.showMessageDialog(null, "先点击“装载图像”，3Q！","提示：",  
  151.                     JOptionPane.WARNING_MESSAGE);  
  152.             }  
  153.     }  
  154.   //按钮动作的实现 中值滤波    
  155.     public void jMedian_ActionPerformed(ActionEvent e) {      
  156.         if(flag_load){  
  157.             try{  
  158.                   PixelGrabber pg = new PixelGrabber(im,0,0,iw,ih,pixels,0,iw);  
  159.                   pg.grabPixels();  
  160.               }catch(InterruptedException e3){  
  161.                 e3.printStackTrace();  
  162.               }  
  163.             BufferedImage grayImage = new BufferedImage(iw, ih,   
  164.                       BufferedImage.TYPE_INT_RGB);  
  165.               
  166.             ColorModel cm = ColorModel.getRGBdefault();  
  167.               
  168.             int[] tpRed = new int[9];  
  169.             int[] tpGreen = new int[9];  
  170.             int[] tpBlue = new int[9];  
  171.               
  172.             for(int i=1;i<ih-1;i++){  
  173.                 for(int j=1;j<iw-1;j++){  
  174.                       
  175.                     tpRed[0] = cm.getRed(pixels[(i-1)*iw+j-1]);  
  176.                     tpRed[1] = cm.getRed(pixels[(i-1)*iw+j]);  
  177.                     tpRed[2] = cm.getRed(pixels[(i-1)*iw+j+1]);  
  178.                     tpRed[3] = cm.getRed(pixels[i*iw+j-1]);  
  179.                     tpRed[4] = cm.getRed(pixels[i*iw+j]);  
  180.                     tpRed[5] = cm.getRed(pixels[i*iw+j+1]);  
  181.                     tpRed[6] = cm.getRed(pixels[(i+1)*iw+j-1]);  
  182.                     tpRed[7] = cm.getRed(pixels[(i+1)*iw+j]);  
  183.                     tpRed[8] = cm.getRed(pixels[(i+1)*iw+j+1]);  
  184.                         for(int rj=0; rj<8; rj++){  
  185.                         for(int ri=0; ri<8-rj; ri++){  
  186.                             if(tpRed[ri]>tpRed[ri+1]){  
  187.                                 int Red_Temp = tpRed[ri];  
  188.                                 tpRed[ri] = tpRed[ri+1];  
  189.                                 tpRed[ri+1] = Red_Temp;  
  190.                             }  
  191.                         }  
  192.                     }  
  193.                     int medianRed = tpRed[4];  
  194.                       
  195.                     tpGreen[0] = cm.getGreen(pixels[(i-1)*iw+j-1]);  
  196.                     tpGreen[1] = cm.getGreen(pixels[(i-1)*iw+j]);  
  197.                     tpGreen[2] = cm.getGreen(pixels[(i-1)*iw+j+1]);  
  198.                     tpGreen[3] = cm.getGreen(pixels[i*iw+j-1]);  
  199.                     tpGreen[4] = cm.getGreen(pixels[i*iw+j]);  
  200.                     tpGreen[5] = cm.getGreen(pixels[i*iw+j+1]);  
  201.                     tpGreen[6] = cm.getGreen(pixels[(i+1)*iw+j-1]);  
  202.                     tpGreen[7] = cm.getGreen(pixels[(i+1)*iw+j]);  
  203.                     tpGreen[8] = cm.getGreen(pixels[(i+1)*iw+j+1]);  
  204.                     for(int rj=0; rj<8; rj++){  
  205.                         for(int ri=0; ri<8-rj; ri++){  
  206.                             if(tpGreen[ri]>tpGreen[ri+1]){  
  207.                                 int Green_Temp = tpGreen[ri];  
  208.                                 tpGreen[ri] = tpGreen[ri+1];  
  209.                                 tpGreen[ri+1] = Green_Temp;  
  210.                             }  
  211.                         }  
  212.                     }  
  213.                     int medianGreen = tpGreen[4];  
  214.                       
  215.                     tpBlue[0] = cm.getBlue(pixels[(i-1)*iw+j-1]);  
  216.                     tpBlue[1] = cm.getBlue(pixels[(i-1)*iw+j]);  
  217.                     tpBlue[2] = cm.getBlue(pixels[(i-1)*iw+j+1]);  
  218.                     tpBlue[3] = cm.getBlue(pixels[i*iw+j-1]);  
  219.                     tpBlue[4] = cm.getBlue(pixels[i*iw+j]);  
  220.                     tpBlue[5] = cm.getBlue(pixels[i*iw+j+1]);  
  221.                     tpBlue[6] = cm.getBlue(pixels[(i+1)*iw+j-1]);  
  222.                     tpBlue[7] = cm.getBlue(pixels[(i+1)*iw+j]);  
  223.                     tpBlue[8] = cm.getBlue(pixels[(i+1)*iw+j+1]);  
  224.                     for(int rj=0; rj<8; rj++){  
  225.                         for(int ri=0; ri<8-rj; ri++){  
  226.                             if(tpBlue[ri]>tpBlue[ri+1]){  
  227.                                 int Blue_Temp = tpBlue[ri];  
  228.                                 tpBlue[ri] = tpBlue[ri+1];  
  229.                                 tpBlue[ri+1] = Blue_Temp;  
  230.                             }  
  231.                         }  
  232.                     }  
  233.                     int medianBlue = tpBlue[4];  
  234.                       
  235.                     int rgb = 255<<24|medianRed<<16|medianGreen<<8|medianBlue;   
  236.                     grayImage.setRGB(j, i, rgb);  
  237.                 }     
  238.             }  
  239.             tmp = grayImage;  
  240.             repaint();  
  241.           
  242.         }else{  
  243.             JOptionPane.showMessageDialog(null, "先点击“装载图像”，3Q！","提示：",  
  244.                     JOptionPane.WARNING_MESSAGE);  
  245.             }  
  246.     }  
  247.     //按钮动作的实现  save  
  248.     public void jSave_ActionPerformed(ActionEvent e) throws IOException{      
  249.         if(flag_load){  
  250.               
  251.             BufferedImage bi = new BufferedImage(tmp.getWidth(null),tmp.getHeight(null),   
  252.                     BufferedImage.TYPE_INT_RGB);  
  253.             Graphics g = bi.getGraphics();  
  254.             g.drawImage(tmp,0, 0,null);  
  255.             g.dispose();  
  256.               
  257.             File save_path=new File("E:\\f2\\sc\\save.jpg");  
  258.             ImageIO.write(bi, "JPG", save_path);  
  259.   
  260.     }else{  
  261.         JOptionPane.showMessageDialog(null, "先点击“装载图像”，3Q！","提示：",  
  262.                 JOptionPane.WARNING_MESSAGE);  
  263.         }  
  264.     }  
  265.     //按钮动作的实现  退出  
  266.     public void jQuit_ActionPerformed(ActionEvent e){  
  267.         System.exit(0);  
  268.     }  
  269.   //绘图函数  
  270.     public void paint(Graphics g){  
  271.         if(flag_load){  
  272.             g.drawImage(tmp,50,50,this);  
  273.         }else{}  
  274.     }  
  275.       
  276.     public static void main(String[] args) {  
  277.         colorfilter ti = new colorfilter();  
  278.         ti.setSize(1000,860);  
  279.         ti.setVisible(true);  
  280.     }  
  281. }  
  • 大小: 145.4 KB
  • 大小: 47.9 KB
  • 大小: 35.4 KB

http://hello-wangfeng.iteye.com/blog/1719909
u011393661
关注
均值滤波java_均值滤波和中值滤波的java代码
weixin_30845345的博客
02-13 312
packagep01;importjava.awt.*;importjava.awt.event.*;importjava.awt.image.*;importjava.io.File;importjava.io.IOException;importjavax.imageio.ImageIO;importjavax.swing.*;publicclasscolorfilter...
java——实现中值、均值滤波器
梁超的博客
08-28 832
入口类Entry.java public class Entry { public static void main(String[] args) { MyFrame myFrame=new MyFrame(); } } 窗口类MyFrame.java public class MyFrame extends JFrame{ Filter mf; public MyFrame() ...
Java数据处理之中值滤波算法
01-13 571
　　一般而言，对于硬件收集来的各种数据都是要进行滤波的，滤波的手法有很多种，只是一般都不会在java层进行。但是也有一些特别小巧实用易懂的方法，可以用来对数据进行滤波，譬如中值滤波算法。 　　该算法在波形类数据中经常会用上，主要效果是突出特征波形，使得波形更加”凹凸有致“。但是也有一定副作用，那就是如果波形本身就非常漂亮，那就有可能将其特征波形稍稍磨平——当然这种效果基本还是在能接受范...
OpenCV计算机视觉库全面解析
最新发布
极客代码
07-23 1431
OpenCV（Open Source Computer Vision Library）是一个广泛使用的开源计算机视觉库，它提供了丰富的图像和视频处理功能，以及一些机器学习算法。OpenCV的核心技术主要包括图像处理、特征检测与描述、目标检测与跟踪、摄像机标定与姿态估计等。OpenCV的设计目标是提供一套简单而且可扩展的计算机视觉库，使得它能够方便地在实际的应用、研究、开发中被使用。OpenCV的高级应用使得计算机视觉任务得以更加高效和准确地完成。
使用中值滤波原理过滤异常数据
weixin_30662109的博客
03-24 603
extends：http://www.cnblogs.com/haoxinyue/archive/2013/09/07/3307044.html 最近有一个程序需要做一些数据分析，遇见一个求平均值的需求。数据序列由传感器输出类似如下：[10,12,11,25,9,10,9,45,13,12,10,11,78,12,12,13,10,9]。在这个序列中很明显的25，45，78都是要远远大于其他...
均值滤波与中值滤波的应用_MATLAB中值滤波_均值滤波中值滤波的matlab代码_中值滤波_plandop_
09-30
在MATLAB中，我们可以利用内置函数实现均值滤波和中值滤波。这两种滤波方法各有特点，广泛应用于不同场景。下面我们将详细介绍这两种滤波方法以及它们在MATLAB中的实现。 **1. 均值滤波** 均值滤波是一种线性滤波...
均值滤波和中值滤波matlab代码
12-19
本文件包提供了两种基本的滤波方法的MATLAB实现：均值滤波和中值滤波。这两种滤波器在图像处理中扮演着重要的角色，各有其独特优势和应用场景。 1. **均值滤波**： 均值滤波是一种线性滤波方法，它通过在图像上...
matlab实现均值滤波和中值滤波（自编写源码）
12-12
在给定的压缩包文件中，重点展示了两种基本的滤波方法：均值滤波和中值滤波，这些都是使用Matlab编程环境实现的。Matlab作为强大的科学计算工具，提供了丰富的图像处理函数和便利的编程接口，使得这些滤波算法的实现...
均值滤波_均值滤波_中值滤波_
09-29
在给定的标题“均值滤波_均值滤波_中值滤波_”和描述“matlab实现均值滤波，中值滤波，同时操作”中，我们关注的焦点是两种基本的滤波方法：均值滤波和中值滤波。MATLAB作为一种强大的数值计算和编程环境，被广泛...
java实现图像中值滤波
04-16
java实现图像中值滤波
均值中值滤波java实现.docx
06-16
用java实现中值滤波与均值滤波，具体包括通过按钮实现对彩色图像的滤波处理。
中值滤波Java实现
01-24
中值滤波Java实现.实现图像中值滤波。
程序4.2五点滑动平均法平滑处理
09-06
数据平滑处理可以除去采样信号中的噪声部分也可以消除信号中的不规则趋势。
均值滤波、中值滤波 matlab代码.m
08-13
用于对图像的均值滤波或中值滤波处理比较的MATLAB代码
【图像去噪】中值滤波和均值滤波matlab源码
m0_60703264的博客
09-08 2074
一.均值滤波 图片中一个方块区域（一般为3*3）内，中心点的像素为全部点像素值的平均值。均值滤波就是对于整张图片进行以上操作。 我们可以看下图的矩阵进行理解 缺陷：均值滤波本身存在着固有的缺陷，即它不能很好地保护图像细节，在图像去噪的同时也破坏了图像的细节部分，从而使图像变得模糊，不能很...
JAVA空间滤波——中值滤波
席木木的博客
10-09 1253
在讲述如何通过JAVA编程实现中值滤波之前，先谈一下与空间滤波相关的数字图像处理的概念。 1.关于图像和数字图像处理 可以将图像视为是一个二维函数F(x,y),其中(x,y)代表一张数字图像上面对应像素点的坐标，而在任意坐标处的函数值F(x,y)就是该像素点的灰度或者亮度。因此，数字图像处理的过程就是通过计算机编程实现操作数字图像像素矩阵的过程。初学者大多接触的数字图像处理工具是Matlab，它里...
java 中值滤波_matlab图像处理-中值滤波原理(示例代码)
weixin_39639040的博客
02-21 199
中值滤波原理??中值滤波本质上是一种统计排序滤波器。对于原图像中某点(i，j)，中值滤波以该点为中心的邻域内的所有像素的统计排序中值作为(i，j)点的响应。??中值不同于均值，是指排序队列中位于中间位置的元素的值，例如，采用3x3中值滤波器，某点(i，j)的8个邻域的一系列像素值为12，18，25，11、118，17、35，29，23，统计排序结果为11、12，17，18，23，25，29，35，...
Java实现均值、索伯尔、拉普拉斯滤波
你们瞎搞
10-22 1573
空间滤波的定义： 滤波的本义是指信号有各种频率的成分,滤掉不想要的成分,即为滤掉常说的噪声,留下想要的成分，这即是滤波的过程,也是目的。空间滤波是一种采用滤波处理的影像增强方法。其理论基础是空间卷积和空间相关。目的是改善影像质量，包括去除高频噪声与干扰，及影像边缘增强、线性增强以及去模糊等。分为低通滤波（平滑化）、高通滤波（锐化）和带通滤波。 图像需要增强的原因： 各类图像处理系统在图像的采集、获取、传送和转换(如成像、复制扫描、传输以及显示等)过程中，均处在复杂的环境中，光照、电磁多变，所有的图像均
matlab均值滤波和中值滤波代码
04-19
我可以回答关于matlab均值滤波和中值滤波代码的问题。以下是matlab均值滤波的代码示例： ```Matlab img = imread('image.jpg'); % 读入图像 img_noise = imnoise(img, 'salt & pepper', 0.02); % 添加噪声 h = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值