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

Example 31 with Length

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

the class WlzReader 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();
        wlz = factory.getInstance(WlzService.class);
    } catch (DependencyException e) {
        throw new FormatException(NO_WLZ_MSG, e);
    }
    if (wlz != null) {
        wlz.open(id, "r");
        CoreMetadata md = core.get(0);
        MetadataStore store = makeFilterMetadata();
        md.rgb = wlz.isRGB();
        md.interleaved = false;
        md.indexed = false;
        md.sizeX = wlz.getSizeX();
        md.sizeY = wlz.getSizeY();
        md.sizeZ = wlz.getSizeZ();
        md.sizeC = wlz.getSizeC();
        md.sizeT = wlz.getSizeT();
        md.dimensionOrder = "XYZCT";
        md.imageCount = wlz.getSizeZ();
        md.pixelType = wlz.getPixelType();
        PositiveFloat x = new PositiveFloat(Math.abs(wlz.getVoxSzX()));
        PositiveFloat y = new PositiveFloat(Math.abs(wlz.getVoxSzY()));
        PositiveFloat z = new PositiveFloat(Math.abs(wlz.getVoxSzZ()));
        store.setPixelsPhysicalSizeX(FormatTools.createLength(x, UNITS.MICROMETER), 0);
        store.setPixelsPhysicalSizeY(FormatTools.createLength(y, UNITS.MICROMETER), 0);
        store.setPixelsPhysicalSizeZ(FormatTools.createLength(z, UNITS.MICROMETER), 0);
        store.setStageLabelName(wlz.getWlzOrgLabelName(), 0);
        store.setStageLabelX(new Length(wlz.getOrgX(), UNITS.REFERENCEFRAME), 0);
        store.setStageLabelY(new Length(wlz.getOrgY(), UNITS.REFERENCEFRAME), 0);
        store.setStageLabelZ(new Length(wlz.getOrgZ(), UNITS.REFERENCEFRAME), 0);
        MetadataTools.populatePixels(store, this);
    }
}

Example 32 with Length

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

the class ZeissCZIReader method translateInformation.

