disable logging.

README.md

@@ -13,12 +13,12 @@ mvn package
 
 ### run by jar
 ```shell
-java -jar ./target/dist/lib/bioformats-imageinfo-1.0.0.jar "[path to image file]"
+java -jar ./target/dist/lib/bioformats-imageinfo-1.1.2.jar "[path to image file]"
 ```
 
 ### run by fat jar
 ```shell
-java -jar ./target/bioformats-imageinfo-1.0.0-jar-with-dependencies.jar "[path to image file]"
+java -jar ./target/bioformats-imageinfo-1.1.2-jar-with-dependencies.jar "[path to image file]"
 ```
 
 ### library usage
@@ -26,14 +26,17 @@ java -jar ./target/bioformats-imageinfo-1.0.0-jar-with-dependencies.jar "[path t
 import java.util.LinkedHashMap;
 import java.util.Map;
 import jp.riken.neurodata.tools.BioFormatsImageInfo;
-import jp.riken.neurodata.tools.BioFormatsException;
+import jp.riken.neurodata.tools.BioFormatsImageException;
+import jp.riken.neurodata.tools.BioFormatsImageThumbnail;
 
 String path = "[path to image file]";
 String format = "";
 Map<String, Object> metadata = new LinkedHashMap<String, Object>();
+Map<String, Object> thumbnail = new LinkedHashMap<String, Object>();
 
 try {
   format = BioFormatsImageInfo.readMetadata(path, metadata);
+  BioFormatsImageThumbnail.readThumbnail(path, thumbnail);
 } catch (BioFormatsImageException e) {
   // error occurred
   e.printStackTrace();

pom.xml

@@ -1,17 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
-
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>jp.riken.neurodata.tools.BioFormatsImageInfo</groupId>
   <artifactId>bioformats-imageinfo</artifactId>
-  <version>1.0.0</version>
+  <version>1.1.2</version>
 
   <name>bioformats-imageinfo</name>
   <url>https://neurodata.riken.jp</url>
 
   <properties>
-    <bio-formats.version>6.10.0</bio-formats.version>
+    <bio-formats.version>6.10.1</bio-formats.version>
     <bioformats-imageinfo.mainClass>jp.riken.neurodata.tools.BioFormatsImageInfo</bioformats-imageinfo.mainClass>
 
     <maven.compiler.source>1.8</maven.compiler.source>
@@ -44,7 +42,7 @@
             </goals>
             <configuration>
               <overWriteIfNewer>true</overWriteIfNewer>
-           </configuration>
+            </configuration>
           </execution>
         </executions>
       </plugin>
@@ -56,7 +54,7 @@
           <archive>
             <manifest>
               <addClasspath>true</addClasspath>
-	      <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
+              <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
             </manifest>
           </archive>
         </configuration>
@@ -64,14 +62,14 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-assembly-plugin</artifactId>
-	<version>3.4.1</version>
+        <version>3.4.1</version>
         <configuration>
           <descriptorRefs>
             <descriptorRef>jar-with-dependencies</descriptorRef>
           </descriptorRefs>
           <archive>
             <manifest>
-	      <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
+              <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
             </manifest>
           </archive>
         </configuration>
@@ -91,12 +89,12 @@
         <version>1.10</version>
         <configuration>
           <assembleDirectory>${project.build.directory}/dist</assembleDirectory>
-	  <repositoryLayout>flat</repositoryLayout>
+          <repositoryLayout>flat</repositoryLayout>
-	  <repositoryName>lib</repositoryName>
+          <repositoryName>lib</repositoryName>
           <programs>
             <program>
-	      <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
+              <mainClass>${bioformats-imageinfo.mainClass}</mainClass>
-	      <id>${project.name}</id>
+              <id>${project.name}</id>
             </program>
           </programs>
         </configuration>
@@ -132,6 +130,7 @@
       <layout>default</layout>
     </pluginRepository>
   </pluginRepositories>
+
   <repositories>
     <repository>
       <id>central</id>

src/main/java/jp/riken/neurodata/tools/BioFormatsImageInfo.java

@@ -24,257 +24,259 @@ import loci.formats.tools.ImageInfo;
 
 public class BioFormatsImageInfo {
 
-  protected static Map<String, Object> readImages(final IFormatReader reader) throws FormatException, IOException {
+    protected static Map<String, Object> readImages(final IFormatReader reader) throws FormatException, IOException {
-    final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
+        final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
 
-    // read basic metadata
+        // read basic metadata
-    final int seriesCount = reader.getSeriesCount();
+        final int seriesCount = reader.getSeriesCount();
-    final MetadataStore ms = reader.getMetadataStore();
+        final MetadataStore ms = reader.getMetadataStore();
-    final 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);
-      final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
+            final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
 
-      final int imageCount = reader.getImageCount();
+            final int imageCount = reader.getImageCount();
-      final int resolutionCount = reader.getResolutionCount();
+            final int resolutionCount = reader.getResolutionCount();
-      final 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) {
-        final 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),
-              makeRectangle(reader.getSizeX(), reader.getSizeY()));
+                            makeRectangle(reader.getSizeX(), reader.getSizeY()));
+                }
+                seriesMetadata.put("resolutions", resolutionsMetadata);
+                reader.setResolution(0);
+            }
+
+            seriesMetadata.put("imageCount", imageCount);
+            seriesMetadata.put("RGB", new Object[] { reader.isRGB(), reader.getRGBChannelCount() });
+            seriesMetadata.put("interleaved", reader.isInterleaved());
+
+            // indexed
+            {
+                final List<Object> indexed = new ArrayList<Object>();
+                indexed.add(reader.isIndexed());
+                indexed.add(String.format("%b color", !reader.isFalseColor()));
+                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));
+                }
+                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));
+                }
+                seriesMetadata.put("indexed", indexed);
+            }
+
+            seriesMetadata.put("sizeX", reader.getSizeX());
+            seriesMetadata.put("sizeY", reader.getSizeY());
+            final int sizeZ = reader.getSizeZ();
+            seriesMetadata.put("sizeZ", makeDimension(sizeZ, sizeZ, reader.getModuloZ()));
+            seriesMetadata.put("sizeC",
+                    makeDimension(reader.getSizeC(), reader.getEffectiveSizeC(), reader.getModuloC()));
+            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()));
+            seriesMetadata.put("endianness", reader.isLittleEndian() ? "little" : "big");
+            seriesMetadata.put("dimensionOrder",
+                    new String[] { reader.getDimensionOrder(), reader.isOrderCertain() ? "certain" : "uncertain" });
+            seriesMetadata.put("pixelType", FormatTools.getPixelTypeString(reader.getPixelType()));
+            seriesMetadata.put("validBitsPerPixel", reader.getBitsPerPixel());
+            seriesMetadata.put("metadataComplete", reader.isMetadataComplete());
+            seriesMetadata.put("thumbnailSeries", reader.isThumbnailSeries());
+
+            // plane
+            {
+                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 };
+                } else if (imageCount > 2) {
+                    indices = new int[] { 0, imageCount / 2, imageCount - 1 };
+                } else if (imageCount > 1) {
+                    indices = new int[] { 0, 1 };
+                } else {
+                    indices = new int[] { 0 };
+                }
+                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]);
+                    final Map<String, Object> planeMetadata = new LinkedHashMap<String, Object>();
+                    planeMetadata.put("Z", zct[i][0]);
+                    planeMetadata.put("C", zct[i][1]);
+                    planeMetadata.put("T", zct[i][2]);
+                    if (indices[i] != indices2[i]) {
+                        planeMetadata.put("[mismatch]", indices2[i]);
+                    }
+                    seriesMetadata.put(String.format("plane[%d]", indices[i]), planeMetadata);
+                }
+            }
+            metadata.put(String.format("series[%d]", j), seriesMetadata);
         }
