Examples with Length ome.units.quantity.Length used on opensource projects

Example 1 with Length

use of ome.units.quantity.Length in project bioformats by openmicroscopy.

the class LeicaReader method initFile.

// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
    close();
    String leiFile = findLEIFile(id);
    if (leiFile == null || leiFile.trim().length() == 0 || new Location(leiFile).isDirectory()) {
        if (checkSuffix(id, TiffReader.TIFF_SUFFIXES)) {
            super.initFile(id);
            TiffReader r = new TiffReader();
            r.setMetadataStore(getMetadataStore());
            r.setId(id);
            core = new ArrayList<CoreMetadata>(r.getCoreMetadataList());
            metadataStore = r.getMetadataStore();
            final Map<String, Object> globalMetadata = r.getGlobalMetadata();
            for (final Map.Entry<String, Object> entry : globalMetadata.entrySet()) {
                addGlobalMeta(entry.getKey(), entry.getValue());
            }
            r.close();
            files = new List[] { new ArrayList<String>() };
            files[0].add(id);
            tiff = new MinimalTiffReader();
            return;
        } else {
            throw new FormatException("LEI file not found.");
        }
    }
    // parse the LEI file
    super.initFile(leiFile);
    leiFilename = new File(leiFile).exists() ? new Location(leiFile).getAbsolutePath() : id;
    in = new RandomAccessInputStream(leiFile);
    byte[] data = null;
    try {
        data = new byte[(int) in.length()];
        in.read(data);
    } finally {
        in.close();
    }
    in = new RandomAccessInputStream(data);
    MetadataLevel metadataLevel = metadataOptions.getMetadataLevel();
    seriesNames = new ArrayList<String>();
    byte[] fourBytes = new byte[4];
    in.read(fourBytes);
    core.get(0).littleEndian = (fourBytes[0] == TiffConstants.LITTLE && fourBytes[1] == TiffConstants.LITTLE && fourBytes[2] == TiffConstants.LITTLE && fourBytes[3] == TiffConstants.LITTLE);
    boolean realLittleEndian = isLittleEndian();
    in.order(isLittleEndian());
    LOGGER.info("Reading metadata blocks");
    in.skipBytes(8);
    int addr = in.readInt();
    headerIFDs = new IFDList();
    while (addr != 0) {
        IFD ifd = new IFD();
        headerIFDs.add(ifd);
        in.seek(addr + 4);
        int tag = in.readInt();
        while (tag != 0) {
            // create the IFD structure
            int offset = in.readInt();
            long pos = in.getFilePointer();
            in.seek(offset + 12);
            int size = in.readInt();
            ifd.putIFDValue(tag, in.getFilePointer());
            in.seek(pos);
            tag = in.readInt();
        }
        addr = in.readInt();
    }
    numSeries = headerIFDs.size();
    tileWidth = new int[numSeries];
    tileHeight = new int[numSeries];
    core.clear();
    for (int i = 0; i < numSeries; i++) {
        core.add(new CoreMetadata());
    }
    files = new List[numSeries];
    channelNames = new List[getSeriesCount()];
    emWaves = new List[getSeriesCount()];
    exWaves = new List[getSeriesCount()];
    cutInPopulated = new boolean[getSeriesCount()][];
    cutOutPopulated = new boolean[getSeriesCount()][];
    filterRefPopulated = new boolean[getSeriesCount()][];
    for (int i = 0; i < getSeriesCount(); i++) {
        channelNames[i] = new ArrayList();
        emWaves[i] = new ArrayList();
        exWaves[i] = new ArrayList();
    }
    // determine the length of a filename
    LOGGER.info("Parsing metadata blocks");
    core.get(0).littleEndian = !isLittleEndian();
    int seriesIndex = 0;
    int invalidCount = 0;
    valid = new boolean[numSeries];
    timestamps = new String[headerIFDs.size()][];
    for (int i = 0; i < headerIFDs.size(); i++) {
        IFD ifd = headerIFDs.get(i);
        valid[i] = true;
        if (ifd.get(SERIES) != null) {
            long offset = ((Long) ifd.get(SERIES)).longValue();
            in.seek(offset + 8);
            nameLength = in.readInt() * 2;
        }
        in.seek(((Long) ifd.get(IMAGES)).longValue());
        parseFilenames(i);
        if (!valid[i])
            invalidCount++;
    }
    numSeries -= invalidCount;
    if (numSeries <= 0) {
        throw new FormatException("TIFF files not found");
    }
    int[] count = new int[getSeriesCount()];
    for (int i = 0; i < getSeriesCount(); i++) {
        count[i] = core.get(i).imageCount;
    }
    final List<String>[] tempFiles = files;
    IFDList tempIFDs = headerIFDs;
    core = new ArrayList<CoreMetadata>(numSeries);
    files = new List[numSeries];
    headerIFDs = new IFDList();
    int index = 0;
    core.clear();
    for (int i = 0; i < numSeries; i++) {
        CoreMetadata ms = new CoreMetadata();
        while (index < valid.length && !valid[index]) index++;
        if (index >= valid.length) {
            break;
        }
        ms.imageCount = count[index];
        files[i] = tempFiles[index];
        Collections.sort(files[i]);
        headerIFDs.add(tempIFDs.get(index));
        index++;
        core.add(ms);
    }
    tiff = new MinimalTiffReader();
    LOGGER.info("Populating metadata");
    if (headerIFDs == null)
        headerIFDs = ifds;
    seriesDescriptions = new ArrayList<String>();
    physicalSizes = new double[headerIFDs.size()][5];
    pinhole = new double[headerIFDs.size()];
    exposureTime = new double[headerIFDs.size()];
    channelColor = new Color[headerIFDs.size()][];
    for (int i = 0; i < headerIFDs.size(); i++) {
        IFD ifd = headerIFDs.get(i);
        CoreMetadata ms = core.get(i);
        ms.littleEndian = isLittleEndian();
        setSeries(i);
        Integer[] keys = ifd.keySet().toArray(new Integer[ifd.size()]);
        Arrays.sort(keys);
        for (Integer key : keys) {
            long offset = ((Long) ifd.get(key)).longValue();
            in.seek(offset);
            if (key.equals(SERIES)) {
                parseSeriesTag();
            } else if (key.equals(IMAGES)) {
                parseImageTag(i);
            } else if (key.equals(DIMDESCR)) {
                parseDimensionTag(i);
            } else if (key.equals(TIMEINFO) && metadataLevel != MetadataLevel.MINIMUM) {
                parseTimeTag(i);
            } else if (key.equals(EXPERIMENT) && metadataLevel != MetadataLevel.MINIMUM) {
                parseExperimentTag();
            } else if (key.equals(LUTDESC)) {
                parseLUT(i);
            } else if (key.equals(CHANDESC) && metadataLevel != MetadataLevel.MINIMUM) {
                parseChannelTag();
            }
        }
        ms.orderCertain = true;
        ms.littleEndian = isLittleEndian();
        ms.falseColor = true;
        ms.metadataComplete = true;
        ms.interleaved = false;
        String filename = (String) files[i].get(0);
        if (checkSuffix(filename, TiffReader.TIFF_SUFFIXES)) {
            RandomAccessInputStream s = new RandomAccessInputStream(filename, 16);
            try {
                TiffParser parser = new TiffParser(s);
                parser.setDoCaching(false);
                IFD firstIFD = parser.getFirstIFD();
                parser.fillInIFD(firstIFD);
                ms.sizeX = (int) firstIFD.getImageWidth();
                ms.sizeY = (int) firstIFD.getImageLength();
                // override the .lei pixel type, in case a TIFF file was overwritten
                ms.pixelType = firstIFD.getPixelType();
                // won't affect the pixel data
                if (FormatTools.getBytesPerPixel(ms.pixelType) > 1) {
                    ms.littleEndian = firstIFD.isLittleEndian();
                } else {
                    ms.littleEndian = realLittleEndian;
                }
                tileWidth[i] = (int) firstIFD.getTileWidth();
                tileHeight[i] = (int) firstIFD.getTileLength();
            } finally {
                s.close();
            }
        } else {
            ms.littleEndian = realLittleEndian;
        }
    }
    for (int i = 0; i < getSeriesCount(); i++) {
        setSeries(i);
        CoreMetadata ms = core.get(i);
        if (getSizeZ() == 0)
            ms.sizeZ = 1;
        if (getSizeT() == 0)
            ms.sizeT = 1;
        if (getSizeC() == 0)
            ms.sizeC = 1;
        if (getImageCount() == 0)
            ms.imageCount = 1;
        if (getImageCount() == 1 && getSizeZ() * getSizeT() > 1) {
            ms.sizeZ = 1;
            ms.sizeT = 1;
        }
        if (getSizeY() == 1 || getSizeY() == getSizeZ() || getSizeY() == getSizeT()) {
            // XZ or XT scan
            if (getSizeZ() > 1 && getImageCount() == getSizeC() * getSizeT()) {
                ms.sizeY = getSizeZ();
                ms.sizeZ = 1;
            } else if (getSizeT() > 1 && getImageCount() == getSizeC() * getSizeZ()) {
                ms.sizeY = getSizeT();
                ms.sizeT = 1;
            }
        }
        if (isRGB())
            ms.indexed = false;
        ms.dimensionOrder = MetadataTools.makeSaneDimensionOrder(getDimensionOrder());
    }
    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this, true);
    // minimum metadata level.
    for (int i = 0; i < getSeriesCount(); i++) {
        store.setImageName(seriesNames.get(i), i);
    }
    if (metadataLevel == MetadataLevel.MINIMUM)
        return;
    for (int i = 0; i < getSeriesCount(); i++) {
        CoreMetadata ms = core.get(i);
        IFD ifd = headerIFDs.get(i);
        long firstPlane = 0;
        if (i < timestamps.length && timestamps[i] != null && timestamps[i].length > 0) {
            firstPlane = DateTools.getTime(timestamps[i][0], DATE_FORMAT, ":");
            String date = DateTools.formatDate(timestamps[i][0], DATE_FORMAT);
            if (date != null) {
                store.setImageAcquisitionDate(new Timestamp(date), i);
            }
        }
        store.setImageDescription(seriesDescriptions.get(i), i);
        String instrumentID = MetadataTools.createLSID("Instrument", i);
        store.setInstrumentID(instrumentID, i);
        // parse instrument data
        nextDetector = 0;
        nextChannel = 0;
        detectors.clear();
        cutInPopulated[i] = new boolean[ms.sizeC];
        cutOutPopulated[i] = new boolean[ms.sizeC];
        filterRefPopulated[i] = new boolean[ms.sizeC];
        Integer[] keys = ifd.keySet().toArray(new Integer[ifd.size()]);
        Arrays.sort(keys);
        int nextInstrumentBlock = 1;
        sequential = DataTools.indexOf(keys, SEQ_SCANNERSET) != -1;
        for (Integer key : keys) {
            if (key.equals(FILTERSET) || key.equals(SCANNERSET) || key.equals(SEQ_SCANNERSET) || key.equals(SEQ_FILTERSET) || (key > SEQ_SCANNERSET && key < SEQ_SCANNERSET_END) || (key > SEQ_FILTERSET && key < SEQ_FILTERSET_END)) {
                if (sequential && (key.equals(FILTERSET) || key.equals(SCANNERSET))) {
                    continue;
                }
                long offset = ((Long) ifd.get(key)).longValue();
                in.seek(offset);
                setSeries(i);
                parseInstrumentData(store, nextInstrumentBlock++);
            }
        }
        activeChannelIndices.clear();
        // link Instrument and Image
        store.setImageInstrumentRef(instrumentID, i);
        Length sizeX = FormatTools.getPhysicalSizeX(physicalSizes[i][0]);
        Length sizeY = FormatTools.getPhysicalSizeY(physicalSizes[i][1]);
        Length sizeZ = FormatTools.getPhysicalSizeZ(physicalSizes[i][2]);
        if (sizeX != null) {
            store.setPixelsPhysicalSizeX(sizeX, i);
        }
        if (sizeY != null) {
            store.setPixelsPhysicalSizeY(sizeY, i);
        }
        if (sizeZ != null) {
            store.setPixelsPhysicalSizeZ(sizeZ, i);
        }
        if ((int) physicalSizes[i][4] > 0) {
            store.setPixelsTimeIncrement(new Time(physicalSizes[i][4], UNITS.SECOND), i);
        }
        for (int j = 0; j < ms.imageCount; j++) {
            if (timestamps[i] != null && j < timestamps[i].length) {
                long time = DateTools.getTime(timestamps[i][j], DATE_FORMAT, ":");
                double elapsedTime = (double) (time - firstPlane) / 1000;
                store.setPlaneDeltaT(new Time(elapsedTime, UNITS.SECOND), i, j);
                if (exposureTime[i] > 0) {
                    store.setPlaneExposureTime(new Time(exposureTime[i], UNITS.SECOND), i, j);
                }
            }
        }
    }
    setSeries(0);
}

