From d6c0c9fd30ecf71563f146ebf369895a94fa627c Mon Sep 17 00:00:00 2001 From: Yoshihiro OKUMURA Date: Thu, 29 Sep 2022 15:10:53 +0900 Subject: [PATCH] support to extract thumbnail image. --- .../neurodata/tools/BioFormatsImageInfo.java | 97 +++---- .../tools/BioFormatsImageThumbnail.java | 243 ++++++++++++++++++ 2 files changed, 295 insertions(+), 45 deletions(-) create mode 100644 src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java diff --git a/src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java b/src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java index 3b2828b..c37421f 100644 --- a/src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java +++ b/src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java @@ -24,29 +24,29 @@ import loci.formats.tools.ImageInfo; public class BioFormatsImageInfo { - protected static Map readImages(IFormatReader reader) throws FormatException, IOException { - Map metadata = new LinkedHashMap(); + protected static Map readImages(final IFormatReader reader) throws FormatException, IOException { + final Map metadata = new LinkedHashMap(); // read basic metadata - int seriesCount = reader.getSeriesCount(); - MetadataStore ms = reader.getMetadataStore(); - MetadataRetrieve mr = ms instanceof MetadataRetrieve ? (MetadataRetrieve) ms : null; + final int seriesCount = reader.getSeriesCount(); + final MetadataStore ms = reader.getMetadataStore(); + final MetadataRetrieve mr = ms instanceof MetadataRetrieve ? (MetadataRetrieve) ms : null; for (int j = 0; j < seriesCount; j++) { // read basic metadata for series #j reader.setSeries(j); - Map seriesMetadata = new LinkedHashMap(); + final Map seriesMetadata = new LinkedHashMap(); - int imageCount = reader.getImageCount(); - int resolutionCount = reader.getResolutionCount(); - String seriesName = mr == null ? null : mr.getImageName(j); + final int imageCount = reader.getImageCount(); + final int resolutionCount = reader.getResolutionCount(); + final String seriesName = mr == null ? null : mr.getImageName(j); if (seriesName != null) { seriesMetadata.put("name", seriesName); } // resolutions if (resolutionCount > 1) { - Map resolutionsMetadata = new LinkedHashMap(); + final Map resolutionsMetadata = new LinkedHashMap(); for (int i = 0; i < resolutionCount; i++) { reader.setResolution(i); resolutionsMetadata.put(String.format("resolution[%d]", i), @@ -62,15 +62,15 @@ public class BioFormatsImageInfo { // indexed { - List indexed = new ArrayList(); + final List indexed = new ArrayList(); indexed.add(reader.isIndexed()); indexed.add(String.format("%b color", !reader.isFalseColor())); - byte[][] table8 = reader.get8BitLookupTable(); + final byte[][] table8 = reader.get8BitLookupTable(); if (table8 != null) { indexed.add( String.format("8-bit LUT: %d x %s", table8.length, table8[0] == null ? "null" : "" + table8[0].length)); } - short[][] table16 = reader.get16BitLookupTable(); + final short[][] table16 = reader.get16BitLookupTable(); if (table16 != null) { indexed.add(String.format("16-bit LUT: %d x %s", table16.length, table16[0] == null ? "null" : "" + table16[0].length)); @@ -80,10 +80,10 @@ public class BioFormatsImageInfo { seriesMetadata.put("sizeX", reader.getSizeX()); seriesMetadata.put("sizeY", reader.getSizeY()); - int sizeZ = reader.getSizeZ(); + final int sizeZ = reader.getSizeZ(); seriesMetadata.put("sizeZ", makeDimension(sizeZ, sizeZ, reader.getModuloZ())); seriesMetadata.put("sizeC", makeDimension(reader.getSizeC(), reader.getEffectiveSizeC(), reader.getModuloC())); - int sizeT = reader.getSizeT(); + final int sizeT = reader.getSizeT(); seriesMetadata.put("sizeT", makeDimension(sizeT, sizeT, reader.getModuloT())); seriesMetadata.put("tileSize", makeRectangle(reader.getOptimalTileWidth(), reader.getOptimalTileHeight())); seriesMetadata.put("thumbnailSize", makeRectangle(reader.getThumbSizeX(), reader.getThumbSizeY())); @@ -97,7 +97,7 @@ public class BioFormatsImageInfo { // plane { - int[] indices; + final int[] indices; if (imageCount > 6) { int q = imageCount / 2; indices = new int[] { 0, q - 2, q - 1, q, q + 1, q + 2, imageCount - 1 }; @@ -108,12 +108,12 @@ public class BioFormatsImageInfo { } else { indices = new int[] { 0 }; } - int[][] zct = new int[indices.length][]; - int[] indices2 = new int[indices.length]; + final int[][] zct = new int[indices.length][]; + final int[] indices2 = new int[indices.length]; for (int i = 0; i < indices.length; i++) { zct[i] = reader.getZCTCoords(indices[i]); indices2[i] = reader.getIndex(zct[i][0], zct[i][1], zct[i][2]); - Map planeMetadata = new LinkedHashMap(); + final Map planeMetadata = new LinkedHashMap(); planeMetadata.put("Z", zct[i][0]); planeMetadata.put("C", zct[i][1]); planeMetadata.put("T", zct[i][2]); @@ -129,21 +129,21 @@ public class BioFormatsImageInfo { return metadata; } - protected static Map readAnnotations(IFormatReader reader) { - Map metadata = new LinkedHashMap(); + protected static Map readAnnotations(final IFormatReader reader) { + final Map metadata = new LinkedHashMap(); // global metadata - Hashtable globalMetadata = reader.getGlobalMetadata(); + final Hashtable globalMetadata = reader.getGlobalMetadata(); for (String key : MetadataTools.keys(globalMetadata)) { metadata.put(key, globalMetadata.get(key)); } // original metadata - int seriesCount = reader.getSeriesCount(); + final int seriesCount = reader.getSeriesCount(); for (int j = 0; j < seriesCount; j++) { reader.setSeries(j); - Hashtable seriesMagedata = reader.getSeriesMetadata(); + final Hashtable seriesMagedata = reader.getSeriesMetadata(); if (!seriesMagedata.isEmpty()) { - Map seriesMetadata = new LinkedHashMap(); - String[] keys = MetadataTools.keys(seriesMagedata); + final Map seriesMetadata = new LinkedHashMap(); + final String[] keys = MetadataTools.keys(seriesMagedata); for (int i = 0; i < keys.length; i++) { seriesMetadata.put(keys[i], seriesMagedata.get(keys[i])); } @@ -154,12 +154,12 @@ public class BioFormatsImageInfo { return metadata; } - protected static Object makeDimension(int size, int effSize, Modulo modulo) { - int mLength = modulo.length(); + protected static Object makeDimension(final int size, final int effSize, final Modulo modulo) { + final int mLength = modulo.length(); if (size == effSize && mLength == 1) { return size; } - List ret = new ArrayList(); + final List ret = new ArrayList(); ret.add(size); if (size != effSize) { ret.add(String.format("(effectively %d)", effSize)); @@ -171,20 +171,21 @@ public class BioFormatsImageInfo { return ret; } - protected static Map makeRectangle(int width, int height) { - Map ret = new LinkedHashMap(); + protected static Map makeRectangle(final int width, final int height) { + final Map ret = new LinkedHashMap(); ret.put("width", width); ret.put("height", height); + return ret; } - protected static String getJsonString(Map map) { - ObjectMapper mapper = new ObjectMapper(); + protected static String getJsonString(final Map map) { + final ObjectMapper mapper = new ObjectMapper(); String json = null; try { // json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map); json = mapper.writeValueAsString(map); - } catch (Exception e) { + } catch (final Throwable e) { // return "null" if conversion error occured json = "null"; } @@ -192,14 +193,15 @@ public class BioFormatsImageInfo { return json; } - public static String readMetadata(String path, Map metadata) throws BioFormatsImageException { + public static String readMetadata(final String path, final Map metadata) + throws BioFormatsImageException { if (FilenameUtils.getExtension(path).toLowerCase().equals("zip")) { // ignore if file is zip archive throw new BioFormatsImageException("Zip is not supported"); } String format = ""; - ImageInfo info = new ImageInfo(); - IFormatReader reader = new ImageReader(); + final ImageInfo info = new ImageInfo(); + final IFormatReader reader = new ImageReader(); try { // info.parseArgs(new String[] { path, "-nopix", "-noflat", "-omexml" }); info.parseArgs(new String[] { path, "-nopix", "-noflat" }); @@ -220,17 +222,17 @@ public class BioFormatsImageInfo { reader.setResolution(0); // info.printGlobalMetadata(); // info.printOriginalMetadata(); - Map annotations = readAnnotations(reader); + final Map annotations = readAnnotations(reader); if (!annotations.isEmpty()) { metadata.put("annotations", annotations); } - } catch (Exception e) { + } catch (final Throwable e) { throw new BioFormatsImageException(e); } finally { if (reader != null) { try { reader.close(); - } catch (IOException e) { + } catch (final IOException e) { throw new BioFormatsImageException(e); } } @@ -240,29 +242,34 @@ public class BioFormatsImageInfo { } // -- Main method -- - public static void main(String[] args) { + public static void main(final String[] args) { boolean status = true; String message = ""; String format = ""; - Map metadata = new LinkedHashMap(); + final Map metadata = new LinkedHashMap(); + final Map thumbnail = new LinkedHashMap(); if (args.length != 1) { status = false; message = "filename argument required"; } else { + final String path = args[0]; try { DebugTools.enableLogging("ERROR"); - format = readMetadata(args[0], metadata); + format = readMetadata(path, metadata); + BioFormatsImageThumbnail.readThumbnail(path, thumbnail); } catch (BioFormatsImageException e) { status = false; - metadata.clear(); message = e.getMessage(); + metadata.clear(); + thumbnail.clear(); } } - Map results = new LinkedHashMap(); + final Map results = new LinkedHashMap(); results.put("status", status); results.put("message", message); results.put("format", format); + results.put("thumbnail", thumbnail.isEmpty() ? null : thumbnail); results.put("metadata", metadata.isEmpty() ? null : metadata); System.out.println(getJsonString(results)); diff --git a/src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java b/src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java new file mode 100644 index 0000000..1ab6e5e --- /dev/null +++ b/src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java @@ -0,0 +1,243 @@ +package jp.riken.neurodata.tools; + +import java.awt.Color; +import java.awt.Graphics2D; +import java.awt.Image; +import java.awt.image.BufferedImage; +import java.io.BufferedOutputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.Base64; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import javax.imageio.IIOImage; +import javax.imageio.ImageIO; +import javax.imageio.ImageWriteParam; +import javax.imageio.ImageWriter; +import javax.imageio.stream.ImageOutputStream; + +import loci.common.DebugTools; +import loci.formats.FormatException; +import loci.formats.ImageReader; +import loci.formats.gui.BufferedImageReader; + +public class BioFormatsImageThumbnail { + + protected static final float JPEG_QUORITY = 0.85f; + protected static final int BACKGROUND_COLOR = 0x000000; + protected static final double MAXIMUM_SCALE = 2.0; + + protected static BufferedImage resize(final BufferedImage image, final int width, final int height) { + final boolean hasAlpha = image.getColorModel().hasAlpha(); + final int imageWidth = image.getWidth(); + final int imageHeight = image.getHeight(); + final double scaleWidth = (double) width / (double) imageWidth; + final double scaleHeight = (double) height / (double) imageHeight; + double scale = Math.min(scaleWidth, scaleHeight); + if (scale > MAXIMUM_SCALE) { + // limit scalling size to maximum scale + scale = MAXIMUM_SCALE; + } + int resizeWidth = imageWidth; + int resizeHeight = imageHeight; + Image resizeImage = image; + if (scale != 1.0) { + // resize image if dimension is larger than maximum dimention. + resizeWidth = (int) (scale * (double) imageWidth); + resizeHeight = (int) (scale * (double) imageHeight); + resizeImage = image.getScaledInstance(resizeWidth, resizeHeight, Image.SCALE_AREA_AVERAGING); + } + final int type = hasAlpha ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB; + final BufferedImage ret = new BufferedImage(width, height, type); + final Graphics2D g = ret.createGraphics(); + final Color c = new Color(image.getRGB(0, 0), hasAlpha); + final int offsetX = (width - resizeWidth) / 2; + final int offsetY = (height - resizeHeight) / 2; + // System.out.println("original:" + imageWidth + "," + imageHeight); + // System.out.println("resize:" + resizeWidth + "," + resizeHeight); + // System.out.println("target:" + width + "," + height); + // System.out.println("offset:" + offsetX + "," + offsetY); + g.setColor(c); + g.fillRect(0, 0, width, height); + g.drawImage(resizeImage, offsetX, offsetY, resizeWidth, resizeHeight, null); + g.dispose(); + + return ret; + } + + protected static BufferedImage removeAlphaChannel(final BufferedImage image, final int matColor) { + if (!image.getColorModel().hasAlpha()) { + return image; + } + final BufferedImage ret = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB); + final Graphics2D g = ret.createGraphics(); + g.setColor(new Color(matColor, false)); + g.fillRect(0, 0, image.getWidth(), image.getHeight()); + g.drawImage(image, 0, 0, null); + g.dispose(); + + return ret; + } + + protected static byte[] getJpegByteArray(final BufferedImage image, final float quality, final int matColor) + throws BioFormatsImageException { + byte[] ret = null; + try (final ByteArrayOutputStream baos = new ByteArrayOutputStream(); + final ImageOutputStream ios = ImageIO.createImageOutputStream(baos);) { + final ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next(); + final ImageWriteParam param = writer.getDefaultWriteParam(); + param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); + param.setCompressionQuality(quality); + writer.setOutput(ios); + writer.write(null, new IIOImage(removeAlphaChannel(image, matColor), null, null), param); + writer.dispose(); + ret = baos.toByteArray(); + } catch (final IOException e) { + throw new BioFormatsImageException(e); + } + + return ret; + } + + protected static byte[] getPngByteArray(final BufferedImage image) throws BioFormatsImageException { + byte[] ret = null; + try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); + BufferedOutputStream bos = new BufferedOutputStream(baos);) { + image.flush(); + ImageIO.write(image, "png", bos); + bos.flush(); + bos.close(); + ret = baos.toByteArray(); + } catch (final IOException e) { + throw new BioFormatsImageException(e); + } + + return ret; + } + + public static String getDataUri(final BufferedImage image, final String mimeType) throws BioFormatsImageException { + byte[] bytes = null; + switch (mimeType) { + case "image/png": + bytes = getPngByteArray(image); + break; + case "image/jpeg": + bytes = getJpegByteArray(image, JPEG_QUORITY, BACKGROUND_COLOR); + break; + default: + throw new BioFormatsImageException("Unsupported image format: " + mimeType); + } + final String dataUri = "data:" + mimeType + ";base64," + Base64.getEncoder().encodeToString(bytes); + + return dataUri; + } + + public static BufferedImage getImageFromBioFormatsFile(final String path) throws BioFormatsImageException { + BufferedImage ret = null; + final BufferedImageReader reader = new BufferedImageReader(new ImageReader()); + reader.setFlattenedResolutions(false); + reader.setNormalized(true); + reader.setOriginalMetadataPopulated(false); + reader.setMetadataFiltered(true); + try { + reader.setId(path); + } catch (FormatException | IOException e) { + throw new BioFormatsImageException("unsupported file: " + path); + } + try { + final int series = 0; + final int no = 0; + // System.out.println("series count: " + reader.getSeriesCount()); + // System.out.println("image count: " + reader.getImageCount()); + // System.out.println("resolution: " + reader.getResolutionCount()); + reader.setSeries(series); + ret = reader.openThumbImage(no); + } catch (final Throwable e) { + for (Throwable t = e; t != null; t = t.getCause()) { + if (t instanceof OutOfMemoryError) { + throw new BioFormatsImageException("out of memory"); + } + } + throw new BioFormatsImageException(e); + } finally { + try { + reader.close(); + } catch (final IOException e) { + throw new BioFormatsImageException(e); + } + } + + return ret; + } + + public static BufferedImage getImageFromFile(final String path) throws BioFormatsImageException { + BufferedImage ret = null; + final File file = new File(path); + try { + ret = ImageIO.read(file); + } catch (final IOException e) { + throw new BioFormatsImageException(e); + } + + return ret; + } + + public static void saveFile(final String dataUri, final String path) throws BioFormatsImageException { + final Pattern pattern = Pattern.compile("^data:(image/[^;]+);(base64|utf8),(.*)$", Pattern.MULTILINE); + final Matcher matcher = pattern.matcher(dataUri); + if (!matcher.find()) { + throw new BioFormatsImageException("Unsupported data URI format"); + } + final byte[] bytes = matcher.group(2) == "utf8" ? matcher.group(3).getBytes() + : Base64.getDecoder().decode(matcher.group(3)); + try (final FileOutputStream fos = new FileOutputStream(path);) { + fos.write(bytes); + } catch (final IOException e) { + throw new BioFormatsImageException(e); + } + } + + public static boolean readThumbnail(final String path, final Map thumbnail) { + boolean ret = true; + try { + final BufferedImage image = getImageFromBioFormatsFile(path); + final int width = image.getWidth(); + final int height = image.getHeight(); + final String mimeType = image.getColorModel().hasAlpha() ? "image/png" : "image/jpeg"; + final String dataUri = getDataUri(image, mimeType); + thumbnail.put("width", width); + thumbnail.put("height", height); + thumbnail.put("mimeType", mimeType); + thumbnail.put("url", dataUri); + } catch (final BioFormatsImageException e) { + // ignore + ret = false; + } + + return ret; + } + + public static void main(final String[] args) throws BioFormatsImageException { + if (args.length != 1) { + System.out.println("filename argument required"); + System.exit(1); + } + final String path = args[0]; + try { + DebugTools.enableLogging("ERROR"); + BufferedImage image = getImageFromBioFormatsFile(path); + final String format = image.getColorModel().hasAlpha() ? "png" : "jpeg"; + // image = resize(image, 160, 160); + final String dataUri = getDataUri(image, "image/" + format); + // System.out.println(dataUri); + saveFile(dataUri, "/var/tmp/thumbnail." + format); + } catch (final BioFormatsImageException e) { + System.out.println(e.getMessage()); + System.exit(1); + } + } +}