Examples with PositiveInteger ome.xml.model.primitives.PositiveInteger used on opensource projects

Example 16 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class OMETiffWriterBigTiffLargeImageWidthTest method setUp.

@BeforeClass
public void setUp() throws Exception {
    target = File.createTempFile("OMETiffWriterTest", ".ome.tiff");
    ServiceFactory sf = new ServiceFactory();
    OMEXMLService service = sf.getInstance(OMEXMLService.class);
    ms = service.createOMEXMLMetadata();
    ms.setImageID("Image:1", 0);
    ms.setPixelsID("Pixels:1", 0);
    ms.setPixelsDimensionOrder(DimensionOrder.XYZCT, 0);
    ms.setPixelsSizeX(new PositiveInteger(SIZE_X), 0);
    ms.setPixelsSizeY(new PositiveInteger(SIZE_Y), 0);
    ms.setPixelsSizeZ(new PositiveInteger(SIZE_Z), 0);
    ms.setPixelsSizeC(new PositiveInteger(SIZE_C), 0);
    ms.setPixelsSizeT(new PositiveInteger(SIZE_T), 0);
    ms.setPixelsType(PixelType.UINT8, 0);
    ms.setPixelsBinDataBigEndian(true, 0, 0);
    ms.setChannelID("Channel:1", 0, 0);
    ms.setChannelSamplesPerPixel(new PositiveInteger(1), 0, 0);
}

Example 17 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class ImageConverter method testConvert.

// -- Utility methods --
/**
 * A utility method for converting a file from the command line.
 */
