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

Example 11 with Length

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

the class LeicaHandler method endElement.

// -- DefaultHandler API methods --
@Override
public void endElement(String uri, String localName, String qName) {
    if (!nameStack.isEmpty() && nameStack.peek().equals(qName))
        nameStack.pop();
    if (qName.equals("ImageDescription")) {
        CoreMetadata coreMeta = core.get(numDatasets);
        if (numChannels == 0)
            numChannels = 1;
        coreMeta.sizeC = numChannels;
        if (extras > 1) {
            if (coreMeta.sizeZ == 1)
                coreMeta.sizeZ = extras;
            else {
                if (coreMeta.sizeT == 0)
                    coreMeta.sizeT = extras;
                else
                    coreMeta.sizeT *= extras;
            }
        }
        if (coreMeta.sizeX == 0 && coreMeta.sizeY == 0) {
            if (numDatasets > 0)
                numDatasets--;
        } else {
            if (coreMeta.sizeX == 0)
                coreMeta.sizeX = 1;
            if (coreMeta.sizeZ == 0)
                coreMeta.sizeZ = 1;
            if (coreMeta.sizeT == 0)
                coreMeta.sizeT = 1;
            coreMeta.orderCertain = true;
            coreMeta.metadataComplete = true;
            coreMeta.littleEndian = true;
            coreMeta.interleaved = coreMeta.rgb;
            coreMeta.imageCount = coreMeta.sizeZ * coreMeta.sizeT;
            if (!coreMeta.rgb)
                coreMeta.imageCount *= coreMeta.sizeC;
            coreMeta.indexed = !coreMeta.rgb;
            coreMeta.falseColor = true;
            Integer[] bytes = bytesPerAxis.keySet().toArray(new Integer[0]);
            Arrays.sort(bytes);
            coreMeta.dimensionOrder = "XY";
            for (Integer nBytes : bytes) {
                String axis = bytesPerAxis.get(nBytes);
                if (coreMeta.dimensionOrder.indexOf(axis) == -1) {
                    coreMeta.dimensionOrder += axis;
                }
            }
            String[] axes = new String[] { "Z", "C", "T" };
            for (String axis : axes) {
                if (coreMeta.dimensionOrder.indexOf(axis) == -1) {
                    coreMeta.dimensionOrder += axis;
                }
            }
            core.set(numDatasets, coreMeta);
        }
        if (level != MetadataLevel.MINIMUM) {
            int nChannels = coreMeta.rgb ? 0 : numChannels;
            for (int c = 0; c < nChannels; c++) {
                store.setChannelPinholeSize(new Length(pinhole, UNITS.MICROMETER), numDatasets, c);
            }
            for (int i = 0; i < xPos.size(); i++) {
                int pos = i + 1;
                globalMetadata.put("X position for position #" + pos, xPos.get(i));
                globalMetadata.put("Y position for position #" + pos, yPos.get(i));
                globalMetadata.put("Z position for position #" + pos, zPos.get(i));
                for (int image = 0; image < coreMeta.imageCount; image++) {
                    store.setPlanePositionX(xPos.get(i), numDatasets, image);
                    store.setPlanePositionY(yPos.get(i), numDatasets, image);
                    store.setPlanePositionZ(zPos.get(i), numDatasets, image);
                }
            }
            for (int c = 0; c < nChannels; c++) {
                int index = c < detectorIndices.size() ? detectorIndices.get(c).intValue() : detectorIndices.size() - 1;
                if (index < 0 || index >= nChannels || index >= 0)
                    break;
                String id = MetadataTools.createLSID("Detector", numDatasets, index);
                store.setDetectorSettingsID(id, numDatasets, c);
            }
            String[] keys = channels.keySet().toArray(new String[0]);
            Arrays.sort(keys);
            for (int c = 0; c < keys.length; c++) {
                Channel ch = channels.get(keys[c]);
                store.setDetectorSettingsID(ch.detector, numDatasets, c);
                store.setChannelExcitationWavelength(ch.exWave, numDatasets, c);
                store.setChannelName(ch.name, numDatasets, c);
                store.setDetectorSettingsGain(ch.gain, numDatasets, c);
            }
        }
        channels.clear();
        xPos.clear();
        yPos.clear();
        zPos.clear();
        detectorIndices.clear();
    } else if (qName.equals("Element") && level != MetadataLevel.MINIMUM) {
        multiBands.clear();
        nextROI = 0;
        if (numDatasets >= 0) {
            int nChannels = core.get(numDatasets).rgb ? 1 : numChannels;
            for (int c = 0; c < detectorIndices.size(); c++) {
                int index = detectorIndices.get(c).intValue();
                if (c >= nChannels || index >= nChannels || index >= 0)
                    break;
                String id = MetadataTools.createLSID("Detector", numDatasets, index);
                store.setDetectorSettingsID(id, numDatasets, index);
            }
            for (int c = 0; c < nChannels; c++) {
                store.setChannelPinholeSize(new Length(pinhole, UNITS.MICROMETER), numDatasets, c);
            }
        }
    } else if (qName.equals("Image")) {
        nextChannel = 0;
    } else if (qName.equals("LDM_Block_Sequential_Master")) {
        canParse = true;
    } else if (qName.equals("Annotation") && level != MetadataLevel.MINIMUM) {
        roi.storeROI(store, numDatasets, nextROI++);
    }
}