Example 2 with Length

use of ome.units.quantity.Length in project bioformats by openmicroscopy.

the class LeicaReader method parseInstrumentData.

private void parseInstrumentData(MetadataStore store, int blockNum) throws FormatException, IOException {
    int series = getSeries();
    // read 24 byte SAFEARRAY
    in.skipBytes(4);
    int cbElements = in.readInt();
    in.skipBytes(8);
    int nElements = in.readInt();
    in.skipBytes(4);
    long initialOffset = in.getFilePointer();
    long elementOffset = 0;
    LOGGER.trace("Element LOOP; series {} at offset {}", series, initialOffset);
    for (int j = 0; j < nElements; j++) {
        elementOffset = initialOffset + j * cbElements;
        LOGGER.trace("Seeking to: {}", elementOffset);
        in.seek(elementOffset);
        String contentID = getString(128);
        LOGGER.trace("contentID: {}", contentID);
        String description = getString(64);
        LOGGER.trace("description: {}", description);
        String data = getString(64);
        int dataType = in.readShort();
        LOGGER.trace("dataType: {}", dataType);
        in.skipBytes(6);
        // read data
        switch(dataType) {
            case 2:
                data = String.valueOf(in.readShort());
                break;
            case 3:
                data = String.valueOf(in.readInt());
                break;
            case 4:
                data = String.valueOf(in.readFloat());
                break;
            case 5:
                data = String.valueOf(in.readDouble());
                break;
            case 7:
            case 11:
                data = in.read() == 0 ? "false" : "true";
                break;
            case 17:
                data = in.readString(1);
                break;
        }
        LOGGER.trace("data: {}", data);
        if (data.trim().length() == 0) {
            LOGGER.trace("Zero length dat string, continuing...");
            continue;
        }
        String[] tokens = contentID.split("\\|");
        LOGGER.trace("Parsing tokens: {}", tokens);
        if (tokens[0].startsWith("CDetectionUnit")) {
            if (tokens[1].startsWith("PMT")) {
                // detector information
                Detector detector = new Detector();
                int lastDetector = detectors.size() - 1;
                if (detectors.size() > 0 && detectors.get(lastDetector).id == Integer.parseInt(tokens[3])) {
                    detector = detectors.get(lastDetector);
                } else {
                    detectors.add(detector);
                }
                detector.id = Integer.parseInt(tokens[3]);
                detector.name = tokens[1];
                try {
                    if (tokens[2].equals("VideoOffset")) {
                        detector.offset = new Double(data);
                    } else if (tokens[2].equals("HighVoltage")) {
                        detector.voltage = new Double(data);
                    } else if (tokens[2].equals("State")) {
                        detector.active = data.equals("Active");
                        String index = tokens[1].substring(tokens[1].indexOf(' ') + 1);
                        detector.index = -1;
                        try {
                            detector.index = Integer.parseInt(index) - 1;
                        } catch (NumberFormatException e) {
                        }
                        if (detector.active && detector.index >= 0) {
                            activeChannelIndices.add(detector.index);
                        }
                    }
                } catch (NumberFormatException e) {
                    LOGGER.debug("Failed to parse detector metadata", e);
                }
            }
        } else if (tokens[0].startsWith("CTurret")) {
            // objective information
            int objective = Integer.parseInt(tokens[3]);
            if (tokens[2].equals("NumericalAperture")) {
                store.setObjectiveLensNA(new Double(data), series, objective);
            } else if (tokens[2].equals("Objective")) {
                String[] objectiveData = data.split(" ");
                final StringBuilder model = new StringBuilder();
                String mag = null, na = null;
                String immersion = null, correction = null;
                for (int i = 0; i < objectiveData.length; i++) {
                    if (objectiveData[i].indexOf('x') != -1 && mag == null && na == null) {
                        int xIndex = objectiveData[i].indexOf('x');
                        mag = objectiveData[i].substring(0, xIndex).trim();
                        na = objectiveData[i].substring(xIndex + 1).trim();
                    } else if (mag == null && na == null) {
                        model.append(objectiveData[i]);
                        model.append(" ");
                    } else if (correction == null) {
                        correction = objectiveData[i];
                    } else if (immersion == null) {
                        immersion = objectiveData[i];
                    }
                }
                if (immersion != null)
                    immersion = immersion.trim();
                if (correction != null)
                    correction = correction.trim();
                Correction realCorrection = getCorrection(correction);
                Correction testCorrection = getCorrection(immersion);
                Immersion realImmersion = getImmersion(immersion);
                Immersion testImmersion = getImmersion(correction);
                // Correction and Immersion are reversed
                if ((testCorrection != Correction.OTHER && realCorrection == Correction.OTHER) || (testImmersion != Immersion.OTHER && realImmersion == Immersion.OTHER)) {
                    String tmp = correction;
                    correction = immersion;
                    immersion = tmp;
                }
                store.setObjectiveImmersion(getImmersion(immersion), series, objective);
                store.setObjectiveCorrection(getCorrection(correction), series, objective);
                store.setObjectiveModel(model.toString().trim(), series, objective);
                store.setObjectiveLensNA(new Double(na), series, objective);
                Double magnification = Double.parseDouble(mag);
                store.setObjectiveNominalMagnification(magnification, series, objective);
            } else if (tokens[2].equals("OrderNumber")) {
                store.setObjectiveSerialNumber(data, series, objective);
            } else if (tokens[2].equals("RefractionIndex")) {
                store.setObjectiveSettingsRefractiveIndex(new Double(data), series);
            }
            // link Objective to Image
            String objectiveID = MetadataTools.createLSID("Objective", series, objective);
            store.setObjectiveID(objectiveID, series, objective);
            if (objective == 0) {
                store.setObjectiveSettingsID(objectiveID, series);
            }
        } else if (tokens[0].startsWith("CSpectrophotometerUnit")) {
            int ndx = tokens[1].lastIndexOf(" ");
            int channel = Integer.parseInt(tokens[1].substring(ndx + 1)) - 1;
            if (tokens[2].equals("Wavelength")) {
                Double wavelength = Double.parseDouble(data);
                store.setFilterModel(tokens[1], series, channel);
                String filterID = MetadataTools.createLSID("Filter", series, channel);
                store.setFilterID(filterID, series, channel);
                int index = activeChannelIndices.indexOf(channel);
                if (index >= 0 && index < getEffectiveSizeC()) {
                    if (!filterRefPopulated[series][index]) {
                        store.setLightPathEmissionFilterRef(filterID, series, index, 0);
                        filterRefPopulated[series][index] = true;
                    }
                    if (tokens[3].equals("0") && !cutInPopulated[series][index]) {
                        Length cutIn = FormatTools.getCutIn(wavelength);
                        if (cutIn != null) {
                            store.setTransmittanceRangeCutIn(cutIn, series, channel);
                        }
                        cutInPopulated[series][index] = true;
                    } else if (tokens[3].equals("1") && !cutOutPopulated[series][index]) {
                        Length cutOut = FormatTools.getCutOut(wavelength);
                        if (cutOut != null) {
                            store.setTransmittanceRangeCutOut(cutOut, series, channel);
                        }
                        cutOutPopulated[series][index] = true;
                    }
                }
            } else if (tokens[2].equals("Stain")) {
                if (activeChannelIndices.contains(channel)) {
                    int nNames = channelNames[series].size();
                    String prevValue = nNames == 0 ? "" : (String) channelNames[series].get(nNames - 1);
                    if (!prevValue.equals(data)) {
                        channelNames[series].add(data);
                    }
                }
            }
        } else if (tokens[0].startsWith("CXYZStage")) {
            CoreMetadata ms = core.get(series);
            // NB: there is only one stage position specified for each series
            if (tokens[2].equals("XPos")) {
                for (int q = 0; q < ms.imageCount; q++) {
                    final Double number = Double.valueOf(data);
                    final Length length = new Length(number, UNITS.REFERENCEFRAME);
                    store.setPlanePositionX(length, series, q);
                    if (q == 0) {
                        addGlobalMetaList("X position for position", data);
                    }
                }
            } else if (tokens[2].equals("YPos")) {
                for (int q = 0; q < ms.imageCount; q++) {
                    final Double number = Double.valueOf(data);
                    final Length length = new Length(number, UNITS.REFERENCEFRAME);
                    store.setPlanePositionY(length, series, q);
                    if (q == 0) {
                        addGlobalMetaList("Y position for position", data);
                    }
                }
            } else if (tokens[2].equals("ZPos")) {
                final Double number = Double.valueOf(data);
                final Length length = new Length(number, UNITS.REFERENCEFRAME);
                store.setStageLabelName("Position", series);
                store.setStageLabelZ(length, series);
                addGlobalMetaList("Z position for position", data);
            }
        } else if (tokens[0].equals("CScanActuator") && tokens[1].equals("Z Scan Actuator") && tokens[2].equals("Position")) {
            final double pos = Double.parseDouble(data) * 1000000;
            store.setStageLabelName("Position", series);
            store.setStageLabelZ(new Length(pos, UNITS.REFERENCEFRAME), series);
            addGlobalMetaList("Z position for position", pos);
        }
        if (contentID.equals("dblVoxelX")) {
            physicalSizes[series][0] = Double.parseDouble(data);
        } else if (contentID.equals("dblVoxelY")) {
            physicalSizes[series][1] = Double.parseDouble(data);
        } else if (contentID.equals("dblStepSize")) {
            double size = Double.parseDouble(data);
            if (size > 0) {
                physicalSizes[series][2] = size;
            }
        } else if (contentID.equals("dblPinhole")) {
            // pinhole is stored in meters
            pinhole[series] = Double.parseDouble(data) * 1000000;
        } else if (contentID.startsWith("nDelayTime")) {
            exposureTime[series] = Double.parseDouble(data);
            if (contentID.endsWith("_ms")) {
                exposureTime[series] /= 1000;
            }
        }
        addSeriesMeta("Block " + blockNum + " " + contentID, data);
    }
    for (Detector detector : detectors) {
        // link Detector to Image, if the detector was actually used
        if (detector.active) {
            store.setDetectorOffset(detector.offset, series, nextDetector);
            store.setDetectorVoltage(new ElectricPotential(detector.voltage, UNITS.VOLT), series, nextDetector);
            store.setDetectorType(getDetectorType("PMT"), series, nextDetector);
            String detectorID = MetadataTools.createLSID("Detector", series, nextDetector);
            store.setDetectorID(detectorID, series, nextDetector);
            if (nextDetector == 0) {
                // overwritten
                for (int c = 0; c < getEffectiveSizeC(); c++) {
                    store.setDetectorSettingsID(detectorID, series, c);
                }
            }
            if (nextChannel < getEffectiveSizeC()) {
                store.setDetectorSettingsID(detectorID, series, nextChannel);
                if (nextChannel < channelNames[series].size()) {
                    String name = (String) channelNames[series].get(nextChannel);
                    if (name == null || name.trim().equals("") || name.equals("None")) {
                        channelNames[series].set(nextChannel, detector.name);
                    }
                } else {
                    while (channelNames[series].size() < nextChannel) {
                        channelNames[series].add("");
                    }
                    channelNames[series].add(detector.name);
                }
                nextChannel++;
            }
            nextDetector++;
        }
    }
    detectors.clear();
    for (int i = 0; i < getSeriesCount(); i++) {
        setSeries(i);
        for (int channel = 0; channel < getEffectiveSizeC(); channel++) {
            if (channel < channelNames[i].size()) {
                String name = (String) channelNames[i].get(channel);
                if (name != null && !name.trim().equals("") && !name.equals("None")) {
                    store.setChannelName(name, i, channel);
                }
            }
            if (channel < emWaves[i].size()) {
                Double wave = new Double(emWaves[i].get(channel).toString());
                Length emission = FormatTools.getEmissionWavelength(wave);
                if (emission != null) {
                    store.setChannelEmissionWavelength(emission, i, channel);
                }
            }
            if (channel < exWaves[i].size()) {
                Double wave = new Double(exWaves[i].get(channel).toString());
                Length ex = FormatTools.getExcitationWavelength(wave);
                if (ex != null) {
                    store.setChannelExcitationWavelength(ex, i, channel);
                }
            }
            if (i < pinhole.length) {
                store.setChannelPinholeSize(new Length(pinhole[i], UNITS.MICROMETER), i, channel);
            }
            if (channel < channelColor[i].length) {
                store.setChannelColor(channelColor[i][channel], i, channel);
            }
        }
    }
    setSeries(0);
}

