panel1.java

Java灵感编程1-101之61-80

package imageproc;

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

/**
 * <p>Title:  ImageProc Demo</p>
 * <p>Description: This is a ImageProc Demo</p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: D6-125</p>
 * @author liujun
 * @version 1.0
 */

public class Panel1 extends JPanel {
  BorderLayout borderLayout1 = new BorderLayout();
 //声明两个图像类的变量用于显示和备份
  BufferedImage image,bakimage;

  public Panel1() {
    try {
      jbInit();
    }
    catch(Exception ex) {
      ex.printStackTrace();
    }
  }
  void jbInit() throws Exception {
    this.setLayout(borderLayout1);
  }
  protected void paintComponent(Graphics g) {
    /**@todo: Override this javax.swing.JComponent method*/
    super.paintComponent( g);
      if (image != null)
         g.drawImage(image, 0, 0, null);
  }

   public void loadImage(String name)
   {  // 调用图像
      Image loadedImage
         = Toolkit.getDefaultToolkit().getImage(name);
      MediaTracker tracker = new MediaTracker(this);
      tracker.addImage(loadedImage, 0);
      try { tracker.waitForID(0); }
      catch (InterruptedException e) {}
      //调入图像缓冲
      image = new BufferedImage(loadedImage.getWidth(null),
         loadedImage.getHeight(null), BufferedImage.TYPE_INT_RGB);
      Graphics2D g2 = image.createGraphics();
      g2.drawImage(loadedImage, 0, 0, null);
      bakimage=image;//备份图像，用于恢复图像
      repaint();
   }

   private void filter(BufferedImageOp op)
   {  //创建图像过滤器
       BufferedImage filteredImage
         = new BufferedImage(image.getWidth(), image.getHeight(),
            image.getType());
      op.filter(image, filteredImage);//过滤图像
      image = filteredImage;//画出过滤后的图像
      repaint();
   }

   public  void restore()
   {  //恢复原始图像
      image = bakimage;
      repaint();
   }

   private void convolve(float[] elements)
   {  //用于一个卷积公式的转换
      Kernel kernel = new Kernel(3, 3, elements);
      ConvolveOp op = new ConvolveOp(kernel);
      filter(op);
   }

   public void blur()
   {  //模糊图像
      float weight = 1.0f/9.0f;
      float[] elements = new float[9];
      for (int i = 0; i < 9; i++)
         elements[i] = weight;
      convolve(elements);
   }

   void edgeDetect()
   {  //实现边界处理
     float[] elements =
         {  0.0f, -1.0f, 0.0f,
            -1.0f,  4.f, -1.0f,
            0.0f, -1.0f, 0.0f
         };
      convolve(elements);
   }

   public void brighten()
   {  //加亮图像
      float a = 1.5f;
      float b = -20.0f;
      //RescaleOp类可以得出Xnew=X*a+b;
      RescaleOp op = new RescaleOp(a, b, null);
      filter(op);
   }

   void  toGray()
   { //将有颜色的图像转换为灰度图像
      ColorSpace myColor=ColorSpace.getInstance(ColorSpace.CS_GRAY);
      ColorConvertOp op=new ColorConvertOp(myColor,null);
     filter(op);
   }

}