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.
com.dahuatech.hutool.core.img.Img Maven / Gradle / Ivy
package com.dahuatech.hutool.core.img;
import com.dahuatech.hutool.core.io.FileUtil;
import com.dahuatech.hutool.core.io.IORuntimeException;
import com.dahuatech.hutool.core.io.IoUtil;
import com.dahuatech.hutool.core.io.resource.Resource;
import com.dahuatech.hutool.core.lang.Assert;
import com.dahuatech.hutool.core.util.NumberUtil;
import com.dahuatech.hutool.core.util.ObjectUtil;
import com.dahuatech.hutool.core.util.StrUtil;
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.*;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.net.URL;
import java.nio.file.Path;
/**
* 图像编辑器
*
* @author looly
* @since 4.1.5
*/
public class Img implements Serializable {
private static final long serialVersionUID = 1L;
private BufferedImage srcImage;
private Image targetImage;
/** 目标图片文件格式，用于写出 */
private String targetImageType = ImgUtil.IMAGE_TYPE_JPG;
/** 计算x,y坐标的时候是否从中心做为原始坐标开始计算 */
private boolean positionBaseCentre = true;
/** 图片输出质量，用于压缩 */
private float quality = -1;
/**
* 构造
*
* @param srcImage 来源图片
*/
public Img(BufferedImage srcImage) {
this.srcImage = srcImage;
}
/**
* 从Path读取图片并开始处理
*
* @param imagePath 图片文件路径
* @return {@link Img}
*/
public static Img from(Path imagePath) {
return from(imagePath.toFile());
}
/**
* 从文件读取图片并开始处理
*
* @param imageFile 图片文件
* @return {@link Img}
*/
public static Img from(File imageFile) {
return new Img(ImgUtil.read(imageFile));
}
/**
* 从资源对象中读取图片并开始处理
*
* @param resource 图片资源对象
* @return {@link Img}
* @since 4.4.1
*/
public static Img from(Resource resource) {
return from(resource.getStream());
}
/**
* 从流读取图片并开始处理
*
* @param in 图片流
* @return {@link Img}
*/
public static Img from(InputStream in) {
return new Img(ImgUtil.read(in));
}
/**
* 从ImageInputStream取图片并开始处理
*
* @param imageStream 图片流
* @return {@link Img}
*/
public static Img from(ImageInputStream imageStream) {
return new Img(ImgUtil.read(imageStream));
}
/**
* 从URL取图片并开始处理
*
* @param imageUrl 图片URL
* @return {@link Img}
*/
public static Img from(URL imageUrl) {
return new Img(ImgUtil.read(imageUrl));
}
/**
* 从Image取图片并开始处理
*
* @param image 图片
* @return {@link Img}
*/
public static Img from(Image image) {
return new Img(ImgUtil.toBufferedImage(image));
}
/**
* 将图片绘制在背景上
*
* @param backgroundImg 背景图片
* @param img 要绘制的图片
* @param rectangle 矩形对象，表示矩形区域的x，y，width，height，x,y从背景图片中心计算
* @return 绘制后的背景
*/
private static BufferedImage draw(
BufferedImage backgroundImg, Image img, Rectangle rectangle, float alpha) {
final Graphics2D g = backgroundImg.createGraphics();
g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
g.drawImage(img, rectangle.x, rectangle.y, rectangle.width, rectangle.height, null); // 绘制切割后的图
g.dispose();
return backgroundImg;
}
/**
* 计算旋转后的图片尺寸
*
* @param width 宽度
* @param height 高度
* @param degree 旋转角度
* @return 计算后目标尺寸
* @since 4.1.20
*/
private static Rectangle calcRotatedSize(int width, int height, int degree) {
if (degree < 0) {
// 负数角度转换为正数角度
degree += 360;
}
if (degree >= 90) {
if (degree / 90 % 2 == 1) {
int temp = height;
height = width;
width = temp;
}
degree = degree % 90;
}
double r = Math.sqrt(height * height + width * width) / 2;
double len = 2 * Math.sin(Math.toRadians(degree) / 2) * r;
double angel_alpha = (Math.PI - Math.toRadians(degree)) / 2;
double angel_dalta_width = Math.atan((double) height / width);
double angel_dalta_height = Math.atan((double) width / height);
int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha - angel_dalta_width));
int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha - angel_dalta_height));
int des_width = width + len_dalta_width * 2;
int des_height = height + len_dalta_height * 2;
return new Rectangle(des_width, des_height);
}
/**
* 设置目标图片文件格式，用于写出
*
* @param imgType 图片格式
* @return this
* @see ImgUtil#IMAGE_TYPE_JPG
* @see ImgUtil#IMAGE_TYPE_PNG
*/
public Img setTargetImageType(String imgType) {
this.targetImageType = imgType;
return this;
}
/**
* 计算x,y坐标的时候是否从中心做为原始坐标开始计算
*
* @param positionBaseCentre 是否从中心做为原始坐标开始计算
* @return this
* @since 4.1.15
*/
public Img setPositionBaseCentre(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(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(float quality) {
if (quality > 0 && quality < 1) {
this.quality = quality;
} else {
this.quality = 1;
}
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)) {
final AffineTransformOp op =
new AffineTransformOp(AffineTransform.getScaleInstance(scale, scale), null);
this.targetImage = op.filter(ImgUtil.toBufferedImage(srcImg), null);
} else {
final String scaleStr = Float.toString(scale);
// 缩放后的图片宽
int width = NumberUtil.mul(Integer.toString(srcImg.getWidth(null)), scaleStr).intValue();
// 缩放后的图片高
int height = NumberUtil.mul(Integer.toString(srcImg.getHeight(null)), scaleStr).intValue();
scale(width, height);
}
return this;
}
/**
* 缩放图像（按长宽缩放）null
* @return this
*/
public Img scale(int width, int height, Color fixedColor) {
Image srcImage = getValidSrcImg();
int srcHeight = srcImage.getHeight(null);
int srcWidth = srcImage.getWidth(null);
double heightRatio = NumberUtil.div(height, srcHeight);
double widthRatio = NumberUtil.div(width, srcWidth);
if (widthRatio == heightRatio) {
// 长宽都按照相同比例缩放时，返回缩放后的图片
scale(width, height);
} else if (widthRatio < heightRatio) {
// 宽缩放比例多就按照宽缩放
scale(width, (int) (srcHeight * widthRatio));
} else {
// 否则按照高缩放
scale((int) (srcWidth * heightRatio), height);
}
// 获取缩放后的新的宽和高
srcImage = getValidSrcImg();
srcHeight = srcImage.getHeight(null);
srcWidth = srcImage.getWidth(null);
if (null == fixedColor) { // 补白
fixedColor = Color.WHITE;
}
final BufferedImage image = new BufferedImage(width, height, getTypeInt());
Graphics2D g = image.createGraphics();
// 设置背景
g.setBackground(fixedColor);
g.clearRect(0, 0, width, height);
// 在中间贴图
g.drawImage(
srcImage,
(width - srcWidth) / 2,
(height - srcHeight) / 2,
srcWidth,
srcHeight,
fixedColor,
null);
g.dispose();
this.targetImage = image;
return this;
}
/**
* 图像切割(按指定起点坐标和宽高切割)
*
* @param rectangle 矩形对象，表示矩形区域的x，y，width，height
* @return this
*/
public Img cut(Rectangle rectangle) {
final Image srcImage = getValidSrcImg();
fixRectangle(rectangle, srcImage.getWidth(null), srcImage.getHeight(null));
final ImageFilter cropFilter =
new CropImageFilter(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
final Image image =
Toolkit.getDefaultToolkit()
.createImage(new FilteredImageSource(srcImage.getSource(), cropFilter));
this.targetImage = ImgUtil.toBufferedImage(image);
return this;
}
/**
* 图像切割为圆形(按指定起点坐标和半径切割)，填充满整个图片（直径取长宽最小值）
*
* @param x 原图的x坐标起始位置
* @param y 原图的y坐标起始位置
* @return this
* @since 4.1.15
*/
public Img cut(int x, int y) {
return cut(x, y, -1);
}
/**
* 图像切割为圆形(按指定起点坐标和半径切割)
*
* @param x 原图的x坐标起始位置
* @param y 原图的y坐标起始位置
* @param radius 半径，小于0表示填充满整个图片（直径取长宽最小值）
* @return this
* @since 4.1.15
*/
public Img cut(int x, int y, int radius) {
final Image srcImage = getValidSrcImg();
final int width = srcImage.getWidth(null);
final int height = srcImage.getHeight(null);
// 计算直径
final int diameter = radius > 0 ? radius * 2 : Math.min(width, height);
final BufferedImage targetImage =
new BufferedImage(diameter, diameter, BufferedImage.TYPE_INT_ARGB);
final Graphics2D g = targetImage.createGraphics();
g.setClip(new Ellipse2D.Double(0, 0, diameter, diameter));
if (this.positionBaseCentre) {
x = x - width / 2 + diameter / 2;
y = y - height / 2 + diameter / 2;
}
g.drawImage(srcImage, x, y, null);
g.dispose();
this.targetImage = targetImage;
return this;
}
/**
* 图片圆角处理
*
* @param arc 圆角弧度，0~1，为长宽占比
* @return this
* @since 4.5.3
*/
public Img round(double arc) {
final Image srcImage = getValidSrcImg();
final int width = srcImage.getWidth(null);
final int height = srcImage.getHeight(null);
// 通过弧度占比计算弧度
arc = NumberUtil.mul(arc, Math.min(width, height));
final BufferedImage targetImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
final Graphics2D g2 = targetImage.createGraphics();
g2.setComposite(AlphaComposite.Src);
// 抗锯齿
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.fill(new RoundRectangle2D.Double(0, 0, width, height, arc, arc));
g2.setComposite(AlphaComposite.SrcAtop);
g2.drawImage(srcImage, 0, 0, null);
g2.dispose();
this.targetImage = targetImage;
return this;
}
/**
* 彩色转为黑白
*
* @return this
*/
public Img gray() {
final ColorConvertOp op = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
this.targetImage = op.filter(ImgUtil.toBufferedImage(getValidSrcImg()), null);
return this;
}
/**
* 彩色转为黑白二值化图片
*
* @return this
*/
public Img binary() {
this.targetImage = ImgUtil.copyImage(getValidSrcImg(), BufferedImage.TYPE_BYTE_BINARY);
return this;
}
/**
* 给图片添加文字水印