Example 3 with Length

use of ome.units.quantity.Length in project bioformats by openmicroscopy.

the class MINCReader method initFile.

// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
    super.initFile(id);
    try {
        ServiceFactory factory = new ServiceFactory();
        netcdf = factory.getInstance(NetCDFService.class);
        netcdf.setFile(id);
    } catch (DependencyException e) {
        throw new MissingLibraryException(e);
    }
    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
        Vector<String> variableList = netcdf.getVariableList();
        for (String variable : variableList) {
            Hashtable<String, Object> attributes = netcdf.getVariableAttributes(variable);
            String[] keys = attributes.keySet().toArray(new String[0]);
            Arrays.sort(keys);
            for (String key : keys) {
                if (attributes.get(key) instanceof Object[]) {
                    final StringBuilder sb = new StringBuilder();
                    Object[] o = (Object[]) attributes.get(key);
                    for (Object q : o) {
                        sb.append(q.toString());
                    }
                    addGlobalMeta(variable + " " + key, sb.toString());
                } else {
                    addGlobalMeta(variable + " " + key, attributes.get(key));
                }
            }
        }
    }
    CoreMetadata m = core.get(0);
    try {
        Object pixels = netcdf.getVariableValue("/image");
        if (pixels == null) {
            pixels = netcdf.getVariableValue("/minc-2.0/image/0/image");
            isMINC2 = true;
        }
        m.littleEndian = isMINC2;
        boolean signed = false;
        if (isMINC2) {
            Hashtable<String, Object> attrs = netcdf.getVariableAttributes("/minc-2.0/image/0/image");
            String unsigned = attrs.get("_Unsigned").toString();
            if (!unsigned.startsWith("true")) {
                signed = true;
            }
        } else {
            Hashtable<String, Object> attrs = netcdf.getVariableAttributes("/image");
            String signtype = attrs.get("signtype").toString();
            if (signtype.startsWith("signed")) {
                signed = true;
            }
        }
        if (pixels instanceof byte[][][]) {
            m.pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8;
            pixelData = (byte[][][]) pixels;
        } else if (pixels instanceof byte[][][][]) {
            byte[][][][] actualPixels = (byte[][][][]) pixels;
            m.pixelType = signed ? FormatTools.INT8 : FormatTools.UINT8;
            pixelData = new byte[actualPixels.length * actualPixels[0].length][][];
            int nextPlane = 0;
            for (int t = 0; t < actualPixels.length; t++) {
                for (int z = 0; z < actualPixels[t].length; z++) {
                    pixelData[nextPlane++] = actualPixels[t][z];
                }
            }
        } else if (pixels instanceof short[][][]) {
            m.pixelType = signed ? FormatTools.INT16 : FormatTools.UINT16;
            short[][][] s = (short[][][]) pixels;
            pixelData = new byte[s.length][][];
            for (int i = 0; i < s.length; i++) {
                pixelData[i] = new byte[s[i].length][];
                for (int j = 0; j < s[i].length; j++) {
                    pixelData[i][j] = DataTools.shortsToBytes(s[i][j], isLittleEndian());
                }
            }
        } else if (pixels instanceof int[][][]) {
            m.pixelType = signed ? FormatTools.INT32 : FormatTools.UINT32;
            int[][][] s = (int[][][]) pixels;
            pixelData = new byte[s.length][][];
            for (int i = 0; i < s.length; i++) {
                pixelData[i] = new byte[s[i].length][];
                for (int j = 0; j < s[i].length; j++) {
                    pixelData[i][j] = DataTools.intsToBytes(s[i][j], isLittleEndian());
                }
            }
        } else if (pixels instanceof float[][][]) {
            m.pixelType = FormatTools.FLOAT;
            float[][][] s = (float[][][]) pixels;
            pixelData = new byte[s.length][][];
            for (int i = 0; i < s.length; i++) {
                pixelData[i] = new byte[s[i].length][];
                for (int j = 0; j < s[i].length; j++) {
                    pixelData[i][j] = DataTools.floatsToBytes(s[i][j], isLittleEndian());
                }
            }
        } else if (pixels instanceof double[][][]) {
            m.pixelType = FormatTools.DOUBLE;
            double[][][] s = (double[][][]) pixels;
            pixelData = new byte[s.length][][];
            for (int i = 0; i < s.length; i++) {
                pixelData[i] = new byte[s[i].length][];
                for (int j = 0; j < s[i].length; j++) {
                    pixelData[i][j] = DataTools.doublesToBytes(s[i][j], isLittleEndian());
                }
            }
        }
    } catch (ServiceException e) {
        throw new FormatException(e);
    }
    Length physicalX = null;
    Length physicalY = null;
    Length physicalZ = null;
    Length xPosition = null;
    Length yPosition = null;
    Length zPosition = null;
    if (isMINC2) {
        Hashtable<String, Object> attrs = netcdf.getVariableAttributes("/minc-2.0/dimensions/xspace");
        m.sizeX = Integer.parseInt(attrs.get("length").toString());
        physicalX = getStepSize(attrs);
        xPosition = getStart(attrs);
        attrs = netcdf.getVariableAttributes("/minc-2.0/dimensions/yspace");
        m.sizeY = Integer.parseInt(attrs.get("length").toString());
        physicalY = getStepSize(attrs);
        yPosition = getStart(attrs);
        attrs = netcdf.getVariableAttributes("/minc-2.0/dimensions/zspace");
        m.sizeZ = Integer.parseInt(attrs.get("length").toString());
        physicalZ = getStepSize(attrs);
        zPosition = getStart(attrs);
    } else {
        m.sizeX = netcdf.getDimension("/xspace");
        m.sizeY = netcdf.getDimension("/yspace");
        m.sizeZ = netcdf.getDimension("/zspace");
        Hashtable<String, Object> attrs = netcdf.getVariableAttributes("/xspace");
        physicalX = getStepSize(attrs);
        xPosition = getStart(attrs);
        attrs = netcdf.getVariableAttributes("/yspace");
        physicalY = getStepSize(attrs);
        yPosition = getStart(attrs);
        attrs = netcdf.getVariableAttributes("/zspace");
        physicalZ = getStepSize(attrs);
        zPosition = getStart(attrs);
    }
    try {
        m.sizeT = netcdf.getDimension("/time");
    } catch (NullPointerException e) {
        m.sizeT = 1;
    }
    m.sizeC = 1;
    m.imageCount = getSizeZ() * getSizeT() * getSizeC();
    m.rgb = false;
    m.indexed = false;
    m.dimensionOrder = "XYZCT";
    String history = null;
    if (isMINC2) {
        history = netcdf.getAttributeValue("/minc-2.0/ident");
    } else {
        history = netcdf.getAttributeValue("/history");
    }
    addGlobalMeta("Comment", history);
    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this, xPosition != null || yPosition != null || zPosition != null);
    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
        store.setImageDescription(history, 0);
        if (physicalX != null) {
            store.setPixelsPhysicalSizeX(physicalX, 0);
        }
        if (physicalY != null) {
            store.setPixelsPhysicalSizeY(physicalY, 0);
        }
        if (physicalZ != null) {
            store.setPixelsPhysicalSizeZ(physicalZ, 0);
        }
        for (int i = 0; i < getImageCount(); i++) {
            if (xPosition != null) {
                store.setPlanePositionX(xPosition, 0, i);
            }
            if (yPosition != null) {
                store.setPlanePositionY(yPosition, 0, i);
            }
            if (zPosition != null) {
                int z = getZCTCoords(i)[0];
                Double pos = zPosition.value().doubleValue();
                if (physicalZ != null && z > 0) {
                    pos += z * physicalZ.value().doubleValue();
                }
                store.setPlanePositionZ(FormatTools.createLength(pos, zPosition.unit()), 0, i);
            }
        }
    }
}