private void translateInformation(Element root) throws FormatException {
    NodeList informations = root.getElementsByTagName("Information");
    if (informations == null || informations.getLength() == 0) {
        return;
    }
    Element information = (Element) informations.item(0);
    Element image = getFirstNode(information, "Image");
    Element user = getFirstNode(information, "User");
    Element environment = getFirstNode(information, "Environment");
    Element instrument = getFirstNode(information, "Instrument");
    Element document = getFirstNode(information, "Document");
    if (image != null) {
        String bitCount = getFirstNodeValue(image, "ComponentBitCount");
        if (bitCount != null) {
            core.get(0).bitsPerPixel = Integer.parseInt(bitCount);
        }
        acquiredDate = getFirstNodeValue(image, "AcquisitionDateAndTime");
        Element objectiveSettings = getFirstNode(image, "ObjectiveSettings");
        correctionCollar = getFirstNodeValue(objectiveSettings, "CorrectionCollar");
        medium = getFirstNodeValue(objectiveSettings, "Medium");
        refractiveIndex = getFirstNodeValue(objectiveSettings, "RefractiveIndex");
        String sizeV = getFirstNodeValue(image, "SizeV");
        if (sizeV != null && angles == 1) {
            angles = Integer.parseInt(sizeV);
        }
        Element dimensions = getFirstNode(image, "Dimensions");
        Element tNode = getFirstNode(dimensions, "T");
        if (tNode != null) {
            Element positions = getFirstNode(tNode, "Positions");
            if (positions != null) {
                Element interval = getFirstNode(positions, "Interval");
                if (interval != null) {
                    Element incrementNode = getFirstNode(interval, "Increment");
                    if (incrementNode != null) {
                        String increment = incrementNode.getTextContent();
                        timeIncrement = new Time(DataTools.parseDouble(increment), UNITS.SECOND);
                    }
                }
            }
        }
        Element sNode = getFirstNode(dimensions, "S");
        if (sNode != null) {
            NodeList scenes = sNode.getElementsByTagName("Scene");
            int nextPosition = 0;
            for (int i = 0; i < scenes.getLength(); i++) {
                Element scene = (Element) scenes.item(i);
                NodeList positions = scene.getElementsByTagName("Position");
                for (int p = 0; p < positions.getLength(); p++) {
                    Element position = (Element) positions.item(p);
                    String x = position.getAttribute("X");
                    String y = position.getAttribute("Y");
                    String z = position.getAttribute("Z");
                    if (nextPosition < positionsX.length && positionsX[nextPosition] == null) {
                        positionsX[nextPosition] = new Length(DataTools.parseDouble(x), UNITS.MICROM);
                        positionsY[nextPosition] = new Length(DataTools.parseDouble(y), UNITS.MICROM);
                        positionsZ[nextPosition] = new Length(DataTools.parseDouble(z), UNITS.MICROM);
                        nextPosition++;
                    }
                }
            }
        }
        NodeList channelNodes = getGrandchildren(dimensions, "Channel");
        if (channelNodes == null) {
            channelNodes = image.getElementsByTagName("Channel");
        }
        if (channelNodes != null) {
            for (int i = 0; i < channelNodes.getLength(); i++) {
                Element channel = (Element) channelNodes.item(i);
                while (channels.size() <= i) {
                    channels.add(new Channel());
                }
                channels.get(i).emission = getFirstNodeValue(channel, "EmissionWavelength");
                channels.get(i).excitation = getFirstNodeValue(channel, "ExcitationWavelength");
                channels.get(i).pinhole = getFirstNodeValue(channel, "PinholeSize");
                channels.get(i).name = channel.getAttribute("Name");
                String illumination = getFirstNodeValue(channel, "IlluminationType");
                if (illumination != null) {
                    channels.get(i).illumination = getIlluminationType(illumination);
                }
                String acquisition = getFirstNodeValue(channel, "AcquisitionMode");
                if (acquisition != null) {
                    channels.get(i).acquisitionMode = getAcquisitionMode(acquisition);
                }
                Element detectorSettings = getFirstNode(channel, "DetectorSettings");
                String binning = getFirstNodeValue(detectorSettings, "Binning");
                if (binning != null) {
                    binning = binning.replaceAll(",", "x");
                    binnings.add(binning);
                }
                Element scanInfo = getFirstNode(channel, "LaserScanInfo");
                if (scanInfo != null) {
                    zoom = getFirstNodeValue(scanInfo, "ZoomX");
                }
                Element detector = getFirstNode(detectorSettings, "Detector");
                if (detector != null) {
                    String detectorID = detector.getAttribute("Id");
                    if (detectorID.indexOf(' ') != -1) {
                        detectorID = detectorID.substring(detectorID.lastIndexOf(" ") + 1);
                    }
                    if (!detectorID.startsWith("Detector:")) {
                        detectorID = "Detector:" + detectorID;
                    }
                    detectorRefs.add(detectorID);
                }
                Element filterSet = getFirstNode(channel, "FilterSetRef");
                if (filterSet != null) {
                    channels.get(i).filterSetRef = filterSet.getAttribute("Id");
                }
            }
        }
    }
    if (user != null) {
        userDisplayName = getFirstNodeValue(user, "DisplayName");
        userFirstName = getFirstNodeValue(user, "FirstName");
        userLastName = getFirstNodeValue(user, "LastName");
        userMiddleName = getFirstNodeValue(user, "MiddleName");
        userEmail = getFirstNodeValue(user, "Email");
        userInstitution = getFirstNodeValue(user, "Institution");
        userName = getFirstNodeValue(user, "UserName");
    }
    if (environment != null) {
        temperature = getFirstNodeValue(environment, "Temperature");
        airPressure = getFirstNodeValue(environment, "AirPressure");
        humidity = getFirstNodeValue(environment, "Humidity");
        co2Percent = getFirstNodeValue(environment, "CO2Percent");
    }
    if (instrument != null) {
        NodeList microscopes = getGrandchildren(instrument, "Microscope");
        Element manufacturerNode = null;
        store.setInstrumentID(MetadataTools.createLSID("Instrument", 0), 0);
        if (microscopes != null) {
            Element microscope = (Element) microscopes.item(0);
            manufacturerNode = getFirstNode(microscope, "Manufacturer");
            store.setMicroscopeManufacturer(getFirstNodeValue(manufacturerNode, "Manufacturer"), 0);
            store.setMicroscopeModel(getFirstNodeValue(manufacturerNode, "Model"), 0);
            store.setMicroscopeSerialNumber(getFirstNodeValue(manufacturerNode, "SerialNumber"), 0);
            store.setMicroscopeLotNumber(getFirstNodeValue(manufacturerNode, "LotNumber"), 0);
            String microscopeType = getFirstNodeValue(microscope, "Type");
            if (microscopeType != null) {
                store.setMicroscopeType(getMicroscopeType(microscopeType), 0);
            }
        }
        NodeList lightSources = getGrandchildren(instrument, "LightSource");
        if (lightSources != null) {
            for (int i = 0; i < lightSources.getLength(); i++) {
                Element lightSource = (Element) lightSources.item(i);
                manufacturerNode = getFirstNode(lightSource, "Manufacturer");
                String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
                String model = getFirstNodeValue(manufacturerNode, "Model");
                String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
                String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
                String type = getFirstNodeValue(lightSource, "LightSourceType");
                String power = getFirstNodeValue(lightSource, "Power");
                if ("Laser".equals(type)) {
                    if (power != null) {
                        store.setLaserPower(new Power(new Double(power), UNITS.MILLIWATT), 0, i);
                    }
                    store.setLaserLotNumber(lotNumber, 0, i);
                    store.setLaserManufacturer(manufacturer, 0, i);
                    store.setLaserModel(model, 0, i);
                    store.setLaserSerialNumber(serialNumber, 0, i);
                } else if ("Arc".equals(type)) {
                    if (power != null) {
                        store.setArcPower(new Power(new Double(power), UNITS.MILLIWATT), 0, i);
                    }
                    store.setArcLotNumber(lotNumber, 0, i);
                    store.setArcManufacturer(manufacturer, 0, i);
                    store.setArcModel(model, 0, i);
                    store.setArcSerialNumber(serialNumber, 0, i);
                } else if ("LightEmittingDiode".equals(type)) {
                    if (power != null) {
                        store.setLightEmittingDiodePower(new Power(new Double(power), UNITS.MILLIWATT), 0, i);
                    }
                    store.setLightEmittingDiodeLotNumber(lotNumber, 0, i);
                    store.setLightEmittingDiodeManufacturer(manufacturer, 0, i);
                    store.setLightEmittingDiodeModel(model, 0, i);
                    store.setLightEmittingDiodeSerialNumber(serialNumber, 0, i);
                } else if ("Filament".equals(type)) {
                    if (power != null) {
                        store.setFilamentPower(new Power(new Double(power), UNITS.MILLIWATT), 0, i);
                    }
                    store.setFilamentLotNumber(lotNumber, 0, i);
                    store.setFilamentManufacturer(manufacturer, 0, i);
                    store.setFilamentModel(model, 0, i);
                    store.setFilamentSerialNumber(serialNumber, 0, i);
                }
            }
        }
        NodeList detectors = getGrandchildren(instrument, "Detector");
        if (detectors != null) {
            HashSet<String> uniqueDetectors = new HashSet<String>();
            for (int i = 0; i < detectors.getLength(); i++) {
                Element detector = (Element) detectors.item(i);
                manufacturerNode = getFirstNode(detector, "Manufacturer");
                String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
                String model = getFirstNodeValue(manufacturerNode, "Model");
                String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
                String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
                String detectorID = detector.getAttribute("Id");
                if (detectorID.indexOf(' ') != -1) {
                    detectorID = detectorID.substring(detectorID.lastIndexOf(" ") + 1);
                }
                if (!detectorID.startsWith("Detector:")) {
                    detectorID = "Detector:" + detectorID;
                }
                if (uniqueDetectors.contains(detectorID)) {
                    continue;
                }
                uniqueDetectors.add(detectorID);
                int detectorIndex = uniqueDetectors.size() - 1;
                store.setDetectorID(detectorID, 0, detectorIndex);
                store.setDetectorManufacturer(manufacturer, 0, detectorIndex);
                store.setDetectorModel(model, 0, detectorIndex);
                store.setDetectorSerialNumber(serialNumber, 0, detectorIndex);
                store.setDetectorLotNumber(lotNumber, 0, detectorIndex);
                if (gain == null || gain.equals("0")) {
                    gain = getFirstNodeValue(detector, "Gain");
                }
                if (detectorIndex == 0 || detectorIndex >= gains.size()) {
                    store.setDetectorGain(DataTools.parseDouble(gain), 0, detectorIndex);
                } else {
                    store.setDetectorGain(DataTools.parseDouble(gains.get(detectorIndex)), 0, detectorIndex);
                }
                String offset = getFirstNodeValue(detector, "Offset");
                if (offset != null && !offset.equals("")) {
                    store.setDetectorOffset(new Double(offset), 0, detectorIndex);
                }
                if (zoom == null) {
                    zoom = getFirstNodeValue(detector, "Zoom");
                }
                if (zoom != null && !zoom.equals("")) {
                    store.setDetectorZoom(new Double(zoom), 0, detectorIndex);
                }
                String ampGain = getFirstNodeValue(detector, "AmplificationGain");
                if (ampGain != null && !ampGain.equals("")) {
                    store.setDetectorAmplificationGain(new Double(ampGain), 0, detectorIndex);
                }
                String detectorType = getFirstNodeValue(detector, "Type");
                if (detectorType != null && !detectorType.equals("")) {
                    store.setDetectorType(getDetectorType(detectorType), 0, detectorIndex);
                }
            }
        }
        NodeList objectives = getGrandchildren(instrument, "Objective");
        parseObjectives(objectives);
        NodeList filterSets = getGrandchildren(instrument, "FilterSet");
        if (filterSets != null) {
            for (int i = 0; i < filterSets.getLength(); i++) {
                Element filterSet = (Element) filterSets.item(i);
                manufacturerNode = getFirstNode(filterSet, "Manufacturer");
                String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
                String model = getFirstNodeValue(manufacturerNode, "Model");
                String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
                String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
                String dichroicRef = getFirstNodeValue(filterSet, "DichroicRef");
                NodeList excitations = getGrandchildren(filterSet, "ExcitationFilters", "ExcitationFilterRef");
                NodeList emissions = getGrandchildren(filterSet, "EmissionFilters", "EmissionFilterRef");
                if (dichroicRef == null || dichroicRef.length() <= 0) {
                    Element ref = getFirstNode(filterSet, "DichroicRef");
                    if (ref != null) {
                        dichroicRef = ref.getAttribute("Id");
                    }
                }
                if (excitations == null) {
                    excitations = filterSet.getElementsByTagName("ExcitationFilterRef");
                }
                if (emissions == null) {
                    emissions = filterSet.getElementsByTagName("EmissionFilterRef");
                }
                if (dichroicRef != null || excitations != null || emissions != null) {
                    store.setFilterSetID(filterSet.getAttribute("Id"), 0, i);
                    store.setFilterSetManufacturer(manufacturer, 0, i);
                    store.setFilterSetModel(model, 0, i);
                    store.setFilterSetSerialNumber(serialNumber, 0, i);
                    store.setFilterSetLotNumber(lotNumber, 0, i);
                }
                if (dichroicRef != null && dichroicRef.length() > 0) {
                    store.setFilterSetDichroicRef(dichroicRef, 0, i);
                }
                if (excitations != null) {
                    for (int ex = 0; ex < excitations.getLength(); ex++) {
                        Element excitation = (Element) excitations.item(ex);
                        String ref = excitation.getTextContent();
                        if (ref == null || ref.length() <= 0) {
                            ref = excitation.getAttribute("Id");
                        }
                        if (ref != null && ref.length() > 0) {
                            store.setFilterSetExcitationFilterRef(ref, 0, i, ex);
                        }
                    }
                }
                if (emissions != null) {
                    for (int em = 0; em < emissions.getLength(); em++) {
                        Element emission = (Element) emissions.item(em);
                        String ref = emission.getTextContent();
                        if (ref == null || ref.length() <= 0) {
                            ref = emission.getAttribute("Id");
                        }
                        if (ref != null && ref.length() > 0) {
                            store.setFilterSetEmissionFilterRef(ref, 0, i, em);
                        }
                    }
                }
            }
        }
        NodeList filters = getGrandchildren(instrument, "Filter");
        if (filters != null) {
            for (int i = 0; i < filters.getLength(); i++) {
                Element filter = (Element) filters.item(i);
                manufacturerNode = getFirstNode(filter, "Manufacturer");
                String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
                String model = getFirstNodeValue(manufacturerNode, "Model");
                String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
                String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
                store.setFilterID(filter.getAttribute("Id"), 0, i);
                store.setFilterManufacturer(manufacturer, 0, i);
                store.setFilterModel(model, 0, i);
                store.setFilterSerialNumber(serialNumber, 0, i);
                store.setFilterLotNumber(lotNumber, 0, i);
                String filterType = getFirstNodeValue(filter, "Type");
                if (filterType != null) {
                    store.setFilterType(getFilterType(filterType), 0, i);
                }
                store.setFilterFilterWheel(getFirstNodeValue(filter, "FilterWheel"), 0, i);
                Element transmittance = getFirstNode(filter, "TransmittanceRange");
                String cutIn = getFirstNodeValue(transmittance, "CutIn");
                String cutOut = getFirstNodeValue(transmittance, "CutOut");
                Double inWave = cutIn == null ? 0 : new Double(cutIn);
                Double outWave = cutOut == null ? 0 : new Double(cutOut);
                Length in = FormatTools.getCutIn(inWave);
                Length out = FormatTools.getCutOut(outWave);
                if (in != null) {
                    store.setTransmittanceRangeCutIn(in, 0, i);
                }
                if (out != null) {
                    store.setTransmittanceRangeCutOut(out, 0, i);
                }
                String inTolerance = getFirstNodeValue(transmittance, "CutInTolerance");
                String outTolerance = getFirstNodeValue(transmittance, "CutOutTolerance");
                if (inTolerance != null) {
                    Double cutInTolerance = new Double(inTolerance);
                    store.setTransmittanceRangeCutInTolerance(new Length(cutInTolerance, UNITS.NANOMETER), 0, i);
                }
                if (outTolerance != null) {
                    Double cutOutTolerance = new Double(outTolerance);
                    store.setTransmittanceRangeCutOutTolerance(new Length(cutOutTolerance, UNITS.NANOMETER), 0, i);
                }
                String transmittancePercent = getFirstNodeValue(transmittance, "Transmittance");
                if (transmittancePercent != null) {
                    store.setTransmittanceRangeTransmittance(PercentFraction.valueOf(transmittancePercent), 0, i);
                }
            }
        }
        NodeList dichroics = getGrandchildren(instrument, "Dichroic");
        if (dichroics != null) {
            for (int i = 0; i < dichroics.getLength(); i++) {
                Element dichroic = (Element) dichroics.item(i);
                manufacturerNode = getFirstNode(dichroic, "Manufacturer");
                String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
                String model = getFirstNodeValue(manufacturerNode, "Model");
                String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
                String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
                store.setDichroicID(dichroic.getAttribute("Id"), 0, i);
                store.setDichroicManufacturer(manufacturer, 0, i);
                store.setDichroicModel(model, 0, i);
                store.setDichroicSerialNumber(serialNumber, 0, i);
                store.setDichroicLotNumber(lotNumber, 0, i);
            }
        }
    }
    if (document != null) {
        description = getFirstNodeValue(document, "Description");
        if (userName == null) {
            userName = getFirstNodeValue(document, "UserName");
        }
        imageName = getFirstNodeValue(document, "Name");
    }
}