Example 12 with Length

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

the class LeicaSCNReader method initMetadataStore.

/* @see loci.formats.BaseTiffReader#initMetadataStore() */
@Override
protected void initMetadataStore() throws FormatException {
    super.initMetadataStore();
    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this, true);
    HashMap<String, Integer> instrumentIDs = new HashMap<String, Integer>();
    int instrumentidno = 0;
    HashMap<String, String> objectives = new HashMap<String, String>();
    int objectiveidno = 0;
    int parent = 0;
    for (int s = 0; s < getSeriesCount(); s++) {
        int coreIndex = seriesToCoreIndex(s);
        ImageCollection c = handler.collection;
        Image i = handler.imageMap.get(coreIndex);
        int subresolution = coreIndex - parent;
        if (!hasFlattenedResolutions()) {
            subresolution = 0;
        }
        if (core.get(s).resolutionCount > 1) {
            parent = s;
        } else if (core.get(parent).resolutionCount - 1 == subresolution) {
            parent = s + 1;
        }
        Dimension dimension = i.pixels.lookupDimension(0, 0, subresolution);
        if (dimension == null) {
            throw new FormatException("No dimension information for subresolution=" + subresolution);
        }
        // Leica units are nanometres; convert to µm
        double sizeX = i.vSizeX / 1000.0;
        double sizeY = i.vSizeY / 1000.0;
        final Length offsetX = new Length(i.vOffsetX, UNITS.REFERENCEFRAME);
        final Length offsetY = new Length(i.vOffsetY, UNITS.REFERENCEFRAME);
        double sizeZ = i.vSpacingZ / 1000.0;
        store.setPixelsPhysicalSizeX(FormatTools.getPhysicalSizeX(sizeX / dimension.sizeX), s);
        store.setPixelsPhysicalSizeY(FormatTools.getPhysicalSizeY(sizeY / dimension.sizeY), s);
        store.setPixelsPhysicalSizeZ(FormatTools.getPhysicalSizeZ(sizeZ), s);
        if (instrumentIDs.get(i.devModel) == null) {
            String instrumentID = MetadataTools.createLSID("Instrument", instrumentidno);
            instrumentIDs.put(i.devModel, instrumentidno);
            store.setInstrumentID(instrumentID, instrumentidno);
            instrumentidno++;
        }
        int inst = instrumentIDs.get(i.devModel);
        String objectiveName = i.devModel + ":" + i.objMag;
        if (objectives.get(objectiveName) == null) {
            String objectiveID = MetadataTools.createLSID("Objective", inst, objectiveidno);
            objectives.put(objectiveName, objectiveID);
            store.setObjectiveID(objectiveID, inst, objectiveidno);
            Double mag = Double.parseDouble(i.objMag);
            store.setObjectiveNominalMagnification(mag, inst, objectiveidno);
            store.setObjectiveCalibratedMagnification(mag, inst, objectiveidno);
            store.setObjectiveLensNA(new Double(i.illumNA), inst, objectiveidno);
            objectiveidno++;
        }
        store.setImageInstrumentRef(MetadataTools.createLSID("Instrument", inst), s);
        store.setObjectiveSettingsID(objectives.get(objectiveName), s);
        // TODO: Only "brightfield" has been seen in example files
        if (i.illumSource.equals("brightfield")) {
            store.setChannelIlluminationType(IlluminationType.TRANSMITTED, s, 0);
        } else {
            store.setChannelIlluminationType(IlluminationType.OTHER, s, 0);
            LOGGER.debug("Unknown illumination source {}", i.illumSource);
        }
        CoreMetadata ms = core.get(s);
        for (int q = 0; q < ms.imageCount; q++) {
            store.setPlanePositionX(offsetX, s, q);
            store.setPlanePositionY(offsetY, s, q);
        }
        store.setImageName(i.name + " (R" + subresolution + ")", s);
        store.setImageDescription("Collection " + c.name, s);
        store.setImageAcquisitionDate(new Timestamp(i.creationDate), s);
        // Original metadata...
        addSeriesMeta("collection.name", c.name);
        addSeriesMeta("collection.uuid", c.uuid);
        addSeriesMeta("collection.barcode", c.barcode);
        addSeriesMeta("collection.ocr", c.ocr);
        addSeriesMeta("creationDate", i.creationDate);
        addSeriesMeta("device.model for image", i.devModel);
        addSeriesMeta("device.version for image", i.devVersion);
        addSeriesMeta("view.sizeX for image", i.vSizeX);
        addSeriesMeta("view.sizeY for image", i.vSizeY);
        addSeriesMeta("view.offsetX for image", i.vOffsetX);
        addSeriesMeta("view.offsetY for image", i.vOffsetY);
        addSeriesMeta("view.spacingZ for image", i.vSpacingZ);
        addSeriesMeta("scanSettings.objectiveSettings.objective for image", i.objMag);
        addSeriesMeta("scanSettings.illuminationSettings.numericalAperture for image", i.illumNA);
        addSeriesMeta("scanSettings.illuminationSettings.illuminationSource for image", i.illumSource);
    }
}

