imageframe.java

一个Java图形图像处理编辑器的源代码,常见的图片处理效果里面都实现了

package PictureDrawer;

import javax.swing.JInternalFrame;
import javax.swing.event.InternalFrameEvent;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JSlider;
import javax.swing.event.ChangeListener;
import javax.swing.SwingConstants;

import javax.imageio.ImageIO;

import java.awt.image.BufferedImage;
import java.awt.Graphics2D;
import java.awt.image.LookupOp;
import java.awt.image.ConvolveOp;
import java.awt.image.RescaleOp;
import java.awt.image.Kernel;
import java.awt.image.ByteLookupTable;
import java.awt.RenderingHints;
import java.awt.image.AffineTransformOp;
import java.awt.geom.AffineTransform;
import java.awt.image.DataBuffer;
import java.awt.image.Raster;

import java.io.File;


/** 
 * 本类继承了JInternalFrame类，用于完成大部分的图像操作。
 */
public class ImageFrame extends JInternalFrame 
                    implements ChangeListener{
   //常量定义
                                     
   /**
    * 缩放图像的比例因子，控制图像放大的的最大倍数
    */
    private static final int ZOOM_FACTOR = 200;
                                     
   /**
    * 保留对主窗口的引用
    */
   private PictureDrawer pd;
   
   /**
    * 放大镜
    */
   private JLabel jlblMagnifier;
   
   /**
    * 用于调整黑色的阈值
    */
   private JSlider sliderBlack;

   /**
    * 用于调整黑色的阈值的对话框，sliderBlack
    */
   private JDialog jdBlack;
   
   /**
    * 用于调整白色的阈值
    */
   private JSlider sliderWhite;

   /**
    * 用于调整白色的阈值的对话框，里面包含sliderWhite
    */
   private JDialog jdWhite;
   
   /**
    * 用于调节图像明暗
    */
   private JSlider sliderRescale;
   
   /**
    * 用于调整图像明暗的对话框，里面包含sliderRescale
    */
   private JDialog jdrescale;

   /**
    * 用于放大或者缩小图像
    */
   private JSlider sliderZoom;

   /**
    * 用于放大或者缩小图像的对话框，sliderZoom
    */
   private JDialog jdZoom;
   
   /**
    * 保存原始的图像
    */
    private BufferedImage biOriginal;
   
    private JAdvLabel jlblImage;
    private JScrollPane jScrollPane1;

   /**
    * 当前的操作标志
    */
   private int current_tool = PictureDrawer.TOOL_MOUSE;
   
    /** 
     * ImageFrame的构造函数，它创建了一个内部的子窗口，
     * 在窗口中装载并显示指定的图像。
     * @param pd 主窗口的引用
     * @param imageName 要打开显示的图像文件名。
     */
    public ImageFrame(PictureDrawer pd, String imageName ) {
        this.pd = pd;
        initComponents();
        setTitle(imageName);
        jlblImage.filename = imageName;
        jlblImage.setImageIcon(new ImageIcon(imageName) );

        //根据图像大小调整窗口大小
        setSize(400,300); 
        biOriginal = jlblImage.abuffered_image;
    }

    /** 
     * 初始化窗口中的组件
     */
    private void initComponents() {
        jScrollPane1 = new JScrollPane();
        //jlblImage = new javax.swing.JLabel();
        jlblImage = new JAdvLabel();

        setClosable(true);
        setIconifiable(true);
        setResizable(true);
        getAccessibleContext().setAccessibleName(
            java.util.ResourceBundle.getBundle("PictureDrawer/default").
                getString("Image_Internal_Frame"));
        getAccessibleContext().setAccessibleDescription(
            java.util.ResourceBundle.getBundle("PictureDrawer/default").
                getString("Image_internal_frame."));
        jScrollPane1.setViewportView(jlblImage);
        
        //设置为透明
        jlblImage.setOpaque(false);
        jlblImage.getAccessibleContext().setAccessibleName(
            java.util.ResourceBundle.getBundle("PictureDrawer/default").
                getString("Image_Label"));
        jlblImage.getAccessibleContext().setAccessibleDescription(
            java.util.ResourceBundle.getBundle("PictureDrawer/default").
                getString("Image_label."));
        jlblImage.setVerticalAlignment(SwingConstants.TOP);
        
        getContentPane().add(jScrollPane1, java.awt.BorderLayout.CENTER);
    }
 
      
  /**
   * 执行相应的图像操作
   * <p>
   * @param op_flag 当前的操作标志，其取值应该为：
   * <ol>
   * <li> PictureDrawer.TOOL_MOUSE</li>
   * <li> PictureDrawer.TOOL_MAGNIFIER</li>
   * <li> PictureDrawer.TOOL_GRAY</li>
   * ...
   * </ol>
   */
  public void operate(int op_flag) {
      current_tool = op_flag;
      
      //是否显示放大镜
      jlblImage.showMagnifier(current_tool==PictureDrawer.TOOL_MAGNIFIER);
      
      if (current_tool == PictureDrawer.TOOL_ROTATE) {
          rotate(270);
      }	else if (current_tool == PictureDrawer.TOOL_INVERT) {
      	  invertImage();
      } else if (current_tool == PictureDrawer.TOOL_OTHER_INVERT) {
      	  otherInvertImage();
      }	else if (current_tool == PictureDrawer.TOOL_BLACK_THRESHOLD) {
          //用于调整黑色的阈值
          if (jdBlack == null) {
              jdBlack = new JDialog(pd);
              jdBlack.setBounds(getWidth()/2, getHeight()/2,  200, 100);
              jdBlack.setTitle(
                    java.util.ResourceBundle.getBundle("PictureDrawer/default").
                        getString("Set_Black_Threshold_Value"));
              sliderBlack = new JSlider(JSlider.HORIZONTAL, 0, 255, 0);
              sliderBlack.addChangeListener(this);
              jdBlack.getContentPane().add(sliderBlack);
          }
          jdBlack.show();          
          biOriginal = jlblImage.buffered_image;
      }	else if (current_tool == PictureDrawer.TOOL_WHITE_THRESHOLD) {
          //用于调整白色的阈值
          if (jdWhite == null) {
              //创建对话
              jdWhite = new JDialog(pd);
              jdWhite.setBounds(getWidth()/2, getHeight()/2,  200, 100);
              jdWhite.setTitle(
                    java.util.ResourceBundle.getBundle("PictureDrawer/default").
                        getString("Set_White_Threshold_Value"));
              sliderWhite = new JSlider(JSlider.HORIZONTAL, 0, 255, 255);
              sliderWhite.addChangeListener(this);
              jdWhite.getContentPane().add(sliderWhite);
          }
          //显示对话框
          jdWhite.show();
          biOriginal = jlblImage.buffered_image;
      }	else if (current_tool == PictureDrawer.TOOL_RESCALE) {
          //对图像进行明暗调节
          if (jdrescale == null) {
              //创建对话
              jdrescale = new JDialog(pd);
              jdrescale.setBounds(getWidth()/2, getHeight()/2,  200, 100);
              jdrescale.setTitle(
                    java.util.ResourceBundle.getBundle("PictureDrawer/default").
                        getString("Rescale"));
              sliderRescale = new JSlider(JSlider.HORIZONTAL, 0, 1000, 800);
              sliderRescale.addChangeListener(this);
              jdrescale.getContentPane().add(sliderRescale);
          }
          //显示对话框
          jdrescale.show();     
          biOriginal = jlblImage.buffered_image;        
      }	else if (current_tool == PictureDrawer.TOOL_ZOOM) {
          //对图像进行缩放调节
          if (jdZoom == null) {
              //创建对话
              jdZoom = new JDialog(pd);
              jdZoom.setBounds(getWidth()/2, getHeight()/2,  200, 100);
              jdZoom.setTitle(
                    java.util.ResourceBundle.getBundle("PictureDrawer/default").
                        getString("Zoom"));
              //设置调节范围
              sliderZoom = new JSlider(JSlider.HORIZONTAL,0,1000,ZOOM_FACTOR);
              sliderZoom.addChangeListener(this);
              jdZoom.getContentPane().add(sliderZoom);
          }
          //显示对话框
          jdZoom.show();               
          biOriginal = jlblImage.buffered_image;
      }	else if (current_tool == PictureDrawer.TOOL_EDGE33) {
      	  edge(true);
      }	else if (current_tool == PictureDrawer.TOOL_EDGE55) {
      	  edge(false);
      }	else if (current_tool == PictureDrawer.TOOL_SHARPEN) {
      	  opShpBlur(true);
      }	else if (current_tool == PictureDrawer.TOOL_BLUR) {
      	  opShpBlur(false);
      }	else if (current_tool == PictureDrawer.TOOL_VERTICAL_MIRROR) {
      	  verticalMirror_2();
      }	else if (current_tool == PictureDrawer.TOOL_HORIZONTAL_MIRROR) {
      	  horizontalMirror();
      }	else if (current_tool == PictureDrawer.TOOL_RETRIEVE) {
      	  retrieve();
      }	
  }   
  
  /**
   * 当JInternalFrame改变时，该函数将被调用，
   * 下面的事件可能被执行:
   *    InternalFrameEvent.INTERNAL_FRAME_OPENED 
   *    InternalFrameEvent.INTERNAL_FRAME_CLOSING 
   *    InternalFrameEvent.INTERNAL_FRAME_CLOSED
   *    InternalFrameEvent.INTERNAL_FRAME_ICONIFIED 
   *    InternalFrameEvent.INTERNAL_FRAME_DEICONIFIED 
   *    InternalFrameEvent.INTERNAL_FRAME_ACTIVATED 
   *    InternalFrameEvent.INTERNAL_FRAME_DEACTIVATED 
   */
  protected void fireInternalFrameEvent(int id) {
      if (id == InternalFrameEvent.INTERNAL_FRAME_ACTIVATED) {
          pd.debug("ImageFrame.fireInternalFrameEvent", 
                    getTitle() + " Frame is actived");
          pd.updateToolButtons(current_tool);
      } if (id ==InternalFrameEvent.INTERNAL_FRAME_CLOSED)  {
          //当窗口关闭时，关闭任何打开的slider对话框
          sliderBlack = null;
          sliderWhite = null;
          sliderRescale = null;
          sliderZoom = null;
          jdBlack = null;
          jdWhite = null;
          jdrescale = null;
          jdZoom = null;
      }
  }

    /**
     * 当Slider的值变化时触发该函数
     * 用于根据当前的Slider对象修改相应的图像参数
     * <p>
     * @param e 事件的ChangeEvent参数
     */
    public void stateChanged(javax.swing.event.ChangeEvent e) {
        if (e.getSource().equals(sliderBlack)) {
            thresholdOp(0, true, sliderBlack.getValue());
        } else if (e.getSource().equals(sliderWhite)) {
            thresholdOp(255, false, sliderWhite.getValue());
        } else if (e.getSource().equals(sliderRescale)) {
            rescale((float)sliderRescale.getValue()/1000);
        } else {
            //设置调节范围是：0－2倍
            zoom(sliderZoom.getValue());
        }
    }
  
     /**
      * 恢复原始图像
      */
     private void retrieve() {
         jlblImage.setImageIcon(new ImageIcon(biOriginal));
         pd.debug("ImageFrame.retrieve", "完成原始图像恢复");
     } 
     
 
    /**
    * 对图像进行反色处理
    */ 
    private void invertImage() {
        int w = jlblImage.image_icon.getIconWidth();
        int h = jlblImage.image_icon.getIconHeight();

        BufferedImage biDst =  new BufferedImage(
                    w,h, BufferedImage.TYPE_INT_RGB); 


        BufferedImage biSrc = jlblImage.buffered_image;

        byte invert[] = new byte[256];
        //初始化invert数组
        for (int j = 0; j < 256 ; j++) {
            invert[j] = (byte) (256-j);
        }

        //创建LoopupOp对象
        LookupOp lo = new LookupOp(new ByteLookupTable(0,invert), null);
        //进行图像变换
        lo.filter(biSrc, biDst);

        jlblImage.setImageIcon(new ImageIcon(biDst));
        pd.debug("ImageFrame.invertImage", "Image invertion is finished");
    }
    
     /**
      * 对图像进行其他反色处理
      */ 
     private void otherInvertImage() {
 	
         int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

	 BufferedImage biSrc = jlblImage.buffered_image;