fixed some warnings.
This commit is contained in:
		@@ -6,7 +6,7 @@ public class BioFormatsImageException extends Exception {
 | 
			
		||||
        super(message);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    public BioFormatsImageException(Throwable cause) {
 | 
			
		||||
    public BioFormatsImageException(Exception cause) {
 | 
			
		||||
        super(cause.getMessage());
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -2,7 +2,7 @@ package jp.riken.neurodata.tools;
 | 
			
		||||
 | 
			
		||||
import java.io.IOException;
 | 
			
		||||
import java.util.ArrayList;
 | 
			
		||||
import java.util.Hashtable;
 | 
			
		||||
import java.util.HashMap;
 | 
			
		||||
import java.util.LinkedHashMap;
 | 
			
		||||
import java.util.List;
 | 
			
		||||
import java.util.Map;
 | 
			
		||||
@@ -16,7 +16,6 @@ import loci.formats.FormatException;
 | 
			
		||||
import loci.formats.FormatTools;
 | 
			
		||||
import loci.formats.IFormatReader;
 | 
			
		||||
import loci.formats.ImageReader;
 | 
			
		||||
import loci.formats.MetadataTools;
 | 
			
		||||
import loci.formats.Modulo;
 | 
			
		||||
import loci.formats.meta.MetadataRetrieve;
 | 
			
		||||
import loci.formats.meta.MetadataStore;
 | 
			
		||||
@@ -25,7 +24,7 @@ import loci.formats.tools.ImageInfo;
 | 
			
		||||
public class BioFormatsImageInfo {
 | 
			
		||||
 | 
			
		||||
    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<>();
 | 
			
		||||
 | 
			
		||||
        // read basic metadata
 | 
			
		||||
        final int seriesCount = reader.getSeriesCount();
 | 
			
		||||
@@ -35,7 +34,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
 | 
			
		||||
            // read basic metadata for series #j
 | 
			
		||||
            reader.setSeries(j);
 | 
			
		||||
            final Map<String, Object> seriesMetadata = new LinkedHashMap<String, Object>();
 | 
			
		||||
            final Map<String, Object> seriesMetadata = new LinkedHashMap<>();
 | 
			
		||||
 | 
			
		||||
            final int imageCount = reader.getImageCount();
 | 
			
		||||
            final int resolutionCount = reader.getResolutionCount();
 | 
			
		||||
@@ -46,7 +45,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
 | 
			
		||||
            // resolutions
 | 
			
		||||
            if (resolutionCount > 1) {
 | 
			
		||||
                final Map<String, Object> resolutionsMetadata = new LinkedHashMap<String, Object>();
 | 
			
		||||
                final Map<String, Object> resolutionsMetadata = new LinkedHashMap<>();
 | 
			
		||||
                for (int i = 0; i < resolutionCount; i++) {
 | 
			
		||||
                    reader.setResolution(i);
 | 
			
		||||
                    resolutionsMetadata.put(String.format("resolution[%d]", i),
 | 
			
		||||
@@ -62,7 +61,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
 | 
			
		||||
            // indexed
 | 
			
		||||
            {
 | 
			
		||||
                final List<Object> indexed = new ArrayList<Object>();
 | 
			
		||||
                final List<Object> indexed = new ArrayList<>();
 | 
			
		||||
                indexed.add(reader.isIndexed());
 | 
			
		||||
                indexed.add(String.format("%b color", !reader.isFalseColor()));
 | 
			
		||||
                final byte[][] table8 = reader.get8BitLookupTable();
 | 
			
		||||
@@ -115,7 +114,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
                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>();
 | 
			
		||||
                    final Map<String, Object> planeMetadata = new LinkedHashMap<>();
 | 
			
		||||
                    planeMetadata.put("Z", zct[i][0]);
 | 
			
		||||
                    planeMetadata.put("C", zct[i][1]);
 | 
			
		||||
                    planeMetadata.put("T", zct[i][2]);
 | 
			
		||||
@@ -132,22 +131,21 @@ public class BioFormatsImageInfo {
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    protected static Map<String, Object> readAnnotations(final IFormatReader reader) {
 | 
			
		||||
        final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
 | 
			
		||||
        final Map<String, Object> metadata = new LinkedHashMap<>();
 | 
			
		||||
        // global metadata
 | 
			
		||||
        final Hashtable<String, Object> globalMetadata = reader.getGlobalMetadata();
 | 
			
		||||
        for (String key : MetadataTools.keys(globalMetadata)) {
 | 
			
		||||
            metadata.put(key, globalMetadata.get(key));
 | 
			
		||||
        final HashMap<String, Object> globalMetadata = new HashMap<>(reader.getGlobalMetadata());
 | 
			
		||||
        for (Map.Entry<String, Object> entry : globalMetadata.entrySet()) {
 | 
			
		||||
            metadata.put(entry.getKey(), entry.getValue());
 | 
			
		||||
        }
 | 
			
		||||
        // original metadata
 | 
			
		||||
        final int seriesCount = reader.getSeriesCount();
 | 
			
		||||
        for (int j = 0; j < seriesCount; j++) {
 | 
			
		||||
            reader.setSeries(j);
 | 
			
		||||
            final Hashtable<String, Object> seriesMetadata = reader.getSeriesMetadata();
 | 
			
		||||
            final HashMap<String, Object> seriesMetadata = new HashMap<>(reader.getSeriesMetadata());
 | 
			
		||||
            if (!seriesMetadata.isEmpty()) {
 | 
			
		||||
                final Map<String, Object> originalMetadata = new LinkedHashMap<String, Object>();
 | 
			
		||||
                final String[] keys = MetadataTools.keys(seriesMetadata);
 | 
			
		||||
                for (int i = 0; i < keys.length; i++) {
 | 
			
		||||
                    originalMetadata.put(keys[i], seriesMetadata.get(keys[i]));
 | 
			
		||||
                final Map<String, Object> originalMetadata = new LinkedHashMap<>();
 | 
			
		||||
                for (Map.Entry<String, Object> entry : seriesMetadata.entrySet()) {
 | 
			
		||||
                    originalMetadata.put(entry.getKey(), entry.getValue());
 | 
			
		||||
                }
 | 
			
		||||
                metadata.put(String.format("series[%d]", j), originalMetadata);
 | 
			
		||||
            }
 | 
			
		||||
@@ -161,7 +159,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
        if (size == effSize && mLength == 1) {
 | 
			
		||||
            return size;
 | 
			
		||||
        }
 | 
			
		||||
        final List<Object> ret = new ArrayList<Object>();
 | 
			
		||||
        final List<Object> ret = new ArrayList<>();
 | 
			
		||||
        ret.add(size);
 | 
			
		||||
        if (size != effSize) {
 | 
			
		||||
            ret.add(String.format("(effectively %d)", effSize));
 | 
			
		||||
@@ -174,7 +172,7 @@ public class BioFormatsImageInfo {
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    protected static Map<String, Object> makeRectangle(final int width, final int height) {
 | 
			
		||||
        final Map<String, Object> ret = new LinkedHashMap<String, Object>();
 | 
			
		||||
        final Map<String, Object> ret = new LinkedHashMap<>();
 | 
			
		||||
        ret.put("width", width);
 | 
			
		||||
        ret.put("height", height);
 | 
			
		||||
 | 
			
		||||
@@ -185,9 +183,8 @@ public class BioFormatsImageInfo {
 | 
			
		||||
        final ObjectMapper mapper = new ObjectMapper();
 | 
			
		||||
        String json = null;
 | 
			
		||||
        try {
 | 
			
		||||
            // json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(map);
 | 
			
		||||
            json = mapper.writeValueAsString(map);
 | 
			
		||||
        } catch (final Throwable e) {
 | 
			
		||||
        } catch (final Exception e) {
 | 
			
		||||
            // return "null" if conversion error occurred
 | 
			
		||||
            json = "null";
 | 
			
		||||
        }
 | 
			
		||||
@@ -197,15 +194,13 @@ public class BioFormatsImageInfo {
 | 
			
		||||
 | 
			
		||||
    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).equalsIgnoreCase("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" });
 | 
			
		||||
        try (final IFormatReader reader = new ImageReader()) {
 | 
			
		||||
            info.parseArgs(new String[] { path, "-nopix", "-noflat" });
 | 
			
		||||
            info.setReader(reader);
 | 
			
		||||
            info.mapLocation();
 | 
			
		||||
@@ -216,28 +211,17 @@ public class BioFormatsImageInfo {
 | 
			
		||||
            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) {
 | 
			
		||||
        } catch (final Exception e) {
 | 
			
		||||
            throw new BioFormatsImageException(e);
 | 
			
		||||
        } finally {
 | 
			
		||||
            if (reader != null) {
 | 
			
		||||
                try {
 | 
			
		||||
                    reader.close();
 | 
			
		||||
                } catch (final IOException e) {
 | 
			
		||||
                    throw new BioFormatsImageException(e);
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        return format;
 | 
			
		||||
@@ -251,8 +235,8 @@ public class BioFormatsImageInfo {
 | 
			
		||||
        boolean metadataON = true;
 | 
			
		||||
        boolean thumbnailON = true;
 | 
			
		||||
        String path = "";
 | 
			
		||||
        final Map<String, Object> metadata = new LinkedHashMap<String, Object>();
 | 
			
		||||
        final Map<String, Object> thumbnail = new LinkedHashMap<String, Object>();
 | 
			
		||||
        final Map<String, Object> metadata = new LinkedHashMap<>();
 | 
			
		||||
        final Map<String, Object> thumbnail = new LinkedHashMap<>();
 | 
			
		||||
        if (args.length == 1) {
 | 
			
		||||
            path = args[0];
 | 
			
		||||
        } else if (args.length == 2) {
 | 
			
		||||
@@ -276,15 +260,15 @@ public class BioFormatsImageInfo {
 | 
			
		||||
                if (thumbnailON) {
 | 
			
		||||
                    BioFormatsImageThumbnail.readThumbnail(path, thumbnail);
 | 
			
		||||
                }
 | 
			
		||||
            } catch (Throwable t) {
 | 
			
		||||
            } catch (final Exception e) {
 | 
			
		||||
                status = false;
 | 
			
		||||
                message = t.getMessage();
 | 
			
		||||
                message = e.getMessage();
 | 
			
		||||
                metadata.clear();
 | 
			
		||||
                thumbnail.clear();
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        final Map<String, Object> results = new LinkedHashMap<String, Object>();
 | 
			
		||||
        final Map<String, Object> results = new LinkedHashMap<>();
 | 
			
		||||
        results.put("status", status);
 | 
			
		||||
        results.put("message", message);
 | 
			
		||||
        results.put("format", format);
 | 
			
		||||
 
 | 
			
		||||
@@ -47,8 +47,8 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
        Image resizeImage = image;
 | 
			
		||||
        if (scale != 1.0) {
 | 
			
		||||
            // resize image if dimension is different with requested dimension.
 | 
			
		||||
            resizeWidth = (int) (scale * (double) imageWidth);
 | 
			
		||||
            resizeHeight = (int) (scale * (double) imageHeight);
 | 
			
		||||
            resizeWidth = (int) (scale * imageWidth);
 | 
			
		||||
            resizeHeight = (int) (scale * imageHeight);
 | 
			
		||||
            resizeImage = image.getScaledInstance(resizeWidth, resizeHeight, Image.SCALE_AREA_AVERAGING);
 | 
			
		||||
        }
 | 
			
		||||
        final int type = hasAlpha ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
 | 
			
		||||
@@ -57,10 +57,6 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
        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);
 | 
			
		||||
@@ -141,26 +137,18 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
        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;
 | 
			
		||||
        return "data:" + mimeType + ";base64," + Base64.getEncoder().encodeToString(bytes);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    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 {
 | 
			
		||||
        try (final BufferedImageReader reader = new BufferedImageReader(new ImageReader())) {
 | 
			
		||||
            reader.setFlattenedResolutions(false);
 | 
			
		||||
            reader.setNormalized(true);
 | 
			
		||||
            reader.setOriginalMetadataPopulated(false);
 | 
			
		||||
            reader.setMetadataFiltered(true);
 | 
			
		||||
            reader.setId(path);
 | 
			
		||||
        } catch (FormatException | IOException e) {
 | 
			
		||||
            throw new BioFormatsImageException("unsupported file: " + path);
 | 
			
		||||
        } catch (Throwable t) {
 | 
			
		||||
            throw new BioFormatsImageException(t);
 | 
			
		||||
        }
 | 
			
		||||
        try {
 | 
			
		||||
            int series = 0;
 | 
			
		||||
            final int seriesCount = reader.getSeriesCount();
 | 
			
		||||
            for (int i = 0; i < seriesCount; i++) {
 | 
			
		||||
@@ -175,10 +163,7 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
            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());
 | 
			
		||||
            // System.out.println("thumbnail series: " + series);
 | 
			
		||||
 | 
			
		||||
            ret = reader.openThumbImage(no);
 | 
			
		||||
            final boolean is16bit = reader.getBitsPerPixel() > 8;
 | 
			
		||||
            final boolean isGrayScale = ret.getSampleModel().getNumBands() == 1;
 | 
			
		||||
@@ -186,19 +171,12 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
                // perform auto scaling 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(t);
 | 
			
		||||
        } finally {
 | 
			
		||||
            try {
 | 
			
		||||
                reader.close();
 | 
			
		||||
            } catch (final IOException e) {
 | 
			
		||||
                throw new BioFormatsImageException(e);
 | 
			
		||||
            }
 | 
			
		||||
        } catch (final OutOfMemoryError e) {
 | 
			
		||||
            throw new BioFormatsImageException("out of memory");
 | 
			
		||||
        } catch (final FormatException | IOException e) {
 | 
			
		||||
            throw new BioFormatsImageException("unsupported file: " + path);
 | 
			
		||||
        } catch (final Exception e) {
 | 
			
		||||
            throw new BioFormatsImageException(e);
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        return ret;
 | 
			
		||||
@@ -222,7 +200,7 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
        if (!matcher.find()) {
 | 
			
		||||
            throw new BioFormatsImageException("Unsupported data URI format");
 | 
			
		||||
        }
 | 
			
		||||
        final byte[] bytes = matcher.group(2) == "utf8" ? matcher.group(3).getBytes()
 | 
			
		||||
        final byte[] bytes = "utf8".equals(matcher.group(2)) ? matcher.group(3).getBytes()
 | 
			
		||||
                : Base64.getDecoder().decode(matcher.group(3));
 | 
			
		||||
        try (final FileOutputStream fos = new FileOutputStream(path);) {
 | 
			
		||||
            fos.write(bytes);
 | 
			
		||||
@@ -243,7 +221,7 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
            thumbnail.put("height", height);
 | 
			
		||||
            thumbnail.put("mimeType", mimeType);
 | 
			
		||||
            thumbnail.put("url", dataUri);
 | 
			
		||||
        } catch (final Throwable t) {
 | 
			
		||||
        } catch (final Exception e) {
 | 
			
		||||
            // ignore
 | 
			
		||||
            ret = false;
 | 
			
		||||
        }
 | 
			
		||||
@@ -261,13 +239,12 @@ public class BioFormatsImageThumbnail {
 | 
			
		||||
            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);
 | 
			
		||||
            // saveFile(dataUri, "/var/tmp/thumbnail." + format);
 | 
			
		||||
        } catch (final Throwable t) {
 | 
			
		||||
            // t.printStackTrace();
 | 
			
		||||
            System.out.println(t.getMessage());
 | 
			
		||||
            saveFile(dataUri, "/var/tmp/thumbnail." + format);
 | 
			
		||||
        } catch (final Exception e) {
 | 
			
		||||
            e.printStackTrace();
 | 
			
		||||
            System.out.println(e.getMessage());
 | 
			
		||||
            System.exit(1);
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user