JAVA使用Graphics2D合成新图片

2022-07-26

简介

Graphics2D 类继承于 Graphics 类，提供了几何学、坐标转换、颜色管理及文本排列等更高级的控制。Graphics2D 类是 java 平台渲染二维图形，文字及图片的基础类，提供较好的对绘制形状，填充形状、旋转形状、及定义颜色的支持。

使用

本地工具类

package com.example.captache.utils;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/25 10:22 PM
 */
public class NewImageUtils {

    /**
     * @param file      源文件(图片)
     * @param waterFile 贴图文件(图片)
     * @param x         距离右下角的X偏移量
     * @param y         距离右下角的Y偏移量
     * @param alpha     透明度, 选择值从0.0~1.0: 完全透明~完全不透明
     * @return BufferedImage
     * @throws IOException
     * @Title: 构造图片
     * @Description: 合并图片并返回java.awt.image.BufferedImage
     */
    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() / 2;
        // 获取层图的高度
        int waterImgHeight = waterImg.getHeight() / 2;
        // 在图形和图像中实现混合和透明效果
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        // 绘制
        g2d.drawImage(waterImg, x, y, waterImgWidth, waterImgHeight, null);
        // 释放图形上下文使用的系统资源
        g2d.dispose();

        return buffImg;
    }

    public static BufferedImage watermark(BufferedImage buffImg, File waterFile, int x, int y, float alpha) throws IOException {
        // 获取层图
        BufferedImage waterImg = ImageIO.read(waterFile);
        // 创建Graphics2D对象，用在底图对象上绘图
        Graphics2D g2d = buffImg.createGraphics();
        // 获取层图的宽度
        int waterImgWidth = waterImg.getWidth() / 2;
        // 获取层图的高度
        int waterImgHeight = waterImg.getHeight() / 2;
        // 在图形和图像中实现混合和透明效果
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        // 绘制
        g2d.drawImage(waterImg, x, y, waterImgWidth, waterImgHeight, null);
        // 释放图形上下文使用的系统资源
        g2d.dispose();

        return buffImg;
    }

    /**
     * 增加水印标记
     */
    public static BufferedImage addFontWaterMark(File file, Color markContentColor, String content, Font font, int x, int y) throws IOException {

        // 读取原图片信息
        BufferedImage bufImg = ImageIO.read(file);
        // 获取层图的宽度
        int srcImgWidth = bufImg.getWidth();
        // 获取层图的高度
        int srcImgHeight = bufImg.getHeight();

        Graphics2D g2d = bufImg.createGraphics();
        g2d.drawImage(bufImg, 0, 0, srcImgWidth, srcImgHeight, null);
        // 根据图片的背景设置水印颜色
        g2d.setColor(markContentColor);
        // 设置字体
        g2d.setFont(font);

        // 设置水印的坐标 如果水印长度超过图片宽度则换行
        // 水印文字总长度
        int fontLen = getWatermarkLength(content, g2d);
        // 文字长度相对于图片宽度应该有多少行
        int line = fontLen / srcImgWidth;
        int yFont = (line + 1) * font.getSize();
        System.out.println("水印文字总长度:" + fontLen + ",图片宽度:" + srcImgWidth + ",字符个数:" + content.length());

        // 文字叠加,自动换行叠加
        // 文字初始x坐标位置
        int tempX = x;
        // 文字初始y坐标位置
        int tempY = y + yFont;
        // 单字符长度
        int tempCharLen;
        // 单行字符总长度临时计算
        int tempLineLen = 0;
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < content.length(); i++) {
            char tempChar = content.charAt(i);
            tempCharLen = getCharLen(tempChar, g2d);
            tempLineLen += tempCharLen;
            if (tempLineLen >= srcImgWidth - 530) {
                // 长度已经满一行,进行文字叠加
                g2d.drawString(sb.toString(), tempX, tempY);
                // 清空内容,重新追加
                sb.delete(0, sb.length());
                tempY += font.getSize();
                tempLineLen = 0;
            }
            // 追加字符
            sb.append(tempChar);
        }

        // 最后叠加余下的文字
        g2d.drawString(sb.toString(), tempX, tempY);
        g2d.dispose();

        return bufImg;
    }

    /**
     * 增加水印标记
     */
    public static BufferedImage addFontWaterMark(BufferedImage bufImg, Color markContentColor, String content, Font font, int x, int y) throws IOException {

        // 获取层图的宽度
        int srcImgWidth = bufImg.getWidth();
        // 获取层图的高度
        int srcImgHeight = bufImg.getHeight();

        Graphics2D g2d = bufImg.createGraphics();
        g2d.drawImage(bufImg, 0, 0, srcImgWidth, srcImgHeight, null);
        // 根据图片的背景设置水印颜色
        g2d.setColor(markContentColor);
        // 设置字体
        g2d.setFont(font);

        // 设置水印的坐标 如果水印长度超过图片宽度则换行
        // 水印文字总长度
        int fontLen = getWatermarkLength(content, g2d);
        // 文字长度相对于图片宽度应该有多少行
        int line = fontLen / srcImgWidth;
        int yFont = (line + 1) * font.getSize();
        System.out.println("水印文字总长度:" + fontLen + ",图片宽度:" + srcImgWidth + ",字符个数:" + content.length());

        // 文字叠加,自动换行叠加
        // 文字初始x坐标位置
        int tempX = x;
        // 文字初始y坐标位置
        int tempY = y + yFont;
        // 单字符长度
        int tempCharLen;
        // 单行字符总长度临时计算
        int tempLineLen = 0;
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < content.length(); i++) {
            char tempChar = content.charAt(i);
            tempCharLen = getCharLen(tempChar, g2d);
            tempLineLen += tempCharLen;
            if (tempLineLen >= srcImgWidth - 530) {
                // 长度已经满一行,进行文字叠加
                g2d.drawString(sb.toString(), tempX, tempY);
                // 清空内容,重新追加
                sb.delete(0, sb.length());
                tempY += font.getSize();
                tempLineLen = 0;
            }
            // 追加字符
            sb.append(tempChar);
        }

        // 最后叠加余下的文字
        g2d.drawString(sb.toString(), tempX, tempY);
        g2d.dispose();

        return bufImg;
    }

    /**
     * 获取水印文字总长度
     *
     * @param waterMarkContent
     * @param g
     * @return
     */
    public static int getWatermarkLength(String waterMarkContent, Graphics2D g) {
        return g.getFontMetrics(g.getFont()).charsWidth(waterMarkContent.toCharArray(), 0, waterMarkContent.length());
    }

    /**
     * 获取水印对应文字的位置
     *
     * @param c
     * @param g
     * @return
     */
    public static int getCharLen(char c, Graphics2D g) {
        return g.getFontMetrics(g.getFont()).charWidth(c);
    }

    /**
     * 增加水印标记
     */
    public static BufferedImage addFontWaterMark(File file, String content, int x, int y) throws IOException, FontFormatException {

        File fontFile = new File("./static/AaKaiSong.ttf");
        Font dynamicFont = Font.createFont(Font.TRUETYPE_FONT, fontFile);
        // 引用外部字体
        Font font = dynamicFont.deriveFont(Font.PLAIN, 60);

        // 水印图片色彩以及透明度
        Color color = new Color(7, 7, 7);

        return addFontWaterMark(file, color, content, font, x, y);
    }

    /**
     * 增加水印标记
     */
    public static BufferedImage addFontWaterMark(BufferedImage bufImg, String content, int x, int y) throws IOException, FontFormatException {

        File fontFile = new File("./static/AaKaiSong.ttf");
        Font dynamicFont = Font.createFont(Font.TRUETYPE_FONT, fontFile);
        // 引用外部字体
        Font font = dynamicFont.deriveFont(Font.PLAIN, 60);

        // 水印图片色彩以及透明度
        Color color = new Color(7, 7, 7);

        return addFontWaterMark(bufImg, color, content, font, x, y);
    }

    /**
     * 输出合并图片
     *
     * @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, FontFormatException {
        String sourceFilePath = "./static/base.jpg";
        String waterFilePath = "./static/1.png";
        String waterFile2Path = "./static/2.png";
        String saveFilePath = "./static/new.png";
        NewImageUtils newImageUtils = new NewImageUtils();
        // 构建叠加层
        BufferedImage buffImg = NewImageUtils.watermark(new File(sourceFilePath), new File(waterFilePath), 350, 400, 1.0f);
        // 构建叠加层
        BufferedImage buffImg1 = NewImageUtils.watermark(buffImg, new File(waterFile2Path), 1000, 500, 1.0f);
        // 添加文字
        buffImg1 = addFontWaterMark(buffImg1, "Supreme ss22 week 1" +
                "deer tee 小鹿箭靶图案印" +
                "花圆领短袖t恤 男女同款", 300, 1000);
        // 添加文字
        buffImg1 = addFontWaterMark(buffImg1, "规格：颜色 红色 尺寸 L", 300, 1300);
        // 添加文字
        buffImg1 = addFontWaterMark(buffImg1, "版权平：小恐龙2021", 300, 1400);
        // 输出水印图片
        newImageUtils.generateWaterFile(buffImg1, saveFilePath);
    }
}

效果

线上工具类

动态缩放，动态改变放置位置。

package com.folkspace.market.common.utils.common;

import javax.imageio.ImageIO;
import javax.imageio.stream.ImageOutputStream;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.URL;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/25 10:22 PM
 */