Example 4 with Length

use of ome.units.quantity.Length in project bioformats by openmicroscopy.

the class MetamorphReader method initFile.

// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
    if (checkSuffix(id, ND_SUFFIX)) {
        LOGGER.info("Initializing " + id);
        // find an associated STK file
        String stkFile = id.substring(0, id.lastIndexOf("."));
        if (stkFile.indexOf(File.separatorChar) != -1) {
            stkFile = stkFile.substring(stkFile.lastIndexOf(File.separator) + 1);
        }
        Location parent = new Location(id).getAbsoluteFile().getParentFile();
        LOGGER.info("Looking for STK file in {}", parent.getAbsolutePath());
        String[] dirList = parent.list(true);
        Arrays.sort(dirList);
        for (String f : dirList) {
            int underscore = f.indexOf('_');
            if (underscore < 0)
                underscore = f.indexOf('.');
            if (underscore < 0)
                underscore = f.length();
            String prefix = f.substring(0, underscore);
            if ((f.equals(stkFile) || stkFile.startsWith(prefix)) && checkSuffix(f, STK_SUFFIX)) {
                stkFile = new Location(parent.getAbsolutePath(), f).getAbsolutePath();
                break;
            }
        }
        if (!checkSuffix(stkFile, STK_SUFFIX)) {
            throw new FormatException("STK file not found in " + parent.getAbsolutePath() + ".");
        }
        super.initFile(stkFile);
    } else
        super.initFile(id);
    Location ndfile = null;
    if (checkSuffix(id, ND_SUFFIX))
        ndfile = new Location(id);
    else if (canLookForND && isGroupFiles()) {
        // an STK file was passed to initFile
        // let's check the parent directory for an .nd file
        Location stk = new Location(id).getAbsoluteFile();
        String stkName = stk.getName();
        String stkPrefix = stkName;
        if (stkPrefix.indexOf('_') >= 0) {
            stkPrefix = stkPrefix.substring(0, stkPrefix.indexOf('_') + 1);
        }
        Location parent = stk.getParentFile();
        String[] list = parent.list(true);
        int matchingChars = 0;
        for (String f : list) {
            if (checkSuffix(f, ND_SUFFIX)) {
                String prefix = f.substring(0, f.lastIndexOf("."));
                if (prefix.indexOf('_') >= 0) {
                    prefix = prefix.substring(0, prefix.indexOf('_') + 1);
                }
                if (stkName.startsWith(prefix) || prefix.equals(stkPrefix)) {
                    int charCount = 0;
                    for (int i = 0; i < f.length(); i++) {
                        if (i >= stkName.length()) {
                            break;
                        }
                        if (f.charAt(i) == stkName.charAt(i)) {
                            charCount++;
                        } else {
                            break;
                        }
                    }
                    if (charCount > matchingChars || (charCount == matchingChars && f.charAt(charCount) == '.')) {
                        ndfile = new Location(parent, f).getAbsoluteFile();
                        matchingChars = charCount;
                    }
                }
            }
        }
    }
    String creationTime = null;
    if (ndfile != null && ndfile.exists() && (fileGroupOption(id) == FormatTools.MUST_GROUP || isGroupFiles())) {
        // parse key/value pairs from .nd file
        int zc = getSizeZ(), cc = getSizeC(), tc = getSizeT();
        int nstages = 0;
        String z = null, c = null, t = null;
        final List<Boolean> hasZ = new ArrayList<Boolean>();
        waveNames = new ArrayList<String>();
        stageNames = new ArrayList<String>();
        boolean useWaveNames = true;
        ndFilename = ndfile.getAbsolutePath();
        String[] lines = DataTools.readFile(ndFilename).split("\n");
        boolean globalDoZ = true;
        boolean doTimelapse = false;
        StringBuilder currentValue = new StringBuilder();
        String key = "";
        for (String line : lines) {
            int comma = line.indexOf(',');
            if (comma <= 0) {
                currentValue.append("\n");
                currentValue.append(line);
                continue;
            }
            String value = currentValue.toString();
            addGlobalMeta(key, value);
            if (key.equals("NZSteps"))
                z = value;
            else if (key.equals("DoTimelapse")) {
                doTimelapse = Boolean.parseBoolean(value);
            } else if (key.equals("NWavelengths"))
                c = value;
            else if (key.equals("NTimePoints"))
                t = value;
            else if (key.startsWith("WaveDoZ")) {
                hasZ.add(Boolean.parseBoolean(value));
            } else if (key.startsWith("WaveName")) {
                String waveName = value.substring(1, value.length() - 1);
                if (waveName.equals("Both lasers") || waveName.startsWith("DUAL")) {
                    bizarreMultichannelAcquisition = true;
                }
                waveNames.add(waveName);
            } else if (key.startsWith("Stage")) {
                stageNames.add(value);
            } else if (key.startsWith("StartTime")) {
                creationTime = value;
            } else if (key.equals("ZStepSize")) {
                value = value.replace(',', '.');
                stepSize = Double.parseDouble(value);
            } else if (key.equals("NStagePositions")) {
                nstages = Integer.parseInt(value);
            } else if (key.equals("WaveInFileName")) {
                useWaveNames = Boolean.parseBoolean(value);
            } else if (key.equals("DoZSeries")) {
                globalDoZ = Boolean.parseBoolean(value);
            }
            key = line.substring(1, comma - 1).trim();
            currentValue.delete(0, currentValue.length());
            currentValue.append(line.substring(comma + 1).trim());
        }
        if (!globalDoZ) {
            for (int i = 0; i < hasZ.size(); i++) {
                hasZ.set(i, false);
            }
        }
        if (z != null)
            zc = Integer.parseInt(z);
        if (c != null)
            cc = Integer.parseInt(c);
        if (t != null)
            tc = Integer.parseInt(t);
        else if (!doTimelapse) {
            tc = 1;
        }
        if (cc == 0)
            cc = 1;
        if (cc == 1 && bizarreMultichannelAcquisition) {
            cc = 2;
        }
        if (tc == 0) {
            tc = 1;
        }
        int numFiles = cc * tc;
        if (nstages > 0)
            numFiles *= nstages;
        // determine series count
        int stagesCount = nstages == 0 ? 1 : nstages;
        int seriesCount = stagesCount;
        firstSeriesChannels = new boolean[cc];
        Arrays.fill(firstSeriesChannels, true);
        boolean differentZs = false;
        for (int i = 0; i < cc; i++) {
            boolean hasZ1 = i < hasZ.size() && hasZ.get(i);
            boolean hasZ2 = i != 0 && (i - 1 < hasZ.size()) && hasZ.get(i - 1);
            if (i > 0 && hasZ1 != hasZ2 && globalDoZ) {
                if (!differentZs)
                    seriesCount *= 2;
                differentZs = true;
            }
        }
        int channelsInFirstSeries = cc;
        if (differentZs) {
            channelsInFirstSeries = 0;
            for (int i = 0; i < cc; i++) {
                if ((!hasZ.get(0) && i == 0) || (hasZ.get(0) && hasZ.get(i))) {
                    channelsInFirstSeries++;
                } else
                    firstSeriesChannels[i] = false;
            }
        }
        stks = new String[seriesCount][];
        if (seriesCount == 1)
            stks[0] = new String[numFiles];
        else if (differentZs) {
            for (int i = 0; i < stagesCount; i++) {
                stks[i * 2] = new String[channelsInFirstSeries * tc];
                stks[i * 2 + 1] = new String[(cc - channelsInFirstSeries) * tc];
            }
        } else {
            for (int i = 0; i < stks.length; i++) {
                stks[i] = new String[numFiles / stks.length];
            }
        }
        String prefix = ndfile.getPath();
        prefix = prefix.substring(prefix.lastIndexOf(File.separator) + 1, prefix.lastIndexOf("."));
        // build list of STK files
        boolean anyZ = hasZ.contains(Boolean.TRUE);
        int[] pt = new int[seriesCount];
        for (int i = 0; i < tc; i++) {
            for (int s = 0; s < stagesCount; s++) {
                for (int j = 0; j < cc; j++) {
                    boolean validZ = j >= hasZ.size() || hasZ.get(j);
                    int seriesNdx = s * (seriesCount / stagesCount);
                    if ((seriesCount != 1 && (!validZ || (hasZ.size() > 0 && !hasZ.get(0)))) || (nstages == 0 && ((!validZ && cc > 1) || seriesCount > 1))) {
                        if (anyZ && j > 0 && seriesNdx < seriesCount - 1 && (!validZ || !hasZ.get(0))) {
                            seriesNdx++;
                        }
                    }
                    if (seriesNdx >= stks.length || seriesNdx >= pt.length || pt[seriesNdx] >= stks[seriesNdx].length) {
                        continue;
                    }
                    stks[seriesNdx][pt[seriesNdx]] = prefix;
                    if (j < waveNames.size() && waveNames.get(j) != null) {
                        stks[seriesNdx][pt[seriesNdx]] += "_w" + (j + 1);
                        if (useWaveNames) {
                            String waveName = waveNames.get(j);
                            // If there are underscores in the wavelength name, translate
                            // them to hyphens. (See #558)
                            waveName = waveName.replace('_', '-');
                            // If there are slashes (forward or backward) in the wavelength
                            // name, translate them to hyphens. (See #5922)
                            waveName = waveName.replace('/', '-');
                            waveName = waveName.replace('\\', '-');
                            waveName = waveName.replace('(', '-');
                            waveName = waveName.replace(')', '-');
                            stks[seriesNdx][pt[seriesNdx]] += waveName;
                        }
                    }
                    if (nstages > 0) {
                        stks[seriesNdx][pt[seriesNdx]] += "_s" + (s + 1);
                    }
                    if (tc > 1 || doTimelapse) {
                        stks[seriesNdx][pt[seriesNdx]] += "_t" + (i + 1) + ".STK";
                    } else
                        stks[seriesNdx][pt[seriesNdx]] += ".STK";
                    pt[seriesNdx]++;
                }
            }
        }
        ndfile = ndfile.getAbsoluteFile();
        for (int s = 0; s < stks.length; s++) {
            for (int f = 0; f < stks[s].length; f++) {
                Location l = new Location(ndfile.getParent(), stks[s][f]);
                stks[s][f] = getRealSTKFile(l);
            }
        }
        String file = locateFirstValidFile();
        if (file == null) {
            throw new FormatException("Unable to locate at least one valid STK file!");
        }
        RandomAccessInputStream s = new RandomAccessInputStream(file, 16);
        TiffParser tp = new TiffParser(s);
        IFD ifd = tp.getFirstIFD();
        CoreMetadata ms0 = core.get(0);
        s.close();
        ms0.sizeX = (int) ifd.getImageWidth();
        ms0.sizeY = (int) ifd.getImageLength();
        if (bizarreMultichannelAcquisition) {
            ms0.sizeX /= 2;
        }
        ms0.sizeZ = hasZ.size() > 0 && !hasZ.get(0) ? 1 : zc;
        ms0.sizeC = cc;
        ms0.sizeT = tc;
        ms0.imageCount = getSizeZ() * getSizeC() * getSizeT();
        ms0.dimensionOrder = "XYZCT";
        if (stks != null && stks.length > 1) {
            // Note that core can't be replaced with newCore until the end of this block.
            ArrayList<CoreMetadata> newCore = new ArrayList<CoreMetadata>();
            for (int i = 0; i < stks.length; i++) {
                CoreMetadata ms = new CoreMetadata();
                newCore.add(ms);
                ms.sizeX = getSizeX();
                ms.sizeY = getSizeY();
                ms.sizeZ = getSizeZ();
                ms.sizeC = getSizeC();
                ms.sizeT = getSizeT();
                ms.pixelType = getPixelType();
                ms.imageCount = getImageCount();
                ms.dimensionOrder = getDimensionOrder();
                ms.rgb = isRGB();
                ms.littleEndian = isLittleEndian();
                ms.interleaved = isInterleaved();
                ms.orderCertain = true;
            }
            if (stks.length > nstages) {
                for (int j = 0; j < stagesCount; j++) {
                    int idx = j * 2 + 1;
                    CoreMetadata midx = newCore.get(idx);
                    CoreMetadata pmidx = newCore.get(j * 2);
                    pmidx.sizeC = stks[j * 2].length / getSizeT();
                    midx.sizeC = stks[idx].length / midx.sizeT;
                    midx.sizeZ = hasZ.size() > 1 && hasZ.get(1) && core.get(0).sizeZ == 1 ? zc : 1;
                    pmidx.imageCount = pmidx.sizeC * pmidx.sizeT * pmidx.sizeZ;
                    midx.imageCount = midx.sizeC * midx.sizeT * midx.sizeZ;
                }
            }
            core = newCore;
        }
    }
    if (stks == null) {
        stkReaders = new MetamorphReader[1][1];
        stkReaders[0][0] = new MetamorphReader();
        stkReaders[0][0].setCanLookForND(false);
    } else {
        stkReaders = new MetamorphReader[stks.length][];
        for (int i = 0; i < stks.length; i++) {
            stkReaders[i] = new MetamorphReader[stks[i].length];
            for (int j = 0; j < stkReaders[i].length; j++) {
                stkReaders[i][j] = new MetamorphReader();
                stkReaders[i][j].setCanLookForND(false);
                if (j > 0) {
                    stkReaders[i][j].setMetadataOptions(new DefaultMetadataOptions(MetadataLevel.MINIMUM));
                }
            }
        }
    }
    // check stage labels for plate data
    int rows = 0;
    int cols = 0;
    Map<String, Integer> rowMap = null;
    Map<String, Integer> colMap = null;
    isHCS = true;
    if (null == stageLabels) {
        isHCS = false;
    } else {
        Set<Map.Entry<Integer, Integer>> uniqueWells = new HashSet<Map.Entry<Integer, Integer>>();
        rowMap = new HashMap<String, Integer>();
        colMap = new HashMap<String, Integer>();
        for (String label : stageLabels) {
            if (null == label) {
                isHCS = false;
                break;
            }
            Map.Entry<Integer, Integer> wellCoords = getWellCoords(label);
            if (null == wellCoords) {
                isHCS = false;
                break;
            }
            uniqueWells.add(wellCoords);
            rowMap.put(label, wellCoords.getKey());
            colMap.put(label, wellCoords.getValue());
        }
        if (uniqueWells.size() != stageLabels.length) {
            isHCS = false;
        } else {
            rows = Collections.max(rowMap.values());
            cols = Collections.max(colMap.values());
            CoreMetadata c = core.get(0);
            core.clear();
            c.sizeZ = 1;
            c.sizeT = 1;
            c.imageCount = 1;
            for (int s = 0; s < uniqueWells.size(); s++) {
                CoreMetadata toAdd = new CoreMetadata(c);
                if (s > 0) {
                    toAdd.seriesMetadata.clear();
                }
                core.add(toAdd);
            }
            seriesToIFD = true;
        }
    }
    List<String> timestamps = null;
    MetamorphHandler handler = null;
    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this, true);
    if (isHCS) {
        store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
        store.setPlateRows(new PositiveInteger(rows), 0);
        store.setPlateColumns(new PositiveInteger(cols), 0);
        store.setPlateRowNamingConvention(NamingConvention.LETTER, 0);
        store.setPlateColumnNamingConvention(NamingConvention.NUMBER, 0);
    }
    int nextObjective = 0;
    String instrumentID = MetadataTools.createLSID("Instrument", 0);
    String detectorID = MetadataTools.createLSID("Detector", 0, 0);
    store.setInstrumentID(instrumentID, 0);
    store.setDetectorID(detectorID, 0, 0);
    store.setDetectorType(getDetectorType("Other"), 0, 0);
    for (int i = 0; i < getSeriesCount(); i++) {
        setSeries(i);
        // do not reparse the same XML for every well
        if (i == 0 || !isHCS) {
            handler = new MetamorphHandler(getSeriesMetadata());
        }
        if (isHCS) {
            String label = stageLabels[i];
            String wellID = MetadataTools.createLSID("Well", 0, i);
            store.setWellID(wellID, 0, i);
            store.setWellColumn(new NonNegativeInteger(colMap.get(label)), 0, i);
            store.setWellRow(new NonNegativeInteger(rowMap.get(label)), 0, i);
            store.setWellSampleID(MetadataTools.createLSID("WellSample", 0, i, 0), 0, i, 0);
            store.setWellSampleImageRef(MetadataTools.createLSID("Image", i), 0, i, 0);
            store.setWellSampleIndex(new NonNegativeInteger(i), 0, i, 0);
        }
        store.setImageInstrumentRef(instrumentID, i);
        String comment = getFirstComment(i);
        if (i == 0 || !isHCS) {
            if (comment != null && comment.startsWith("<MetaData>")) {
                try {
                    XMLTools.parseXML(XMLTools.sanitizeXML(comment), handler);
                } catch (IOException e) {
                }
            }
        }
        if (creationTime != null) {
            String date = DateTools.formatDate(creationTime, SHORT_DATE_FORMAT, ".");
            if (date != null) {
                store.setImageAcquisitionDate(new Timestamp(date), 0);
            }
        }
        store.setImageName(makeImageName(i).trim(), i);
        if (getMetadataOptions().getMetadataLevel() == MetadataLevel.MINIMUM) {
            continue;
        }
        store.setImageDescription("", i);
        store.setImagingEnvironmentTemperature(new Temperature(handler.getTemperature(), UNITS.CELSIUS), i);
        if (sizeX == null)
            sizeX = handler.getPixelSizeX();
        if (sizeY == null)
            sizeY = handler.getPixelSizeY();
        Length physicalSizeX = FormatTools.getPhysicalSizeX(sizeX);
        Length physicalSizeY = FormatTools.getPhysicalSizeY(sizeY);
        if (physicalSizeX != null) {
            store.setPixelsPhysicalSizeX(physicalSizeX, i);
        }
        if (physicalSizeY != null) {
            store.setPixelsPhysicalSizeY(physicalSizeY, i);
        }
        if (zDistances != null) {
            stepSize = zDistances[0];
        } else {
            List<Double> zPositions = new ArrayList<Double>();
            final List<Double> uniqueZ = new ArrayList<Double>();
            for (IFD ifd : ifds) {
                MetamorphHandler zPlaneHandler = new MetamorphHandler();
                String zComment = ifd.getComment();
                if (zComment != null && zComment.startsWith("<MetaData>")) {
                    try {
                        XMLTools.parseXML(XMLTools.sanitizeXML(zComment), zPlaneHandler);
                    } catch (IOException e) {
                    }
                }
                zPositions = zPlaneHandler.getZPositions();
                for (Double z : zPositions) {
                    if (!uniqueZ.contains(z))
                        uniqueZ.add(z);
                }
            }
            if (uniqueZ.size() > 1 && uniqueZ.size() == getSizeZ()) {
                BigDecimal lastZ = BigDecimal.valueOf(uniqueZ.get(uniqueZ.size() - 1));
                BigDecimal firstZ = BigDecimal.valueOf(uniqueZ.get(0));
                BigDecimal zRange = (lastZ.subtract(firstZ)).abs();
                BigDecimal zSize = BigDecimal.valueOf((double) (getSizeZ() - 1));
                MathContext mc = new MathContext(10, RoundingMode.HALF_UP);
                stepSize = zRange.divide(zSize, mc).doubleValue();
            }
        }
        Length physicalSizeZ = FormatTools.getPhysicalSizeZ(stepSize);
        if (physicalSizeZ != null) {
            store.setPixelsPhysicalSizeZ(physicalSizeZ, i);
        }
        if (handler.getLensNA() != 0 || handler.getLensRI() != 0) {
            String objectiveID = MetadataTools.createLSID("Objective", 0, nextObjective);
            store.setObjectiveID(objectiveID, 0, nextObjective);
            if (handler.getLensNA() != 0) {
                store.setObjectiveLensNA(handler.getLensNA(), 0, nextObjective);
            }
            store.setObjectiveSettingsID(objectiveID, i);
            if (handler.getLensRI() != 0) {
                store.setObjectiveSettingsRefractiveIndex(handler.getLensRI(), i);
            }
            nextObjective++;
        }
        int waveIndex = 0;
        for (int c = 0; c < getEffectiveSizeC(); c++) {
            if (firstSeriesChannels == null || (stageNames != null && stageNames.size() == getSeriesCount())) {
                waveIndex = c;
            } else if (firstSeriesChannels != null) {
                int s = i % 2;
                while (firstSeriesChannels[waveIndex] == (s == 1) && waveIndex < firstSeriesChannels.length) {
                    waveIndex++;
                }
            }
            if (waveNames != null && waveIndex < waveNames.size()) {
                store.setChannelName(waveNames.get(waveIndex).trim(), i, c);
            }
            if (handler.getBinning() != null)
                binning = handler.getBinning();
            if (binning != null) {
                store.setDetectorSettingsBinning(getBinning(binning), i, c);
            }
            if (handler.getReadOutRate() != 0) {
                store.setDetectorSettingsReadOutRate(new Frequency(handler.getReadOutRate(), UNITS.HERTZ), i, c);
            }
            if (gain == null) {
                gain = handler.getGain();
            }
            if (gain != null) {
                store.setDetectorSettingsGain(gain, i, c);
            }
            store.setDetectorSettingsID(detectorID, i, c);
            if (wave != null && waveIndex < wave.length) {
                Length wavelength = FormatTools.getWavelength(wave[waveIndex]);
                if ((int) wave[waveIndex] >= 1) {
                    // link LightSource to Image
                    int laserIndex = i * getEffectiveSizeC() + c;
                    String lightSourceID = MetadataTools.createLSID("LightSource", 0, laserIndex);
                    store.setLaserID(lightSourceID, 0, laserIndex);
                    store.setChannelLightSourceSettingsID(lightSourceID, i, c);
                    store.setLaserType(getLaserType("Other"), 0, laserIndex);
                    store.setLaserLaserMedium(getLaserMedium("Other"), 0, laserIndex);
                    if (wavelength != null) {
                        store.setChannelLightSourceSettingsWavelength(wavelength, i, c);
                    }
                }
            }
            waveIndex++;
        }
        timestamps = handler.getTimestamps();
        for (int t = 0; t < timestamps.size(); t++) {
            String date = DateTools.convertDate(DateTools.getTime(timestamps.get(t), SHORT_DATE_FORMAT, "."), DateTools.UNIX, SHORT_DATE_FORMAT + ".SSS");
            addSeriesMetaList("timestamp", date);
        }
        long startDate = 0;
        if (timestamps.size() > 0) {
            startDate = DateTools.getTime(timestamps.get(0), SHORT_DATE_FORMAT, ".");
        }
        final Length positionX = handler.getStagePositionX();
        final Length positionY = handler.getStagePositionY();
        final List<Double> exposureTimes = handler.getExposures();
        if (exposureTimes.size() == 0) {
            for (int p = 0; p < getImageCount(); p++) {
                exposureTimes.add(exposureTime);
            }
        } else if (exposureTimes.size() == 1 && exposureTimes.size() < getSizeC()) {
            for (int c = 1; c < getSizeC(); c++) {
                MetamorphHandler channelHandler = new MetamorphHandler();
                String channelComment = getComment(i, c);
                if (channelComment != null && channelComment.startsWith("<MetaData>")) {
                    try {
                        XMLTools.parseXML(XMLTools.sanitizeXML(channelComment), channelHandler);
                    } catch (IOException e) {
                    }
                }
                final List<Double> channelExpTime = channelHandler.getExposures();
                exposureTimes.add(channelExpTime.get(0));
            }
        }
        int lastFile = -1;
        IFDList lastIFDs = null;
        IFD lastIFD = null;
        double distance = zStart;
        TiffParser tp = null;
        RandomAccessInputStream stream = null;
        for (int p = 0; p < getImageCount(); p++) {
            int[] coords = getZCTCoords(p);
            Double deltaT = 0d;
            Double expTime = exposureTime;
            Double xmlZPosition = null;
            int fileIndex = getIndex(0, coords[1], coords[2]) / getSizeZ();
            if (fileIndex >= 0) {
                String file = stks == null ? currentId : stks[i][fileIndex];
                if (file != null) {
                    if (fileIndex != lastFile) {
                        if (stream != null) {
                            stream.close();
                        }
                        stream = new RandomAccessInputStream(file, 16);
                        tp = new TiffParser(stream);
                        tp.checkHeader();
                        IFDList f = tp.getIFDs();
                        if (f.size() > 0) {
                            lastFile = fileIndex;
                            lastIFDs = f;
                        } else {
                            file = null;
                            stks[i][fileIndex] = null;
                        }
                    }
                }
                if (file != null) {
                    lastIFD = lastIFDs.get(p % lastIFDs.size());
                    Object commentEntry = lastIFD.get(IFD.IMAGE_DESCRIPTION);
                    if (commentEntry != null) {
                        if (commentEntry instanceof String) {
                            comment = (String) commentEntry;
                        } else if (commentEntry instanceof TiffIFDEntry) {
                            comment = tp.getIFDValue((TiffIFDEntry) commentEntry).toString();
                        }
                    }
                    if (comment != null)
                        comment = comment.trim();
                    if (comment != null && comment.startsWith("<MetaData>")) {
                        String[] lines = comment.split("\n");
                        timestamps = new ArrayList<String>();
                        for (String line : lines) {
                            line = line.trim();
                            if (line.startsWith("<prop")) {
                                int firstQuote = line.indexOf("\"") + 1;
                                int lastQuote = line.lastIndexOf("\"");
                                String key = line.substring(firstQuote, line.indexOf("\"", firstQuote));
                                String value = line.substring(line.lastIndexOf("\"", lastQuote - 1) + 1, lastQuote);
                                if (key.equals("z-position")) {
                                    xmlZPosition = new Double(value);
                                } else if (key.equals("acquisition-time-local")) {
                                    timestamps.add(value);
                                }
                            }
                        }
                    }
                }
            }
            int index = 0;
            if (timestamps.size() > 0) {
                if (coords[2] < timestamps.size())
                    index = coords[2];
                String stamp = timestamps.get(index);
                long ms = DateTools.getTime(stamp, SHORT_DATE_FORMAT, ".");
                deltaT = (ms - startDate) / 1000.0;
            } else if (internalStamps != null && p < internalStamps.length) {
                long delta = internalStamps[p] - internalStamps[0];
                deltaT = delta / 1000.0;
                if (coords[2] < exposureTimes.size())
                    index = coords[2];
            }
            if (index == 0 && p > 0 && exposureTimes.size() > 0) {
                index = coords[1] % exposureTimes.size();
            }
            if (index < exposureTimes.size()) {
                expTime = exposureTimes.get(index);
            }
            if (deltaT != null) {
                store.setPlaneDeltaT(new Time(deltaT, UNITS.SECOND), i, p);
            }
            if (expTime != null) {
                store.setPlaneExposureTime(new Time(expTime, UNITS.SECOND), i, p);
            }
            if (stageX != null && p < stageX.length) {
                store.setPlanePositionX(stageX[p], i, p);
            } else if (positionX != null) {
                store.setPlanePositionX(positionX, i, p);
            }
            if (stageY != null && p < stageY.length) {
                store.setPlanePositionY(stageY[p], i, p);
            } else if (positionY != null) {
                store.setPlanePositionY(positionY, i, p);
            }
            if (zDistances != null && p < zDistances.length) {
                if (p > 0) {
                    if (zDistances[p] != 0d)
                        distance += zDistances[p];
                    else
                        distance += zDistances[0];
                }
                final Length zPos = new Length(distance, UNITS.REFERENCEFRAME);
                store.setPlanePositionZ(zPos, i, p);
            } else if (xmlZPosition != null) {
                final Length zPos = new Length(xmlZPosition, UNITS.REFERENCEFRAME);
                store.setPlanePositionZ(zPos, i, p);
            }
        }
        if (stream != null) {
            stream.close();
        }
    }
    setSeries(0);
}

