private BufferedImage getImage(File file) {
ImageInputStream iis = null;
BufferedImage image = null;
try {
iis = ImageIO.createImageInputStream(file);
Iterator<ImageReader> it = ImageIO.getImageReaders(iis);
if (!it.hasNext()) throw new UnsupportedOperationException("No image reader fround.");
ImageReader reader = it.next();
reader.setInput(iis);
int scaleFactor;
if (reader.getWidth(0) >= reader.getHeight(0))
scaleFactor = Math.round(((float) reader.getWidth(0)) / MAX_SIZE);
else scaleFactor = Math.round(((float) reader.getHeight(0)) / MAX_SIZE);
ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(scaleFactor, scaleFactor, 0, 0);
image = reader.read(0, param);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (iis != null)
try {
iis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return image;
}
@Override
public BufferedImage read(Class<? extends BufferedImage> clazz, HttpInputMessage inputMessage)
throws IOException, HttpMessageNotReadableException {
ImageInputStream imageInputStream = null;
ImageReader imageReader = null;
try {
imageInputStream = createImageInputStream(inputMessage.getBody());
MediaType contentType = inputMessage.getHeaders().getContentType();
Iterator<ImageReader> imageReaders =
ImageIO.getImageReadersByMIMEType(contentType.toString());
if (imageReaders.hasNext()) {
imageReader = imageReaders.next();
ImageReadParam irp = imageReader.getDefaultReadParam();
process(irp);
imageReader.setInput(imageInputStream, true);
return imageReader.read(0, irp);
} else {
throw new HttpMessageNotReadableException(
"Could not find javax.imageio.ImageReader for Content-Type [" + contentType + "]");
}
} finally {
if (imageReader != null) {
imageReader.dispose();
}
if (imageInputStream != null) {
try {
imageInputStream.close();
} catch (IOException ex) {
// ignore
}
}
}
}
/**
* Gets pixel data of an <code>IIOImage</code> object.
*
* @param oimage an <code>IIOImage</code> object
* @return a byte buffer of pixel data
* @throws Exception
*/
public static ByteBuffer getImageByteBuffer(BufferedImage oimage) throws IOException {
// Get tif writer and set output to file
ImageWriter writer = new TIFFImageWriterSpi().createWriterInstance();
// Set up the writeParam
// We are using the old JAI ImageIO plugin, because for some reason, OCR don't work with
// TwelveMonkeys' plugin
ImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.US);
tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED);
// Get the stream metadata
IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(tiffWriteParam);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ImageOutputStream ios = ImageIO.createImageOutputStream(outputStream);
writer.setOutput(ios);
writer.write(streamMetadata, new IIOImage(oimage, null, null), tiffWriteParam);
writer.dispose();
// Read the writed image
ios.seek(0);
ImageReader reader = new TIFFImageReaderSpi().createReaderInstance();
ImageReadParam param = reader.getDefaultReadParam();
reader.setInput(ios, true, true);
BufferedImage bi;
try {
bi = reader.read(0, param);
} finally {
reader.dispose();
ios.close();
}
return convertImageData(bi);
}
/**
* Gets a list of <code>IIOImage</code> objects for an image file.
*
* @param imageFile input image file. It can be any of the supported formats, including TIFF,
* JPEG, GIF, PNG, BMP, JPEG, and PDF if GPL Ghostscript is installed
* @return a list of <code>IIOImage</code> objects
* @throws Exception
*/
public static List<IIOImage> getIIOImageList(File imageFile) throws IOException {
File workingTiffFile = null;
ImageReader reader = null;
ImageInputStream iis = null;
try {
// convert PDF to TIFF
if (imageFile.getName().toLowerCase().endsWith(".pdf")) {
workingTiffFile = PdfUtilities.convertPdf2Tiff(imageFile);
imageFile = workingTiffFile;
}
List<IIOImage> iioImageList = new ArrayList<IIOImage>();
String imageFileName = imageFile.getName();
String imageFormat = imageFileName.substring(imageFileName.lastIndexOf('.') + 1);
if (imageFormat.matches("(pbm|pgm|ppm)")) {
imageFormat = "pnm";
} else if (imageFormat.equals("jp2")) {
imageFormat = "jpeg2000";
}
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageFormat);
reader = readers.next();
if (reader == null) {
throw new RuntimeException(
"Need to install JAI Image I/O package.\nhttps://jai-imageio.dev.java.net");
}
iis = ImageIO.createImageInputStream(imageFile);
reader.setInput(iis);
int imageTotal = reader.getNumImages(true);
for (int i = 0; i < imageTotal; i++) {
// IIOImage oimage = new IIOImage(reader.read(i), null,
// reader.getImageMetadata(i));
IIOImage oimage = reader.readAll(i, reader.getDefaultReadParam());
iioImageList.add(oimage);
}
return iioImageList;
} finally {
try {
if (iis != null) {
iis.close();
}
if (reader != null) {
reader.dispose();
}
} catch (Exception e) {
// ignore
}
if (workingTiffFile != null && workingTiffFile.exists()) {
workingTiffFile.delete();
}
}
}
public void readDescendingRasterBand(
final int sourceOffsetX,
final int sourceOffsetY,
final int sourceStepX,
final int sourceStepY,
final ProductData destBuffer,
final int destOffsetX,
final int destOffsetY,
final int destWidth,
final int destHeight,
final int imageID,
final ImageIOFile img,
final int bandSampleOffset,
final boolean isAntennaPointingRight)
throws IOException {
final Raster data;
synchronized (dataDir) {
final ImageReader reader = img.getReader();
final ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(
sourceStepX, sourceStepY, sourceOffsetX % sourceStepX, sourceOffsetY % sourceStepY);
final RenderedImage image = reader.readAsRenderedImage(0, param);
if (flipToSARGeometry && isAntennaPointingRight) { // flip the image left to right
data =
image.getData(
new Rectangle(
img.getSceneWidth() - destOffsetX - destWidth,
destOffsetY,
destWidth,
destHeight));
} else {
data = image.getData(new Rectangle(destOffsetX, destOffsetY, destWidth, destHeight));
}
}
final DataBuffer dataBuffer = data.getDataBuffer();
final SampleModel sampleModel = data.getSampleModel();
final int sampleOffset = imageID + bandSampleOffset;
if (flipToSARGeometry && isAntennaPointingRight) { // flip the image left to right
final int[] dArray = new int[destWidth * destHeight];
sampleModel.getSamples(0, 0, destWidth, destHeight, sampleOffset, dArray, dataBuffer);
int srcStride, destStride;
for (int r = 0; r < destHeight; r++) {
srcStride = r * destWidth;
destStride = r * destWidth + destWidth;
for (int c = 0; c < destWidth; c++) {
destBuffer.setElemIntAt(destStride - c - 1, dArray[srcStride + c]);
}
}
} else { // no flipping is needed
sampleModel.getSamples(
0, 0, destWidth, destHeight, sampleOffset, (int[]) destBuffer.getElems(), dataBuffer);
}
}
private ImageReadParam decompressParam(ImageReadParam param) {
ImageReadParam decompressParam = decompressor.getDefaultReadParam();
ImageTypeSpecifier imageType = param.getDestinationType();
BufferedImage dest = param.getDestination();
if (isRLELossless() && imageType == null && dest == null)
imageType = createImageType(bitsStored, dataType, true);
decompressParam.setDestinationType(imageType);
decompressParam.setDestination(dest);
return decompressParam;
}
/*
* 图片裁剪通用接口
*/
public static void cutImage(String src, String dest, int x, int y, int w, int h)
throws IOException {
Iterator iterator = ImageIO.getImageReadersByFormatName("jpg");
ImageReader reader = (ImageReader) iterator.next();
InputStream in = new FileInputStream(src);
ImageInputStream iis = ImageIO.createImageInputStream(in);
reader.setInput(iis, true);
ImageReadParam param = reader.getDefaultReadParam();
Rectangle rect = new Rectangle(x, y, w, h);
param.setSourceRegion(rect);
BufferedImage bi = reader.read(0, param);
ImageIO.write(bi, "jpg", new File(dest));
}
/**
* Creates a list of TIFF image files from an image file. It basically converts images of other
* formats to TIFF format, or a multi-page TIFF image to multiple TIFF image files.
*
* @param imageFile input image file
* @param index an index of the page; -1 means all pages, as in a multi-page TIFF image
* @return a list of TIFF image files
* @throws Exception
*/
public static List<File> createTiffFiles(File imageFile, int index) throws IOException {
List<File> tiffFiles = new ArrayList<File>();
String imageFileName = imageFile.getName();
String imageFormat = imageFileName.substring(imageFileName.lastIndexOf('.') + 1);
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(imageFormat);
ImageReader reader = readers.next();
if (reader == null) {
throw new RuntimeException(
"Need to install JAI Image I/O package.\nhttps://jai-imageio.dev.java.net");
}
ImageInputStream iis = ImageIO.createImageInputStream(imageFile);
reader.setInput(iis);
// Read the stream metadata
// IIOMetadata streamMetadata = reader.getStreamMetadata();
// Set up the writeParam
TIFFImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.US);
tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED);
// Get tif writer and set output to file
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(TIFF_FORMAT);
ImageWriter writer = writers.next();
// Read the stream metadata
IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(tiffWriteParam);
int imageTotal = reader.getNumImages(true);
for (int i = 0; i < imageTotal; i++) {
// all if index == -1; otherwise, only index-th
if (index == -1 || i == index) {
// BufferedImage bi = reader.read(i);
// IIOImage oimage = new IIOImage(bi, null, reader.getImageMetadata(i));
IIOImage oimage = reader.readAll(i, reader.getDefaultReadParam());
File tiffFile = File.createTempFile(OUTPUT_FILE_NAME, TIFF_EXT);
ImageOutputStream ios = ImageIO.createImageOutputStream(tiffFile);
writer.setOutput(ios);
writer.write(streamMetadata, oimage, tiffWriteParam);
ios.close();
tiffFiles.add(tiffFile);
}
}
writer.dispose();
reader.dispose();
return tiffFiles;
}
/*
* 图片裁剪二分之一
*/
public static void cutHalfImage(String src, String dest) throws IOException {
Iterator iterator = ImageIO.getImageReadersByFormatName("jpg");
ImageReader reader = (ImageReader) iterator.next();
InputStream in = new FileInputStream(src);
ImageInputStream iis = ImageIO.createImageInputStream(in);
reader.setInput(iis, true);
ImageReadParam param = reader.getDefaultReadParam();
int imageIndex = 0;
int width = reader.getWidth(imageIndex) / 2;
int height = reader.getHeight(imageIndex) / 2;
Rectangle rect = new Rectangle(width / 2, height / 2, width, height);
param.setSourceRegion(rect);
BufferedImage bi = reader.read(0, param);
ImageIO.write(bi, "jpg", new File(dest));
}
/**
* Load image data for file and put user data attributes into file.
*
* @param file File
* @return true if file image is loaded.
* @throws java.io.IOException if image can not be loaded
*/
private static boolean refresh(@NotNull VirtualFile file) throws IOException {
Long loadedTimeStamp = file.getUserData(TIMESTAMP_KEY);
SoftReference<BufferedImage> imageRef = file.getUserData(BUFFERED_IMAGE_REF_KEY);
if (loadedTimeStamp == null
|| loadedTimeStamp.longValue() != file.getTimeStamp()
|| SoftReference.dereference(imageRef) == null) {
try {
final byte[] content = file.contentsToByteArray();
if (ICO_FORMAT.equalsIgnoreCase(file.getExtension())) {
try {
final BufferedImage image =
ICO_IMAGE_PARSER.getBufferedImage(new ByteSourceArray(content), null);
file.putUserData(FORMAT_KEY, ICO_FORMAT);
file.putUserData(BUFFERED_IMAGE_REF_KEY, new SoftReference<>(image));
return true;
} catch (ImageReadException ignore) {
}
}
InputStream inputStream = new ByteArrayInputStream(content, 0, content.length);
ImageInputStream imageInputStream = ImageIO.createImageInputStream(inputStream);
try {
Iterator<ImageReader> imageReaders = ImageIO.getImageReaders(imageInputStream);
if (imageReaders.hasNext()) {
ImageReader imageReader = imageReaders.next();
try {
file.putUserData(FORMAT_KEY, imageReader.getFormatName());
ImageReadParam param = imageReader.getDefaultReadParam();
imageReader.setInput(imageInputStream, true, true);
int minIndex = imageReader.getMinIndex();
BufferedImage image = imageReader.read(minIndex, param);
file.putUserData(BUFFERED_IMAGE_REF_KEY, new SoftReference<>(image));
return true;
} finally {
imageReader.dispose();
}
}
} finally {
imageInputStream.close();
}
} finally {
// We perform loading no more needed
file.putUserData(TIMESTAMP_KEY, file.getTimeStamp());
}
}
return false;
}
@Test
public void imageReadParam2() throws IOException {
Iterator<ImageReader> itr = ImageIO.getImageReadersByFormatName("jpg");
ImageReader imageReader = itr.next();
ImageInputStream imageInputStream = ImageIO.createImageInputStream(new File(SRCIMG));
imageReader.setInput(imageInputStream, true);
ImageReadParam imageReadParam = imageReader.getDefaultReadParam();
imageReadParam.setSourceSubsampling(3, 3, 0, 0);
BufferedImage bufferedImage = imageReader.read(0, imageReadParam);
boolean b = ImageIO.write(bufferedImage, "jpg", new File(CONTEXT + "1.jpg"));
System.out.println(b);
}
@Test
public void imageReadParam() throws IOException {
Iterator<ImageReader> itr = ImageIO.getImageReadersByFormatName("jpg");
ImageReader imageReader = itr.next();
ImageInputStream imageInputStream = ImageIO.createImageInputStream(new File(SRCIMG));
imageReader.setInput(imageInputStream, true);
ImageReadParam imageReadParam = imageReader.getDefaultReadParam();
int halfWidth = imageReader.getWidth(0) / 2;
int halfHeight = imageReader.getHeight(0) / 2;
Rectangle rectangle = new Rectangle(0, 0, halfWidth, halfHeight);
imageReadParam.setSourceRegion(rectangle);
BufferedImage bufferedImage = imageReader.read(0, imageReadParam);
System.out.println(bufferedImage.getWidth());
boolean result = ImageIO.write(bufferedImage, "png", new File(CONTEXT + "999.png"));
System.out.println(result);
}
/**
* 图片截取
*
* @param file
* @param newName
* @param path
* @param x
* @param y
* @param width
* @param height
* @return author:caobo date:Oct 14, 2009 12:38:05 PM
*/
public static File cutting(
File file, String newName, String path, int x, int y, int width, int height) {
ImageOutputStream out = null;
InputStream is = null;
ImageInputStream iis = null;
try {
String endName = file.getName();
endName = endName.substring(endName.lastIndexOf(".") + 1);
Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(endName);
ImageReader reader = (ImageReader) readers.next();
is = new FileInputStream(file);
iis = ImageIO.createImageInputStream(is);
reader.setInput(iis, true);
ImageReadParam param = reader.getDefaultReadParam();
Rectangle rect = new Rectangle(x, y, width, height);
param.setSourceRegion(rect);
BufferedImage bi = reader.read(0, param);
File newFile = new File(path);
if (!newFile.exists()) newFile.mkdirs();
newFile = new File(path, newName);
out = ImageIO.createImageOutputStream(new FileOutputStream(newFile));
ImageIO.write(bi, endName, out);
file = newFile;
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
iis.close();
is.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return file;
}
private BufferedImage scaleDown(
final ImageInputStream inputStream, final int maxWidth, final int maxHeight)
throws IOException {
final Iterator<ImageReader> readers = ImageIO.getImageReaders(inputStream);
if (!readers.hasNext()) {
throw new IOException("No ImageReader available for the given ImageInputStream");
}
// Use the first reader, next will instantiate ImageReader which needs to be disposed
final ImageReader reader = readers.next();
try {
final ImageReadParam param = reader.getDefaultReadParam();
reader.setInput(inputStream);
final Dimension original = new Dimension(reader.getWidth(0), reader.getHeight(0));
final Dimension target = new Dimension(maxWidth, maxHeight);
final int ratio = maintainAspectRatio(original, target);
param.setSourceSubsampling(ratio, ratio, 0, 0);
return reader.read(0, param);
} finally {
reader.dispose();
}
}
/**
* 根据指定坐标和长宽裁剪图片
*
* @param inputFilePath 源图片
* @param outputFilePath 产生新图片路径
* @param x x轴的开始坐标
* @param y y轴的开始坐标
* @param width 所裁剪的宽度
* @param height 所裁剪的高度
*/
public static void cut(
String inputFilePath, String outputFilePath, int x, int y, int width, int height) {
FileInputStream fileInputStream = null;
ImageInputStream imageInputStream = null;
try {
// 获得源文件
File inputFile = new File(inputFilePath);
if (!inputFile.exists()) {
logger.fatal(new FileNotFoundException());
return;
}
// 读取图片文件
fileInputStream = new FileInputStream(inputFilePath);
String format = FileUtil.getFileSuffix(inputFilePath);
// System.out.println(format);
// ImageReader声称能够解码指定格式
Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(format);
ImageReader reader = it.next();
// 获取图片流
imageInputStream = ImageIO.createImageInputStream(fileInputStream);
// 输入源中的图像将只按顺序读取
reader.setInput(imageInputStream, true);
// 描述如何对流进行解码
ImageReadParam param = reader.getDefaultReadParam();
// 图片裁剪区域
Rectangle rect = new Rectangle(x, y, width, height);
// 提供一个 BufferedImage，将其用作解码像素数据的目标
param.setSourceRegion(rect);
// 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象
BufferedImage bi = reader.read(0, param);
// 保存新图片
// File tempOutFile = new File(outputFilePath);
// if (!tempOutFile.exists()) {
// tempOutFile.mkdirs();
// }
ImageIO.write(bi, format, new File(outputFilePath));
} catch (Exception e) {
e.printStackTrace();
logger.fatal(e);
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (imageInputStream != null) {
imageInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
logger.fatal(e);
}
}
}
