use of loci.common.Location in project bioformats by openmicroscopy.
the class MIASReader method initFile.
// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
if (checkSuffix(id, "txt")) {
// first need to find a relevant TIFF file
Location base = new Location(id).getAbsoluteFile();
Location plate = null;
if (base.getParentFile().getName().equals("Batchresults")) {
Location experiment = base.getParentFile().getParentFile();
String[] plates = experiment.list(true);
Arrays.sort(plates);
plate = new Location(experiment, plates[0]);
} else {
plate = base.getParentFile();
if (plate.getName().equals("results"))
plate = plate.getParentFile();
}
String[] list = plate.list(true);
for (String f : list) {
if (f.startsWith("Well")) {
Location well = new Location(plate, f);
String[] wellList = well.list(true);
for (String file : wellList) {
String path = new Location(well, file).getAbsolutePath();
if (isThisType(path) && checkSuffix(path, new String[] { "tif", "tiff" })) {
initFile(path);
return;
}
}
}
}
throw new FormatException("Could not locate an appropriate TIFF file.");
}
if (!isGroupFiles()) {
tiffs = new String[][] { { id } };
readers = new MinimalTiffReader[1][1];
readers[0][0] = new MinimalTiffReader();
TiffReader r = new TiffReader();
r.setMetadataStore(getMetadataStore());
r.setId(tiffs[0][0]);
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();
tileRows = 1;
tileCols = 1;
return;
}
analysisFiles = new ArrayList<AnalysisFile>();
// MIAS is a high content screening format which supports multiple plates,
// wells and fields.
// Most of the metadata comes from the directory hierarchy, as very little
// metadata is present in the actual files.
//
// The directory hierarchy is either:
//
// <experiment name> top level experiment directory
// Batchresults analysis results for experiment
// <plate number>_<plate barcode> one directory for each plate
// results analysis results for plate
// Well<xxxx> one directory for each well
// mode<x>_z<xxx>_t<xxx>_im<x>_<x>.tif
//
// or:
//
// <experiment name> top level experiment directory
// <plate number> plate directory (3 digits)
// <well number> well directory (4 digits)
// <channel number> channel directory (1 digit)
// <tile row>_<tile col>_<Z>_<T>.tif
//
// Each TIFF file contains a single grayscale plane. The "mode" block
// refers to the channel number; the "z" and "t" blocks refer to the
// Z section and timepoint, respectively. The "im<x>_<x>" block gives
// the row and column coordinates of the image within a mosaic.
//
// We are initially given one of these TIFF files; from there, we need
// to find the top level experiment directory and work our way down to
// determine how many plates and wells are present.
LOGGER.info("Building list of TIFF files");
Location baseFile = new Location(id).getAbsoluteFile();
Location plate = baseFile.getParentFile().getParentFile();
String plateName = plate.getName();
if (!(plateName.length() == 3 || (plateName.length() > 3 && plateName.replaceAll("\\d", "").startsWith("-")))) {
plate = plate.getParentFile();
plateName = plate.getName();
}
int plateNumber = Integer.parseInt(plateName.substring(0, 3));
Location experiment = plate.getParentFile();
String[] directories = experiment.list(true);
Arrays.sort(directories);
for (String dir : directories) {
Location f = new Location(experiment, dir);
if (dir.equals("Batchresults")) {
String[] results = f.list(true);
for (String result : results) {
Location file = new Location(f, result);
if (result.startsWith("NEO_Results")) {
resultFile = file.getAbsolutePath();
AnalysisFile af = new AnalysisFile();
af.filename = resultFile;
analysisFiles.add(af);
} else if (result.startsWith("NEO_PlateOutput_")) {
int plateIndex = Integer.parseInt(result.substring(16, 19));
if (plateIndex == plateNumber) {
AnalysisFile af = new AnalysisFile();
af.filename = file.getAbsolutePath();
af.plate = 0;
analysisFiles.add(af);
}
}
}
}
}
String[] list = plate.list(true);
Arrays.sort(list);
final List<String> wellDirectories = new ArrayList<String>();
for (String dir : list) {
Location f = new Location(plate, dir);
if (f.getName().startsWith("Well") || f.getName().length() == 4) {
// directory name is valid, but we need to make sure that the
// directory contains a TIFF or a subdirectory
String[] wellList = f.list(true);
if (wellList != null) {
boolean validWell = false;
for (String potentialTIFF : wellList) {
if (potentialTIFF.toLowerCase().endsWith(".tif") || new Location(f, potentialTIFF).isDirectory()) {
validWell = true;
break;
}
}
if (validWell)
wellDirectories.add(f.getAbsolutePath());
}
} else if (f.getName().equals("results")) {
String[] resultsList = f.list(true);
for (String result : resultsList) {
// exclude proprietary program state files
if (!result.endsWith(".sav") && !result.endsWith(".dsv") && !result.endsWith(".dat")) {
Location r = new Location(f, result);
AnalysisFile af = new AnalysisFile();
af.filename = r.getAbsolutePath();
af.plate = 0;
if (result.toLowerCase().startsWith("well")) {
af.well = Integer.parseInt(result.substring(4, 8)) - 1;
}
analysisFiles.add(af);
}
}
} else if (f.getName().equals("Nugenesistemplate.txt")) {
templateFile = f.getAbsolutePath();
}
}
int nWells = wellDirectories.size();
LOGGER.debug("Found {} wells.", nWells);
readers = new MinimalTiffReader[nWells][];
tiffs = new String[nWells][];
int[] zCount = new int[nWells];
int[] cCount = new int[nWells];
int[] tCount = new int[nWells];
String[] order = new String[nWells];
wellNumber = new int[nWells];
String[] wells = wellDirectories.toArray(new String[nWells]);
Arrays.sort(wells);
for (int j = 0; j < nWells; j++) {
Location well = new Location(wells[j]);
String wellName = well.getName().replaceAll("Well", "");
wellNumber[j] = Integer.parseInt(wellName) - 1;
String[] tiffFiles = well.list(true);
final List<String> tmpFiles = new ArrayList<String>();
for (String tiff : tiffFiles) {
String name = tiff.toLowerCase();
if (name.endsWith(".tif") || name.endsWith(".tiff")) {
tmpFiles.add(new Location(well, tiff).getAbsolutePath());
}
}
if (tmpFiles.size() == 0) {
LOGGER.debug("No TIFFs in well directory {}", wells[j]);
// directories which contain the TIFFs
for (String dir : tiffFiles) {
Location file = new Location(well, dir);
if (dir.length() == 1 && file.isDirectory()) {
cCount[j]++;
String[] tiffs = file.list(true);
for (String tiff : tiffs) {
String name = tiff.toLowerCase();
if (name.endsWith(".tif") || name.endsWith(".tiff")) {
tmpFiles.add(new Location(file, tiff).getAbsolutePath());
}
}
}
}
}
tiffFiles = tmpFiles.toArray(new String[0]);
if (ArrayUtils.isEmpty(tiffFiles)) {
throw new FormatException("Empty dataset - No tiff files were found.");
}
Location firstTiff = new Location(tiffFiles[0]);
List<String> names = new ArrayList<String>();
for (Location f : firstTiff.getParentFile().listFiles()) {
names.add(f.getName());
}
FilePattern fp = new FilePattern(FilePattern.findPattern(firstTiff.getName(), null, names.toArray(new String[names.size()])));
String[] blocks = fp.getPrefixes();
order[j] = "XY";
int[] count = fp.getCount();
for (int block = blocks.length - 1; block >= 0; block--) {
blocks[block] = blocks[block].toLowerCase();
blocks[block] = blocks[block].substring(blocks[block].lastIndexOf("_") + 1);
if (blocks[block].equals("z")) {
zCount[j] = count[block];
order[j] += 'Z';
} else if (blocks[block].equals("t")) {
tCount[j] = count[block];
order[j] += 'T';
} else if (blocks[block].equals("mode")) {
cCount[j] = count[block];
order[j] += 'C';
} else if (blocks[block].equals("im"))
tileRows = count[block];
else if (blocks[block].equals(""))
tileCols = count[block];
else if (blocks[block].replaceAll("\\d", "").length() == 0) {
if (block == 3)
tileRows = count[block];
else if (block == 2)
tileCols = count[block];
else if (block == 0) {
zCount[j] = count[block];
order[j] += 'Z';
} else if (block == 1) {
tCount[j] = count[block];
order[j] += 'T';
}
} else {
throw new FormatException("Unsupported block '" + blocks[block]);
}
}
Arrays.sort(tiffFiles);
tiffs[j] = tiffFiles;
LOGGER.debug("Well {} has {} files.", j, tiffFiles.length);
readers[j] = new MinimalTiffReader[tiffFiles.length];
for (int k = 0; k < tiffFiles.length; k++) {
readers[j][k] = new MinimalTiffReader();
}
}
// Populate core metadata
LOGGER.info("Populating core metadata");
int nSeries = tiffs.length;
bpp = new int[nSeries];
if (readers.length == 0) {
throw new FormatException("No wells were found.");
}
// assume that all wells have the same width, height, and pixel type
readers[0][0].setId(tiffs[0][0]);
tileWidth = readers[0][0].getSizeX();
tileHeight = readers[0][0].getSizeY();
if (tileCols == 0)
tileCols = 1;
if (tileRows == 0)
tileRows = 1;
core.clear();
for (int i = 0; i < nSeries; i++) {
CoreMetadata ms = new CoreMetadata();
core.add(ms);
ms.sizeZ = zCount[i];
ms.sizeC = cCount[i];
ms.sizeT = tCount[i];
if (ms.sizeZ == 0)
ms.sizeZ = 1;
if (ms.sizeC == 0)
ms.sizeC = 1;
if (ms.sizeT == 0)
ms.sizeT = 1;
ms.sizeX = tileWidth * tileCols;
ms.sizeY = tileHeight * tileRows;
ms.pixelType = readers[0][0].getPixelType();
ms.sizeC *= readers[0][0].getSizeC();
ms.rgb = readers[0][0].isRGB();
ms.littleEndian = readers[0][0].isLittleEndian();
ms.interleaved = readers[0][0].isInterleaved();
ms.indexed = readers[0][0].isIndexed();
ms.falseColor = readers[0][0].isFalseColor();
ms.dimensionOrder = order[i];
if (ms.dimensionOrder.indexOf('Z') == -1) {
ms.dimensionOrder += 'Z';
}
if (ms.dimensionOrder.indexOf('C') == -1) {
ms.dimensionOrder += 'C';
}
if (ms.dimensionOrder.indexOf('T') == -1) {
ms.dimensionOrder += 'T';
}
ms.imageCount = ms.sizeZ * ms.sizeT * cCount[i];
if (ms.imageCount == 0) {
ms.imageCount = 1;
}
bpp[i] = FormatTools.getBytesPerPixel(ms.pixelType);
}
// Populate metadata hashtable
LOGGER.info("Populating metadata hashtable");
if (resultFile != null && getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
String[] cols = null;
final List<String> rows = new ArrayList<String>();
boolean doKeyValue = true;
int nStarLines = 0;
String analysisResults = DataTools.readFile(resultFile);
String[] lines = analysisResults.split("\n");
for (String line : lines) {
line = line.trim();
if (line.length() == 0)
continue;
if (line.startsWith("******") && line.endsWith("******"))
nStarLines++;
if (doKeyValue) {
String[] n = line.split("\t");
if (n[0].endsWith(":"))
n[0] = n[0].substring(0, n[0].length() - 1);
if (n.length >= 2)
addGlobalMeta(n[0], n[1]);
} else {
if (cols == null)
cols = line.split("\t");
else
rows.add(line);
}
if (nStarLines == 2)
doKeyValue = false;
}
for (String row : rows) {
String[] d = row.split("\t");
for (int col = 3; col < cols.length; col++) {
addGlobalMeta("Plate " + d[0] + ", Well " + d[2] + " " + cols[col], d[col]);
if (cols[col].equals("AreaCode")) {
String wellID = d[col].replaceAll("\\D", "");
wellColumns = Integer.parseInt(wellID);
}
}
}
}
// Populate MetadataStore
LOGGER.info("Populating MetadataStore");
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this, true);
// assume that a 96 well plate is 8x12, and a 384 well plate is 16x24
if (wellColumns == 0) {
if (nWells == 96) {
wellColumns = 12;
} else if (nWells == 384) {
wellColumns = 24;
} else {
LOGGER.warn("Could not determine the plate dimensions.");
wellColumns = 24;
}
}
store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
String plateAcqId = MetadataTools.createLSID("PlateAcquisition", 0, 0);
store.setPlateAcquisitionID(plateAcqId, 0, 0);
store.setPlateAcquisitionMaximumFieldCount(new PositiveInteger(1), 0, 0);
for (int well = 0; well < nWells; well++) {
int wellIndex = wellNumber[well];
int row = wellIndex / wellColumns;
int wellCol = (wellIndex % wellColumns) + 1;
char wellRow = (char) ('A' + row);
store.setWellID(MetadataTools.createLSID("Well", 0, well), 0, well);
store.setWellRow(new NonNegativeInteger(row), 0, well);
store.setWellColumn(new NonNegativeInteger(wellCol - 1), 0, well);
String imageID = MetadataTools.createLSID("Image", well);
String wellSampleID = MetadataTools.createLSID("WellSample", 0, well, 0);
store.setWellSampleID(wellSampleID, 0, well, 0);
store.setWellSampleIndex(new NonNegativeInteger(well), 0, well, 0);
store.setImageID(imageID, well);
store.setImageName("Well " + wellRow + wellCol, well);
store.setWellSampleImageRef(imageID, 0, well, 0);
store.setPlateAcquisitionWellSampleRef(wellSampleID, 0, 0, well);
}
MetadataLevel level = getMetadataOptions().getMetadataLevel();
if (level != MetadataLevel.MINIMUM) {
String experimentID = MetadataTools.createLSID("Experiment", 0);
store.setExperimentID(experimentID, 0);
store.setExperimentType(getExperimentType("Other"), 0);
store.setExperimentDescription(experiment.getName(), 0);
// populate SPW metadata
store.setPlateColumnNamingConvention(getNamingConvention("Number"), 0);
store.setPlateRowNamingConvention(getNamingConvention("Letter"), 0);
parseTemplateFile(store);
plateName = plateName.substring(plateName.indexOf('-') + 1);
store.setPlateName(plateName, 0);
store.setPlateExternalIdentifier(plateName, 0);
for (int well = 0; well < nWells; well++) {
// populate Image/Pixels metadata
store.setImageExperimentRef(experimentID, well);
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
store.setImageInstrumentRef(instrumentID, well);
}
roiFiles = new ArrayList<AnalysisFile>();
for (AnalysisFile af : analysisFiles) {
String file = af.filename;
String name = new Location(file).getName();
if (!name.startsWith("Well"))
continue;
if (name.endsWith("AllModesOverlay.tif")) {
roiFiles.add(af);
} else if (name.endsWith("overlay.tif")) {
roiFiles.add(af);
}
}
if (level != MetadataLevel.NO_OVERLAYS) {
// populate image-level ROIs
Color[] colors = new Color[getSizeC()];
int nextROI = 0;
for (AnalysisFile af : analysisFiles) {
String file = af.filename;
String name = new Location(file).getName();
if (!name.startsWith("Well"))
continue;
int[] position = getPositionFromFile(file);
int well = position[0];
if (name.endsWith("detail.txt")) {
String data = DataTools.readFile(file);
String[] lines = data.split("\n");
int start = 0;
while (start < lines.length && !lines[start].startsWith("Label")) {
start++;
}
if (start >= lines.length)
continue;
String[] columns = lines[start].split("\t");
List<String> columnNames = Arrays.asList(columns);
for (int j = start + 1; j < lines.length; j++) {
populateROI(columnNames, lines[j].split("\t"), well, nextROI++, position[1], position[2], store);
}
} else if (name.endsWith("AllModesOverlay.tif")) {
// results/Well<nnnn>_mode<n>_z<nnn>_t<nnn>_AllModesOverlay.tif
if (colors[position[3]] != null)
continue;
try {
colors[position[3]] = getChannelColorFromFile(file);
} catch (IOException e) {
}
if (colors[position[3]] == null)
continue;
for (int s = 0; s < getSeriesCount(); s++) {
store.setChannelColor(colors[position[3]], s, position[3]);
}
if (position[3] == 0) {
nextROI += parseMasks(store, well, nextROI, file);
}
} else if (name.endsWith("overlay.tif")) {
nextROI += parseMasks(store, well, nextROI, file);
}
}
}
}
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class FlexReader method findFiles.
private String[] findFiles(Location baseFile, String[] suffixes) throws IOException {
// we're assuming that the directory structure looks something like this:
//
// top level directory
// / \
// top level flex dir top level measurement dir
// / | \ / | \
// plate #0 ... plate #n plate #0 ... plate #n
// / | \ / \
// .flex ... .flex .mea .res
//
// or like this:
//
// top level directory
// / | \ / | \
// Flex plate #0 ... #n #0 ... Measurement plate #n
//
// or that the .mea and .res are in the same directory as the .flex files
LOGGER.debug("findFiles({})", baseFile.getAbsolutePath());
LOGGER.info("Looking for files that are in the same dataset as " + baseFile.getAbsolutePath());
final List<String> fileList = new ArrayList<String>();
Location plateDir = baseFile.getParentFile();
String[] files = plateDir.list(true);
// check if the measurement files are in the same directory
LOGGER.debug("Looking for files in {}", plateDir.getAbsolutePath());
for (String file : files) {
String lfile = file.toLowerCase();
String path = new Location(plateDir, file).getAbsolutePath();
if (checkSuffix(file, suffixes)) {
fileList.add(path);
LOGGER.debug("Found file {}", path);
}
}
// file list is valid (i.e. can be returned) if there is at least
// one file with each of the desired suffixes
LOGGER.debug("Checking to see if at least one file with each suffix was found...");
boolean validList = true;
for (String suffix : suffixes) {
boolean foundSuffix = false;
for (String file : fileList) {
if (checkSuffix(file, suffix)) {
foundSuffix = true;
break;
}
}
if (!foundSuffix) {
validList = false;
break;
}
}
LOGGER.debug("{} required files.", validList ? "Found" : "Did not find");
if (validList) {
LOGGER.debug("Returning file list:");
for (String file : fileList) {
LOGGER.debug(" {}", file);
if (checkSuffix(file, MEASUREMENT_SUFFIXES) && !measurementFiles.contains(file)) {
measurementFiles.add(file);
}
}
return fileList.toArray(new String[fileList.size()]);
}
Location flexDir = null;
try {
flexDir = plateDir.getParentFile();
} catch (NullPointerException e) {
}
LOGGER.debug("Looking for files in {}", flexDir);
if (flexDir == null)
return null;
// check if the measurement directory and the Flex directory
// have the same parent
Location measurementDir = null;
String[] flexDirList = flexDir.list(true);
if (flexDirList.length > 1) {
String plateName = plateDir.getName();
for (String file : flexDirList) {
if (!file.equals(plateName) && (plateName.startsWith(file) || file.startsWith(plateName))) {
measurementDir = new Location(flexDir, file);
LOGGER.debug("Expect measurement files to be in {}", measurementDir.getAbsolutePath());
break;
}
}
}
if (measurementDir == null) {
Location topDir = flexDir.getParentFile();
LOGGER.debug("First attempt at finding measurement file directory " + "failed. Looking for an appropriate measurement directory in {}.", topDir.getAbsolutePath());
String[] topDirList = topDir.list(true);
for (String file : topDirList) {
if (!flexDir.getAbsolutePath().endsWith(file)) {
measurementDir = new Location(topDir, file);
LOGGER.debug("Expect measurement files to be in {}", measurementDir.getAbsolutePath());
break;
}
}
if (measurementDir == null) {
LOGGER.debug("Failed to find measurement file directory.");
return null;
}
} else
plateDir = measurementDir;
if (!plateDir.getAbsolutePath().equals(measurementDir.getAbsolutePath())) {
LOGGER.debug("Measurement files are in a subdirectory of {}", measurementDir.getAbsolutePath());
String[] measurementPlates = measurementDir.list(true);
String plate = plateDir.getName();
LOGGER.debug("Determining which subdirectory contains the measurements " + "for plate {}", plate);
plateDir = null;
if (measurementPlates != null) {
for (String file : measurementPlates) {
LOGGER.debug("Checking {}", file);
if (file.indexOf(plate) != -1 || plate.indexOf(file) != -1) {
plateDir = new Location(measurementDir, file);
LOGGER.debug("Measurement files are in {}", plateDir.getAbsolutePath());
break;
}
}
}
}
if (plateDir == null) {
LOGGER.debug("Could not find appropriate subdirectory.");
return null;
}
files = plateDir.list(true);
for (String file : files) {
fileList.add(new Location(plateDir, file).getAbsolutePath());
}
LOGGER.debug("Returning file list:");
for (String file : fileList) {
LOGGER.debug(" {}", file);
if (checkSuffix(file, MEASUREMENT_SUFFIXES) && !measurementFiles.contains(file)) {
measurementFiles.add(file);
}
}
return fileList.toArray(new String[fileList.size()]);
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class FlexReader method initFlexFile.
private void initFlexFile(String id) throws FormatException, IOException {
LOGGER.debug("initFlexFile({})", id);
boolean doGrouping = true;
Location currentFile = new Location(id).getAbsoluteFile();
LOGGER.info("Storing well indices");
try {
String name = currentFile.getName();
int[] well = getWell(name);
if (well[0] > nRows)
nRows = well[0];
if (well[1] > nCols)
nCols = well[1];
} catch (NumberFormatException e) {
LOGGER.debug("Could not parse well indices", e);
doGrouping = false;
}
LOGGER.info("Looking for other .flex files");
if (!isGroupFiles())
doGrouping = false;
if (isGroupFiles()) {
LOGGER.debug("Attempting to find files in the same dataset.");
try {
findFiles(currentFile);
} catch (NullPointerException e) {
LOGGER.debug("", e);
} catch (IOException e) {
LOGGER.debug("", e);
}
if (measurementFiles.isEmpty()) {
LOGGER.warn("Measurement files not found.");
} else {
for (String f : measurementFiles) {
if (checkSuffix(f, RES_SUFFIX)) {
parseResFile(f);
}
}
}
}
MetadataStore store = makeFilterMetadata();
LOGGER.info("Making sure that all .flex files are valid");
final List<String> flex = new ArrayList<String>();
if (doGrouping) {
// group together .flex files that are in the same directory
Location dir = currentFile.getParentFile();
String[] files = dir.list(true);
for (String file : files) {
// file names should be nnnnnnnnn.flex, where 'n' is 0-9
LOGGER.debug("Checking if {} belongs in the same dataset.", file);
if (file.endsWith(".flex") && file.length() == 14) {
flex.add(new Location(dir, file).getAbsolutePath());
LOGGER.debug("Added {} to dataset.", flex.get(flex.size() - 1));
}
}
}
String[] files = doGrouping ? flex.toArray(new String[flex.size()]) : new String[] { currentFile.getAbsolutePath() };
if (files.length == 0) {
if (Location.getMappedFile(currentFile.getName()) != null) {
files = new String[] { currentFile.getName() };
} else {
files = new String[] { currentFile.getAbsolutePath() };
}
}
LOGGER.debug("Determined that {} .flex files belong together.", files.length);
groupFiles(files, store);
populateMetadataStore(store);
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class FlexReader method populateMetadataStore.
private void populateMetadataStore(MetadataStore store) throws FormatException {
LOGGER.info("Populating MetadataStore");
MetadataTools.populatePixels(store, this, true);
Location currentFile = new Location(getCurrentFile()).getAbsoluteFile();
int[] lengths = new int[] { fieldCount, wellCount, plateCount };
store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
String plateAcqID = MetadataTools.createLSID("PlateAcquisition", 0, 0);
store.setPlateAcquisitionID(plateAcqID, 0, 0);
PositiveInteger maxFieldCount = FormatTools.getMaxFieldCount(fieldCount);
if (maxFieldCount != null) {
store.setPlateAcquisitionMaximumFieldCount(maxFieldCount, 0, 0);
}
plateAcqStartTime = DateTools.formatDate(plateAcqStartTime, "dd.MM.yyyy HH:mm:ss");
if (plateAcqStartTime != null) {
store.setPlateAcquisitionStartTime(new Timestamp(plateAcqStartTime), 0, 0);
}
for (int row = 0; row < wellRows; row++) {
for (int col = 0; col < wellColumns; col++) {
int well = row * wellColumns + col;
store.setWellID(MetadataTools.createLSID("Well", 0, well), 0, well);
store.setWellRow(new NonNegativeInteger(row), 0, well);
store.setWellColumn(new NonNegativeInteger(col), 0, well);
}
}
for (int i = 0; i < getSeriesCount(); i++) {
int[] pos = FormatTools.rasterToPosition(lengths, i);
String imageID = MetadataTools.createLSID("Image", i);
store.setImageID(imageID, i);
int well = wellNumber[pos[1]][0] * wellColumns + wellNumber[pos[1]][1];
char wellRow = (char) ('A' + wellNumber[pos[1]][0]);
store.setImageName("Well " + wellRow + "-" + (wellNumber[pos[1]][1] + 1) + "; Field #" + (pos[0] + 1), i);
if (acquisitionDates.get(i) != null) {
store.setImageAcquisitionDate(acquisitionDates.get(i), i);
}
if (wellRows == 0 && wellColumns == 0) {
well = pos[1];
NonNegativeInteger row = new NonNegativeInteger(wellNumber[pos[1]][0]);
NonNegativeInteger col = new NonNegativeInteger(wellNumber[pos[1]][1]);
String wellID = MetadataTools.createLSID("Well", pos[2], well);
store.setWellID(wellID, pos[2], well);
store.setWellRow(row, pos[2], pos[1]);
store.setWellColumn(col, pos[2], pos[1]);
}
String wellSample = MetadataTools.createLSID("WellSample", pos[2], well, pos[0]);
store.setWellSampleID(wellSample, pos[2], well, pos[0]);
store.setWellSampleIndex(new NonNegativeInteger(i), pos[2], well, pos[0]);
store.setWellSampleImageRef(imageID, pos[2], well, pos[0]);
store.setPlateAcquisitionWellSampleRef(wellSample, 0, 0, i);
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
if (plateName == null)
plateName = currentFile.getParentFile().getName();
if (plateBarcode != null)
plateName = plateBarcode + " " + plateName;
store.setPlateName(plateName, 0);
store.setPlateRowNamingConvention(getNamingConvention("Letter"), 0);
store.setPlateColumnNamingConvention(getNamingConvention("Number"), 0);
for (int i = 0; i < getSeriesCount(); i++) {
int[] pos = FormatTools.rasterToPosition(lengths, i);
store.setImageInstrumentRef(instrumentID, i);
int seriesIndex = i * getImageCount();
if (seriesIndex < objectiveRefs.size()) {
store.setObjectiveSettingsID(objectiveRefs.get(seriesIndex), i);
}
for (int c = 0; c < getEffectiveSizeC(); c++) {
int channelIndex = seriesIndex + c;
if (seriesIndex > 0 && channelNames.length == getEffectiveSizeC() * getSeriesCount()) {
channelIndex = i * getEffectiveSizeC() + c;
}
if (channelNames != null && channelIndex >= channelNames.length) {
channelIndex = c;
}
if (channelNames != null && channelIndex < channelNames.length) {
store.setChannelName(channelNames[channelIndex], i, c);
}
}
if (seriesIndex < lightSourceCombinationRefs.size()) {
String lightSourceCombo = lightSourceCombinationRefs.get(seriesIndex);
List<String> lightSources = lightSourceCombinationIDs.get(lightSourceCombo);
for (int c = 0; c < getEffectiveSizeC(); c++) {
int index = seriesIndex + c;
if (index < cameraRefs.size()) {
store.setDetectorSettingsID(cameraRefs.get(index), i, c);
if (index < binnings.size()) {
store.setDetectorSettingsBinning(getBinning(binnings.get(index)), i, c);
}
}
if (lightSources != null && c < lightSources.size()) {
store.setChannelLightSourceSettingsID(lightSources.get(c), i, c);
} else if (c > 0 && lightSources != null && lightSources.size() == 1) {
lightSourceCombo = lightSourceCombinationRefs.get(seriesIndex + c);
lightSources = lightSourceCombinationIDs.get(lightSourceCombo);
store.setChannelLightSourceSettingsID(lightSources.get(0), i, c);
}
if (index < filterSets.size()) {
FilterGroup group = filterSetMap.get(filterSets.get(index));
if (group != null) {
if (group.emission != null) {
store.setLightPathEmissionFilterRef(group.emission, i, c, 0);
}
if (group.excitation != null) {
store.setLightPathExcitationFilterRef(group.excitation, i, c, 0);
}
if (group.dichroic != null) {
store.setLightPathDichroicRef(group.dichroic, i, c);
}
}
}
}
}
if (seriesIndex < xSizes.size()) {
Length size = FormatTools.getPhysicalSizeX(xSizes.get(seriesIndex));
if (size != null) {
store.setPixelsPhysicalSizeX(size, i);
}
}
if (seriesIndex < ySizes.size()) {
Length size = FormatTools.getPhysicalSizeY(ySizes.get(seriesIndex));
if (size != null) {
store.setPixelsPhysicalSizeY(size, i);
}
}
int well = wellNumber[pos[1]][0] * wellColumns + wellNumber[pos[1]][1];
if (wellRows == 0 && wellColumns == 0) {
well = pos[1];
}
if (pos[0] < xPositions.size()) {
Length l = new Length(xPositions.get(pos[0]), UNITS.REFERENCEFRAME);
store.setWellSamplePositionX(l, pos[2], well, pos[0]);
}
if (pos[0] < yPositions.size()) {
Length l = new Length(yPositions.get(pos[0]), UNITS.REFERENCEFRAME);
store.setWellSamplePositionY(l, pos[2], well, pos[0]);
}
for (int image = 0; image < getImageCount(); image++) {
int plane = i * getImageCount() + image;
int c = getZCTCoords(image)[1];
if (plane < planePositionX.size()) {
store.setPlanePositionX(planePositionX.get(plane), i, image);
}
if (plane < planePositionY.size()) {
store.setPlanePositionY(planePositionY.get(plane), i, image);
}
if (plane < planePositionZ.size()) {
store.setPlanePositionZ(planePositionZ.get(plane), i, image);
}
if (plane - image + c < planeExposureTime.size()) {
if (planeExposureTime.get(plane - image + c) != null) {
store.setPlaneExposureTime(new Time(planeExposureTime.get(plane - image + c), UNITS.SECOND), i, image);
}
}
if (plane < planeDeltaT.size() && planeDeltaT.get(plane) != null) {
store.setPlaneDeltaT(new Time(planeDeltaT.get(plane), UNITS.SECOND), i, image);
}
}
}
}
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class FlexReader method initResFile.
// -- Helper methods --
/**
* Initialize the dataset from a .res file.
*/
private void initResFile(String id) throws FormatException, IOException {
LOGGER.debug("initResFile({})", id);
parseResFile(id);
Location thisFile = new Location(id).getAbsoluteFile();
Location parent = thisFile.getParentFile();
LOGGER.debug(" Looking for an .mea file in {}", parent.getAbsolutePath());
String[] list = parent.list();
for (String file : list) {
if (checkSuffix(file, MEA_SUFFIX)) {
String mea = new Location(parent, file).getAbsolutePath();
LOGGER.debug(" Found .mea file {}", mea);
initMeaFile(mea);
if (!measurementFiles.contains(thisFile.getAbsolutePath())) {
measurementFiles.add(thisFile.getAbsolutePath());
}
return;
}
}
throw new FormatException("Could not find an .mea file.");
}
Aggregations