Example 33 with Length

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

the class ZeissCZIReader method translateExperiment.

private void translateExperiment(Element root) throws FormatException {
    NodeList experiments = root.getElementsByTagName("Experiment");
    if (experiments == null || experiments.getLength() == 0) {
        return;
    }
    Element experimentBlock = getFirstNode((Element) experiments.item(0), "ExperimentBlocks");
    Element acquisition = getFirstNode(experimentBlock, "AcquisitionBlock");
    Element tilesSetup = getFirstNode(acquisition, "TilesSetup");
    NodeList groups = getGrandchildren(tilesSetup, "PositionGroup");
    positionsX = new Length[core.size()];
    positionsY = new Length[core.size()];
    positionsZ = new Length[core.size()];
    if (groups != null) {
        for (int i = 0; i < groups.getLength(); i++) {
            Element group = (Element) groups.item(i);
            Element position = getFirstNode(group, "Position");
            String tilesXValue = getFirstNodeValue(group, "TilesX");
            String tilesYValue = getFirstNodeValue(group, "TilesY");
            if (position != null && tilesXValue != null && !tilesXValue.isEmpty() && tilesYValue != null && !tilesYValue.isEmpty()) {
                Integer tilesX = DataTools.parseInteger(tilesXValue);
                Integer tilesY = DataTools.parseInteger(tilesYValue);
                String x = position.getAttribute("X");
                String y = position.getAttribute("Y");
                String z = position.getAttribute("Z");
                Length xPos = null;
                try {
                    xPos = new Length(Double.valueOf(x), UNITS.METRE);
                } catch (NumberFormatException e) {
                }
                Length yPos = null;
                try {
                    yPos = new Length(Double.valueOf(y), UNITS.METRE);
                } catch (NumberFormatException e) {
                }
                Length zPos = null;
                try {
                    zPos = new Length(Double.valueOf(z), UNITS.METRE);
                } catch (NumberFormatException e) {
                }
                int numTiles = (tilesX == null || tilesY == null) ? 0 : tilesX * tilesY;
                for (int tile = 0; tile < numTiles; tile++) {
                    int index = i * tilesX * tilesY + tile;
                    if (groups.getLength() == core.size()) {
                        index = i;
                    }
                    if (index < positionsX.length) {
                        positionsX[index] = xPos;
                        positionsY[index] = yPos;
                        positionsZ[index] = zPos;
                    }
                }
            }
        }
    } else {
        Element regionsSetup = getFirstNode(acquisition, "RegionsSetup");
        if (regionsSetup != null) {
            Element sampleHolder = getFirstNode(regionsSetup, "SampleHolder");
            if (sampleHolder != null) {
                NodeList regions = getGrandchildren(sampleHolder, "SingleTileRegionArray", "SingleTileRegion");
                if (regions != null) {
                    for (int i = 0; i < regions.getLength(); i++) {
                        Element region = (Element) regions.item(i);
                        String x = getFirstNode(region, "X").getTextContent();
                        String y = getFirstNode(region, "Y").getTextContent();
                        String z = getFirstNode(region, "Z").getTextContent();
                        // safe to assume all 3 arrays have the same length
                        if (i < positionsX.length) {
                            if (x == null) {
                                positionsX[i] = null;
                            } else {
                                final Double number = Double.valueOf(x);
                                positionsX[i] = new Length(number, UNITS.MICROMETER);
                            }
                            if (y == null) {
                                positionsY[i] = null;
                            } else {
                                final Double number = Double.valueOf(y);
                                positionsY[i] = new Length(number, UNITS.MICROMETER);
                            }
                            if (z == null) {
                                positionsZ[i] = null;
                            } else {
                                final Double number = Double.valueOf(z);
                                positionsZ[i] = new Length(number, UNITS.MICROMETER);
                            }
                        }
                    }
                }
            }
        }
    }
    NodeList detectors = getGrandchildren(acquisition, "Detector");
    Element setup = getFirstNode(acquisition, "AcquisitionModeSetup");
    String cameraModel = getFirstNodeValue(setup, "SelectedCamera");
    if (detectors != null) {
        for (int i = 0; i < detectors.getLength(); i++) {
            Element detector = (Element) detectors.item(i);
            String id = MetadataTools.createLSID("Detector", 0, i);
            store.setDetectorID(id, 0, i);
            String model = detector.getAttribute("Id");
            store.setDetectorModel(model, 0, i);
            String bin = getFirstNodeValue(detector, "Binning");
            if (bin != null) {
                bin = bin.replaceAll(",", "x");
                Binning binning = getBinning(bin);
                if (model != null && model.equals(cameraModel)) {
                    for (int image = 0; image < getSeriesCount(); image++) {
                        for (int c = 0; c < getEffectiveSizeC(); c++) {
                            store.setDetectorSettingsID(id, image, c);
                            store.setDetectorSettingsBinning(binning, image, c);
                        }
                    }
                    hasDetectorSettings = true;
                }
            }
        }
    }
    Element multiTrack = getFirstNode(acquisition, "MultiTrackSetup");
    if (multiTrack == null) {
        return;
    }
    NodeList detectorGroups = multiTrack.getElementsByTagName("Detectors");
    for (int d = 0; d < detectorGroups.getLength(); d++) {
        Element detectorGroup = (Element) detectorGroups.item(d);
        detectors = detectorGroup.getElementsByTagName("Detector");
        if (detectors != null && detectors.getLength() > 0) {
            for (int i = 0; i < detectors.getLength(); i++) {
                Element detector = (Element) detectors.item(i);
                String voltage = getFirstNodeValue(detector, "Voltage");
                if (i == 0 && d == 0) {
                    gain = voltage;
                }
                gains.add(voltage);
            }
        }
    }
    NodeList tracks = multiTrack.getElementsByTagName("Track");
    if (tracks != null && tracks.getLength() > 0) {
        for (int i = 0; i < tracks.getLength(); i++) {
            Element track = (Element) tracks.item(i);
            Element channel = getFirstNode(track, "Channel");
            String exposure = getFirstNodeValue(channel, "ExposureTime");
            String gain = getFirstNodeValue(channel, "EMGain");
            while (channels.size() <= i) {
                channels.add(new Channel());
            }
            try {
                if (exposure != null) {
                    channels.get(i).exposure = new Double(exposure);
                }
            } catch (NumberFormatException e) {
                LOGGER.debug("Could not parse exposure time", e);
            }
            try {
                if (gain != null) {
                    channels.get(i).gain = new Double(gain);
                }
            } catch (NumberFormatException e) {
                LOGGER.debug("Could not parse gain", e);
            }
        }
    }
}