Example 13 with Length

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

the class MRCReader method initFile.

// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
public void initFile(String id) throws FormatException, IOException {
    super.initFile(id);
    in = new RandomAccessInputStream(id);
    MetadataLevel level = getMetadataOptions().getMetadataLevel();
    CoreMetadata m = core.get(0);
    LOGGER.info("Reading header");
    // check endianness
    in.seek(ENDIANNESS_OFFSET);
    m.littleEndian = in.read() == 68;
    // read dimension information from 1024 byte header
    in.seek(0);
    in.order(isLittleEndian());
    m.sizeX = in.readInt();
    m.sizeY = in.readInt();
    m.sizeZ = in.readInt();
    // We are using BigInteger here because of the very real possiblity
    // of not just an int overflow but also a long overflow when multiplying
    // sizeX * sizeY * sizeZ.
    BigInteger v = BigInteger.valueOf(getSizeX());
    v = v.multiply(BigInteger.valueOf(getSizeY()));
    v = v.multiply(BigInteger.valueOf(getSizeZ()));
    if (getSizeX() < 0 || getSizeY() < 0 || getSizeZ() < 0 || (v.compareTo(BigInteger.valueOf(in.length())) > 0)) {
        LOGGER.debug("Detected endianness is wrong, swapping");
        m.littleEndian = !isLittleEndian();
        in.seek(0);
        in.order(isLittleEndian());
        m.sizeX = in.readInt();
        m.sizeY = in.readInt();
        m.sizeZ = in.readInt();
    }
    m.sizeC = 1;
    m.rgb = false;
    int mode = in.readInt();
    switch(mode) {
        case 0:
            in.seek(IMODSTAMP_OFFSET);
            if (in.readInt() == 1146047817) {
                m.pixelType = FormatTools.INT8;
            } else {
                m.pixelType = FormatTools.UINT8;
            }
            break;
        case 1:
            m.pixelType = FormatTools.INT16;
            break;
        case 6:
            m.pixelType = FormatTools.UINT16;
            break;
        case 2:
            m.pixelType = FormatTools.FLOAT;
            break;
        case 3:
            m.pixelType = FormatTools.UINT32;
            break;
        case 4:
            m.pixelType = FormatTools.DOUBLE;
            break;
        case 16:
            m.sizeC = 3;
            m.pixelType = FormatTools.UINT8;
            m.rgb = true;
            break;
    }
    in.seek(GRIDSIZE_OFFSET);
    // pixel size = xlen / mx
    double xSize = 0d, ySize = 0d, zSize = 0d;
    if (level != MetadataLevel.MINIMUM) {
        int mx = in.readInt();
        int my = in.readInt();
        int mz = in.readInt();
        float xlen = in.readFloat();
        float ylen = in.readFloat();
        float zlen = in.readFloat();
        // physical sizes are stored in ångströms
        xSize = (xlen / mx);
        ySize = (ylen / my);
        zSize = (zlen / mz);
        addGlobalMeta("Grid size (X)", mx);
        addGlobalMeta("Grid size (Y)", my);
        addGlobalMeta("Grid size (Z)", mz);
        addGlobalMeta("Cell size (X)", xlen);
        addGlobalMeta("Cell size (Y)", ylen);
        addGlobalMeta("Cell size (Z)", zlen);
        addGlobalMeta("Alpha angle", in.readFloat());
        addGlobalMeta("Beta angle", in.readFloat());
        addGlobalMeta("Gamma angle", in.readFloat());
        in.skipBytes(12);
    // min, max and mean pixel values
    } else
        in.skipBytes(48);
    double minValue = in.readFloat();
    double maxValue = in.readFloat();
    addGlobalMeta("Minimum pixel value", minValue);
    addGlobalMeta("Maximum pixel value", maxValue);
    addGlobalMeta("Mean pixel value", in.readFloat());
    int bytes = FormatTools.getBytesPerPixel(getPixelType());
    double range = Math.pow(2, bytes * 8) - 1;
    double pixelTypeMin = 0;
    boolean signed = FormatTools.isSigned(getPixelType());
    if (signed) {
        pixelTypeMin -= (range / 2);
    }
    double pixelTypeMax = pixelTypeMin + range;
    // See https://trac.openmicroscopy.org/ome/ticket/4619
    if (pixelTypeMax < maxValue || pixelTypeMin > minValue && signed) {
        switch(getPixelType()) {
            case FormatTools.INT16:
                m.pixelType = FormatTools.UINT16;
                break;
            case FormatTools.INT32:
                m.pixelType = FormatTools.UINT32;
                break;
        }
    }
    int ispg = in.readInt();
    addGlobalMeta("ISPG", ispg);
    addGlobalMeta("Is data cube", ispg == 1);
    extHeaderSize = in.readInt();
    if (level != MetadataLevel.MINIMUM) {
        in.skipBytes(64);
        int idtype = in.readShort();
        String type = "unknown";
        if (idtype >= 0 && idtype < TYPES.length)
            type = TYPES[idtype];
        addGlobalMeta("Series type", type);
        addGlobalMeta("Lens", in.readShort());
        addGlobalMeta("ND1", in.readShort());
        addGlobalMeta("ND2", in.readShort());
        addGlobalMeta("VD1", in.readShort());
        addGlobalMeta("VD2", in.readShort());
        for (int i = 0; i < 6; i++) {
            addGlobalMetaList("Angle", in.readFloat());
        }
        in.skipBytes(24);
        addGlobalMeta("Number of useful labels", in.readInt());
        for (int i = 0; i < 10; i++) {
            addGlobalMetaList("Label", in.readString(80));
        }
    }
    LOGGER.info("Populating metadata");
    m.sizeT = 1;
    m.dimensionOrder = isRGB() ? "XYCZT" : "XYZTC";
    m.imageCount = getSizeZ() * (isRGB() ? 1 : getSizeC());
    m.interleaved = true;
    m.indexed = false;
    m.falseColor = false;
    m.metadataComplete = true;
    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this);
    if (level != MetadataLevel.MINIMUM) {
        Length sizeX = FormatTools.getPhysicalSizeX(xSize, UNITS.ANGSTROM);
        Length sizeY = FormatTools.getPhysicalSizeY(ySize, UNITS.ANGSTROM);
        Length sizeZ = FormatTools.getPhysicalSizeZ(zSize, UNITS.ANGSTROM);
        if (sizeX != null) {
            store.setPixelsPhysicalSizeX(sizeX, 0);
        }
        if (sizeY != null) {
            store.setPixelsPhysicalSizeY(sizeY, 0);
        }
        if (sizeZ != null) {
            store.setPixelsPhysicalSizeZ(sizeZ, 0);
        }
    }
}

