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.ImgUtil 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.codec.binary.Base64;
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.file.FileUtil;
import org.dromara.hutool.core.io.resource.Resource;
import org.dromara.hutool.core.io.stream.FastByteArrayOutputStream;
import org.dromara.hutool.core.lang.Assert;
import org.dromara.hutool.core.lang.tuple.Pair;
import org.dromara.hutool.core.math.NumberUtil;
import org.dromara.hutool.core.net.url.UrlUtil;
import org.dromara.hutool.core.text.StrUtil;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
import javax.swing.ImageIcon;
import java.awt.*;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.*;
import java.io.*;
import java.net.URL;
import java.util.Iterator;
/**
* 图片处理工具类：http://blog.csdn.net/zhangzhikaixinya/article/details/8459400
*
* @author Looly
*/
public class ImgUtil {
// region ----- [const] image type
/**
* 图形交换格式：GIF
*/
public static final String IMAGE_TYPE_GIF = "gif";
/**
* 联合照片专家组：JPG
*/
public static final String IMAGE_TYPE_JPG = "jpg";
/**
* 联合照片专家组：JPEG
*/
public static final String IMAGE_TYPE_JPEG = "jpeg";
/**
* 英文Bitmap（位图）的简写，它是Windows操作系统中的标准图像文件格式：BMP
*/
public static final String IMAGE_TYPE_BMP = "bmp";
/**
* 可移植网络图形：PNG
*/
public static final String IMAGE_TYPE_PNG = "png";
/**
* Photoshop的专用格式：PSD
*/
public static final String IMAGE_TYPE_PSD = "psd";
// endregion
// region ----- scale
/**
* 缩放图像（按比例缩放），目标文件的扩展名决定目标文件类型
*
* @param srcImageFile 源图像文件
* @param destImageFile 缩放后的图像文件，扩展名决定目标类型
* @param scale 缩放比例。比例大于1时为放大，小于1大于0为缩小
*/
public static void scale(final File srcImageFile, final File destImageFile, final float scale) {
BufferedImage image = null;
try {
image = read(srcImageFile);
scale(image, destImageFile, scale);
} finally {
flush(image);
}
}
/**
* 缩放图像（按比例缩放）http://blog.51cto.com/cping1982/130066
*
* @param image 需要旋转的图像，使用结束后需手动调用{@link #flush(Image)}释放资源
* @param degree 旋转角度
* @return 旋转后的图片
* @since 3.2.2
*/
public static Image rotate(final Image image, final int degree) {
return Img.from(image).rotate(degree).getImg();
}
// endregion
// region ----- flip
/**
* 水平翻转图像
*
* @param imageFile 图像文件
* @param outFile 输出文件
* @throws IORuntimeException IO异常
* @since 3.2.2
*/
public static void flip(final File imageFile, final File outFile) throws IORuntimeException {
BufferedImage image = null;
try {
image = read(imageFile);
flip(image, outFile);
} finally {
flush(image);
}
}
/**
* 水平翻转图像
*
* @param image 图像，使用结束后需手动调用{@link #flush(Image)}释放资源
* @param outFile 输出文件
* @throws IORuntimeException IO异常
* @since 3.2.2
*/
public static void flip(final Image image, final File outFile) throws IORuntimeException {
write(flip(image), outFile);
}
/**
* 水平翻转图像
*
* @param image 图像，使用结束后需手动调用{@link #flush(Image)}释放资源
* @param out 输出
* @throws IORuntimeException IO异常
* @since 3.2.2
*/
public static void flip(final Image image, final OutputStream out) throws IORuntimeException {
flip(image, getImageOutputStream(out));
}
/**
* 水平翻转图像，写出格式为JPG
*
* @param image 图像，使用结束后需手动调用{@link #flush(Image)}释放资源
* @param out 输出
* @throws IORuntimeException IO异常
* @since 3.2.2
*/
public static void flip(final Image image, final ImageOutputStream out) throws IORuntimeException {
writeJpg(flip(image), out);
}
/**
* 水平翻转图像
*
* @param image 图像，使用结束后需手动调用{@link #flush(Image)}释放资源
* @return 翻转后的图片
* @since 3.2.2
*/
public static Image flip(final Image image) {
return Img.from(image).flip().getImg();
}
// endregion
// region ----- compress
/**
* 压缩图像，输出图像只支持jpg文件
*
* @param imageFile 图像文件
* @param outFile 输出文件，只支持jpg文件
* @param quality 压缩比例，必须为0~1
* @throws IORuntimeException IO异常
* @since 4.3.2
*/
public static void compress(final File imageFile, final File outFile, final float quality) throws IORuntimeException {
Img img = null;
try {
img = Img.from(imageFile);
img.setQuality(quality).write(outFile);
} finally {
IoUtil.flush(img);
}
}
// endregion
// region ------ toImage
/**
* {@link Image} 转 {@link RenderedImage} iter = ImageIO.getImageWriters(type, formatName);
return iter.hasNext() ? iter.next() : null;
}
/**
* 根据给定的图片格式或者扩展名获取{@link ImageWriter}，如果未找到合适的Writer，返回null
*
* @param formatName 图片格式或扩展名，例如"jpg"、"png"，{@code null}则使用默认值"jpg"
* @return {@link ImageWriter}
* @since 4.3.2
*/
public static ImageWriter getWriter(String formatName) {
if (null == formatName) {
formatName = IMAGE_TYPE_JPG;
}
ImageWriter writer = null;
Iterator iter = ImageIO.getImageWritersByFormatName(formatName);
if (iter.hasNext()) {
writer = iter.next();
}
if (null == writer) {
// 尝试扩展名获取
iter = ImageIO.getImageWritersBySuffix(formatName);
if (iter.hasNext()) {
writer = iter.next();
}
}
return writer;
}
// endregion
// region ----- read
/**
* 从文件中读取图片，请使用绝对路径，使用相对路径会相对于ClassPath
*
* @param imageFilePath 图片文件路径
* @return 图片
* @since 4.1.15
*/
public static BufferedImage read(final String imageFilePath) {
return read(FileUtil.file(imageFilePath));
}
/**
* 从文件中读取图片
*
* @param imageFile 图片文件
* @return 图片
* @since 3.2.2
*/
public static BufferedImage read(final File imageFile) {
final BufferedImage result;
try {
result = ImageIO.read(imageFile);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type of file [" + imageFile.getName() + "] is not supported!");
}
return result;
}
/**
* 从{@link Resource}中读取图片
*
* @param resource 图片资源
* @return 图片
* @since 4.4.1
*/
public static BufferedImage read(final Resource resource) {
return read(resource.getStream());
}
/**
* 从流中读取图片
*
* @param imageStream 图片文件
* @return 图片
* @since 3.2.2
*/
public static BufferedImage read(final InputStream imageStream) {
final BufferedImage result;
try {
result = ImageIO.read(imageStream);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type is not supported!");
}
return result;
}
/**
* 从图片流中读取图片
*
* @param imageStream 图片文件
* @return 图片
* @since 3.2.2
*/
public static BufferedImage read(final ImageInputStream imageStream) {
final BufferedImage result;
try {
result = ImageIO.read(imageStream);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type is not supported!");
}
return result;
}
/**
* 从URL中读取图片
*
* @param imageUrl 图片文件
* @return 图片
* @since 3.2.2
*/
public static BufferedImage read(final URL imageUrl) {
final BufferedImage result;
try {
result = ImageIO.read(imageUrl);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type of [" + imageUrl + "] is not supported!");
}
return result;
}
/**
* 获得{@link ImageReader}
*
* @param type 图片文件类型，例如 "jpeg" 或 "tiff"
* @return {@link ImageReader}
*/
public static ImageReader getReader(final String type) {
final Iterator iterator = ImageIO.getImageReadersByFormatName(type);
if (iterator.hasNext()) {
return iterator.next();
}
return null;
}
/**
* 通过 {@link ImageInputStream} 获取对应类型的宽和高
*
* @param imageStream {@link ImageInputStream}
* @param type 图片类型
* @return 宽和高
* @since 6.0.0
*/
public static Pair getWidthAndHeight(final InputStream imageStream, final String type) {
return getWidthAndHeight(getImageInputStream(imageStream), type);
}
/**
* 通过 {@link ImageInputStream} 获取对应类型的宽和高
*
* @param imageStream {@link ImageInputStream}
* @param type 图片类型
* @return 宽和高
* @since 6.0.0
*/
public static Pair getWidthAndHeight(final ImageInputStream imageStream, final String type) {
final ImageReader reader = getReader(type);
if (null != reader) {
reader.setInput(imageStream, true);
try {
return Pair.of(reader.getWidth(0), reader.getHeight(0));
} catch (final IOException e) {
throw new IORuntimeException(e);
}
}
return null;
}
// endregion
// region ----- getImage and getPoint
/**
* 从URL中获取或读取图片对象
*
* @param url URL
* @return {@link Image}
* @since 5.5.8
*/
public static Image getImage(final URL url) {
return Toolkit.getDefaultToolkit().getImage(url);
}
/**
* 获取{@link ImageOutputStream}
*
* @param out {@link OutputStream}
* @return {@link ImageOutputStream}
* @throws IORuntimeException IO异常
* @since 3.1.2
*/
public static ImageOutputStream getImageOutputStream(final OutputStream out) throws IORuntimeException {
final ImageOutputStream result;
try {
result = ImageIO.createImageOutputStream(out);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type is not supported!");
}
return result;
}
/**
* 获取{@link ImageOutputStream}
*
* @param outFile {@link File}
* @return {@link ImageOutputStream}
* @throws IORuntimeException IO异常
* @since 3.2.2
*/
public static ImageOutputStream getImageOutputStream(final File outFile) throws IORuntimeException {
final ImageOutputStream result;
try {
result = ImageIO.createImageOutputStream(outFile);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type of file [" + outFile.getName() + "] is not supported!");
}
return result;
}
/**
* 获取{@link ImageInputStream}
*
* @param in {@link InputStream}
* @return {@link ImageInputStream}
* @throws IORuntimeException IO异常
* @since 3.1.2
*/
public static ImageInputStream getImageInputStream(final InputStream in) throws IORuntimeException {
final ImageOutputStream result;
try {
result = ImageIO.createImageOutputStream(in);
} catch (final IOException e) {
throw new IORuntimeException(e);
}
if (null == result) {
throw new IllegalArgumentException("Image type is not supported!");
}
return result;
}
/**
* 获得修正后的矩形坐标位置，变为以背景中心为基准坐标（即x,y == 0,0时，处于背景正中）
*
* @param rectangle 矩形
* @param backgroundWidth 参考宽（背景宽）
* @param backgroundHeight 参考高（背景高）
* @return 修正后的{@link Point}
* @since 5.3.6
*/
public static Point getPointBaseCentre(final Rectangle rectangle, final int backgroundWidth, final int backgroundHeight) {
return new Point(
rectangle.x + (Math.abs(backgroundWidth - rectangle.width) / 2), //
rectangle.y + (Math.abs(backgroundHeight - rectangle.height) / 2)//
);
}
// endregion
// region ----- backgroundRemoval
/**
* 背景移除
* 图片去底工具
* 将 "纯色背景的图片" 还原成 "透明背景的图片"
* 将纯色背景的图片转成矢量图
* 取图片边缘的像素点和获取到的图片主题色作为要替换的背景色
* 再加入一定的容差值,然后将所有像素点与该颜色进行比较
* 发现相同则将颜色不透明度设置为0,使颜色完全透明.
*
* @param inputPath 要处理图片的路径
* @param outputPath 输出图片的路径
* @param tolerance 容差值[根据图片的主题色,加入容差值,值的范围在0~255之间]
*/
public static void backgroundRemoval(final String inputPath, final String outputPath, final int tolerance) {
BackgroundRemoval.backgroundRemoval(inputPath, outputPath, tolerance);
}
/**
* 背景移除
* 图片去底工具
* 将 "纯色背景的图片" 还原成 "透明背景的图片"
* 将纯色背景的图片转成矢量图
* 取图片边缘的像素点和获取到的图片主题色作为要替换的背景色
* 再加入一定的容差值,然后将所有像素点与该颜色进行比较
* 发现相同则将颜色不透明度设置为0,使颜色完全透明.
*
* @param input 需要进行操作的图片
* @param output 最后输出的文件
* @param tolerance 容差值[根据图片的主题色,加入容差值,值的取值范围在0~255之间]
*/
public static void backgroundRemoval(final File input, final File output, final int tolerance) {
BackgroundRemoval.backgroundRemoval(input, output, tolerance);
}
/**
* 背景移除
* 图片去底工具
* 将 "纯色背景的图片" 还原成 "透明背景的图片"
* 将纯色背景的图片转成矢量图
* 取图片边缘的像素点和获取到的图片主题色作为要替换的背景色
* 再加入一定的容差值,然后将所有像素点与该颜色进行比较
* 发现相同则将颜色不透明度设置为0,使颜色完全透明.
*
* @param input 需要进行操作的图片
* @param output 最后输出的文件
* @param override 指定替换成的背景颜色 为null时背景为透明
* @param tolerance 容差值[根据图片的主题色,加入容差值,值的取值范围在0~255之间]
*/
public static void backgroundRemoval(final File input, final File output, final Color override, final int tolerance) {
BackgroundRemoval.backgroundRemoval(input, output, override, tolerance);
}
/**
* 背景移除
* 图片去底工具
* 将 "纯色背景的图片" 还原成 "透明背景的图片"
* 将纯色背景的图片转成矢量图
* 取图片边缘的像素点和获取到的图片主题色作为要替换的背景色
* 再加入一定的容差值,然后将所有像素点与该颜色进行比较
* 发现相同则将颜色不透明度设置为0,使颜色完全透明.
*
* @param bufferedImage 需要进行处理的图片流
* @param override 指定替换成的背景颜色 为null时背景为透明
* @param tolerance 容差值[根据图片的主题色,加入容差值,值的取值范围在0~255之间]
* @return 返回处理好的图片流
*/
public static BufferedImage backgroundRemoval(final BufferedImage bufferedImage, final Color override, final int tolerance) {
return BackgroundRemoval.backgroundRemoval(bufferedImage, override, tolerance);
}
/**
* 背景移除
* 图片去底工具
* 将 "纯色背景的图片" 还原成 "透明背景的图片"
* 将纯色背景的图片转成矢量图
* 取图片边缘的像素点和获取到的图片主题色作为要替换的背景色
* 再加入一定的容差值,然后将所有像素点与该颜色进行比较
* 发现相同则将颜色不透明度设置为0,使颜色完全透明.
*
* @param outputStream 需要进行处理的图片字节数组流
* @param override 指定替换成的背景颜色 为null时背景为透明
* @param tolerance 容差值[根据图片的主题色,加入容差值,值的取值范围在0~255之间]
* @return 返回处理好的图片流
*/
public static BufferedImage backgroundRemoval(final ByteArrayOutputStream outputStream, final Color override, final int tolerance) {
return BackgroundRemoval.backgroundRemoval(outputStream, override, tolerance);
}
// endregion
// region ------ transform and filter
/**
* 图片颜色转换