Example 34 with Length

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

the class ZeissCZIReader method translateHardwareSettings.

private void translateHardwareSettings(Element root) throws FormatException {
    NodeList hardwareSettings = root.getElementsByTagName("HardwareSetting");
    if (hardwareSettings == null || hardwareSettings.getLength() == 0) {
        return;
    }
    Element hardware = (Element) hardwareSettings.item(0);
    store.setInstrumentID(MetadataTools.createLSID("Instrument", 0), 0);
    Element microscope = getFirstNode(hardware, "Microscope");
    if (microscope != null) {
        String model = microscope.getAttribute("Name");
        store.setMicroscopeModel(model, 0);
    }
    Element objectiveChanger = getFirstNode(hardware, "ObjectiveChanger");
    if (objectiveChanger != null) {
        String position = getFirstNodeValue(objectiveChanger, "Position");
        int positionIndex = -1;
        if (position != null) {
            try {
                positionIndex = Integer.parseInt(position) - 1;
            } catch (NumberFormatException e) {
                LOGGER.debug("Could not parse ObjectiveSettings", e);
            }
        }
        NodeList objectives = objectiveChanger.getElementsByTagName("Objective");
        if (objectives != null) {
            for (int i = 0; i < objectives.getLength(); i++) {
                Element objective = (Element) objectives.item(i);
                String objectiveID = MetadataTools.createLSID("Objective", 0, i);
                if (i == positionIndex || (objectives.getLength() == 1 && objectiveSettingsID != null)) {
                    objectiveSettingsID = objectiveID;
                }
                store.setObjectiveID(objectiveID, 0, i);
                store.setObjectiveModel(objective.getAttribute("Model"), 0, i);
                store.setObjectiveSerialNumber(objective.getAttribute("UniqueName"), 0, i);
                String immersion = getFirstNodeValue(objective, "Immersions");
                store.setObjectiveImmersion(getImmersion(immersion), 0, i);
                store.setObjectiveCorrection(getCorrection("Other"), 0, i);
                String magnification = getFirstNodeValue(objective, "Magnification");
                String na = getFirstNodeValue(objective, "NumericalAperture");
                String wd = getFirstNodeValue(objective, "WorkingDistance");
                if (magnification != null) {
                    try {
                        store.setObjectiveNominalMagnification(new Double(magnification), 0, i);
                    } catch (NumberFormatException e) {
                        LOGGER.debug("Could not parse magnification", e);
                    }
                }
                if (na != null) {
                    try {
                        store.setObjectiveLensNA(new Double(na), 0, i);
                    } catch (NumberFormatException e) {
                        LOGGER.debug("Could not parse numerical aperture", e);
                    }
                }
                if (wd != null) {
                    try {
                        store.setObjectiveWorkingDistance(new Length(new Double(wd), UNITS.MICROMETER), 0, i);
                    } catch (NumberFormatException e) {
                        LOGGER.debug("Could not parse working distance", e);
                    }
                }
            }
        }
    }
}

