protected static BufferedImage getDestination(
ImageReadParam param, Iterator imageTypes, int width, int height) throws IIOException {
if (imageTypes == null || !imageTypes.hasNext()) {
throw new IllegalArgumentException("imageTypes null or empty!");
}
BufferedImage dest = null;
ImageTypeSpecifier imageType = null;
// If param is non-null, use it
if (param != null) {
// Try to get the image itself
dest = param.getDestination();
if (dest != null) {
return dest;
}
// No image, get the image type
imageType = param.getDestinationType();
}
// No info from param, use fallback image type
if (imageType == null) {
Object o = imageTypes.next();
if (!(o instanceof ImageTypeSpecifier)) {
throw new IllegalArgumentException("Non-ImageTypeSpecifier retrieved from imageTypes!");
}
imageType = (ImageTypeSpecifier) o;
} else {
boolean foundIt = false;
while (imageTypes.hasNext()) {
ImageTypeSpecifier type = (ImageTypeSpecifier) imageTypes.next();
if (type.equals(imageType)) {
foundIt = true;
break;
}
}
if (!foundIt) {
throw new IIOException("Destination type from ImageReadParam does not match!");
}
}
Rectangle srcRegion = new Rectangle(0, 0, 0, 0);
Rectangle destRegion = new Rectangle(0, 0, 0, 0);
computeRegions(param, width, height, null, srcRegion, destRegion);
int destWidth = destRegion.x + destRegion.width;
int destHeight = destRegion.y + destRegion.height;
// Create a new image based on the type specifier
if ((long) destWidth * destHeight > Integer.MAX_VALUE) {
throw new IllegalArgumentException("width*height > Integer.MAX_VALUE!");
}
return imageType.createBufferedImage(destWidth, destHeight);
}
public void compressJpegFile(
File infile, File outfile, float compressionQuality, int widthCanvas, int heightCanvas)
throws IOException {
// Retrieve jpg image to be compressed
BufferedImage rendImage = ImageIO.read(infile);
widthFile = rendImage.getWidth();
heightFile = rendImage.getHeight();
double aspectRatioCanvas = widthCanvas / heightCanvas;
double aspectRatioFile = widthFile / heightFile;
widthFile = widthCanvas;
heightFile = widthCanvas / aspectRatioFile;
if (heightFile > heightCanvas) {
heightFile = heightCanvas;
widthFile = heightCanvas * aspectRatioFile;
}
this.width = (int) widthFile;
this.height = (int) heightFile;
ImageTypeSpecifier its = ImageTypeSpecifier.createFromRenderedImage(rendImage);
BufferedImage outImage = its.createBufferedImage(width, height);
Graphics2D graphics2D = outImage.createGraphics();
graphics2D.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
// graphics2D.drawRenderedImage(rendImage, new AffineTransform());
graphics2D.drawImage(rendImage, 0, 0, width, height, null);
// Find a jpeg writer
ImageWriter writer = null;
Iterator iter = ImageIO.getImageWritersByFormatName("jpg");
if (iter.hasNext()) {
writer = (ImageWriter) iter.next();
}
// Prepare output file
ImageOutputStream ios = ImageIO.createImageOutputStream(outfile);
writer.setOutput(ios);
// Set the compression quality
ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());
iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwparam.setCompressionQuality(compressionQuality);
// Write the image
writer.write(null, new IIOImage(outImage, null, null), iwparam);
// infile.delete();
// Cleanup
ios.flush();
writer.dispose();
ios.close();
// return
}
@Override
public BufferedImage read(final int imageIndex, final ImageReadParam param) throws IOException {
Iterator<ImageTypeSpecifier> imageTypes = getImageTypes(imageIndex);
ImageTypeSpecifier rawType = getRawImageType(imageIndex);
if (header.getPaletteInfo() != PCX.PALETTEINFO_COLOR
&& header.getPaletteInfo() != PCX.PALETTEINFO_GRAY) {
processWarningOccurred(
String.format(
"Unsupported color mode: %d, colors may look incorrect", header.getPaletteInfo()));
}
int width = getWidth(imageIndex);
int height = getHeight(imageIndex);
BufferedImage destination = getDestination(param, imageTypes, width, height);
Rectangle srcRegion = new Rectangle();
Rectangle destRegion = new Rectangle();
computeRegions(param, width, height, destination, srcRegion, destRegion);
WritableRaster destRaster =
clipToRect(
destination.getRaster(),
destRegion,
param != null ? param.getDestinationBands() : null);
checkReadParamBandSettings(param, rawType.getNumBands(), destRaster.getNumBands());
int compression = header.getCompression();
// Wrap input (COMPRESSION_RLE is really the only value allowed)
DataInput input =
compression == PCX.COMPRESSION_RLE
? new DataInputStream(
new DecoderStream(IIOUtil.createStreamAdapter(imageInput), new RLEDecoder()))
: imageInput;
int xSub = param != null ? param.getSourceXSubsampling() : 1;
int ySub = param != null ? param.getSourceYSubsampling() : 1;
processImageStarted(imageIndex);
if (rawType.getColorModel() instanceof IndexColorModel && header.getChannels() > 1) {
// Bit planes!
// Create raster from a default 8 bit layout
WritableRaster rowRaster = GRAYSCALE.createBufferedImage(header.getWidth(), 1).getRaster();
// Clip to source region
Raster clippedRow =
clipRowToRect(
rowRaster,
srcRegion,
param != null ? param.getSourceBands() : null,
param != null ? param.getSourceXSubsampling() : 1);
int planeWidth = header.getBytesPerLine();
byte[] planeData = new byte[planeWidth * 8];
byte[] rowDataByte = ((DataBufferByte) rowRaster.getDataBuffer()).getData();
for (int y = 0; y < height; y++) {
switch (header.getBitsPerPixel()) {
case 1:
readRowByte(
input,
srcRegion,
xSub,
ySub,
planeData,
0,
planeWidth * header.getChannels(),
destRaster,
clippedRow,
y);
break;
default:
throw new AssertionError();
}
int pixelPos = 0;
for (int planePos = 0; planePos < planeWidth; planePos++) {
BitRotator.bitRotateCW(planeData, planePos, planeWidth, rowDataByte, pixelPos, 1);
pixelPos += 8;
}
processImageProgress(100f * y / height);
if (y >= srcRegion.y + srcRegion.height) {
break;
}
if (abortRequested()) {
processReadAborted();
break;
}
}
} else if (header.getBitsPerPixel() == 24 || header.getBitsPerPixel() == 32) {
// Can't use width here, as we need to take bytesPerLine into account, and re-create a width
// based on this
int rowWidth = (header.getBytesPerLine() * 8) / header.getBitsPerPixel();
WritableRaster rowRaster = rawType.createBufferedImage(rowWidth, 1).getRaster();
// Clip to source region
Raster clippedRow =
clipRowToRect(
rowRaster,
srcRegion,
param != null ? param.getSourceBands() : null,
param != null ? param.getSourceXSubsampling() : 1);
for (int y = 0; y < height; y++) {
byte[] rowDataByte = ((DataBufferByte) rowRaster.getDataBuffer()).getData();
readRowByte(
input,
srcRegion,
xSub,
ySub,
rowDataByte,
0,
rowDataByte.length,
destRaster,
clippedRow,
y);
processImageProgress(100f * y / height);
if (y >= srcRegion.y + srcRegion.height) {
break;
}
if (abortRequested()) {
processReadAborted();
break;
}
}
} else {
// Can't use width here, as we need to take bytesPerLine into account, and re-create a width
// based on this
int rowWidth = (header.getBytesPerLine() * 8) / header.getBitsPerPixel();
WritableRaster rowRaster = rawType.createBufferedImage(rowWidth, 1).getRaster();
// Clip to source region
Raster clippedRow =
clipRowToRect(
rowRaster,
srcRegion,
param != null ? param.getSourceBands() : null,
param != null ? param.getSourceXSubsampling() : 1);
for (int y = 0; y < height; y++) {
for (int c = 0; c < header.getChannels(); c++) {
WritableRaster destChannel =
destRaster.createWritableChild(
destRaster.getMinX(),
destRaster.getMinY(),
destRaster.getWidth(),
destRaster.getHeight(),
0,
0,
new int[] {c});
Raster srcChannel =
clippedRow.createChild(
clippedRow.getMinX(), 0, clippedRow.getWidth(), 1, 0, 0, new int[] {c});
switch (header.getBitsPerPixel()) {
case 1:
case 2:
case 4:
case 8:
byte[] rowDataByte = ((DataBufferByte) rowRaster.getDataBuffer()).getData(c);
readRowByte(
input,
srcRegion,
xSub,
ySub,
rowDataByte,
0,
rowDataByte.length,
destChannel,
srcChannel,
y);
break;
default:
throw new AssertionError();
}
if (abortRequested()) {
break;
}
}
processImageProgress(100f * y / height);
if (y >= srcRegion.y + srcRegion.height) {
break;
}
if (abortRequested()) {
processReadAborted();
break;
}
}
}
processImageComplete();
return destination;
}