public boolean testConvert(IFormatWriter writer, String[] args) throws FormatException, IOException {
    nextOutputIndex.clear();
    options.setValidate(validate);
    writer.setMetadataOptions(options);
    firstTile = true;
    boolean success = parseArgs(args);
    if (!success) {
        return false;
    }
    if (printVersion) {
        CommandLineTools.printVersion();
        return true;
    }
    CommandLineTools.runUpgradeCheck(args);
    if (in == null || out == null) {
        printUsage();
        return false;
    }
    if (new Location(out).exists()) {
        if (overwrite == null) {
            LOGGER.warn("Output file {} exists.", out);
            LOGGER.warn("Do you want to overwrite it? ([y]/n)");
            BufferedReader r = new BufferedReader(new InputStreamReader(System.in, Constants.ENCODING));
            String choice = r.readLine().trim().toLowerCase();
            overwrite = !choice.startsWith("n");
        }
        if (!overwrite) {
            LOGGER.warn("Exiting; next time, please specify an output file that " + "does not exist.");
            return false;
        } else {
            new Location(out).delete();
        }
    }
    if (map != null)
        Location.mapId(in, map);
    long start = System.currentTimeMillis();
    LOGGER.info(in);
    reader = new ImageReader();
    if (stitch) {
        reader = new FileStitcher(reader);
        Location f = new Location(in);
        String pat = null;
        if (!f.exists()) {
            pat = in;
        } else {
            pat = FilePattern.findPattern(f);
        }
        if (pat != null)
            in = pat;
    }
    if (separate)
        reader = new ChannelSeparator(reader);
    if (merge)
        reader = new ChannelMerger(reader);
    if (fill)
        reader = new ChannelFiller(reader);
    minMax = null;
    if (autoscale) {
        reader = new MinMaxCalculator(reader);
        minMax = (MinMaxCalculator) reader;
    }
    reader.setMetadataOptions(options);
    reader.setGroupFiles(group);
    reader.setMetadataFiltered(true);
    reader.setOriginalMetadataPopulated(true);
    OMEXMLService service = null;
    try {
        ServiceFactory factory = new ServiceFactory();
        service = factory.getInstance(OMEXMLService.class);
        reader.setMetadataStore(service.createOMEXMLMetadata());
    } catch (DependencyException de) {
        throw new MissingLibraryException(OMEXMLServiceImpl.NO_OME_XML_MSG, de);
    } catch (ServiceException se) {
        throw new FormatException(se);
    }
    reader.setId(in);
    MetadataStore store = reader.getMetadataStore();
    MetadataTools.populatePixels(store, reader, false, false);
    boolean dimensionsSet = true;
    if (width == 0 || height == 0) {
        // otherwise default to series 0
        if (series >= 0) {
            reader.setSeries(series);
        }
        width = reader.getSizeX();
        height = reader.getSizeY();
        dimensionsSet = false;
    }
    if (channel >= reader.getEffectiveSizeC()) {
        throw new FormatException("Invalid channel '" + channel + "' (" + reader.getEffectiveSizeC() + " channels in source file)");
    }
    if (timepoint >= reader.getSizeT()) {
        throw new FormatException("Invalid timepoint '" + timepoint + "' (" + reader.getSizeT() + " timepoints in source file)");
    }
    if (zSection >= reader.getSizeZ()) {
        throw new FormatException("Invalid Z section '" + zSection + "' (" + reader.getSizeZ() + " Z sections in source file)");
    }
    if (store instanceof MetadataRetrieve) {
        try {
            String xml = service.getOMEXML(service.asRetrieve(store));
            OMEXMLMetadataRoot root = (OMEXMLMetadataRoot) store.getRoot();
            IMetadata meta = service.createOMEXMLMetadata(xml);
            if (series >= 0) {
                Image exportImage = new Image(root.getImage(series));
                Pixels exportPixels = new Pixels(root.getImage(series).getPixels());
                exportImage.setPixels(exportPixels);
                OMEXMLMetadataRoot newRoot = (OMEXMLMetadataRoot) meta.getRoot();
                while (newRoot.sizeOfImageList() > 0) {
                    newRoot.removeImage(newRoot.getImage(0));
                }
                newRoot.addImage(exportImage);
                meta.setRoot(newRoot);
                meta.setPixelsSizeX(new PositiveInteger(width), 0);
                meta.setPixelsSizeY(new PositiveInteger(height), 0);
                if (autoscale) {
                    store.setPixelsType(PixelType.UINT8, 0);
                }
                if (channel >= 0) {
                    meta.setPixelsSizeC(new PositiveInteger(1), 0);
                }
                if (zSection >= 0) {
                    meta.setPixelsSizeZ(new PositiveInteger(1), 0);
                }
                if (timepoint >= 0) {
                    meta.setPixelsSizeT(new PositiveInteger(1), 0);
                }
                writer.setMetadataRetrieve((MetadataRetrieve) meta);
            } else {
                for (int i = 0; i < reader.getSeriesCount(); i++) {
                    meta.setPixelsSizeX(new PositiveInteger(width), 0);
                    meta.setPixelsSizeY(new PositiveInteger(height), 0);
                    if (autoscale) {
                        store.setPixelsType(PixelType.UINT8, i);
                    }
                    if (channel >= 0) {
                        meta.setPixelsSizeC(new PositiveInteger(1), 0);
                    }
                    if (zSection >= 0) {
                        meta.setPixelsSizeZ(new PositiveInteger(1), 0);
                    }
                    if (timepoint >= 0) {
                        meta.setPixelsSizeT(new PositiveInteger(1), 0);
                    }
                }
                writer.setMetadataRetrieve((MetadataRetrieve) meta);
            }
        } catch (ServiceException e) {
            throw new FormatException(e);
        }
    }
    writer.setWriteSequentially(true);
    if (writer instanceof TiffWriter) {
        ((TiffWriter) writer).setBigTiff(bigtiff);
    } else if (writer instanceof ImageWriter) {
        IFormatWriter w = ((ImageWriter) writer).getWriter(out);
        if (w instanceof TiffWriter) {
            ((TiffWriter) w).setBigTiff(bigtiff);
        }
    }
    String format = writer.getFormat();
    LOGGER.info("[{}] -> {} [{}]", new Object[] { reader.getFormat(), out, format });
    long mid = System.currentTimeMillis();
    int total = 0;
    int num = writer.canDoStacks() ? reader.getSeriesCount() : 1;
    long read = 0, write = 0;
    int first = series == -1 ? 0 : series;
    int last = series == -1 ? num : series + 1;
    long timeLastLogged = System.currentTimeMillis();
    for (int q = first; q < last; q++) {
        reader.setSeries(q);
        firstTile = true;
        if (!dimensionsSet) {
            width = reader.getSizeX();
            height = reader.getSizeY();
        }
        int writerSeries = series == -1 ? q : 0;
        writer.setSeries(writerSeries);
        writer.setInterleaved(reader.isInterleaved() && !autoscale);
        writer.setValidBitsPerPixel(reader.getBitsPerPixel());
        int numImages = writer.canDoStacks() ? reader.getImageCount() : 1;
        int startPlane = (int) Math.max(0, firstPlane);
        int endPlane = (int) Math.min(numImages, lastPlane);
        numImages = endPlane - startPlane;
        if (channel >= 0) {
            numImages /= reader.getEffectiveSizeC();
        }
        if (zSection >= 0) {
            numImages /= reader.getSizeZ();
        }
        if (timepoint >= 0) {
            numImages /= reader.getSizeT();
        }
        total += numImages;
        int count = 0;
        for (int i = startPlane; i < endPlane; i++) {
            int[] coords = reader.getZCTCoords(i);
            if ((zSection >= 0 && coords[0] != zSection) || (channel >= 0 && coords[1] != channel) || (timepoint >= 0 && coords[2] != timepoint)) {
                continue;
            }
            String outputName = FormatTools.getFilename(q, i, reader, out, zeroPadding);
            if (outputName.equals(FormatTools.getTileFilename(0, 0, 0, outputName))) {
                writer.setId(outputName);
                if (compression != null)
                    writer.setCompression(compression);
            } else {
                int tileNum = outputName.indexOf(FormatTools.TILE_NUM);
                int tileX = outputName.indexOf(FormatTools.TILE_X);
                int tileY = outputName.indexOf(FormatTools.TILE_Y);
                if (tileNum < 0 && (tileX < 0 || tileY < 0)) {
                    throw new FormatException("Invalid file name pattern; " + FormatTools.TILE_NUM + " or both of " + FormatTools.TILE_X + " and " + FormatTools.TILE_Y + " must be specified.");
                }
            }
            int outputIndex = 0;
            if (nextOutputIndex.containsKey(outputName)) {
                outputIndex = nextOutputIndex.get(outputName);
            }
            long s = System.currentTimeMillis();
            long m = convertPlane(writer, i, outputIndex, outputName);
            long e = System.currentTimeMillis();
            read += m - s;
            write += e - m;
            nextOutputIndex.put(outputName, outputIndex + 1);
            if (i == endPlane - 1) {
                nextOutputIndex.remove(outputName);
            }
            // log number of planes processed every second or so
            if (count == numImages - 1 || (e - timeLastLogged) / 1000 > 0) {
                int current = (count - startPlane) + 1;
                int percent = 100 * current / numImages;
                StringBuilder sb = new StringBuilder();
                sb.append("\t");
                int numSeries = last - first;
                if (numSeries > 1) {
                    sb.append("Series ");
                    sb.append(q);
                    sb.append(": converted ");
                } else
                    sb.append("Converted ");
                LOGGER.info(sb.toString() + "{}/{} planes ({}%)", new Object[] { current, numImages, percent });
                timeLastLogged = e;
            }
            count++;
        }
    }
    writer.close();
    long end = System.currentTimeMillis();
    LOGGER.info("[done]");
    // output timing results
    float sec = (end - start) / 1000f;
    long initial = mid - start;
    float readAvg = (float) read / total;
    float writeAvg = (float) write / total;
    LOGGER.info("{}s elapsed ({}+{}ms per plane, {}ms overhead)", new Object[] { sec, readAvg, writeAvg, initial });
    return true;
}