Example 14 with Length

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

the class MetamorphHandler method checkKey.

// -- Helper methods --
/**
 * Check if the value needs to be saved.
 */
private void checkKey(String key, String value) {
    if (key.equals("Temperature")) {
        temperature = Double.parseDouble(value);
    } else if (key.equals("spatial-calibration-x")) {
        pixelSizeX = Double.parseDouble(value);
    } else if (key.equals("spatial-calibration-y")) {
        pixelSizeY = Double.parseDouble(value);
    } else if (key.equals("z-position")) {
        zPositions.add(new Double(value));
    } else if (key.equals("wavelength")) {
        wavelengths.add(new Integer(value));
    } else if (key.equals("acquisition-time-local")) {
        date = value;
        timestamps.add(date);
    } else if (key.equals("image-name"))
        imageName = value;
    else if (key.equals("Binning")) {
        binning = value;
    } else if (key.equals("Readout Frequency")) {
        readOutRate = Double.parseDouble(value);
    } else if (key.equals("zoom-percent")) {
        zoom = Double.parseDouble(value);
    } else if (key.equals("stage-position-x")) {
        final Double number = Double.valueOf(value);
        positionX = new Length(number, UNITS.REFERENCEFRAME);
        if (metadata != null) {
            metadata.put("X position for position #1", positionX);
        }
    } else if (key.equals("stage-position-y")) {
        final Double number = Double.valueOf(value);
        positionY = new Length(number, UNITS.REFERENCEFRAME);
        if (metadata != null) {
            metadata.put("Y position for position #1", positionY);
        }
    } else if (key.equals("Speed")) {
        int space = value.indexOf(' ');
        if (space > 0) {
            value = value.substring(0, space);
        }
        try {
            readOutRate = Double.parseDouble(value.trim());
        } catch (NumberFormatException e) {
        }
    } else if (key.equals("Exposure")) {
        if (value.indexOf(' ') != -1) {
            value = value.substring(0, value.indexOf(' '));
        }
        // exposure times are stored in milliseconds, we want them in seconds
        try {
            exposures.add(new Double(Double.parseDouble(value) / 1000));
        } catch (NumberFormatException e) {
        }
    } else if (key.equals("_IllumSetting_")) {
        if (channelName == null) {
            channelName = value;
        }
        channelNames.add(value);
    } else if (key.equals("stage-label")) {
        stageLabel = value;
    } else if (key.endsWith("Gain") && gain == null) {
        try {
            gain = new Double(value.replaceAll("[xX]", ""));
        } catch (NumberFormatException e) {
        }
    } else if (key.equals("_MagNA_")) {
        lensNA = Double.parseDouble(value);
    } else if (key.equals("_MagRI_")) {
        lensRI = Double.parseDouble(value);
    } else if (key.startsWith("Dual Camera")) {
        // Determine if image has been already split by Metamorph.
        // Metamorph seems to add the wavelength number to the end
        // of the Description field when splitting. Example:
        // Dual Camera Time Difference: 7 msec 561
        int space = value.lastIndexOf(" ");
        if (space == -1) {
            // unknown value format, assume dual camera
            dualCamera = true;
        } else {
            try {
                Double.parseDouble(value.substring(space));
                // last number is a wavelength and indicates this dual camera
                // image has been split
                dualCamera = false;
            } catch (NumberFormatException e) {
                // last token is not a number, so image has not been split
                dualCamera = true;
            }
        }
    }
}