Example 5 with Length

use of ome.units.quantity.Length in project bioformats by openmicroscopy.

the class ND2Handler method startElement.

@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) {
    String runtype = attributes.getValue("runtype");
    if ("CLxListVariant".equals(runtype) || "RLxIRect".equals(runtype)) {
        prevElement = qName;
    }
    String value = attributes.getValue("value");
    CoreMetadata ms0 = core.get(0);
    try {
        if (qName.equals("uiWidth")) {
            int x = Integer.parseInt(value);
            if (x != 0 && populateXY) {
                ms0.sizeX = x;
            }
        } else if (qName.equals("uiCamPxlCountX")) {
            if (ms0.sizeX == 0 && populateXY) {
                ms0.sizeX = Integer.parseInt(value);
            }
        } else if (qName.equals("uiCamPxlCountY")) {
            if (ms0.sizeY == 0 && populateXY) {
                ms0.sizeY = Integer.parseInt(value);
            }
        } else if (qName.equals("iXFields")) {
            int fields = Integer.parseInt(value);
            nXFields += fields;
        } else if (qName.equals("iYFields")) {
            int fields = Integer.parseInt(value);
            nYFields += fields;
        } else if ("rectSensorUser".equals(prevElement) && populateXY) {
            if (qName.equals("left") && ms0.sizeX == 0) {
                ms0.sizeX = -1 * Integer.parseInt(value);
            } else if (qName.equals("top") && ms0.sizeY == 0) {
                ms0.sizeY = -1 * Integer.parseInt(value);
            } else if (qName.equals("right") && ms0.sizeX <= 0) {
                ms0.sizeX += Integer.parseInt(value);
            } else if (qName.equals("bottom") && ms0.sizeY <= 0) {
                ms0.sizeY += Integer.parseInt(value);
            }
        } else if ("LoopState".equals(prevElement) && value != null) {
            long v = Long.parseLong(value);
            validLoopState.add(v != 529 && v < 0xfffff);
        } else if ("LoopSize".equals(prevElement) && value != null) {
            int v = Integer.parseInt(value);
            int loopIndex = 0;
            while (validLoopState.get(loopIndex) == null) {
                loopIndex++;
            }
            boolean loop = validLoopState.get(loopIndex);
            if (!loop && validLoopState.contains(true)) {
                v = 1;
            }
            if (ms0.sizeT == 0 || (ms0.sizeT * ms0.sizeZ > nImages && v < ms0.sizeT)) {
                ms0.sizeT = v;
            } else if (qName.equals("no_name") && v > 1 && core.size() == 1) {
                core = new ArrayList<CoreMetadata>();
                for (int q = 0; q < v; q++) {
                    core.add(ms0);
                }
            } else if (ms0.sizeZ == 0) {
                ms0.sizeZ = v;
            } else {
                canAdjustDimensions = false;
            }
            ms0.dimensionOrder = "CZT";
        } else if ("pPosName".equals(prevElement) && value != null) {
            posNames.add(value);
        } else if (qName.equals("FramesBefore")) {
            if (ms0.sizeZ == 0) {
                ms0.sizeZ = 1;
            }
            // only adjust if we haven't parsed all of the dimensions already
            if (canAdjustDimensions && core.size() == 1 && (ms0.sizeT <= 1 || ms0.sizeT * ms0.sizeZ != nImages)) {
                ms0.sizeZ *= Integer.parseInt(value);
            }
        } else if (qName.equals("FramesAfter")) {
            int loopIndex = 0;
            while (validLoopState.get(loopIndex) == null) {
                loopIndex++;
            }
            boolean loop = validLoopState.get(loopIndex);
            validLoopState.set(loopIndex, null);
            if (canAdjustDimensions && core.size() == 1) {
                ms0.sizeZ *= Integer.parseInt(value);
                if (ms0.sizeT * ms0.sizeZ > nImages && ms0.sizeT <= nImages && ms0.sizeT != ms0.sizeZ) {
                    ms0.sizeZ = ms0.sizeT;
                    ms0.sizeT = 1;
                }
            }
        } else if (qName.equals("TimeBefore") && canAdjustDimensions) {
            if (ms0.sizeT == 0) {
                ms0.sizeT = 1;
            }
            ms0.sizeT *= Integer.parseInt(value);
        } else if (qName.equals("TimeAfter") && canAdjustDimensions) {
            ms0.sizeT *= Integer.parseInt(value);
        } else if (qName.equals("uiMaxDst")) {
            int maxPixelValue = Integer.parseInt(value) + 1;
            int bits = 0;
            while (maxPixelValue > 0) {
                maxPixelValue /= 2;
                bits++;
            }
            try {
                if (ms0.pixelType == 0) {
                    ms0.pixelType = FormatTools.pixelTypeFromBytes(bits / 8, false, false);
                }
            } catch (FormatException e) {
                LOGGER.warn("Could not set the pixel type", e);
            }
        } else if (qName.equals("uiWidthBytes") || qName.startsWith("uiBpcInMemory") || qName.startsWith("uiBpcSignificant")) {
            int div = qName.equals("uiWidthBytes") ? ms0.sizeX : 8;
            if (div > 0) {
                int bits = Integer.parseInt(value);
                int bytes = bits / div;
                if (bytes * div == bits) {
                    try {
                        ms0.pixelType = FormatTools.pixelTypeFromBytes(bytes, false, false);
                    } catch (FormatException e) {
                    }
                }
                parseKeyAndValue(qName, value, prevRuntype);
            }
        } else if ("dPosX".equals(prevElement) && qName.startsWith("item_")) {
            final Double number = DataTools.parseDouble(value);
            posX.add(new Length(number, UNITS.REFERENCEFRAME));
            metadata.put("X position for position #" + posX.size(), value);
        } else if ("dPosY".equals(prevElement) && qName.startsWith("item_")) {
            final Double number = DataTools.parseDouble(value);
            posY.add(new Length(number, UNITS.REFERENCEFRAME));
            metadata.put("Y position for position #" + posY.size(), value);
        } else if ("dPosZ".equals(prevElement) && qName.startsWith("item_")) {
            final Double number = DataTools.parseDouble(value);
            posZ.add(new Length(number, UNITS.REFERENCEFRAME));
            metadata.put("Z position for position #" + posZ.size(), value);
        } else if (qName.startsWith("item_")) {
            int v = Integer.parseInt(qName.substring(qName.indexOf('_') + 1));
            if (v == numSeries) {
                numSeries++;
            }
        } else if (qName.equals("uiCompCount")) {
            int v = Integer.parseInt(value);
            ms0.sizeC = (int) Math.max(ms0.sizeC, v);
        } else if (qName.equals("uiHeight") && populateXY) {
            int y = Integer.parseInt(value);
            if (y != 0) {
                ms0.sizeY = y;
            }
        } else if (qName.startsWith("TextInfo")) {
            parseKeyAndValue(qName, attributes.getValue("Text"), prevRuntype);
            parseKeyAndValue(qName, value, prevRuntype);
        } else if (qName.equals("dCompressionParam")) {
            isLossless = Double.parseDouble(value) > 0;
            parseKeyAndValue(qName, value, prevRuntype);
        } else if (qName.equals("CalibrationSeq") || qName.equals("MetadataSeq")) {
            prefix = qName + " " + attributes.getValue("_SEQUENCE_INDEX");
        } else if (qName.equals("HorizontalLine") || qName.equals("VerticalLine") || qName.equals("Text")) {
            Hashtable<String, String> roi = new Hashtable<String, String>();
            roi.put("ROIType", qName);
            for (int q = 0; q < attributes.getLength(); q++) {
                roi.put(attributes.getQName(q), attributes.getValue(q));
            }
            rois.add(roi);
        } else if (qName.equals("dPinholeRadius")) {
            pinholeSize = DataTools.parseDouble(value);
            metadata.put("Pinhole size", value);
        } else if (qName.endsWith("ChannelColor")) {
            String name = qName.substring(0, qName.indexOf("Channel"));
            colors.put(name, new Integer(value));
        } else if (qName.endsWith("DyeName")) {
            int channelIndex = qName.indexOf("Channel");
            if (channelIndex < 0)
                channelIndex = 0;
            dyes.put(qName.substring(0, channelIndex), value);
        } else if (qName.equals("uiSequenceCount")) {
            int imageCount = Integer.parseInt(value);
            if (core.size() > 0) {
                int newCount = imageCount / core.size();
                if (newCount * core.size() == imageCount) {
                    imageCount = newCount;
                }
            }
            if (ms0.sizeZ * ms0.sizeT != imageCount && ms0.sizeZ * ms0.sizeC * ms0.sizeT != imageCount) {
                if (ms0.sizeZ > 1 && ms0.sizeT <= 1) {
                    ms0.sizeZ = imageCount;
                    ms0.sizeT = 1;
                    ms0.imageCount = imageCount;
                } else if (ms0.sizeT > 1 && ms0.sizeZ <= 1) {
                    ms0.sizeT = imageCount;
                    ms0.sizeZ = 1;
                    ms0.imageCount = imageCount;
                } else if (imageCount == 0) {
                    ms0.sizeT = 0;
                    ms0.sizeZ = 0;
                    ms0.imageCount = 0;
                }
            }
            metadata.put(qName, value);
        } else {
            final StringBuilder sb = new StringBuilder();
            if (prefix != null) {
                sb.append(prefix);
                sb.append(" ");
            }
            sb.append(qName);
            parseKeyAndValue(sb.toString(), value, prevRuntype);
        }
    } catch (NumberFormatException exc) {
        LOGGER.warn("Could not parse {} value: {}", qName, value);
    }
    prevRuntype = attributes.getValue("runtype");
}