niu/bioformats-imageinfo
7
0
Fork 0
Code Issues Pull Requests Projects Releases 6 Wiki Activity

support to extract thumbnail image.

Browse Source
This commit is contained in:
Yoshihiro OKUMURA 2022-09-29 15:10:53 +09:00
parent 4a562db135
commit d6c0c9fd30
2 changed files with 295 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java
View File

@ -24,29 +24,29 @@ import loci.formats.tools.ImageInfo;
public class BioFormatsImageInfo { public class BioFormatsImageInfo {
protected static Map<String, Object> readImages(IFormatReader reader) throws FormatException, IOException { protected static Map<String, Object> readImages(final IFormatReader reader) throws FormatException, IOException {
Map<String, Object> metadata = new LinkedHashMap<String, Object>(); final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
// read basic metadata // read basic metadata
int seriesCount = reader.getSeriesCount(); final int seriesCount = reader.getSeriesCount();
MetadataStore ms = reader.getMetadataStore(); final MetadataStore ms = reader.getMetadataStore();
MetadataRetrieve mr = ms instanceof MetadataRetrieve ? (MetadataRetrieve) ms : null; final MetadataRetrieve mr = ms instanceof MetadataRetrieve ? (MetadataRetrieve) ms : null;
for (int j = 0; j < seriesCount; j++) { for (int j = 0; j < seriesCount; j++) {
// read basic metadata for series #j // read basic metadata for series #j
reader.setSeries(j); reader.setSeries(j);
Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>(); final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
int imageCount = reader.getImageCount(); final int imageCount = reader.getImageCount();
int resolutionCount = reader.getResolutionCount(); final int resolutionCount = reader.getResolutionCount();
String seriesName = mr == null ? null : mr.getImageName(j); final String seriesName = mr == null ? null : mr.getImageName(j);
if (seriesName != null) { if (seriesName != null) {
seriesMetadata.put("name", seriesName); seriesMetadata.put("name", seriesName);
} }
// resolutions // resolutions
if (resolutionCount > 1) { if (resolutionCount > 1) {
Map<String, Object> resolutionsMetadata = new LinkedHashMap<String, Object>(); final Map<String, Object> resolutionsMetadata = new LinkedHashMap<String, Object>();
for (int i = 0; i < resolutionCount; i++) { for (int i = 0; i < resolutionCount; i++) {
reader.setResolution(i); reader.setResolution(i);
resolutionsMetadata.put(String.format("resolution[%d]", i), resolutionsMetadata.put(String.format("resolution[%d]", i),
@ -62,15 +62,15 @@ public class BioFormatsImageInfo {
// indexed // indexed
{ {
List<Object> indexed = new ArrayList<Object>(); final List<Object> indexed = new ArrayList<Object>();
indexed.add(reader.isIndexed()); indexed.add(reader.isIndexed());
indexed.add(String.format("%b color", !reader.isFalseColor())); indexed.add(String.format("%b color", !reader.isFalseColor()));
byte[][] table8 = reader.get8BitLookupTable(); final byte[][] table8 = reader.get8BitLookupTable();
if (table8 != null) { if (table8 != null) {
indexed.add( indexed.add(
String.format("8-bit LUT: %d x %s", table8.length, table8[0] == null ? "null" : "" + table8[0].length)); 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) { if (table16 != null) {
indexed.add(String.format("16-bit LUT: %d x %s", table16.length, indexed.add(String.format("16-bit LUT: %d x %s", table16.length,
table16[0] == null ? "null" : "" + table16[0].length)); table16[0] == null ? "null" : "" + table16[0].length));
@ -80,10 +80,10 @@ public class BioFormatsImageInfo {
seriesMetadata.put("sizeX", reader.getSizeX()); seriesMetadata.put("sizeX", reader.getSizeX());
seriesMetadata.put("sizeY", reader.getSizeY()); seriesMetadata.put("sizeY", reader.getSizeY());
int sizeZ = reader.getSizeZ(); final int sizeZ = reader.getSizeZ();
seriesMetadata.put("sizeZ", makeDimension(sizeZ, sizeZ, reader.getModuloZ())); seriesMetadata.put("sizeZ", makeDimension(sizeZ, sizeZ, reader.getModuloZ()));
seriesMetadata.put("sizeC", makeDimension(reader.getSizeC(), reader.getEffectiveSizeC(), reader.getModuloC())); 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("sizeT", makeDimension(sizeT, sizeT, reader.getModuloT()));
seriesMetadata.put("tileSize", makeRectangle(reader.getOptimalTileWidth(), reader.getOptimalTileHeight())); seriesMetadata.put("tileSize", makeRectangle(reader.getOptimalTileWidth(), reader.getOptimalTileHeight()));
seriesMetadata.put("thumbnailSize", makeRectangle(reader.getThumbSizeX(), reader.getThumbSizeY())); seriesMetadata.put("thumbnailSize", makeRectangle(reader.getThumbSizeX(), reader.getThumbSizeY()));
@ -97,7 +97,7 @@ public class BioFormatsImageInfo {
// plane // plane
{ {
int[] indices; final int[] indices;
if (imageCount > 6) { if (imageCount > 6) {
int q = imageCount / 2; int q = imageCount / 2;
indices = new int[] { 0, q - 2, q - 1, q, q + 1, q + 2, imageCount - 1 }; indices = new int[] { 0, q - 2, q - 1, q, q + 1, q + 2, imageCount - 1 };
@ -108,12 +108,12 @@ public class BioFormatsImageInfo {
} else { } else {
indices = new int[] { 0 }; indices = new int[] { 0 };
} }
int[][] zct = new int[indices.length][]; final int[][] zct = new int[indices.length][];
int[] indices2 = new int[indices.length]; final int[] indices2 = new int[indices.length];
for (int i = 0; i < indices.length; i++) { for (int i = 0; i < indices.length; i++) {
zct[i] = reader.getZCTCoords(indices[i]); zct[i] = reader.getZCTCoords(indices[i]);
indices2[i] = reader.getIndex(zct[i][0], zct[i][1], zct[i][2]); indices2[i] = reader.getIndex(zct[i][0], zct[i][1], zct[i][2]);
Map<String, Object> planeMetadata = new LinkedHashMap<String, Object>(); final Map<String, Object> planeMetadata = new LinkedHashMap<String, Object>();
planeMetadata.put("Z", zct[i][0]); planeMetadata.put("Z", zct[i][0]);
planeMetadata.put("C", zct[i][1]); planeMetadata.put("C", zct[i][1]);
planeMetadata.put("T", zct[i][2]); planeMetadata.put("T", zct[i][2]);
@ -129,21 +129,21 @@ public class BioFormatsImageInfo {
return metadata; return metadata;
} }
protected static Map<String, Object> readAnnotations(IFormatReader reader) { protected static Map<String, Object> readAnnotations(final IFormatReader reader) {
Map<String, Object> metadata = new LinkedHashMap<String, Object>(); final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
// global metadata // global metadata
Hashtable<String, Object> globalMetadata = reader.getGlobalMetadata(); final Hashtable<String, Object> globalMetadata = reader.getGlobalMetadata();
for (String key : MetadataTools.keys(globalMetadata)) { for (String key : MetadataTools.keys(globalMetadata)) {
metadata.put(key, globalMetadata.get(key)); metadata.put(key, globalMetadata.get(key));
} }
// original metadata // original metadata
int seriesCount = reader.getSeriesCount(); final int seriesCount = reader.getSeriesCount();
for (int j = 0; j < seriesCount; j++) { for (int j = 0; j < seriesCount; j++) {
reader.setSeries(j); reader.setSeries(j);
Hashtable<String, Object> seriesMagedata = reader.getSeriesMetadata(); final Hashtable<String, Object> seriesMagedata = reader.getSeriesMetadata();
if (!seriesMagedata.isEmpty()) { if (!seriesMagedata.isEmpty()) {
Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>(); final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
String[] keys = MetadataTools.keys(seriesMagedata); final String[] keys = MetadataTools.keys(seriesMagedata);
for (int i = 0; i < keys.length; i++) { for (int i = 0; i < keys.length; i++) {
seriesMetadata.put(keys[i], seriesMagedata.get(keys[i])); seriesMetadata.put(keys[i], seriesMagedata.get(keys[i]));
} }
@ -154,12 +154,12 @@ public class BioFormatsImageInfo {
return metadata; return metadata;
} }
protected static Object makeDimension(int size, int effSize, Modulo modulo) { protected static Object makeDimension(final int size, final int effSize, final Modulo modulo) {
int mLength = modulo.length(); final int mLength = modulo.length();
if (size == effSize && mLength == 1) { if (size == effSize && mLength == 1) {
return size; return size;
} }
List<Object> ret = new ArrayList<Object>(); final List<Object> ret = new ArrayList<Object>();
ret.add(size); ret.add(size);
if (size != effSize) { if (size != effSize) {
ret.add(String.format("(effectively %d)", effSize)); ret.add(String.format("(effectively %d)", effSize));
@ -171,20 +171,21 @@ public class BioFormatsImageInfo {
return ret; return ret;
} }
protected static Map<String, Object> makeRectangle(int width, int height) { protected static Map<String, Object> makeRectangle(final int width, final int height) {
Map<String, Object> ret = new LinkedHashMap<String, Object>(); final Map<String, Object> ret = new LinkedHashMap<String, Object>();
ret.put("width", width); ret.put("width", width);
ret.put("height", height); ret.put("height", height);
return ret; return ret;
} }
protected static String getJsonString(Map<String, Object> map) { protected static String getJsonString(final Map<String, Object> map) {
ObjectMapper mapper = new ObjectMapper(); final ObjectMapper mapper = new ObjectMapper();
String json = null; String json = null;
try { try {
// json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map); // json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
json = mapper.writeValueAsString(map); json = mapper.writeValueAsString(map);
} catch (Exception e) { } catch (final Throwable e) {
// return "null" if conversion error occured // return "null" if conversion error occured
json = "null"; json = "null";
} }
@ -192,14 +193,15 @@ public class BioFormatsImageInfo {
return json; return json;
} }
public static String readMetadata(String path, Map<String, Object> metadata) throws BioFormatsImageException { public static String readMetadata(final String path, final Map<String, Object> metadata)
throws BioFormatsImageException {
if (FilenameUtils.getExtension(path).toLowerCase().equals("zip")) { if (FilenameUtils.getExtension(path).toLowerCase().equals("zip")) {
// ignore if file is zip archive // ignore if file is zip archive
throw new BioFormatsImageException("Zip is not supported"); throw new BioFormatsImageException("Zip is not supported");
} }
String format = ""; String format = "";
ImageInfo info = new ImageInfo(); final ImageInfo info = new ImageInfo();
IFormatReader reader = new ImageReader(); final IFormatReader reader = new ImageReader();
try { try {
// info.parseArgs(new String[] { path, "-nopix", "-noflat", "-omexml" }); // info.parseArgs(new String[] { path, "-nopix", "-noflat", "-omexml" });
info.parseArgs(new String[] { path, "-nopix", "-noflat" }); info.parseArgs(new String[] { path, "-nopix", "-noflat" });
@ -220,17 +222,17 @@ public class BioFormatsImageInfo {
reader.setResolution(0); reader.setResolution(0);
// info.printGlobalMetadata(); // info.printGlobalMetadata();
// info.printOriginalMetadata(); // info.printOriginalMetadata();
Map<String, Object> annotations = readAnnotations(reader); final Map<String, Object> annotations = readAnnotations(reader);
if (!annotations.isEmpty()) { if (!annotations.isEmpty()) {
metadata.put("annotations", annotations); metadata.put("annotations", annotations);
} }
} catch (Exception e) { } catch (final Throwable e) {
throw new BioFormatsImageException(e); throw new BioFormatsImageException(e);
} finally { } finally {
if (reader != null) { if (reader != null) {
try { try {
reader.close(); reader.close();
} catch (IOException e) { } catch (final IOException e) {
throw new BioFormatsImageException(e); throw new BioFormatsImageException(e);
} }
} }
@ -240,29 +242,34 @@ public class BioFormatsImageInfo {
} }
// -- Main method -- // -- Main method --
public static void main(String[] args) { public static void main(final String[] args) {
boolean status = true; boolean status = true;
String message = ""; String message = "";
String format = ""; String format = "";
Map<String, Object> metadata = new LinkedHashMap<String, Object>(); final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
final Map<String, Object> thumbnail = new LinkedHashMap<String, Object>();
if (args.length != 1) { if (args.length != 1) {
status = false; status = false;
message = "filename argument required"; message = "filename argument required";
} else { } else {
final String path = args[0];
try { try {
DebugTools.enableLogging("ERROR"); DebugTools.enableLogging("ERROR");
format = readMetadata(args[0], metadata); format = readMetadata(path, metadata);
BioFormatsImageThumbnail.readThumbnail(path, thumbnail);
} catch (BioFormatsImageException e) { } catch (BioFormatsImageException e) {
status = false; status = false;
metadata.clear();
message = e.getMessage(); message = e.getMessage();
metadata.clear();
thumbnail.clear();
} }
} }
Map<String, Object> results = new LinkedHashMap<String, Object>(); final Map<String, Object> results = new LinkedHashMap<String, Object>();
results.put("status", status); results.put("status", status);
results.put("message", message); results.put("message", message);
results.put("format", format); results.put("format", format);
results.put("thumbnail", thumbnail.isEmpty() ? null : thumbnail);
results.put("metadata", metadata.isEmpty() ? null : metadata); results.put("metadata", metadata.isEmpty() ? null : metadata);
System.out.println(getJsonString(results)); System.out.println(getJsonString(results));

243
src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java Normal file
View File

@ -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<String, Object> 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);
}
}
}