Example 18 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class ImageConverter method convertTilePlane.

/**
 * Convert the specified plane as a set of tiles, using the specified writer.
 * @param writer the {@link loci.formats.IFormatWriter} to use for writing the plane
 * @param index the index of the plane to convert in the input file
 * @param outputIndex the index of the plane to convert in the output file
 * @param currentFile the file name or pattern being written to
 * @return the time at which conversion started, in milliseconds
 * @throws FormatException
 * @throws IOException
 */
private long convertTilePlane(IFormatWriter writer, int index, int outputIndex, String currentFile) throws FormatException, IOException {
    int w = reader.getOptimalTileWidth();
    int h = reader.getOptimalTileHeight();
    if (saveTileWidth > 0 && saveTileWidth <= width) {
        w = saveTileWidth;
    }
    if (saveTileHeight > 0 && saveTileHeight <= height) {
        h = saveTileHeight;
    }
    if (firstTile) {
        LOGGER.info("Tile size = {} x {}", w, h);
        firstTile = false;
    }
    int nXTiles = width / w;
    int nYTiles = height / h;
    if (nXTiles * w != width) {
        nXTiles++;
    }
    if (nYTiles * h != height) {
        nYTiles++;
    }
    IFD ifd = new IFD();
    ifd.put(IFD.TILE_WIDTH, w);
    ifd.put(IFD.TILE_LENGTH, h);
    Long m = null;
    for (int y = 0; y < nYTiles; y++) {
        for (int x = 0; x < nXTiles; x++) {
            int tileX = xCoordinate + x * w;
            int tileY = yCoordinate + y * h;
            int tileWidth = x < nXTiles - 1 ? w : width - (w * x);
            int tileHeight = y < nYTiles - 1 ? h : height - (h * y);
            byte[] buf = reader.openBytes(index, tileX, tileY, tileWidth, tileHeight);
            String tileName = FormatTools.getTileFilename(x, y, y * nXTiles + x, currentFile);
            if (!currentFile.equals(tileName)) {
                int nTileRows = getTileRows(currentFile);
                int nTileCols = getTileColumns(currentFile);
                int sizeX = nTileCols == 1 ? width : tileWidth;
                int sizeY = nTileRows == 1 ? height : tileHeight;
                MetadataRetrieve retrieve = writer.getMetadataRetrieve();
                if (retrieve instanceof MetadataStore) {
                    ((MetadataStore) retrieve).setPixelsSizeX(new PositiveInteger(sizeX), reader.getSeries());
                    ((MetadataStore) retrieve).setPixelsSizeY(new PositiveInteger(sizeY), reader.getSeries());
                }
                writer.close();
                writer.setMetadataRetrieve(retrieve);
                writer.setId(tileName);
                if (compression != null)
                    writer.setCompression(compression);
                outputIndex = 0;
                if (nextOutputIndex.containsKey(tileName)) {
                    outputIndex = nextOutputIndex.get(tileName);
                }
                nextOutputIndex.put(tileName, outputIndex + 1);
                if (nTileRows > 1) {
                    tileY = 0;
                }
                if (nTileCols > 1) {
                    tileX = 0;
                }
            }
            autoscalePlane(buf, index);
            applyLUT(writer);
            if (m == null) {
                m = System.currentTimeMillis();
            }
            if (writer instanceof TiffWriter) {
                ((TiffWriter) writer).saveBytes(outputIndex, buf, ifd, tileX, tileY, tileWidth, tileHeight);
            } else if (writer instanceof ImageWriter) {
                IFormatWriter baseWriter = ((ImageWriter) writer).getWriter(out);
                if (baseWriter instanceof TiffWriter) {
                    ((TiffWriter) baseWriter).saveBytes(outputIndex, buf, ifd, tileX, tileY, tileWidth, tileHeight);
                }
            }
        }
    }
    return m;
}

