Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.dromara.hutool.swing.img.Img Maven / Gradle / Ivy
/*
* Copyright (c) 2013-2024 Hutool Team and hutool.cn
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.dromara.hutool.swing.img;
import org.dromara.hutool.core.io.IORuntimeException;
import org.dromara.hutool.core.io.IoUtil;
import org.dromara.hutool.core.io.file.FileNameUtil;
import org.dromara.hutool.core.io.resource.Resource;
import org.dromara.hutool.core.lang.Assert;
import org.dromara.hutool.core.math.NumberUtil;
import org.dromara.hutool.core.text.StrUtil;
import org.dromara.hutool.core.util.ObjUtil;
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.ImageFilter;
import java.io.*;
import java.net.URL;
import java.nio.file.Path;
/**
* 图像编辑器
*
* @author looly
* @since 4.1.5
*/
public class Img implements Flushable, Serializable {
private static final long serialVersionUID = 1L;
private final BufferedImage srcImage;
private Image targetImage;
/**
* 目标图片文件格式，用于写出
*/
private String targetImageType;
/**
* 计算x,y坐标的时候是否从中心做为原始坐标开始计算
*/
private boolean positionBaseCentre = true;
/**
* 图片输出质量，用于压缩
*/
private float quality = -1;
/**
* 图片背景色
*/
private Color backgroundColor;
/**
* 从Path读取图片并开始处理
*
* @param imagePath 图片文件路径
* @return Img
*/
public static Img from(final Path imagePath) {
return from(imagePath.toFile());
}
/**
* 从文件读取图片并开始处理
*
* @param imageFile 图片文件
* @return Img
*/
public static Img from(final File imageFile) {
return new Img(ImgUtil.read(imageFile));
}
/**
* 从资源对象中读取图片并开始处理
*
* @param resource 图片资源对象
* @return Img
* @since 4.4.1
*/
public static Img from(final Resource resource) {
return from(resource.getStream());
}
/**
* 从流读取图片并开始处理
*
* @param in 图片流
* @return Img
*/
public static Img from(final InputStream in) {
return new Img(ImgUtil.read(in));
}
/**
* 从ImageInputStream取图片并开始处理
*
* @param imageStream 图片流
* @return Img
*/
public static Img from(final ImageInputStream imageStream) {
return new Img(ImgUtil.read(imageStream));
}
/**
* 从URL取图片并开始处理
*
* @param imageUrl 图片URL
* @return Img
*/
public static Img from(final URL imageUrl) {
return new Img(ImgUtil.read(imageUrl));
}
/**
* 从Image取图片并开始处理
*
* @param image 图片
* @return Img
*/
public static Img from(final Image image) {
return new Img(ImgUtil.castToBufferedImage(image, ImgUtil.IMAGE_TYPE_JPG));
}
/**
* 构造，目标图片类型取决于来源图片类型
*
* @param srcImage 来源图片
*/
public Img(final BufferedImage srcImage) {
this(srcImage, null);
}
/**
* 构造
*
* @param srcImage 来源图片
* @param targetImageType 目标图片类型，null则读取来源图片类型
* @since 5.0.7
*/
public Img(final BufferedImage srcImage, String targetImageType) {
this.srcImage = srcImage;
if (null == targetImageType) {
if (srcImage.getType() == BufferedImage.TYPE_INT_ARGB
|| srcImage.getType() == BufferedImage.TYPE_INT_ARGB_PRE
|| srcImage.getType() == BufferedImage.TYPE_4BYTE_ABGR
|| srcImage.getType() == BufferedImage.TYPE_4BYTE_ABGR_PRE
) {
targetImageType = ImgUtil.IMAGE_TYPE_PNG;
} else {
targetImageType = ImgUtil.IMAGE_TYPE_JPG;
}
}
this.targetImageType = targetImageType;
}
/**
* 设置目标图片文件格式，用于写出
*
* @param imgType 图片格式
* @return this
* @see ImgUtil#IMAGE_TYPE_JPG
* @see ImgUtil#IMAGE_TYPE_PNG
*/
public Img setTargetImageType(final String imgType) {
this.targetImageType = imgType;
return this;
}
/**
* 计算x,y坐标的时候是否从中心做为原始坐标开始计算
*
* @param positionBaseCentre 是否从中心做为原始坐标开始计算
* @return this
* @since 4.1.15
*/
public Img setPositionBaseCentre(final boolean positionBaseCentre) {
this.positionBaseCentre = positionBaseCentre;
return this;
}
/**
* 设置图片输出质量，数字为0~1（不包括0和1）表示质量压缩比，除此数字外设置表示不压缩
*
* @param quality 质量，数字为0~1（不包括0和1）表示质量压缩比，除此数字外设置表示不压缩
* @return this
* @since 4.3.2
*/
public Img setQuality(final double quality) {
return setQuality((float) quality);
}
/**
* 设置图片输出质量，数字为0~1（不包括0和1）表示质量压缩比，除此数字外设置表示不压缩
*
* @param quality 质量，数字为0~1（不包括0和1）表示质量压缩比，除此数字外设置表示不压缩
* @return this
* @since 4.3.2
*/
public Img setQuality(final float quality) {
if (quality > 0 && quality < 1) {
this.quality = quality;
} else {
this.quality = 1;
}
return this;
}
/**
* 设置图片的背景色
*
* @param backgroundColor{@link Color} 背景色
* @return this
*/
public Img setBackgroundColor(final Color backgroundColor) {
this.backgroundColor = backgroundColor;
return this;
}
/**
* 缩放图像（按比例缩放）
*
* @param scale 缩放比例。比例大于1时为放大，小于1大于0为缩小
* @return this
*/
public Img scale(float scale) {
if (scale < 0) {
// 自动修正负数
scale = -scale;
}
final Image srcImg = getValidSrcImg();
// PNG图片特殊处理
if (ImgUtil.IMAGE_TYPE_PNG.equals(this.targetImageType)) {
// 修正float转double导致的精度丢失
final double scaleDouble = NumberUtil.toDouble(scale);
this.targetImage = ImgUtil.transform(AffineTransform.getScaleInstance(scaleDouble, scaleDouble),
ImgUtil.toBufferedImage(srcImg, this.targetImageType));
} else {
// 缩放后的图片宽
final int width = NumberUtil.mul(srcImg.getWidth(null), scale).intValue();
// 缩放后的图片高
final int height = NumberUtil.mul(srcImg.getHeight(null), scale).intValue();
scale(width, height);
}
return this;
}
/**
* 缩放图像（按长宽缩放）http://blog.51cto.com/cping1982/130066
*
* @param degree 旋转角度
* @return 旋转后的图片
* @since 3.2.2
*/
public Img rotate(final int degree) {
if (0 == degree) {
// 不旋转
return this;
}
final Image image = getValidSrcImg();
final int width = image.getWidth(null);
final int height = image.getHeight(null);
final Rectangle rectangle = calcRotatedSize(width, height, degree);
// 目标图像
final BufferedImage targetImg = new BufferedImage(rectangle.width, rectangle.height, getTypeInt());
// 创建画笔并填充背景色
final Graphics2D graphics2d = GraphicsUtil.createGraphics(targetImg, this.backgroundColor);
graphics2d.setRenderingHints(
RenderingHintsBuilder.of()
// 抗锯齿
.setAntialiasing(RenderingHintsBuilder.Antialias.ON)
// 双线性插值
.setInterpolation(RenderingHintsBuilder.Interpolation.BILINEAR).build());
// 从中心旋转
graphics2d.translate((rectangle.width - width) / 2D, (rectangle.height - height) / 2D);
graphics2d.rotate(Math.toRadians(degree), width / 2D, height / 2D);
graphics2d.drawImage(image, 0, 0, null);
graphics2d.dispose();
this.targetImage = targetImg;
return this;
}
/**
* 水平翻转图像
*
* @return this
*/
public Img flip() {
final Image image = getValidSrcImg();
final int width = image.getWidth(null);
final int height = image.getHeight(null);
final BufferedImage targetImg = new BufferedImage(width, height, getTypeInt());
final Graphics2D graphics2d = targetImg.createGraphics();
graphics2d.drawImage(image, 0, 0, width, height, width, 0, 0, height, null);
graphics2d.dispose();
this.targetImage = targetImg;
return this;
}
/**
* 描边，此方法为向内描边，会覆盖图片相应的位置
*
* @param color 描边颜色，默认黑色
* @param width 边框粗细
* @return this
* @since 5.4.1
*/
public Img stroke(final Color color, final float width) {
return stroke(color, new BasicStroke(width));
}
/**
* 描边，此方法为向内描边，会覆盖图片相应的位置
*
* @param color 描边颜色，默认黑色
* @param stroke 描边属性，包括粗细、线条类型等，见{@link BasicStroke}
* @return this
* @since 5.4.1
*/
public Img stroke(final Color color, final Stroke stroke) {
final BufferedImage image = ImgUtil.toBufferedImage(getValidSrcImg(), this.targetImageType);
final int width = image.getWidth();
final int height = image.getHeight();
final Graphics2D g = image.createGraphics();
g.setColor(ObjUtil.defaultIfNull(color, Color.BLACK));
if (null != stroke) {
g.setStroke(stroke);
}
g.drawRect(0, 0, width - 1, height - 1);
g.dispose();
this.targetImage = image;
return this;
}
// ----------------------------------------------------------------------------------------------------------------- Write
/**
* 获取处理过的图片
*
* @return 处理过的图片
*/
public Image getImg() {
return getValidSrcImg();
}
/**
* 写出图像为结果设置格式
