Java2D 简单的应用

图片裁剪

/** 
 * 图片裁剪 
 * @param srcImageFile 图片裁剪地址 
 * @param result 图片输出文件夹 
 * @param destWidth 图片裁剪宽度 
 * @param destHeight 图片裁剪高度 
 */  
public final static void cutImage(String srcImageFile, String result,  
        int destWidth, int destHeight) {  
    try {  
        Iterator iterator = ImageIO.getImageReadersByFormatName("JPEG");/*PNG,BMP*/     
        ImageReader reader = (ImageReader)iterator.next();/*获取图片尺寸*/  
        InputStream inputStream = new FileInputStream(srcImageFile);    
        ImageInputStream iis = ImageIO.createImageInputStream(inputStream);     
        reader.setInput(iis, true);     
        ImageReadParam param = reader.getDefaultReadParam();     
        Rectangle rectangle = new Rectangle(0,0, destWidth, destHeight);/*指定截取范围*/      
        param.setSourceRegion(rectangle);     
        BufferedImage bi = reader.read(0,param);   
        ImageIO.write(bi, "JPEG", new File(result));  
    } catch (Exception e) {  
        LOG.error("图片裁剪出现异常:"+e);  
    }  
} 

图片叠加

import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
public class NewImageUtils {
    /**
     * 
     * @Title: 构造图片
     * @Description: 生成水印并返回java.awt.image.BufferedImage
     * @param file
     *            源文件(图片)
     * @param waterFile
     *            水印文件(图片)
     * @param x
     *            距离右下角的X偏移量
     * @param y
     *            距离右下角的Y偏移量
     * @param alpha
     *            透明度, 选择值从0.0~1.0: 完全透明~完全不透明
     * @return BufferedImage
     * @throws IOException
     */
    public static BufferedImage watermark(File file, File waterFile, int x, int y, float alpha) throws IOException {
        // 获取底图
        BufferedImage buffImg = ImageIO.read(file);
        // 获取层图
        BufferedImage waterImg = ImageIO.read(waterFile);
        // 创建Graphics2D对象，用在底图对象上绘图
        Graphics2D g2d = buffImg.createGraphics();
        int waterImgWidth = waterImg.getWidth();// 获取层图的宽度
        int waterImgHeight = waterImg.getHeight();// 获取层图的高度
        // 在图形和图像中实现混合和透明效果
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        // 绘制
        g2d.drawImage(waterImg, x, y, waterImgWidth, waterImgHeight, null);
        g2d.dispose();// 释放图形上下文使用的系统资源
        return buffImg;
    }

    /**
     * 输出水印图片
     * 
     * @param buffImg
     *            图像加水印之后的BufferedImage对象
     * @param savePath
     *            图像加水印之后的保存路径
     */
    private void generateWaterFile(BufferedImage buffImg, String savePath) {
        int temp = savePath.lastIndexOf(".") + 1;
        try {
            ImageIO.write(buffImg, savePath.substring(temp), new File(savePath));
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }

    /**
     * 
     * @param args
     * @throws IOException
     *             IO异常直接抛出了
     * @author bls
     */
    public static void main(String[] args) throws IOException {
        String sourceFilePath = "D://img//di.png";
        String waterFilePath = "D://img//ceng.png";
        String saveFilePath = "D://img//new.png";
        NewImageUtils newImageUtils = new NewImageUtils();
        // 构建叠加层
        BufferedImage buffImg = NewImageUtils.watermark(new File(sourceFilePath), new File(waterFilePath), 0, 0, 1.0f);
        // 输出水印图片
        newImageUtils.generateWaterFile(buffImg, saveFilePath);
    }
}

抗锯齿描点

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.Line2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.List;

public class ImgDrawer2D {

  private BufferedImage image;
  private Graphics2D graphics;

  public ImgDrawer2D(int width, int height) {
    init(width, height);
  }

  public void init(int width, int height) {
    image = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
    graphics = (Graphics2D) image.getGraphics();
    graphics.setStroke(new BasicStroke(1.6f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_ROUND)); 
    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  }

  public BufferedImage getImg() {
    return this.image;
  }

  /**
   * 绘制一个点-设置颜色，不设置透明度
   * 
   * @param printPoint
   * @throws IOException
   */
  public void drawColorPoint(PrintPoint2D printPoint) throws IOException {
    int[] rgb = printPoint.getRGB();
    graphics.setColor(new Color(rgb[0], rgb[1], rgb[2]));
    graphics.draw(new Line2D.Double(printPoint.getxPixel(), printPoint.getyPixel(),
        printPoint.getxPixel(), printPoint.getyPixel()));
  }

  /**
   * 按照默认颜色绘制一个点，不指定颜色和透明度
   * 
   * @param printPoint
   * @throws IOException
   */
  public void drawPoint(PrintPoint2D printPoint) throws IOException {
    graphics.draw(new Line2D.Double(printPoint.getxPixel(), printPoint.getyPixel(),
        printPoint.getxPixel(), printPoint.getyPixel()));
  }

  /**
   * 绘制一个带透明度的点
   * 
   * @param printPoint
   */
  public void drawAlphaPoint(PrintPoint2D printPoint) {
    int[] rgb = printPoint.getRGB();
    graphics.setColor(new Color(rgb[0], rgb[1], rgb[2], printPoint.getAlpha()));
    graphics.draw(new Line2D.Double(printPoint.getxPixel(), printPoint.getyPixel(),
        printPoint.getxPixel(), printPoint.getyPixel()));
  }

  /**
   * 绘制一堆带透明度的点
   * 
   * @param printPointList
   * @throws IOException
   */
  public void drawAlphaImg(List<PrintPoint2D> printPointList) throws IOException {
    for (int i = 0; i < printPointList.size(); i++) {
      PrintPoint2D printPoint = printPointList.get(i);
      drawAlphaPoint(printPoint);
    }
  }

  /**
   * 绘制
   * 
   * @param printPointList
   * @throws IOException
   */
  public void drawImg(List<PrintPoint2D> printPointList) throws IOException {
    for (int i = 0; i < printPointList.size(); i++) {
      PrintPoint2D printPoint = printPointList.get(i);
      drawColorPoint(printPoint);
    }
  }

}