-        seriesMetadata.put("resolutions", resolutionsMetadata);
-        reader.setResolution(0);
-      }
 
-      seriesMetadata.put("imageCount", imageCount);
+        return metadata;
-      seriesMetadata.put("RGB", new Object[] { reader.isRGB(), reader.getRGBChannelCount() });
+    }
-      seriesMetadata.put("interleaved", reader.isInterleaved());
 
-      // indexed
+    protected static Map<String, Object> readAnnotations(final IFormatReader reader) {
-      {
+        final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
-        final List<Object> indexed = new ArrayList<Object>();
+        // global metadata
-        indexed.add(reader.isIndexed());
+        final Hashtable<String, Object> globalMetadata = reader.getGlobalMetadata();
-        indexed.add(String.format("%b color", !reader.isFalseColor()));
+        for (String key : MetadataTools.keys(globalMetadata)) {
-        final byte[][] table8 = reader.get8BitLookupTable();
+            metadata.put(key, globalMetadata.get(key));
-        if (table8 != null) {
-          indexed.add(
-              String.format("8-bit LUT: %d x %s", table8.length, table8[0] == null ? "null" : "" + table8[0].length));
         }
-        final short[][] table16 = reader.get16BitLookupTable();
+        // original metadata
-        if (table16 != null) {
+        final int seriesCount = reader.getSeriesCount();
-          indexed.add(String.format("16-bit LUT: %d x %s", table16.length,
+        for (int j = 0; j < seriesCount; j++) {
-              table16[0] == null ? "null" : "" + table16[0].length));
+            reader.setSeries(j);
+            final Hashtable<String, Object> seriesMagedata = reader.getSeriesMetadata();
+            if (!seriesMagedata.isEmpty()) {
+                final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
+                final String[] keys = MetadataTools.keys(seriesMagedata);
+                for (int i = 0; i < keys.length; i++) {
+                    seriesMetadata.put(keys[i], seriesMagedata.get(keys[i]));
+                }
+                metadata.put(String.format("series[%d]", j), seriesMetadata);
+            }
         }
-        seriesMetadata.put("indexed", indexed);
-      }
 
-      seriesMetadata.put("sizeX", reader.getSizeX());
+        return metadata;
-      seriesMetadata.put("sizeY", reader.getSizeY());
+    }
-      final int sizeZ = reader.getSizeZ();
-      seriesMetadata.put("sizeZ", makeDimension(sizeZ, sizeZ, reader.getModuloZ()));
-      seriesMetadata.put("sizeC", makeDimension(reader.getSizeC(), reader.getEffectiveSizeC(), reader.getModuloC()));
-      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()));
-      seriesMetadata.put("endianness", reader.isLittleEndian() ? "little" : "big");
-      seriesMetadata.put("dimensionOrder",
-          new String[] { reader.getDimensionOrder(), reader.isOrderCertain() ? "certain" : "uncertain" });
-      seriesMetadata.put("pixelType", FormatTools.getPixelTypeString(reader.getPixelType()));
-      seriesMetadata.put("validBitsPerPixel", reader.getBitsPerPixel());
-      seriesMetadata.put("metadataComplete", reader.isMetadataComplete());
-      seriesMetadata.put("thumbnailSeries", reader.isThumbnailSeries());
 
