图象处理.txt

图象处理程序,可以潜逃在JSP中,实现最基本的功能,GUI的界面,还可以继续扩充功能

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import javax.swing.event.*;
import java.lang.Double;
import java.math.*;

class convolveOpTestPanel extends Panel
{
	BufferedImage bi,biSrc,biDest;
	Graphics2D big;
	Image im,cropped;
	int x,w,h,flag,numberRed,numberBlue,numberGreen;
	float scaleFactor=1.0f;
	float offset=0.0f;
	int[] pixels;
    static int max;
	static int max_number;
	double p_red[];
	double p_green[];
	double p_blue[];
	int number_red[];
	int number_green[];
	int number_blue[];
	
	public convolveOpTestPanel()
	{
		Panel pdown;
		pdown=new Panel();
		JButton sharpen=new JButton("sharpening");
		JButton noise_reduction=new JButton("noise reduction");
		JButton edge=new JButton("edge");
		JButton reset=new JButton("Reset");
		JButton histogram_equalization=new JButton("histogram_equalization");
		JButton contrast_transform_1=new JButton("contrast_transform(making it bright)");
		JButton contrast_transform_2=new JButton("contrast_transform(making it dark)");
		JButton mid_reduction=new JButton("middle noise reduction");
		
		pdown.setBackground(Color.orange);
		pdown.setLayout(new GridLayout(4,0));
		pdown.add(sharpen);
		pdown.add(noise_reduction);
		pdown.add(mid_reduction);
		pdown.add(contrast_transform_1);
		pdown.add(contrast_transform_2);
		pdown.add(histogram_equalization);
		pdown.add(edge);
		pdown.add(reset);
		this.setLayout(new BorderLayout());
		this.add(pdown,BorderLayout.SOUTH);
		
		
	//	filedialog=new FileDialog(pdown,"choose a picture",FileDialog.LOAD);
		
		MediaTracker tracker=new MediaTracker(this);
		im=Toolkit.getDefaultToolkit().getImage("21.jpg");
		tracker.addImage(im,0);
		try
		{
			tracker.waitForID(0);
			
		}catch(InterruptedException e)
		{
			e.printStackTrace();
		}
		w=im.getWidth(this);
		h=im.getHeight(this);
		System.out.println(w);
		System.out.println(h);
		pixels=new int[w*h];
 	    try{
		    PixelGrabber pg=new PixelGrabber(im,0,0,w,h,pixels,0,w);
		    pg.grabPixels();
		
	      }catch(InterruptedException e){e.printStackTrace();}
	
		
		biSrc=new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
		big=biSrc.createGraphics();
		big.drawImage(im,0,0,this);
		biDest=new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
		bi=new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
		bi=biSrc;
		
		sharpen.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				sharpen_actionPerformed(e);
				repaint();
			}
		});
		
		contrast_transform_2.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				contrast_transform_2_actionPerformed(e);
				repaint();
			}
		});
		
		
		noise_reduction.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				noise_reduction_actionPerformed(e);
				repaint();
			}
		});
		
		mid_reduction.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				mid_reduction_actionPerformed(e);
				repaint();
			}
		});
		
		contrast_transform_1.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				contrast_transform_1_actionPerformed(e);
				repaint();
			}
		});
		
		histogram_equalization.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				histogram_equalization_actionPerformed(e);
				repaint();
			}
		});
		
		edge.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				edge_actionPerformed(e);
				repaint();
			}
		});
		
		
		
		reset.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				reset_actionPerformed(e);
				repaint();
			}
		});
	}
		
		
	public void sharpen_actionPerformed(ActionEvent e)
	{
		float data[]={-1.0f,-1.0f,-1.0f,
			          -1.0f,9.0f,-1.0f,
			           -1.0f,-1.0f,-1.0f };
	    Kernel kernel=new Kernel(3,3,data);
		ConvolveOp convolve=new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null);
		convolve.filter(biSrc,biDest);
		bi=biDest;
	   
	}
	
	public void contrast_transform_2_actionPerformed(ActionEvent e)
	{
		ColorModel cm=ColorModel.getRGBdefault();
	    for(x=0;x<w*h;x++)
	      {
		   int alpha=cm.getAlpha(pixels[x]);
		      
		   int red=cm.getRed(pixels[x]);
              red=new Double((red/255.0)*(red/255.0)*255).intValue();
              //red=255;
		   int green=cm.getGreen(pixels[x]);
		      green=new Double((green/255.0)*(green/255.0)*255).intValue();
		      //green=255;
           int blue=cm.getBlue(pixels[x]);
              blue=new Double((blue/255.0)*(blue/255.0)*255).intValue();
             // blue=255;
           pixels[x]=alpha<<24|red<<16|green<<8|blue;
	      }
	
	   ImageProducer ip=new MemoryImageSource(w,h,pixels,0,w);
	   cropped=createImage(ip);
	   big=biDest.createGraphics();
	   big.drawImage(cropped,0,0,this);
	   bi=biDest;
	}
	
	//	float data[]={1.0f/9.0f,1.0f/10.0f,1.0f/9.0f,
                  //  1.0f/9.0f,9.0f/12.0f,1.0f/9.0f,
			       //  1.0f/9.0f,1.0f/10.0f,1.0f/9.0f };
	
	public void mid_reduction_actionPerformed(ActionEvent e)
	{
		ColorModel cm=ColorModel.getRGBdefault();
	    for(x=0;x<w*h;x++)
	      {
		   int alpha=cm.getAlpha(pixels[x]);
	       
	       int a[]=new int[9];
	       int b[]=new int[9];
	       if(x+1>=0&&x+1<w*h)
             a[0]=cm.getRed(pixels[x+1]);
           else
             a[0]=0;
           
           if(x-1>=0&&x-1<w*h)  
             a[1]=cm.getRed(pixels[x-1]);
           else
             a[1]=0;
           
           if(x+w>=0&&x+w<w*h)
             a[2]=cm.getRed(pixels[x+w]);
           else
             a[2]=0;
             
           if(x+w-1>=0&&x+w-1<w*h)
              a[3]=cm.getRed(pixels[x+w-1]);
           else
              a[3]=0;
              
           if(x+w+1>=0&&x+w+1<w*h)
              a[4]=cm.getRed(pixels[x+w+1]);
           else
              a[4]=0;
              
           if(x-w>=0&&x-w<w*h)   
              a[5]=cm.getRed(pixels[x-w]);
           else
              a[5]=0;
           
           if(x-w+1>=0&&x-w+1<w*h)
             a[6]=cm.getRed(pixels[x-w+1]);
           else
              a[6]=0;
           
           if(x-w-1>=0&&x-w-1<w*h)
             a[7]=cm.getRed(pixels[x-w-1]);
           else
             a[7]=0;
             
           if(x>=0&&x<w*h)
             a[8]=cm.getRed(pixels[x]);
           else
             a[8]=0;
           int j,k;
           for (j=0;j<9;j++)
              {
                max=0;
              	for(k=0;k<9;k++)
                  if(a[k]>max)
                 	   	{max=a[k];max_number=k;}
                b[j]=max;
                a[max_number]=0;
               }
           int red=b[4];
                 	   
           if(x+1>=0&&x+1<w*h)
             a[0]=cm.getGreen(pixels[x+1]);
           else
             a[0]=0;
           
           if(x-1>=0&&x-1<w*h)  
             a[1]=cm.getGreen(pixels[x-1]);
           else
             a[1]=0;
           
           if(x+w>=0&&x+w<w*h)
             a[2]=cm.getGreen(pixels[x+w]);
           else
             a[2]=0;
             
           if(x+w-1>=0&&x+w-1<w*h)
              a[3]=cm.getGreen(pixels[x+w-1]);
           else
              a[3]=0;
              
           if(x+w+1>=0&&x+w+1<w*h)
              a[4]=cm.getGreen(pixels[x+w+1]);
           else
              a[4]=0;
              
           if(x-w>=0&&x-w<w*h)   
              a[5]=cm.getGreen(pixels[x-w]);
           else
              a[5]=0;
           
           if(x-w+1>=0&&x-w+1<w*h)
             a[6]=cm.getGreen(pixels[x-w+1]);
           else
              a[6]=0;
           
           if(x-w-1>=0&&x-w-1<w*h)
             a[7]=cm.getGreen(pixels[x-w-1]);
           else
             a[7]=0;
             
           if(x>=0&&x<w*h)
             a[8]=cm.getGreen(pixels[x]);
           else
             a[8]=0;
           for (j=0;j<9;j++)
              {
              	max=0;
              	for(k=0;k<9;k++)
                  if(a[k]>max)
                 	   	{max=a[k];max_number=k;}
                b[j]=max;
                a[max_number]=0;
               }
           int green=b[4];
		      
         if(x+1>=0&&x+1<w*h)
             a[0]=cm.getBlue(pixels[x+1]);
           else
             a[0]=0;
           
           if(x-1>=0&&x-1<w*h)  
             a[1]=cm.getBlue(pixels[x-1]);
           else
             a[1]=0;
           
           if(x+w>=0&&x+w<w*h)
             a[2]=cm.getBlue(pixels[x+w]);
           else
             a[2]=0;
             
           if(x+w-1>=0&&x+w-1<w*h)
              a[3]=cm.getBlue(pixels[x+w-1]);
           else
              a[3]=0;
              
           if(x+w+1>=0&&x+w+1<w*h)
              a[4]=cm.getBlue(pixels[x+w+1]);
           else
              a[4]=0;
              
           if(x-w>=0&&x-w<w*h)   
              a[5]=cm.getBlue(pixels[x-w]);
           else
              a[5]=0;
           
           if(x-w+1>=0&&x-w+1<w*h)
             a[6]=cm.getBlue(pixels[x-w+1]);
           else
              a[6]=0;
           
           if(x-w-1>=0&&x-w-1<w*h)
             a[7]=cm.getBlue(pixels[x-w-1]);
           else
             a[7]=0;
             
           if(x>=0&&x<w*h)
             a[8]=cm.getBlue(pixels[x]);
           else
             a[8]=0;
           for (j=0;j<9;j++)
              {
              	max=0;
              	for(k=0;k<9;k++)
                  if(a[k]>max)
                 	   	{max=a[k];max_number=k;}
                b[j]=max;
                a[max_number]=0;
               }
           int blue=b[4];
             
           pixels[x]=alpha<<24|red<<16|green<<8|blue;
	      }
	
	   ImageProducer ip=new MemoryImageSource(w,h,pixels,0,w);
	   cropped=createImage(ip);
	   big=biDest.createGraphics();
	   big.drawImage(cropped,0,0,this);
	   bi=biDest;
	}	
	
	public void noise_reduction_actionPerformed(ActionEvent e)
	{
		float data[]={ 5.0f/41.0f,5.0f/41.0f,5.0f/41.0f,
			           5.0f/41.0f,1.0f/41.0f,5.0f/41.0f,
			           5.0f/41.0f,5.0f/41.0f,5.0f/41.0f  };
		Kernel kernel=new Kernel(3,3,data);
		ConvolveOp convolve=new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null);
		convolve.filter(biSrc,biDest);
		bi=biDest;
	}
	
	public void contrast_transform_1_actionPerformed(ActionEvent e)
	{
		ColorModel cm=ColorModel.getRGBdefault();
	    for(x=0;x<w*h;x++)
	      {
		   int alpha=cm.getAlpha(pixels[x]);
		      
		   int red=cm.getRed(pixels[x]);
              red=new Double(Math.sqrt(red/255.0)*255).intValue();
              //red=255;
		   int green=cm.getGreen(pixels[x]);
		      green=new Double(Math.sqrt(green/255.0)*255).intValue();
		      //green=255;
           int blue=cm.getBlue(pixels[x]);
              blue=new Double(Math.sqrt(blue/255.0)*255).intValue();
             // blue=255;
           pixels[x]=alpha<<24|red<<16|green<<8|blue;
	      }
	
	   ImageProducer ip=new MemoryImageSource(w,h,pixels,0,w);
	   cropped=createImage(ip);
	   big=biDest.createGraphics();
	   big.drawImage(cropped,0,0,this);
	   bi=biDest;
	   
	   
	}
	
	public void histogram_equalization_actionPerformed(ActionEvent e)
	{
	   ColorModel cm=ColorModel.getRGBdefault();
	   int j;
	   p_red=new double[256];
	   number_red=new int[256];
	   p_green=new double[256];
	   number_green=new int[256];
	   p_blue=new double[256];
	   number_blue=new int[256];
	   for(j=0;j<256;j++)
	   {
		  p_red[j]=0.0;
		  number_red[j]=0;
	   }
	   for(j=0;j<256;j++)
	   {
		  p_green[j]=0.0;
		  number_green[j]=0;
	   }
	   for(j=0;j<256;j++)
	   {
		  p_blue[j]=0.0;
		  number_blue[j]=0;
	   }
	   
	   for(x=0;x<w*h;x++)
	   {
		   int red=cm.getRed(pixels[x]);
		   j=red;
		   number_red[j]++;
		   
		   int green=cm.getGreen(pixels[x]);
           j=green;
		   number_green[j]++;
		   
		   int blue=cm.getBlue(pixels[x]);
		   j=blue;
		   number_blue[j]++;
		} 
	   
	       
	   for(j=0;j<256;j++)
	       p_red[j]=number_red[j]/(w*h*1.0);     
	   for(j=0;j<256;j++)
	       p_green[j]=number_green[j]/(w*h*1.0);         
	   for(j=0;j<256;j++)
	       p_blue[j]=number_blue[j]/(w*h*1.0); 
	   
	   
	       
	   for(j=1;j<256;j++)
	       p_red[j]=p_red[j]+p_red[j-1];
	   
	   for(j=0;j<256;j++)
	       number_red[j]=new Double(p_red[j]*256.0).intValue(); 
	   for(j=1;j<256;j++)
	       p_green[j]=p_green[j]+p_green[j-1];
	   for(j=0;j<256;j++)
	       number_green[j]=new Double(p_green[j]*256.0).intValue();  
       for(j=1;j<256;j++)
	       p_blue[j]=p_blue[j]+p_blue[j-1];
	   for(j=0;j<256;j++)
	       number_blue[j]=new Double(p_blue[j]*256.0).intValue();  
     
     
       for(x=0;x<w*h;x++)
       {
       	  int alpha=cm.getAlpha(pixels[x]); 
       	  
       	  int red=cm.getRed(pixels[x]);
          j=red;
       	  red=number_red[j];
       	  
       	  int green=cm.getGreen(pixels[x]);
       	  j=green;
       	  green=number_green[j];
       	        
       	  int blue=cm.getBlue(pixels[x]);
       	  j=blue;
       	  blue=number_blue[j];  
       	         
	      pixels[x]=alpha<<24|red<<16|green<<8|blue;
       }
	   
	   
	   ImageProducer ip=new MemoryImageSource(w,h,pixels,0,w);
	   cropped=createImage(ip);
	   big=biDest.createGraphics();
	   big.drawImage(cropped,0,0,this);
	   bi=biDest;
	}
		
		
	    
	public void edge_actionPerformed(ActionEvent e)
	{
		float data[]={ 0.0f,-1.0f,0.0f,
			           -1.0f,4.0f,-1.0f,
			            0.0f,-1.0f,0.0f  };
		Kernel kernel=new Kernel(3,3,data);
		ConvolveOp convolve=new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null);
		convolve.filter(biSrc,biDest);
		bi=biDest;
	}
	
	 public void reset_actionPerformed(ActionEvent e)
	{
		bi=biSrc;
	}
		
	public void paint(Graphics g)
	{
		Graphics2D g2D=(Graphics2D)g;
		g2D.drawImage(biSrc,10,30,this);
		g2D.drawImage(bi,10,40+h,this);
	}
	
}
	
public class convolveOpTest extends Frame
{
	public convolveOpTest()
	{
		addWindowListener(new WindowAdapter()
		{
			public void windowClosing(WindowEvent e)
			{
				System.exit(0);
			}
		});
	
	    convolveOpTestPanel p=new convolveOpTestPanel();
	    add(p);
	}
	
	
	public static void main(String args[])
	{
		convolveOpTest f=new convolveOpTest();
		f.setSize(500,250);
		f.setVisible(true);
	}
		
}