public class NewImageUtil {

    /** 构造合成图 */
    public static BufferedImage watermark(
            String waterFileOneUrl,
            String waterFileTwoUrl,
            String skuName,
            String specStr,
            String nftName)
            throws IOException, FontFormatException {

        // 图片到上边缘距离
        float y = 400;
        // 透明度
        float alpha = 1.0f;

        // 获取底图
        // ClassPathResource classPathResource = new ClassPathResource("static/base.jpg");
        // File baseFile = classPathResource.getFile();
        // File baseFile = new File("https://file.folkspace.cn/store/base.jpg");
        // BufferedImage buffImg = ImageIO.read(baseFile);
        URL url = new URL("https://file.folkspace.cn/store/base.jpg");
        BufferedImage buffImg = ImageIO.read(url.openConnection().getInputStream());
        // BufferedImage buffImg = ImageIO.read(new File(fileUrl));
        // 创建Graphics2D对象，用在底图对象上绘图
        Graphics2D g2d = buffImg.createGraphics();

        // 获取层图1
        URL url1 = new URL(waterFileOneUrl);
        BufferedImage waterImgOne = ImageIO.read(url1.openConnection().getInputStream());
        // 获取层图2
        URL url2 = new URL(waterFileTwoUrl);
        BufferedImage waterImgTwo = ImageIO.read(url2.openConnection().getInputStream());
        // BufferedImage waterImgTwo = ImageIO.read(new File(waterFileTwoUrl));

        /** 计算缩放比例 */
        float zoomOne = waterImgOne.getWidth() / (float) (buffImg.getWidth() * 2 / 7);
        // 获取层图1的宽度
        float waterImgOneWidth = waterImgOne.getWidth() / zoomOne;
        // 获取层图1的高度
        float waterImgOneHeight = waterImgOne.getHeight() / zoomOne;

        float zoomTwo = waterImgTwo.getWidth() / (float) (buffImg.getWidth() * 2 / 7);
        // 获取层图2的宽度
        float waterImgTwoWidth = waterImgTwo.getWidth() / zoomTwo;
        // 获取层图2的高度
        float waterImgTwoHeight = waterImgTwo.getHeight() / zoomTwo;

        // 两张图片之间的间隔
        int xInterval = 100;

        // 计算x位置
        float xOne = (buffImg.getWidth() - (waterImgOneWidth + waterImgTwoWidth + xInterval)) / 2;
        float xTwo = xOne + waterImgOneWidth + xInterval;

        // 计算y位置
        // 获取最大高度
        float maxHeight = Math.max(waterImgOneHeight, waterImgTwoHeight);

        // 图片y坐标
        float yOne, yTwo;

        // 图片1高度较大
        if (Math.abs(waterImgOneHeight - maxHeight) <= 0) {
            yOne = y;
            yTwo = yOne + (waterImgOneHeight / 2) - (waterImgTwoHeight / 2);
        } else {
            // 图片2长度较大
            yTwo = y;
            yOne = yTwo + (waterImgTwoHeight / 2) - (waterImgOneHeight / 2);
        }

        // 新内容的y坐标
        y = y + maxHeight;

        // 在图形和图像中实现混合和透明效果
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        // 绘制图层1
        g2d.drawImage(
                waterImgOne,
                (int) xOne,
                (int) yOne,
                (int) waterImgOneWidth,
                (int) waterImgOneHeight,
                null);
        // 绘制图层2
        g2d.drawImage(
                waterImgTwo,
                (int) xTwo,
                (int) yTwo,
                (int) waterImgTwoWidth,
                (int) waterImgTwoHeight,
                null);

        // 引用外部字体
        // ClassPathResource classPathResourceFont = new ClassPathResource("static/AaKaiSong.ttf");
        // File fontFile = classPathResourceFont.getFile();
        // File fontFile = new File("https://file.folkspace.cn/store/AaKaiSong.ttf");
        URL urlFont = new URL("https://file.folkspace.cn/store/AaKaiSong.ttf");
        // File fontFile = new File("./static/AaKaiSong.ttf");
        Font dynamicFont =
                Font.createFont(Font.TRUETYPE_FONT, urlFont.openConnection().getInputStream());
        Font fontSkuName = dynamicFont.deriveFont(Font.BOLD, 70);
        Font fontOther = dynamicFont.deriveFont(Font.BOLD, 45);

        // 水印图片色彩以及透明度
        Color color = new Color(7, 7, 7);

        /** 写SKU名称 */
        // 根据图片的背景设置水印颜色
        g2d.setColor(color);
        // 设置字体
        g2d.setFont(fontSkuName);

        // 设置水印的坐标 如果水印长度超过图片宽度则换行
        // 水印文字总长度
        int fontLen = getWatermarkLength(skuName, g2d);
        // 文字长度相对于图片宽度应该有多少行
        int line = fontLen / (buffImg.getWidth() * 2 / 3);
        int yFont = (line + 1) * fontSkuName.getSize();

        // System.out.println("水印文字总长度:" + fontLen + ",图片宽度:" + buffImg.getWidth() + ",字符个数:" +
        // fontSkuName.length());

        // 文字与图片的左边距差距
        int fontAndImgInterval = 10;
        // 文字距离右边的距离
        int fontAndRightMarginInterval = 800;
        // 上下间距
        int yInterval = 200;

        // 文字叠加,自动换行叠加
        // 文字初始x坐标位置
        float tempX = xOne + fontAndImgInterval;
        // 文字初始y坐标位置
        float tempY = y + yInterval;
        // 单字符长度
        int tempCharLen;
        // 单行字符总长度临时计算
        int tempLineLen = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < skuName.length(); i++) {
            char tempChar = skuName.charAt(i);
            tempCharLen = getCharLen(tempChar, g2d);
            tempLineLen += tempCharLen;
            if (tempLineLen >= buffImg.getWidth() - fontAndRightMarginInterval) {
                // 长度已经满一行,进行文字叠加
                g2d.drawString(sb.toString(), tempX, tempY);
                // 清空内容,重新追加
                sb.delete(0, sb.length());
                tempY += fontSkuName.getSize();
                tempLineLen = 0;
            }
            // 追加字符
            sb.append(tempChar);
        }
        // 最后叠加余下的文字
        g2d.drawString(sb.toString(), tempX, tempY);
        // 更新y坐标
        y = tempY;