-      // plane
+    protected static Object makeDimension(final int size, final int effSize, final Modulo modulo) {
-      {
+        final int mLength = modulo.length();
-        final int[] indices;
+        if (size == effSize && mLength == 1) {
-        if (imageCount > 6) {
+            return size;
-          int q = imageCount / 2;
-          indices = new int[] { 0, q - 2, q - 1, q, q + 1, q + 2, imageCount - 1 };
-        } else if (imageCount > 2) {
-          indices = new int[] { 0, imageCount / 2, imageCount - 1 };
-        } else if (imageCount > 1) {
-          indices = new int[] { 0, 1 };
-        } else {
-          indices = new int[] { 0 };
         }
-        final int[][] zct = new int[indices.length][];
+        final List<Object> ret = new ArrayList<Object>();
-        final int[] indices2 = new int[indices.length];
+        ret.add(size);
-        for (int i = 0; i < indices.length; i++) {
+        if (size != effSize) {
-          zct[i] = reader.getZCTCoords(indices[i]);
+            ret.add(String.format("(effectively %d)", effSize));
-          indices2[i] = reader.getIndex(zct[i][0], zct[i][1], zct[i][2]);
-          final Map<String, Object> planeMetadata = new LinkedHashMap<String, Object>();
-          planeMetadata.put("Z", zct[i][0]);
-          planeMetadata.put("C", zct[i][1]);
-          planeMetadata.put("T", zct[i][2]);
-          if (indices[i] != indices2[i]) {
-            planeMetadata.put("[mismatch]", indices2[i]);
-          }
-          seriesMetadata.put(String.format("plane[%d]", indices[i]), planeMetadata);
         }
-      }
+        if (mLength != 1) {
-      metadata.put(String.format("series[%d]", j), seriesMetadata);
+            ret.add(String.format("(%d %s x %d %s)", size / mLength, modulo.parentType, mLength, modulo.type));
-    }
-
-    return metadata;
-  }
-
-  protected static Map<String, Object> readAnnotations(final IFormatReader reader) {
-    final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
-    // global metadata
-    final Hashtable<String, Object> globalMetadata = reader.getGlobalMetadata();
-    for (String key : MetadataTools.keys(globalMetadata)) {
-      metadata.put(key, globalMetadata.get(key));
-    }
-    // original metadata
-    final int seriesCount = reader.getSeriesCount();
-    for (int j = 0; j < seriesCount; j++) {
-      reader.setSeries(j);
-      final Hashtable<String, Object> seriesMagedata = reader.getSeriesMetadata();
-      if (!seriesMagedata.isEmpty()) {
-        final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
-        final String[] keys = MetadataTools.keys(seriesMagedata);
-        for (int i = 0; i < keys.length; i++) {
-          seriesMetadata.put(keys[i], seriesMagedata.get(keys[i]));
         }
-        metadata.put(String.format("series[%d]", j), seriesMetadata);
+
-      }
+        return ret;
     }
 
-    return metadata;
+    protected static Map<String, Object> makeRectangle(final int width, final int height) {
-  }
+        final Map<String, Object> ret = new LinkedHashMap<String, Object>();
+        ret.put("width", width);
+        ret.put("height", height);
 
-  protected static Object makeDimension(final int size, final int effSize, final Modulo modulo) {
+        return ret;
-    final int mLength = modulo.length();
-    if (size == effSize && mLength == 1) {
-      return size;
-    }
-    final List<Object> ret = new ArrayList<Object>();
-    ret.add(size);
-    if (size != effSize) {
-      ret.add(String.format("(effectively %d)", effSize));
-    }
-    if (mLength != 1) {
-      ret.add(String.format("(%d %s x %d %s)", size / mLength, modulo.parentType, mLength, modulo.type));
     }
 
-    return ret;
+    protected static String getJsonString(final Map<String, Object> map) {
-  }
+        final ObjectMapper mapper = new ObjectMapper();
-
+        String json = null;
-  protected static Map<String, Object> makeRectangle(final int width, final int height) {
-    final Map<String, Object> ret = new LinkedHashMap<String, Object>();
-    ret.put("width", width);
-    ret.put("height", height);
-
-    return ret;
-  }
-
-  protected static String getJsonString(final Map<String, Object> map) {
-    final ObjectMapper mapper = new ObjectMapper();
-    String json = null;
-    try {
-      // json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
-      json = mapper.writeValueAsString(map);
-    } catch (final Throwable e) {
-      // return "null" if conversion error occured
-      json = "null";
-    }
-
-    return json;
-  }
-
-  public static String readMetadata(final String path, final Map<String, Object> 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 = "";
-    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" });
-      info.setReader(reader);
-      info.mapLocation();
-      info.configureReaderPreInit();
-
-      // initialize reader
-      reader.setId(path);
-      format = reader.getFormat();
-      info.configureReaderPostInit();
-      info.checkWarnings();
-      // info.printOMEXML();
-      // info.readCoreMetadata();
-      metadata.put("images", readImages(reader));
-      info.initPreMinMaxValues();
-      reader.setSeries(0);
-      reader.setResolution(0);
-      // info.printGlobalMetadata();
-      // info.printOriginalMetadata();
-      final Map<String, Object> annotations = readAnnotations(reader);
-      if (!annotations.isEmpty()) {
-        metadata.put("annotations", annotations);
-      }
-    } catch (final Throwable e) {
-      throw new BioFormatsImageException(e);
-    } finally {
-      if (reader != null) {
         try {
-          reader.close();
+            // json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
-        } catch (final IOException e) {
+            json = mapper.writeValueAsString(map);
-          throw new BioFormatsImageException(e);
+        } catch (final Throwable e) {
+            // return "null" if conversion error occured
+            json = "null";
         }
-      }
+
+        return json;
     }
 
-    return format;
+    public static String readMetadata(final String path, final Map<String, Object> 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 = "";
+        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" });
+            info.setReader(reader);
+            info.mapLocation();
+            info.configureReaderPreInit();
 
-  // -- Main method --
+            // initialize reader
-  public static void main(final String[] args) {
+            reader.setId(path);
-    boolean status = true;
+            format = reader.getFormat();
-    String message = "";
+            info.configureReaderPostInit();
-    String format = "";
+            info.checkWarnings();
-    final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
+            // info.printOMEXML();
-    final Map<String, Object> thumbnail =  new LinkedHashMap<String, Object>();
+            // info.readCoreMetadata();
-    if (args.length != 1) {
+            metadata.put("images", readImages(reader));
-      status = false;
+            info.initPreMinMaxValues();
-      message = "filename argument required";
+            reader.setSeries(0);
-    } else {
+            reader.setResolution(0);
-      final String path = args[0];
+            // info.printGlobalMetadata();
-      try {
+            // info.printOriginalMetadata();
-        DebugTools.enableLogging("ERROR");
+            final Map<String, Object> annotations = readAnnotations(reader);
-        format = readMetadata(path, metadata);
+            if (!annotations.isEmpty()) {
-        BioFormatsImageThumbnail.readThumbnail(path, thumbnail);
+                metadata.put("annotations", annotations);
-      } catch (BioFormatsImageException e) {
+            }
-        status = false;
+        } catch (final Throwable e) {
-        message = e.getMessage();
+            throw new BioFormatsImageException(e);
-        metadata.clear();
+        } finally {
-        thumbnail.clear();
+            if (reader != null) {
-      }
+                try {
+                    reader.close();
+                } catch (final IOException e) {
+                    throw new BioFormatsImageException(e);
+                }
+            }
+        }
+
+        return format;
     }
 
-    final Map<String, Object> results = new LinkedHashMap<String, Object>();
+    // -- Main method --
-    results.put("status", status);
+    public static void main(final String[] args) {
-    results.put("message", message);
+        boolean status = true;
-    results.put("format", format);
+        String message = "";
-    results.put("thumbnail", thumbnail.isEmpty() ? null : thumbnail);
+        String format = "";
-    results.put("metadata", metadata.isEmpty() ? null : metadata);
+        final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
-    System.out.println(getJsonString(results));
+        final Map<String, Object> thumbnail = new LinkedHashMap<String, Object>();
+        if (args.length != 1) {
+            status = false;
+            message = "filename argument required";
+        } else {
+            final String path = args[0];
+            try {
+                DebugTools.enableLogging("OFF");
+                format = readMetadata(path, metadata);
+                BioFormatsImageThumbnail.readThumbnail(path, thumbnail);
+            } catch (Throwable t) {
+                status = false;
+                message = t.getMessage();
+                metadata.clear();
+                thumbnail.clear();
+            }
+        }
 
-    if (!status) {
+        final Map<String, Object> results = new LinkedHashMap<String, Object>();
-      System.exit(1);
+        results.put("status", status);
+        results.put("message", message);
+        results.put("format", format);
+        results.put("metadata", metadata.isEmpty() ? null : metadata);
+        results.put("thumbnail", thumbnail.isEmpty() ? null : thumbnail);
+        System.out.println(getJsonString(results));
+
+        if (!status) {
+            System.exit(1);
+        }
     }
-  }
 }

src/main/java/jp/riken/neurodata/tools/BioFormatsImageThumbnail.java

@@ -4,7 +4,6 @@ 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;
@@ -23,6 +22,7 @@ import javax.imageio.stream.ImageOutputStream;
 import loci.common.DebugTools;
 import loci.formats.FormatException;
 import loci.formats.ImageReader;
+import loci.formats.gui.AWTImageTools;
 import loci.formats.gui.BufferedImageReader;
 
 public class BioFormatsImageThumbnail {
@@ -31,7 +31,7 @@ public class BioFormatsImageThumbnail {
     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) {
+    public 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();
@@ -46,7 +46,7 @@ public class BioFormatsImageThumbnail {
         int resizeHeight = imageHeight;
         Image resizeImage = image;
         if (scale != 1.0) {
-            // resize image if dimension is larger than maximum dimention.
+            // resize image if dimension is different with requrested dimension.
             resizeWidth = (int) (scale * (double) imageWidth);
             resizeHeight = (int) (scale * (double) imageHeight);
             resizeImage = image.getScaledInstance(resizeWidth, resizeHeight, Image.SCALE_AREA_AVERAGING);
@@ -90,8 +90,10 @@ public class BioFormatsImageThumbnail {
                 final ImageOutputStream ios = ImageIO.createImageOutputStream(baos);) {
             final ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
             final ImageWriteParam param = writer.getDefaultWriteParam();
-            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+            if (param.canWriteCompressed()) {
-            param.setCompressionQuality(quality);
+                param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+                param.setCompressionQuality(quality);
+            }
             writer.setOutput(ios);
             writer.write(null, new IIOImage(removeAlphaChannel(image, matColor), null, null), param);
             writer.dispose();
@@ -105,12 +107,17 @@ public class BioFormatsImageThumbnail {
 
     protected static byte[] getPngByteArray(final BufferedImage image) throws BioFormatsImageException {
         byte[] ret = null;
-        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (final ByteArrayOutputStream baos = new ByteArrayOutputStream();
-                BufferedOutputStream bos = new BufferedOutputStream(baos);) {
+                final ImageOutputStream ios = ImageIO.createImageOutputStream(baos);) {
-            image.flush();
+            final ImageWriter writer = ImageIO.getImageWritersByFormatName("png").next();
-            ImageIO.write(image, "png", bos);
+            final ImageWriteParam param = writer.getDefaultWriteParam();
-            bos.flush();
+            if (param.canWriteCompressed()) {
-            bos.close();
+                param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+                param.setCompressionQuality(0.0f);
+            }
+            writer.setOutput(ios);
+            writer.write(null, new IIOImage(image, null, null), param);
+            writer.dispose();
             ret = baos.toByteArray();
         } catch (final IOException e) {
             throw new BioFormatsImageException(e);
@@ -131,6 +138,9 @@ public class BioFormatsImageThumbnail {
             default:
                 throw new BioFormatsImageException("Unsupported image format: " + mimeType);
         }
+        if (bytes.length == 0) {
+            throw new BioFormatsImageException("Failed to convert to " + mimeType + " format");
+        }
         final String dataUri = "data:" + mimeType + ";base64," + Base64.getEncoder().encodeToString(bytes);
 
         return dataUri;
@@ -147,22 +157,42 @@ public class BioFormatsImageThumbnail {
             reader.setId(path);
         } catch (FormatException | IOException e) {
             throw new BioFormatsImageException("unsupported file: " + path);
+        } catch (Throwable t) {
+            throw new BioFormatsImageException(t);
         }
         try {
-            final int series = 0;
+            int series = 0;
-            final int no = 0;
+            final int seriesCount = reader.getSeriesCount();
-            // System.out.println("series count: " + reader.getSeriesCount());
+            for (int i = 0; i < seriesCount; i++) {
+                reader.setSeries(i);
+                if (reader.isThumbnailSeries()) {
+                    series = i;
+                    break;
+                }
+            }
+            reader.setSeries(series);
+            final int z = reader.getSizeZ() / 2; // middle of slices
+            final int t = reader.getSizeT() / 2; // middle of frames
+            final int c = 0; // first channel
+            final int no = reader.getIndex(z, c, t);
+            // System.out.println("series count: " + seriesCount);
             // System.out.println("image count: " + reader.getImageCount());
             // System.out.println("resolution: " + reader.getResolutionCount());
-            reader.setSeries(series);
+            // System.out.println("thubmail series: " + series);
             ret = reader.openThumbImage(no);
-        } catch (final Throwable e) {
+            final boolean is16bit = reader.getBitsPerPixel() > 8;
-            for (Throwable t = e; t != null; t = t.getCause()) {
+            final boolean isGrayScale = ret.getSampleModel().getNumBands() == 1;
-                if (t instanceof OutOfMemoryError) {
+            if (is16bit || isGrayScale) {
+                // perform auto scalling if 16bit or gray scale thumbnail image.
+                ret = AWTImageTools.autoscale(ret);
+            }
+        } catch (final Throwable t) {
+            for (Throwable e = t; e != null; e = e.getCause()) {
+                if (e instanceof OutOfMemoryError) {
                     throw new BioFormatsImageException("out of memory");
                 }
             }
-            throw new BioFormatsImageException(e);
+            throw new BioFormatsImageException(t);
         } finally {
             try {
                 reader.close();
@@ -213,7 +243,7 @@ public class BioFormatsImageThumbnail {
             thumbnail.put("height", height);
             thumbnail.put("mimeType", mimeType);
             thumbnail.put("url", dataUri);
-        } catch (final BioFormatsImageException e) {
+        } catch (final Throwable t) {
             // ignore
             ret = false;
         }
@@ -221,22 +251,23 @@ public class BioFormatsImageThumbnail {
         return ret;
     }
 
-    public static void main(final String[] args) throws BioFormatsImageException {
+    public static void main(final String[] args) {
         if (args.length != 1) {
             System.out.println("filename argument required");
             System.exit(1);
         }
         final String path = args[0];
         try {
-            DebugTools.enableLogging("ERROR");
+            DebugTools.enableLogging("OFF");
             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);
+            System.out.println(dataUri);
-            saveFile(dataUri, "/var/tmp/thumbnail." + format);
+            // saveFile(dataUri, "/var/tmp/thumbnail." + format);
-        } catch (final BioFormatsImageException e) {
+        } catch (final Throwable t) {
-            System.out.println(e.getMessage());
+            // t.printStackTrace();
+            System.out.println(t.getMessage());
             System.exit(1);
         }
     }