Example 15 with Length

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

the class FEITiffReader method initStandardMetadata.

// -- Internal BaseTiffReader API methods --
/* @see BaseTiffReader#initStandardMetadata() */
@Override
protected void initStandardMetadata() throws FormatException, IOException {
    super.initStandardMetadata();
    boolean helios = ifds.get(0).containsKey(HELIOS_TAG);
    boolean titan = ifds.get(0).containsKey(TITAN_TAG);
    // Helios etc data might have a stray Titan tag
    if (titan && ifds.get(0).getIFDTextValue(TITAN_TAG).trim().isEmpty()) {
        titan = false;
    }
    // Titan data (always?) has an empty Helios tag as well, so the Titan tag is checked first
    String software = "S-FEG";
    if (titan) {
        software = "Titan";
    } else if (helios) {
        software = "Helios NanoLab";
    }
    addGlobalMeta("Software", software);
    int tagKey = SFEG_TAG;
    if (titan) {
        tagKey = TITAN_TAG;
    } else if (helios) {
        tagKey = HELIOS_TAG;
    }
    String tag = ifds.get(0).getIFDTextValue(tagKey);
    if (tag == null) {
        return;
    }
    tag = tag.trim();
    if (tag.isEmpty()) {
        // fall back to regular reader
        return;
    }
    // store metadata for later conversion to OME-XML
    if (tag.startsWith("<")) {
        XMLTools.parseXML(tag, new FEIHandler());
    } else {
        IniParser parser = new IniParser();
        IniList ini = parser.parseINI(new BufferedReader(new StringReader(tag)));
        detectors = new ArrayList<String>();
        if (helios) {
            IniTable userTable = ini.getTable("User");
            date = userTable.get("Date") + " " + userTable.get("Time");
            if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
                userName = userTable.get("User");
                IniTable systemTable = ini.getTable("System");
                if (systemTable == null) {
                    systemTable = ini.getTable("SYSTEM");
                }
                if (systemTable != null) {
                    microscopeModel = systemTable.get("SystemType");
                }
                IniTable beamTable = ini.getTable("Beam");
                if (beamTable != null) {
                    String beamTableName = beamTable.get("Beam");
                    if (beamTableName != null) {
                        beamTable = ini.getTable(beamTableName);
                    }
                }
                if (beamTable != null) {
                    String beamX = beamTable.get("StageX");
                    String beamY = beamTable.get("StageY");
                    String beamZ = beamTable.get("StageZ");
                    IniTable stageTable = ini.getTable("Stage");
                    if (beamX != null) {
                        final Double number = Double.valueOf(beamX);
                        stageX = new Length(number, UNITS.REFERENCEFRAME);
                    } else if (stageTable != null) {
                        final Double number = Double.valueOf(stageTable.get("StageX"));
                        stageX = new Length(number, UNITS.REFERENCEFRAME);
                    }
                    if (beamY != null) {
                        final Double number = Double.valueOf(beamY);
                        stageY = new Length(number, UNITS.REFERENCEFRAME);
                    } else if (stageTable != null) {
                        final Double number = Double.valueOf(stageTable.get("StageY"));
                        stageY = new Length(number, UNITS.REFERENCEFRAME);
                    }
                    if (beamZ != null) {
                        final Double number = Double.valueOf(beamZ);
                        stageZ = new Length(number, UNITS.REFERENCEFRAME);
                    } else if (stageTable != null) {
                        final Double number = Double.valueOf(stageTable.get("StageZ"));
                        stageZ = new Length(number, UNITS.REFERENCEFRAME);
                    }
                }
                IniTable scanTable = ini.getTable("Scan");
                sizeX = new Double(scanTable.get("PixelWidth"));
                sizeY = new Double(scanTable.get("PixelHeight"));
                timeIncrement = new Double(scanTable.get("FrameTime"));
            }
        } else {
            IniTable dataTable = ini.getTable("DatabarData");
            imageName = dataTable.get("ImageName");
            imageDescription = dataTable.get("szUserText");
            String magnification = ini.getTable("Vector").get("Magnification");
            sizeX = new Double(magnification) * MAG_MULTIPLIER;
            sizeY = new Double(magnification) * MAG_MULTIPLIER;
            IniTable scanTable = ini.getTable("Vector.Sysscan");
            final Double posX = Double.valueOf(scanTable.get("PositionX"));
            final Double posY = Double.valueOf(scanTable.get("PositionY"));
            stageX = new Length(posX, UNITS.REFERENCEFRAME);
            stageY = new Length(posY, UNITS.REFERENCEFRAME);
            IniTable detectorTable = ini.getTable("Vector.Video.Detectors");
            int detectorCount = Integer.parseInt(detectorTable.get("NrDetectorsConnected"));
            for (int i = 0; i < detectorCount; i++) {
                detectors.add(detectorTable.get("Detector_" + i + "_Name"));
            }
        }
        if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
            HashMap<String, String> iniMap = ini.flattenIntoHashMap();
            metadata.putAll(iniMap);
        }
    }
}