        /** 写规格 */
        // 文字距离右边的距离
        int fontAndRightMarginInterval2 = 1150;
        // 上下间距
        int yInterval2 = 200;

        // 设置字体
        g2d.setFont(fontOther);

        // 设置水印的坐标 如果水印长度超过图片宽度则换行
        // 水印文字总长度
        int fontLen2 = getWatermarkLength(specStr, g2d);
        // 文字长度相对于图片宽度应该有多少行
        int line2 = fontLen2 / (buffImg.getWidth() * 2 / 3);
        int yFont2 = (line2 + 1) * fontOther.getSize();

        // 文字叠加,自动换行叠加
        // 文字初始y坐标位置
        float tempY2 = y + yInterval2;
        // 单字符长度
        int tempCharLen2;
        // 单行字符总长度临时计算
        int tempLineLen2 = 0;
        StringBuilder sb2 = new StringBuilder();
        for (int i = 0; i < specStr.length(); i++) {
            char tempChar = specStr.charAt(i);
            tempCharLen2 = getCharLen(tempChar, g2d);
            tempLineLen2 += tempCharLen2;
            if (tempLineLen2 >= buffImg.getWidth() - fontAndRightMarginInterval2) {
                // 长度已经满一行,进行文字叠加
                g2d.drawString(sb2.toString(), tempX, tempY2);
                // 清空内容,重新追加
                sb2.delete(0, sb2.length());
                tempY2 += fontOther.getSize();
                tempLineLen2 = 0;
            }
            // 追加字符
            sb2.append(tempChar);
        }
        // 最后叠加余下的文字
        g2d.drawString(sb2.toString(), tempX, tempY2);
        // 更新y坐标
        y = tempY2;