Example 35 with Length

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

the class ZeissCZIReader method parseObjectives.

private void parseObjectives(NodeList objectives) throws FormatException {
    if (objectives != null) {
        for (int i = 0; i < objectives.getLength(); i++) {
            Element objective = (Element) objectives.item(i);
            Element manufacturerNode = getFirstNode(objective, "Manufacturer");
            String manufacturer = getFirstNodeValue(manufacturerNode, "Manufacturer");
            String model = getFirstNodeValue(manufacturerNode, "Model");
            String serialNumber = getFirstNodeValue(manufacturerNode, "SerialNumber");
            String lotNumber = getFirstNodeValue(manufacturerNode, "LotNumber");
            if (objectiveSettingsID == null) {
                objectiveSettingsID = objective.getAttribute("Id");
            }
            store.setObjectiveID(objective.getAttribute("Id"), 0, i);
            store.setObjectiveManufacturer(manufacturer, 0, i);
            store.setObjectiveModel(model, 0, i);
            store.setObjectiveSerialNumber(serialNumber, 0, i);
            store.setObjectiveLotNumber(lotNumber, 0, i);
            String correction = getFirstNodeValue(objective, "Correction");
            if (correction != null) {
                store.setObjectiveCorrection(getCorrection(correction), 0, i);
            }
            store.setObjectiveImmersion(getImmersion(getFirstNodeValue(objective, "Immersion")), 0, i);
            String lensNA = getFirstNodeValue(objective, "LensNA");
            if (lensNA != null) {
                store.setObjectiveLensNA(new Double(lensNA), 0, i);
            }
            String magnification = getFirstNodeValue(objective, "NominalMagnification");
            if (magnification == null) {
                magnification = getFirstNodeValue(objective, "Magnification");
            }
            Double mag = magnification == null ? null : new Double(magnification);
            if (mag != null) {
                store.setObjectiveNominalMagnification(mag, 0, i);
            }
            String calibratedMag = getFirstNodeValue(objective, "CalibratedMagnification");
            if (calibratedMag != null) {
                store.setObjectiveCalibratedMagnification(new Double(calibratedMag), 0, i);
            }
            String wd = getFirstNodeValue(objective, "WorkingDistance");
            if (wd != null) {
                store.setObjectiveWorkingDistance(new Length(new Double(wd), UNITS.MICROMETER), 0, i);
            }
            String iris = getFirstNodeValue(objective, "Iris");
            if (iris != null) {
                store.setObjectiveIris(new Boolean(iris), 0, i);
            }
        }
    }
}