imageprocessingapplet.java

来自「java的书上例子」· Java 代码 · 共 332 行

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.*;
import java.applet.Applet;
import java.awt.color.*;

/** 一个对图象进行处理的小应用程序 
  * @作者：尉哲明
  * @日期：2001年5月 */

/** JApplet类 */
public class ImageProcessingApplet extends JApplet implements ActionListener
{
	private JComboBox comboBox;
	static ImageProcessingPanel panel;
	BufferedImage image;
	
	/** init()方法 */	
	public void init()
	{
		Container contentPane=getContentPane();
		
		panel=new ImageProcessingPanel(); //定义用于显示和处理图像的面板
		contentPane.add(panel,"Center");
		comboBox=new JComboBox();//创建一个下拉式菜单，可选择对图像进行处理
		
		comboBox.addItem(new OrderRotate());//该选项对图像进行顺时针旋转
		comboBox.addItem(new ConverseRotate());//该选项对图像进行逆时针旋转
		comboBox.addItem(new LeftAndUpTranslate());//图像向左和向上平移
		comboBox.addItem(new RightAndDownTranslate());//图像向右和向下平移
		comboBox.addItem(new Contract()); //该选项使图像按比例缩小
		comboBox.addItem(new Expand());  //该选项使图像按比例放大
		comboBox.addItem(new LeftAndUpShear());//该两个选项对图像进行剪切
		comboBox.addItem(new RightAndDownShear());
		comboBox.addItem(new Inverse()); //使图像倒转
		comboBox.addItem(new Blur()); //使图像模糊
		comboBox.addItem(new EdgeDetect()); //该选项执行边界检测
		comboBox.addItem(new Brighten()); //加亮图像
		comboBox.addItem(new ReverseDisplay()); //反向显示
		comboBox.addItem(new ColorConvert()); //对图像进行颜色空间的转换
		
		comboBox.addActionListener(this);
		contentPane.add(comboBox,"North");
		
		String name="pisa.jpg";
		Image loadedImage = getImage(getCodeBase(),name);
      	image=new LoadImage().load(loadedImage);//加载图像并写入缓冲图像中
   		panel.redraw(image); //显示缓冲图像
	}// init()方法结束
	
	/** 对下拉式菜单的动作事件处理方法 */
	public void actionPerformed(ActionEvent evt)
    {
		ImageProcessing source = (ImageProcessing)comboBox.getSelectedItem();
    	if(image!=null)
		{
	  		image=source.imageFilter(panel,image);//对图像进行处理
			panel.redraw(image); //显示被处理后的图像		
      	}
   	}//actionPerformed()方法结束
}// ImageProcessingApplet类定义结束

/** 定义图像处理面板类 */
class ImageProcessingPanel extends JPanel 
{
	private BufferedImage image;
    
	/** 图像处理面板组件的paintComponent()方法 */
	public void paintComponent(Graphics g)
   	{
		super.paintComponent(g);
      	if (image != null)
        	g.drawImage(image, 0, 0, null);
   	}//paintComponent()方法结束

	/** 该方法用来显示加载或处理后的图象 */
   	public void redraw(BufferedImage image)
   	{
   		this.image=image;
		repaint();
   	}//redraw()方法结束
} // ImageProcessingPanel类定义结束

/** 定义加载图像类 */
class LoadImage 
{

	/** 该方法加载图像并写入缓冲图像中 */
	public BufferedImage load(Image loadedImage)
   	{ //下面4行语句加载图像
		MediaTracker tracker = new MediaTracker(ImageProcessingApplet.panel);
      	tracker.addImage(loadedImage, 0);
      	try { tracker.waitForID(0); }
      	catch (InterruptedException e) {}
        //下面5行将加载的图像写入缓冲图像image中
      	BufferedImage image = new BufferedImage(loadedImage.getWidth(null),loadedImage.getHeight(null), BufferedImage.TYPE_INT_RGB);
      	Graphics2D g2 = image.createGraphics();
      	g2.drawImage(loadedImage, 0, 0, null);
      	return image;
	}//load()方法结束
}// LoadImage类定义结束

/** 该抽象类定义图像处理操作 */  
abstract class ImageProcessing
{
	BufferedImage filteredImage;//定义处理后的缓冲图像对象
	
	/** 图像处理操作方法imageFilter()，对img进行操作 */
	public abstract BufferedImage imageFilter(JPanel panel,BufferedImage img); 

	/** 该方法为能在下拉式菜单中显示类名而定义 */
	public String toString() 
	{
		return getClass().getName();
	}
}// ImageProcessing抽象类定义结束