        /** 写版权品 */
        // 上下间距
        int yInterval3 = 100;

        // 设置水印的坐标 如果水印长度超过图片宽度则换行
        // 水印文字总长度
        int fontLen3 = getWatermarkLength(nftName, g2d);
        // 文字长度相对于图片宽度应该有多少行
        int line3 = fontLen3 / (buffImg.getWidth() * 2 / 3);
        int yFont3 = (line3 + 1) * fontOther.getSize();

        // 文字叠加,自动换行叠加
        // 文字初始y坐标位置
        float tempY3 = y + yInterval3;
        // 单字符长度
        int tempCharLen3;
        // 单行字符总长度临时计算
        int tempLineLen3 = 0;
        StringBuilder sb3 = new StringBuilder();
        for (int i = 0; i < nftName.length(); i++) {
            char tempChar = nftName.charAt(i);
            tempCharLen3 = getCharLen(tempChar, g2d);
            tempLineLen3 += tempCharLen3;
            if (tempLineLen3 >= buffImg.getWidth() - fontAndRightMarginInterval2) {
                // 长度已经满一行,进行文字叠加
                g2d.drawString(sb3.toString(), tempX, tempY3);
                // 清空内容,重新追加
                sb3.delete(0, sb3.length());
                tempY3 += fontOther.getSize();
                tempLineLen3 = 0;
            }
            // 追加字符
            sb3.append(tempChar);
        }
        // 最后叠加余下的文字
        g2d.drawString(sb3.toString(), tempX, tempY3);