Example 19 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class FormatWriter method getSamplesPerPixel.

/**
 * Retrieve the number of samples per pixel for given series.
 */
protected int getSamplesPerPixel(int series) {
    MetadataRetrieve r = getMetadataRetrieve();
    PositiveInteger samples = r.getChannelSamplesPerPixel(series, 0);
    if (samples == null) {
        LOGGER.warn("SamplesPerPixel #0 is null. It is assumed to be 1.");
    }
    return samples == null ? 1 : samples.getValue();
}

Example 20 with PositiveInteger

use of ome.xml.model.primitives.PositiveInteger in project bioformats by openmicroscopy.

the class MetadataTools method populatePixelsOnly.

public static void populatePixelsOnly(MetadataStore store, int series, boolean littleEndian, String dimensionOrder, String pixelType, int sizeX, int sizeY, int sizeZ, int sizeC, int sizeT, int samplesPerPixel) {
    store.setPixelsID(createLSID("Pixels", series), series);
    store.setPixelsBigEndian(!littleEndian, series);
    try {
        store.setPixelsDimensionOrder(DimensionOrder.fromString(dimensionOrder), series);
    } catch (EnumerationException e) {
        LOGGER.warn("Invalid dimension order: " + dimensionOrder, e);
    }
    try {
        store.setPixelsType(PixelType.fromString(pixelType), series);
    } catch (EnumerationException e) {
        LOGGER.warn("Invalid pixel type: " + pixelType, e);
    }
    store.setPixelsSizeX(new PositiveInteger(sizeX), series);
    store.setPixelsSizeY(new PositiveInteger(sizeY), series);
    store.setPixelsSizeZ(new PositiveInteger(sizeZ), series);
    store.setPixelsSizeC(new PositiveInteger(sizeC), series);
    store.setPixelsSizeT(new PositiveInteger(sizeT), series);
    int effSizeC = sizeC / samplesPerPixel;
    for (int i = 0; i < effSizeC; i++) {
        store.setChannelID(createLSID("Channel", series, i), series, i);
        store.setChannelSamplesPerPixel(new PositiveInteger(samplesPerPixel), series, i);
    }
}