/** 该类定义对图像的缩小操作 */   
class Contract extends ImageProcessing
{ 
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getScaleInstance(0.5,0.5);//缩小一半
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(image.getWidth()/2, image.getHeight()/2,image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// Contract类定义结束

/** 该类定义对图像的放大操作 */
class Expand extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getScaleInstance(2,2);//放大一倍
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(image.getWidth()*2, image.getHeight()*2,image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// Expand类定义结束

/** 该类定义对图像的倒转操作 */
class Inverse extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform=null;
		try
		{
			transform = new AffineTransform().createInverse();
		}catch(NoninvertibleTransformException e)
		{
		}
		
		if (transform!=null)
		{
      		BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
			filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
			op.filter(image, filteredImage);
      		return filteredImage;
		}
		else
			return image;
   	}
}// Inverse类定义结束

/** 该类定义对图像的顺时针旋转操作 */
class OrderRotate extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getRotateInstance(Math.toRadians(20),image.getWidth() / 2, image.getHeight() / 2);
		//顺时针旋转20度 
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(panel.getWidth(), panel.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// OrderRotate类定义结束

/** 该类定义对图像的反时针旋转操作 */
class ConverseRotate extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getRotateInstance(Math.toRadians(-20),image.getWidth() / 2, image.getHeight() / 2);
		//反时针旋转20度
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(panel.getWidth(), panel.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// ConverseRotate类定义结束

/** 该类定义对图像的左上方向剪切操作 */
class LeftAndUpShear extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getShearInstance(0.1, 0.1);
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// LeftAndUpShear类定义结束

/** 该类定义对图像的右下方向剪切操作 */
class RightAndDownShear extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getShearInstance(-0.1, -0.1);
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// RightAndDownShear类定义结束

/** 该类定义对图像的向右下方向平移操作 */
class RightAndDownTranslate extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getTranslateInstance(image.getWidth() / 5, image.getHeight() / 5);
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(panel.getWidth(), panel.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// RightAndDownTranslate类定义结束

/** 该类定义对图像的向左上方向平移操作 */
class LeftAndUpTranslate extends ImageProcessing
{
	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		AffineTransform transform = AffineTransform.getTranslateInstance(-image.getWidth() / 5, -image.getHeight() / 5);
      	BufferedImageOp op = new AffineTransformOp(transform,AffineTransformOp.TYPE_BILINEAR);
		filteredImage = new BufferedImage(panel.getWidth(), panel.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// LeftAndUpTranslate类定义结束

/** 该类定义图像的模糊操作 */
class Blur extends ImageProcessing
{
   	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
     	float weight = 1.0f/9.0f;
      	float[] elements = new float[9];
      	for (int i = 0; i < 9; i++)
         	elements[i] = weight;
      	Kernel kernel = new Kernel(3, 3, elements);
      	ConvolveOp op = new ConvolveOp(kernel);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// Blur类定义结束

/** 该类定义图像的边界检测操作 */	
class EdgeDetect extends ImageProcessing
{
   	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
     	float[] elements =
         	{  
				0.0f, -1.0f, 0.0f,
            	-1.0f,  4.f, -1.0f,
            	0.0f, -1.0f, 0.0f
         	};
      	Kernel kernel = new Kernel(3, 3, elements);
      	ConvolveOp op = new ConvolveOp(kernel);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// EdgeDetect类定义结束

/** 该类定义增亮图像的操作 */	
class Brighten extends ImageProcessing
{
   	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
     	float a = 1.5f;
      	float b = -20.0f;
      	RescaleOp op = new RescaleOp(a, b, null);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());  
		op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// Brighten类定义结束

/** 该类定义图像的反向显示操作 */	
class ReverseDisplay extends ImageProcessing
{
   	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
     	byte negative[] = new byte[256];
      	for (int i = 0; i < 256; i++)
         	negative[i] = (byte)(255 - i);
      	ByteLookupTable table = new ByteLookupTable(0, negative);
      	LookupOp op = new LookupOp(table, null);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());
	  	op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// ReverseDisplay类定义结束

/** 该类定义图像的颜色空间转换操作 */
class ColorConvert extends ImageProcessing
{ 
   	public BufferedImage imageFilter(JPanel panel,BufferedImage image)
   	{
		ColorModel model = image.getColorModel();
		ColorSpace src = model.getColorSpace();
		ColorSpace dst = ColorSpace.getInstance(ColorSpace.CS_LINEAR_RGB);
		ColorConvertOp op = new ColorConvertOp(src,dst,null);
		filteredImage = new BufferedImage(image.getWidth(), image.getHeight(),image.getType());
	  	op.filter(image, filteredImage);
      	return filteredImage;
   	}
}// ColorConvert类定义结束