        // 释放图形上下文使用的系统资源
        g2d.dispose();

        return buffImg;
    }

    /**
     * 获取水印文字总长度
     *
     * @param waterMarkContent
     * @param g
     * @return
     */
    public static int getWatermarkLength(String waterMarkContent, Graphics2D g) {
        return g.getFontMetrics(g.getFont())
                .charsWidth(waterMarkContent.toCharArray(), 0, waterMarkContent.length());
    }

    /**
     * 获取水印对应文字的位置
     *
     * @param c
     * @param g
     * @return
     */
    public static int getCharLen(char c, Graphics2D g) {
        return g.getFontMetrics(g.getFont()).charWidth(c);
    }

    /**
     * 输出合并图片
     *
     * @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();
        }
    }

    /**
     * BufferedImage 转 InputStream
     *
     * @param buffImg
     * @return
     */
    public static InputStream getImageStream(BufferedImage buffImg) {
        InputStream is = null;
        ByteArrayOutputStream bs = new ByteArrayOutputStream();
        ImageOutputStream imOut;
        try {
            imOut = ImageIO.createImageOutputStream(bs);
            ImageIO.write(buffImg, "png", imOut);
            is = new ByteArrayInputStream(bs.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        }
        return is;
    }

    /**
     * 测试
     *
     * @param args
     * @throws IOException IO异常直接抛出了
     * @author bls
     */
    //    public static void main(String[] args) throws IOException, FontFormatException {
    //
    //        String sourceFilePath = "/static/base.jpg";
    //        String waterFilePath = "/static/1.png";
    //        String waterFile2Path = "/static/2.png";
    //        String saveFilePath = "/static/new.png";
    //        String skuName = "Supreme ss22 week 1" + "deer tee 小鹿箭靶图案印" + "花圆领短袖t恤 男女同款";
    //        String specStr = "规格：颜色 红色 尺寸 L";
    //        String nftName = "版权品：小恐龙2021 44435456435351536516";
    //
    //        NewImageUtil newImageUtils = new NewImageUtil();
    //
    //        // 构建叠加层
    //        BufferedImage buffImg =
    //                NewImageUtil.watermark(
    //                        sourceFilePath,
    //                        waterFilePath,
    //                        waterFile2Path,
    //                        skuName,
    //                        specStr,
    //                        nftName,
    //                        400,
    //                        1.0f);
    //
    //        // 输出水印图片
    //        newImageUtils.generateWaterFile(buffImg, saveFilePath);
    //    }
}

使用

try {
    BufferedImage bufferedImage = NewImageUtil.watermark(spSkuEntity.getMainImage(), ipfsFileEntity.getFileUrl(), spSpuEntity.getSpuName(), specString, "版权品：" + marketNftBaseEntity.getNftName());
    // BufferedImage 转 InputStream
    InputStream inputStream = NewImageUtil.getImageStream(bufferedImage);
    // 文件名
    String fileName = UUID.randomUUID() + ".png";
    log.info("文件名：{}", fileName);
    // 上传对象存储
    if (inputStream != null) {
        log.info("inputStream不为空");
        fileUrl = aliOssCloudUtil.uploadFile2OSS(inputStream, fileName);
        log.info("输出文件：{}", fileUrl);
    }
} catch(IOException | FontFormatException e) {
    // e.printStackTrace();
    log.error("生成证书失败，原因：{}", e.getMessage());
}

效果