imageframe.java

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

         BufferedImage biDst =  new BufferedImage(
                        w,h, biSrc.getType()); 

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

         byte[][] yellowInvert = new byte[][] { invert, invert, ordered };

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

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.otherInvertImage", "otherInvertImage is finished");
     }

    /**
     * 用于调整黑色或者白色的阈值
     * <P>
     * @param color 要设置的新值
     * @param isLow 是否过虑最小值
     * @param thresholdVale 阈值
     */
    private void thresholdOp(int color, 
                    boolean isLow, int thresholdVale) {
        byte threshold[] = new byte[256];
        
        //初始化数组
        for (int j = 0; j < 256 ; j++) {
            if (((isLow)&&(j<thresholdVale)) ||
                ((!isLow)&&(j>thresholdVale))) {
                    threshold[j] = (byte)color;
            } else {
                threshold[j] = (byte)j;
            }
        }
        
        //创建LoopupOp对象
        LookupOp lo = new LookupOp(new ByteLookupTable(0,threshold), null);
        
                 int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

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

          //进行图像变化
         lo.filter(biOriginal, biDst);

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.thresholdOp", "thresholdOp is finished");
    }


     /**
      * 对图像进行边缘化处理
      * <p>
      * @param three 是进行3*3矩阵的边缘化还是5*5矩阵边缘化
      */ 
     private void edge(boolean three) {
         
         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;

         // 3x3 Kernel矩阵
         float data3[] = { 0.f, -1.f,  0.f,                  
                          -1.f,  5.f, -1.f,
                           0.f, -1.f,  0.f};

         // 5x5 Kernel矩阵
         float data5[] = { -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                            -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                            -1.0f, -1.0f, 24.0f, -1.0f, -1.0f,
                            -1.0f, -1.0f, -1.0f, -1.0f, -1.0f,
                            -1.0f, -1.0f, -1.0f, -1.0f, -1.0f};
         ConvolveOp co;
         if (three) {
             co = new ConvolveOp(new Kernel(3,3,data3));
         } else {
             co = new ConvolveOp(new Kernel(5,5,data5));
         }
          
         //进行图像变化
         co.filter(biSrc, biDst);

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.edge", "边缘化处理完成");
     } 

     /**
      * 对图像进行锐化或者钝化处理
      * <p>
      * @param sharpen 是否进行锐化处理，如果该值为False，
      * 则进行钝化处理，否则进行锐化处理。
      */ 
     private void opShpBlur(boolean sharpen) {
         
         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;

         // sharpen
         float sharpData[] = {-1.0f, -1.0f, -1.0f,
                               -1.0f, 9.0f, -1.0f,
                               -1.0f, -1.0f, -1.0f};

         // blur                               
         float blurData[] = { 0.1f, 0.1f, 0.1f,
                               0.1f, 0.2f, 0.1f,
                               0.1f, 0.1f, 0.1f};
         ConvolveOp co;
         //创建ConvolveOp对象                      
         if (sharpen) {
             co = new ConvolveOp(new Kernel(3,3,sharpData));
         } else {
             co = new ConvolveOp(new Kernel(3,3,blurData));
         }

         //进行图像变化
         co.filter(biSrc, biDst);

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.opShpBlur", "锐化/钝化化处理完成");
     }      

     /**
      * 对图像进行明暗调节
      * <p>
      * @param factor 调节系数
      */ 
     private void rescale(float factor) {
         
         int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

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

         //创建RescaleOp
         RescaleOp ro = new RescaleOp(factor, 0, null);

         //进行图像变化
         ro.filter(biOriginal, biDst);

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.rescale", "图像明暗调节完毕");
     }      

     /**
      * 对图像进行缩放处理
      * <p>
      * @param factor 缩放系数
      */ 
     private void zoom(double factor) {
         //获取原图像大小
         int w = biOriginal.getWidth();
         int h = biOriginal.getHeight();

         //计算缩放后的大小
         int newX = (int)(factor==0?1:(w*factor/ZOOM_FACTOR));
         int newY = (int)(factor==0?1:(h*factor/ZOOM_FACTOR));
         
         BufferedImage biDst =  new BufferedImage(
                        newX,newY, BufferedImage.TYPE_4BYTE_ABGR); 

         //创建Graphics2D对象，缩放图像将绘制在其上
         Graphics2D g2d = biDst.createGraphics();
         
         g2d.setRenderingHint(
                RenderingHints.KEY_INTERPOLATION,
                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
         g2d.drawImage(biOriginal, 0, 0, newX, newY, null);

         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.zoom", "图像缩放完毕");
     }           

     /**
      * 对图像进行旋转操作
      * <p>
      * @param degree 旋转角度（0－360）,
      * 这里只选择0, 90. 180, 270度
      */ 
     private void rotate(int degree) {
         int angle = degree % 360;
         //获取原图像大小
         int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

         AffineTransform at = AffineTransform.getRotateInstance(
                                Math.toRadians(angle), w/2, h/2);
         AffineTransformOp ato = new AffineTransformOp(at, 
                    AffineTransformOp.TYPE_BILINEAR);
         
         if (angle != 180) {
             int temp = w;
             w = h;
             h = temp;
         }
         
         //创建BufferedImage
         BufferedImage biDst  =  new BufferedImage(
                        w,h, BufferedImage.TYPE_INT_ARGB); 

         ato.filter(jlblImage.abuffered_image, biDst);

         //显示旋转后的图像
         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.rotate", "图像旋转完毕");
     }       

     /**
      * 对图像进行垂直镜像操作, 
      * 这里演示第一种镜像的方法
      */ 
     private void verticalMirror_1() {
         //获取原图像大小
         int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

         //创建目标BufferedImage
         BufferedImage biDst  =  new BufferedImage(
                        w,h, jlblImage.abuffered_image.getType()); 

         //创建目标DataBuffer
         DataBuffer dbDst = biDst.getRaster().getDataBuffer();

         Raster raster = jlblImage.abuffered_image.getRaster();
         int rw = raster.getWidth();
         int rh = raster.getHeight();
         //创建源DataBuffer
         DataBuffer dbSrc = raster.getDataBuffer();
         
         //翻转操作
         for (int i=rh-1, row=0; row<rh; row++, i--) {
             for (int j=0;j<rw;j++) {
                 dbDst.setElem(i*rw+j, dbSrc.getElem(row*w+j));
             }
         }
         
         //显示旋转后的图像
         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.verticalMirror", "图像垂直镜像方法一完毕");
     }       

     /**
      * 对图像进行垂直镜像操作, 
      * 这里演示第2种镜像的方法
      */ 
     private void verticalMirror_2() {
         //获取原图像大小
         int w = jlblImage.image_icon.getIconWidth();
         int h = jlblImage.image_icon.getIconHeight();

         //创建目标BufferedImage
         BufferedImage biDst  =  new BufferedImage(
                        w,h, jlblImage.abuffered_image.getType()); 

         /*变换矩阵
          [  m00  m01  m02  ]
          [  m10  m11  m12  ]
          [   0    0    1   ]
          */
         //创建垂直镜像矩阵
         float[] vMirror = {1, 0, 0, -1, 0, 0};
                           //{ m00 m10 m01 m11 [m02 m12]}.  

         AffineTransform at = new AffineTransform(vMirror);
         //设置相对坐标，保证图像出现在当前范围内
         at.translate(0, -h);
         AffineTransformOp ato = new AffineTransformOp(at, 
                    AffineTransformOp.TYPE_BILINEAR);
         
         ato.filter(jlblImage.buffered_image, biDst);         
         
         //显示旋转后的图像
         jlblImage.setImageIcon(new ImageIcon(biDst));
         pd.debug("ImageFrame.verticalMirror", "图像垂直镜像方法二完毕");
     }      
     
     /**
      * 对图像进行水平镜像操作
      *  这里演示了一种简单的旋转方法
      */ 
     private void horizontalMirror() {
         verticalMirror_1();
         rotate(180);
         pd.debug("ImageFrame.horizontalMirror", "图像水平镜像完毕");
     }
     
     /**
      * 保存图像
      * <p>
      * @param filename 要另存的文件名，当filename为""时，保存到当前文件中
      */
     public void save(String filename) {
         if (filename=="") {
             //保存到当前的文件中
             saveAs(jlblImage.filename);
         } else {
             saveAs(filename);
         }
     }
    
     /**
      * 保存图像
      * <p>
      * @param filename 要存储的文件名
      */     
     private void saveAs(String filename) {
         String format;
         BufferedImage bi=null;
         if(filename.endsWith(".gif")) {
             format = "gif";
         } else if (filename.endsWith(".jpg")) {
             format = "jpg";
         } else if (filename.endsWith(".png")) {
             format = "png";
         } else {
             pd.debug("ImageFrame.saveAs","不支持的图像格式");
             return;
         }
         
         try {
             ImageIO.write(jlblImage.buffered_image, "jpg", new File(filename));
             //ImageIO.write(bi, "jpg", new File(filename));
         } catch(Exception e) {
             pd.debug("ImageFrame.saveAs", "保存文件时出现异常：" + filename);
             return;	
         }
         jlblImage.filename = filename;
         pd.debug("ImageFrame.saveAs", "图像保存到：" + filename);
     }
}