/**
* Gets pixel data of an <code>IIOImage</code> object.
*
* @param image an <code>IIOImage</code> object
* @return a byte buffer of pixel data
* @throws Exception
*/
public static ByteBuffer getImageByteBuffer(IIOImage image) throws IOException {
// 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();
if (writer == null) {
throw new RuntimeException(
"Need to install JAI Image I/O package.\nhttps://jai-imageio.dev.java.net");
}
// 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(image.getRenderedImage(), null, null), tiffWriteParam);
// writer.write(image.getRenderedImage());
writer.dispose();
// ImageIO.write(image.getRenderedImage(), "tiff", ios); // this can be used in lieu of
// writer
ios.seek(0);
BufferedImage bi = ImageIO.read(ios);
return convertImageData(bi);
}
@SuppressWarnings("unchecked")
public void write() throws IOException {
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(EXTENSION);
ImageWriter writer = writers.next();
ImageWriteParam param = writer.getDefaultWriteParam();
IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(image), param);
if (metadata instanceof com.sun.imageio.plugins.png.PNGMetadata) {
com.sun.imageio.plugins.png.PNGMetadata pngMetadata =
(com.sun.imageio.plugins.png.PNGMetadata) metadata;
ArrayList keyword = pngMetadata.tEXt_keyword;
ArrayList text = pngMetadata.tEXt_text;
for (String key : this.metadata.keySet()) {
if (keyword == null) keyword = new ArrayList();
if (text == null) text = new ArrayList();
keyword.add(key);
text.add(this.metadata.get(key));
}
pngMetadata.tEXt_keyword = keyword;
pngMetadata.tEXt_text = text;
}
IIOImage iioi = new IIOImage(image, null, metadata);
ImageOutputStream ios = ImageIO.createImageOutputStream(file);
writer.setOutput(ios);
writer.write(iioi);
}
/**
* Unwraps nested wrapped writers until the given writer class is found.
*
* @param writerClass Class of the desired nested writer. If null, the core writer (i.e., deepest
* wrapped writer) will be returned.
* @param id Id to use as a basis when unwrapping any nested {@link ImageWriter}s. If null, the
* current id is used.
*/
public IFormatWriter unwrap(Class<? extends IFormatWriter> writerClass, String id)
throws FormatException, IOException {
IFormatWriter w = this;
while (w instanceof WriterWrapper || w instanceof ImageWriter) {
if (writerClass != null && writerClass.isInstance(w)) break;
if (w instanceof ImageWriter) {
ImageWriter iw = (ImageWriter) w;
w = id == null ? iw.getWriter() : iw.getWriter(id);
} else w = ((WriterWrapper) w).getWriter();
}
if (writerClass != null && !writerClass.isInstance(w)) return null;
return w;
}
/**
* 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 boolean compressPic(String srcFilePath, String descFilePath) {
File file = null;
BufferedImage src = null;
FileOutputStream out = null;
ImageWriter imgWrier;
ImageWriteParam imgWriteParams;
// 指定写图片的方式为 jpg
imgWrier = ImageIO.getImageWritersByFormatName("jpg").next();
imgWriteParams = new javax.imageio.plugins.jpeg.JPEGImageWriteParam(null);
// 要使用压缩，必须指定压缩方式为MODE_EXPLICIT
imgWriteParams.setCompressionMode(imgWriteParams.MODE_EXPLICIT);
// 这里指定压缩的程度，参数qality是取值0~1范围内，
imgWriteParams.setCompressionQuality((float) 0.1);
imgWriteParams.setProgressiveMode(imgWriteParams.MODE_DISABLED);
ColorModel colorModel = ColorModel.getRGBdefault();
// 指定压缩时使用的色彩模式
imgWriteParams.setDestinationType(
new javax.imageio.ImageTypeSpecifier(
colorModel, colorModel.createCompatibleSampleModel(16, 16)));
try {
if (StringUtils.isBlank(srcFilePath)) {
return false;
} else {
file = new File(srcFilePath);
src = ImageIO.read(file);
out = new FileOutputStream(descFilePath);
imgWrier.reset();
// 必须先指定 out值，才能调用write方法, ImageOutputStream可以通过任何 OutputStream构造
imgWrier.setOutput(ImageIO.createImageOutputStream(out));
// 调用write方法，就可以向输入流写图片
imgWrier.write(null, new IIOImage(src, null, null), imgWriteParams);
out.flush();
out.close();
}
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
@Test
public void testRegistry() {
final ImageWriterRegistry registry = new ImageWriterRegistry();
ImageWriter writer;
writer = registry.getWriterFor("image/something");
assertNull(writer);
writer = registry.getWriterFor("image/png");
assertTrue(writer instanceof ImageIOPNGImageWriter);
registry.register(new DummyPNGWriter());
ImageWriter dummy = registry.getWriterFor("image/png");
assertEquals(DummyPNGWriter.class, dummy.getClass());
registry.register(new OtherPNGWriter(), 50);
dummy = registry.getWriterFor("image/png");
assertEquals(OtherPNGWriter.class, dummy.getClass());
}
private void writeToFile(File selectedFile, ImageWriterSpiFileFilter ff) {
try {
ImageOutputStream ios = ImageIO.createImageOutputStream(selectedFile);
ImageWriter iw = ff.getImageWriterSpi().createWriterInstance();
iw.setOutput(ios);
ImageWriteParam iwp = iw.getDefaultWriteParam();
if (iwp.canWriteCompressed()) {
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
// set maximum image quality
iwp.setCompressionQuality(1.f);
}
Image image = viewerPanel.getImage();
BufferedImage bufferedImage;
if (viewerPanel.getImage() instanceof BufferedImage)
bufferedImage = (BufferedImage) viewerPanel.getImage();
else {
bufferedImage =
new BufferedImage(
image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
bufferedImage.createGraphics().drawImage(image, 0, 0, null);
}
iw.write(null, new IIOImage(bufferedImage, null, null), iwp);
iw.dispose();
ios.close();
} catch (IOException ioe) {
JOptionPane.showMessageDialog(
viewerPanel,
messagesBundle.getString(
"ImageViewerPanelSaveAction." + "Error_during_image_saving_message_7"),
//$NON-NLS-1$
messagesBundle.getString("ImageViewerPanelSaveAction." + "Error_dialog_title_8"),
//$NON-NLS-1$
JOptionPane.ERROR_MESSAGE);
ioe.printStackTrace();
}
}
/**
* This static method writes the indicated renderedImage (BufferedImage) to the indicated file.
*
* @param writeFile The File that shall receive the jpg data
* @param renderedImage The RenderedImage (BufferedImage) to be written
* @param jpgQuality The quality with which to compress to jpg
*/
public static void writeJpg(File writeFile, RenderedImage renderedImage, float jpgQuality) {
Iterator writers = ImageIO.getImageWritersByFormatName("jpg");
ImageWriter writer = (ImageWriter) writers.next();
JPEGImageWriteParam params = new JPEGImageWriteParam(null);
params.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
params.setCompressionQuality(jpgQuality);
params.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
params.setDestinationType(
new ImageTypeSpecifier(
java.awt.image.IndexColorModel.getRGBdefault(),
IndexColorModel.getRGBdefault().createCompatibleSampleModel(16, 16)));
try (ImageOutputStream ios = ImageIO.createImageOutputStream(new FileOutputStream(writeFile))) {
writer.setOutput(ios);
writer.write(null, new IIOImage(renderedImage, null, null), params);
ios.close();
} catch (IOException e) {
// Tools.log("ScalablePicture.writeJpg caught IOException: " + e.getMessage() + "\nwhile
// writing " + writeFile.toString());
e.printStackTrace();
}
// writer = null;
writer.dispose(); // 1.4.1 documentation says to do this.
}
public static List<File> createTiffFiles(List<IIOImage> imageList, int index, int dpiX, int dpiY)
throws IOException {
List<File> tiffFiles = new ArrayList<File>();
// 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();
if (writer == null) {
throw new RuntimeException(
"Need to install JAI Image I/O package.\nhttps://jai-imageio.dev.java.net");
}
// Get the stream metadata
IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(tiffWriteParam);
// all if index == -1; otherwise, only index-th
for (IIOImage oimage : (index == -1 ? imageList : imageList.subList(index, index + 1))) {
if (dpiX != 0 && dpiY != 0) {
// Get the default image metadata.
ImageTypeSpecifier imageType =
ImageTypeSpecifier.createFromRenderedImage(oimage.getRenderedImage());
IIOMetadata imageMetadata = writer.getDefaultImageMetadata(imageType, null);
imageMetadata = setDPIViaAPI(imageMetadata, dpiX, dpiY);
oimage.setMetadata(imageMetadata);
}
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();
return tiffFiles;
}
/**
* Merges multiple images into one TIFF image.
*
* @param inputImages an array of image files
* @param outputTiff the output TIFF file
* @throws Exception
*/
public static void mergeTiff(File[] inputImages, File outputTiff) throws IOException {
List<IIOImage> imageList = new ArrayList<IIOImage>();
for (int i = 0; i < inputImages.length; i++) {
imageList.addAll(getIIOImageList(inputImages[i]));
}
if (imageList.isEmpty()) {
// if no image
return;
}
Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(TIFF_FORMAT);
ImageWriter writer = writers.next();
// Set up the writeParam
TIFFImageWriteParam tiffWriteParam = new TIFFImageWriteParam(Locale.US);
tiffWriteParam.setCompressionMode(ImageWriteParam.MODE_DISABLED);
// Get the stream metadata
IIOMetadata streamMetadata = writer.getDefaultStreamMetadata(tiffWriteParam);
ImageOutputStream ios = ImageIO.createImageOutputStream(outputTiff);
writer.setOutput(ios);
IIOImage firstIioImage = imageList.remove(0);
writer.write(streamMetadata, firstIioImage, tiffWriteParam);
int i = 1;
for (IIOImage iioImage : imageList) {
writer.writeInsert(i++, iioImage, tiffWriteParam);
}
ios.close();
writer.dispose();
}
public static void main(String[] args)
throws DependencyException, FormatException, IOException, ServiceException {
if (args.length < 1) {
System.out.println("Please specify a (small) image file.");
System.exit(1);
}
String path = args[0];
// read in entire file
System.out.println("Reading file into memory from disk...");
File inputFile = new File(path);
int fileSize = (int) inputFile.length();
DataInputStream in = new DataInputStream(new FileInputStream(inputFile));
byte[] inBytes = new byte[fileSize];
in.readFully(inBytes);
System.out.println(fileSize + " bytes read.");
// determine input file suffix
String fileName = inputFile.getName();
int dot = fileName.lastIndexOf(".");
String suffix = dot < 0 ? "" : fileName.substring(dot);
// map input id string to input byte array
String inId = "inBytes" + suffix;
Location.mapFile(inId, new ByteArrayHandle(inBytes));
// read data from byte array using ImageReader
System.out.println();
System.out.println("Reading image data from memory...");
ServiceFactory factory = new ServiceFactory();
OMEXMLService service = factory.getInstance(OMEXMLService.class);
IMetadata omeMeta = service.createOMEXMLMetadata();
ImageReader reader = new ImageReader();
reader.setMetadataStore(omeMeta);
reader.setId(inId);
int seriesCount = reader.getSeriesCount();
int imageCount = reader.getImageCount();
int sizeX = reader.getSizeX();
int sizeY = reader.getSizeY();
int sizeZ = reader.getSizeZ();
int sizeC = reader.getSizeC();
int sizeT = reader.getSizeT();
// output some details
System.out.println("Series count: " + seriesCount);
System.out.println("First series:");
System.out.println("\tImage count = " + imageCount);
System.out.println("\tSizeX = " + sizeX);
System.out.println("\tSizeY = " + sizeY);
System.out.println("\tSizeZ = " + sizeZ);
System.out.println("\tSizeC = " + sizeC);
System.out.println("\tSizeT = " + sizeT);
// map output id string to output byte array
String outId = fileName + ".ome.tif";
ByteArrayHandle outputFile = new ByteArrayHandle();
Location.mapFile(outId, outputFile);
// write data to byte array using ImageWriter
System.out.println();
System.out.print("Writing planes to destination in memory: ");
ImageWriter writer = new ImageWriter();
writer.setMetadataRetrieve(omeMeta);
writer.setId(outId);
byte[] plane = null;
for (int i = 0; i < imageCount; i++) {
if (plane == null) {
// allow reader to allocate a new byte array
plane = reader.openBytes(i);
} else {
// reuse previously allocated byte array
reader.openBytes(i, plane);
}
writer.saveBytes(i, plane);
System.out.print(".");
}
reader.close();
writer.close();
System.out.println();
byte[] outBytes = outputFile.getBytes();
outputFile.close();
// flush output byte array to disk
System.out.println();
System.out.println("Flushing image data to disk...");
File outFile = new File(fileName + ".ome.tif");
DataOutputStream out = new DataOutputStream(new FileOutputStream(outFile));
out.write(outBytes);
out.close();
}
public void register(ImageWriter writer) {
imageWriterMap.put(writer.getMIMEType(), writer);
}
