use of loci.common.Location in project bioformats by openmicroscopy.
the class MetamorphReader method getRealSTKFile.
// -- Helper methods --
/**
* Check that the given STK file exists. If it does, then return the
* absolute path. If it does not, then apply various formatting rules until
* an existing file is found.
*
* @return the absolute path of an STK file, or null if no STK file is found.
*/
private String getRealSTKFile(Location l) {
if (l.exists())
return l.getAbsolutePath();
String name = l.getName();
String parent = l.getParent();
if (name.indexOf('_') > 0) {
String prefix = name.substring(0, name.indexOf('_'));
String suffix = name.substring(name.indexOf('_'));
String basePrefix = new Location(currentId).getName();
int end = basePrefix.indexOf('_');
if (end < 0)
end = basePrefix.indexOf('.');
basePrefix = basePrefix.substring(0, end);
if (!basePrefix.equals(prefix)) {
name = basePrefix + suffix;
Location p = new Location(parent, name);
if (p.exists())
return p.getAbsolutePath();
}
}
// '%' can be converted to '-'
if (name.indexOf('%') != -1) {
name = name.replaceAll("%", "-");
l = new Location(parent, name);
if (!l.exists()) {
// try replacing extension
name = name.substring(0, name.lastIndexOf(".")) + ".TIF";
l = new Location(parent, name);
if (!l.exists()) {
name = name.substring(0, name.lastIndexOf(".")) + ".tif";
l = new Location(parent, name);
return l.exists() ? l.getAbsolutePath() : null;
}
}
}
if (!l.exists()) {
// try replacing extension
int index = name.lastIndexOf(".");
if (index < 0)
index = name.length();
name = name.substring(0, index) + ".TIF";
l = new Location(parent, name);
if (!l.exists()) {
name = name.substring(0, name.lastIndexOf(".")) + ".tif";
l = new Location(parent, name);
if (!l.exists()) {
name = name.substring(0, name.lastIndexOf(".")) + ".stk";
l = new Location(parent, name);
return l.exists() ? l.getAbsolutePath() : null;
}
}
}
return l.getAbsolutePath();
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class MetamorphReader method initFile.
// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
if (checkSuffix(id, ND_SUFFIX)) {
LOGGER.info("Initializing " + id);
// find an associated STK file
String stkFile = id.substring(0, id.lastIndexOf("."));
if (stkFile.indexOf(File.separatorChar) != -1) {
stkFile = stkFile.substring(stkFile.lastIndexOf(File.separator) + 1);
}
Location parent = new Location(id).getAbsoluteFile().getParentFile();
LOGGER.info("Looking for STK file in {}", parent.getAbsolutePath());
String[] dirList = parent.list(true);
Arrays.sort(dirList);
for (String f : dirList) {
int underscore = f.indexOf('_');
if (underscore < 0)
underscore = f.indexOf('.');
if (underscore < 0)
underscore = f.length();
String prefix = f.substring(0, underscore);
if ((f.equals(stkFile) || stkFile.startsWith(prefix)) && checkSuffix(f, STK_SUFFIX)) {
stkFile = new Location(parent.getAbsolutePath(), f).getAbsolutePath();
break;
}
}
if (!checkSuffix(stkFile, STK_SUFFIX)) {
throw new FormatException("STK file not found in " + parent.getAbsolutePath() + ".");
}
super.initFile(stkFile);
} else
super.initFile(id);
Location ndfile = null;
if (checkSuffix(id, ND_SUFFIX))
ndfile = new Location(id);
else if (canLookForND && isGroupFiles()) {
// an STK file was passed to initFile
// let's check the parent directory for an .nd file
Location stk = new Location(id).getAbsoluteFile();
String stkName = stk.getName();
String stkPrefix = stkName;
if (stkPrefix.indexOf('_') >= 0) {
stkPrefix = stkPrefix.substring(0, stkPrefix.indexOf('_') + 1);
}
Location parent = stk.getParentFile();
String[] list = parent.list(true);
int matchingChars = 0;
for (String f : list) {
if (checkSuffix(f, ND_SUFFIX)) {
String prefix = f.substring(0, f.lastIndexOf("."));
if (prefix.indexOf('_') >= 0) {
prefix = prefix.substring(0, prefix.indexOf('_') + 1);
}
if (stkName.startsWith(prefix) || prefix.equals(stkPrefix)) {
int charCount = 0;
for (int i = 0; i < f.length(); i++) {
if (i >= stkName.length()) {
break;
}
if (f.charAt(i) == stkName.charAt(i)) {
charCount++;
} else {
break;
}
}
if (charCount > matchingChars || (charCount == matchingChars && f.charAt(charCount) == '.')) {
ndfile = new Location(parent, f).getAbsoluteFile();
matchingChars = charCount;
}
}
}
}
}
String creationTime = null;
if (ndfile != null && ndfile.exists() && (fileGroupOption(id) == FormatTools.MUST_GROUP || isGroupFiles())) {
// parse key/value pairs from .nd file
int zc = getSizeZ(), cc = getSizeC(), tc = getSizeT();
int nstages = 0;
String z = null, c = null, t = null;
final List<Boolean> hasZ = new ArrayList<Boolean>();
waveNames = new ArrayList<String>();
stageNames = new ArrayList<String>();
boolean useWaveNames = true;
ndFilename = ndfile.getAbsolutePath();
String[] lines = DataTools.readFile(ndFilename).split("\n");
boolean globalDoZ = true;
boolean doTimelapse = false;
StringBuilder currentValue = new StringBuilder();
String key = "";
for (String line : lines) {
int comma = line.indexOf(',');
if (comma <= 0) {
currentValue.append("\n");
currentValue.append(line);
continue;
}
String value = currentValue.toString();
addGlobalMeta(key, value);
if (key.equals("NZSteps"))
z = value;
else if (key.equals("DoTimelapse")) {
doTimelapse = Boolean.parseBoolean(value);
} else if (key.equals("NWavelengths"))
c = value;
else if (key.equals("NTimePoints"))
t = value;
else if (key.startsWith("WaveDoZ")) {
hasZ.add(Boolean.parseBoolean(value));
} else if (key.startsWith("WaveName")) {
String waveName = value.substring(1, value.length() - 1);
if (waveName.equals("Both lasers") || waveName.startsWith("DUAL")) {
bizarreMultichannelAcquisition = true;
}
waveNames.add(waveName);
} else if (key.startsWith("Stage")) {
stageNames.add(value);
} else if (key.startsWith("StartTime")) {
creationTime = value;
} else if (key.equals("ZStepSize")) {
value = value.replace(',', '.');
stepSize = Double.parseDouble(value);
} else if (key.equals("NStagePositions")) {
nstages = Integer.parseInt(value);
} else if (key.equals("WaveInFileName")) {
useWaveNames = Boolean.parseBoolean(value);
} else if (key.equals("DoZSeries")) {
globalDoZ = Boolean.parseBoolean(value);
}
key = line.substring(1, comma - 1).trim();
currentValue.delete(0, currentValue.length());
currentValue.append(line.substring(comma + 1).trim());
}
if (!globalDoZ) {
for (int i = 0; i < hasZ.size(); i++) {
hasZ.set(i, false);
}
}
if (z != null)
zc = Integer.parseInt(z);
if (c != null)
cc = Integer.parseInt(c);
if (t != null)
tc = Integer.parseInt(t);
else if (!doTimelapse) {
tc = 1;
}
if (cc == 0)
cc = 1;
if (cc == 1 && bizarreMultichannelAcquisition) {
cc = 2;
}
if (tc == 0) {
tc = 1;
}
int numFiles = cc * tc;
if (nstages > 0)
numFiles *= nstages;
// determine series count
int stagesCount = nstages == 0 ? 1 : nstages;
int seriesCount = stagesCount;
firstSeriesChannels = new boolean[cc];
Arrays.fill(firstSeriesChannels, true);
boolean differentZs = false;
for (int i = 0; i < cc; i++) {
boolean hasZ1 = i < hasZ.size() && hasZ.get(i);
boolean hasZ2 = i != 0 && (i - 1 < hasZ.size()) && hasZ.get(i - 1);
if (i > 0 && hasZ1 != hasZ2 && globalDoZ) {
if (!differentZs)
seriesCount *= 2;
differentZs = true;
}
}
int channelsInFirstSeries = cc;
if (differentZs) {
channelsInFirstSeries = 0;
for (int i = 0; i < cc; i++) {
if ((!hasZ.get(0) && i == 0) || (hasZ.get(0) && hasZ.get(i))) {
channelsInFirstSeries++;
} else
firstSeriesChannels[i] = false;
}
}
stks = new String[seriesCount][];
if (seriesCount == 1)
stks[0] = new String[numFiles];
else if (differentZs) {
for (int i = 0; i < stagesCount; i++) {
stks[i * 2] = new String[channelsInFirstSeries * tc];
stks[i * 2 + 1] = new String[(cc - channelsInFirstSeries) * tc];
}
} else {
for (int i = 0; i < stks.length; i++) {
stks[i] = new String[numFiles / stks.length];
}
}
String prefix = ndfile.getPath();
prefix = prefix.substring(prefix.lastIndexOf(File.separator) + 1, prefix.lastIndexOf("."));
// build list of STK files
boolean anyZ = hasZ.contains(Boolean.TRUE);
int[] pt = new int[seriesCount];
for (int i = 0; i < tc; i++) {
for (int s = 0; s < stagesCount; s++) {
for (int j = 0; j < cc; j++) {
boolean validZ = j >= hasZ.size() || hasZ.get(j);
int seriesNdx = s * (seriesCount / stagesCount);
if ((seriesCount != 1 && (!validZ || (hasZ.size() > 0 && !hasZ.get(0)))) || (nstages == 0 && ((!validZ && cc > 1) || seriesCount > 1))) {
if (anyZ && j > 0 && seriesNdx < seriesCount - 1 && (!validZ || !hasZ.get(0))) {
seriesNdx++;
}
}
if (seriesNdx >= stks.length || seriesNdx >= pt.length || pt[seriesNdx] >= stks[seriesNdx].length) {
continue;
}
stks[seriesNdx][pt[seriesNdx]] = prefix;
if (j < waveNames.size() && waveNames.get(j) != null) {
stks[seriesNdx][pt[seriesNdx]] += "_w" + (j + 1);
if (useWaveNames) {
String waveName = waveNames.get(j);
// If there are underscores in the wavelength name, translate
// them to hyphens. (See #558)
waveName = waveName.replace('_', '-');
// If there are slashes (forward or backward) in the wavelength
// name, translate them to hyphens. (See #5922)
waveName = waveName.replace('/', '-');
waveName = waveName.replace('\\', '-');
waveName = waveName.replace('(', '-');
waveName = waveName.replace(')', '-');
stks[seriesNdx][pt[seriesNdx]] += waveName;
}
}
if (nstages > 0) {
stks[seriesNdx][pt[seriesNdx]] += "_s" + (s + 1);
}
if (tc > 1 || doTimelapse) {
stks[seriesNdx][pt[seriesNdx]] += "_t" + (i + 1) + ".STK";
} else
stks[seriesNdx][pt[seriesNdx]] += ".STK";
pt[seriesNdx]++;
}
}
}
ndfile = ndfile.getAbsoluteFile();
for (int s = 0; s < stks.length; s++) {
for (int f = 0; f < stks[s].length; f++) {
Location l = new Location(ndfile.getParent(), stks[s][f]);
stks[s][f] = getRealSTKFile(l);
}
}
String file = locateFirstValidFile();
if (file == null) {
throw new FormatException("Unable to locate at least one valid STK file!");
}
RandomAccessInputStream s = new RandomAccessInputStream(file, 16);
TiffParser tp = new TiffParser(s);
IFD ifd = tp.getFirstIFD();
CoreMetadata ms0 = core.get(0);
s.close();
ms0.sizeX = (int) ifd.getImageWidth();
ms0.sizeY = (int) ifd.getImageLength();
if (bizarreMultichannelAcquisition) {
ms0.sizeX /= 2;
}
ms0.sizeZ = hasZ.size() > 0 && !hasZ.get(0) ? 1 : zc;
ms0.sizeC = cc;
ms0.sizeT = tc;
ms0.imageCount = getSizeZ() * getSizeC() * getSizeT();
ms0.dimensionOrder = "XYZCT";
if (stks != null && stks.length > 1) {
// Note that core can't be replaced with newCore until the end of this block.
ArrayList<CoreMetadata> newCore = new ArrayList<CoreMetadata>();
for (int i = 0; i < stks.length; i++) {
CoreMetadata ms = new CoreMetadata();
newCore.add(ms);
ms.sizeX = getSizeX();
ms.sizeY = getSizeY();
ms.sizeZ = getSizeZ();
ms.sizeC = getSizeC();
ms.sizeT = getSizeT();
ms.pixelType = getPixelType();
ms.imageCount = getImageCount();
ms.dimensionOrder = getDimensionOrder();
ms.rgb = isRGB();
ms.littleEndian = isLittleEndian();
ms.interleaved = isInterleaved();
ms.orderCertain = true;
}
if (stks.length > nstages) {
for (int j = 0; j < stagesCount; j++) {
int idx = j * 2 + 1;
CoreMetadata midx = newCore.get(idx);
CoreMetadata pmidx = newCore.get(j * 2);
pmidx.sizeC = stks[j * 2].length / getSizeT();
midx.sizeC = stks[idx].length / midx.sizeT;
midx.sizeZ = hasZ.size() > 1 && hasZ.get(1) && core.get(0).sizeZ == 1 ? zc : 1;
pmidx.imageCount = pmidx.sizeC * pmidx.sizeT * pmidx.sizeZ;
midx.imageCount = midx.sizeC * midx.sizeT * midx.sizeZ;
}
}
core = newCore;
}
}
if (stks == null) {
stkReaders = new MetamorphReader[1][1];
stkReaders[0][0] = new MetamorphReader();
stkReaders[0][0].setCanLookForND(false);
} else {
stkReaders = new MetamorphReader[stks.length][];
for (int i = 0; i < stks.length; i++) {
stkReaders[i] = new MetamorphReader[stks[i].length];
for (int j = 0; j < stkReaders[i].length; j++) {
stkReaders[i][j] = new MetamorphReader();
stkReaders[i][j].setCanLookForND(false);
if (j > 0) {
stkReaders[i][j].setMetadataOptions(new DefaultMetadataOptions(MetadataLevel.MINIMUM));
}
}
}
}
// check stage labels for plate data
int rows = 0;
int cols = 0;
Map<String, Integer> rowMap = null;
Map<String, Integer> colMap = null;
isHCS = true;
if (null == stageLabels) {
isHCS = false;
} else {
Set<Map.Entry<Integer, Integer>> uniqueWells = new HashSet<Map.Entry<Integer, Integer>>();
rowMap = new HashMap<String, Integer>();
colMap = new HashMap<String, Integer>();
for (String label : stageLabels) {
if (null == label) {
isHCS = false;
break;
}
Map.Entry<Integer, Integer> wellCoords = getWellCoords(label);
if (null == wellCoords) {
isHCS = false;
break;
}
uniqueWells.add(wellCoords);
rowMap.put(label, wellCoords.getKey());
colMap.put(label, wellCoords.getValue());
}
if (uniqueWells.size() != stageLabels.length) {
isHCS = false;
} else {
rows = Collections.max(rowMap.values());
cols = Collections.max(colMap.values());
CoreMetadata c = core.get(0);
core.clear();
c.sizeZ = 1;
c.sizeT = 1;
c.imageCount = 1;
for (int s = 0; s < uniqueWells.size(); s++) {
CoreMetadata toAdd = new CoreMetadata(c);
if (s > 0) {
toAdd.seriesMetadata.clear();
}
core.add(toAdd);
}
seriesToIFD = true;
}
}
List<String> timestamps = null;
MetamorphHandler handler = null;
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this, true);
if (isHCS) {
store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
store.setPlateRows(new PositiveInteger(rows), 0);
store.setPlateColumns(new PositiveInteger(cols), 0);
store.setPlateRowNamingConvention(NamingConvention.LETTER, 0);
store.setPlateColumnNamingConvention(NamingConvention.NUMBER, 0);
}
int nextObjective = 0;
String instrumentID = MetadataTools.createLSID("Instrument", 0);
String detectorID = MetadataTools.createLSID("Detector", 0, 0);
store.setInstrumentID(instrumentID, 0);
store.setDetectorID(detectorID, 0, 0);
store.setDetectorType(getDetectorType("Other"), 0, 0);
for (int i = 0; i < getSeriesCount(); i++) {
setSeries(i);
// do not reparse the same XML for every well
if (i == 0 || !isHCS) {
handler = new MetamorphHandler(getSeriesMetadata());
}
if (isHCS) {
String label = stageLabels[i];
String wellID = MetadataTools.createLSID("Well", 0, i);
store.setWellID(wellID, 0, i);
store.setWellColumn(new NonNegativeInteger(colMap.get(label)), 0, i);
store.setWellRow(new NonNegativeInteger(rowMap.get(label)), 0, i);
store.setWellSampleID(MetadataTools.createLSID("WellSample", 0, i, 0), 0, i, 0);
store.setWellSampleImageRef(MetadataTools.createLSID("Image", i), 0, i, 0);
store.setWellSampleIndex(new NonNegativeInteger(i), 0, i, 0);
}
store.setImageInstrumentRef(instrumentID, i);
String comment = getFirstComment(i);
if (i == 0 || !isHCS) {
if (comment != null && comment.startsWith("<MetaData>")) {
try {
XMLTools.parseXML(XMLTools.sanitizeXML(comment), handler);
} catch (IOException e) {
}
}
}
if (creationTime != null) {
String date = DateTools.formatDate(creationTime, SHORT_DATE_FORMAT, ".");
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), 0);
}
}
store.setImageName(makeImageName(i).trim(), i);
if (getMetadataOptions().getMetadataLevel() == MetadataLevel.MINIMUM) {
continue;
}
store.setImageDescription("", i);
store.setImagingEnvironmentTemperature(new Temperature(handler.getTemperature(), UNITS.CELSIUS), i);
if (sizeX == null)
sizeX = handler.getPixelSizeX();
if (sizeY == null)
sizeY = handler.getPixelSizeY();
Length physicalSizeX = FormatTools.getPhysicalSizeX(sizeX);
Length physicalSizeY = FormatTools.getPhysicalSizeY(sizeY);
if (physicalSizeX != null) {
store.setPixelsPhysicalSizeX(physicalSizeX, i);
}
if (physicalSizeY != null) {
store.setPixelsPhysicalSizeY(physicalSizeY, i);
}
if (zDistances != null) {
stepSize = zDistances[0];
} else {
List<Double> zPositions = new ArrayList<Double>();
final List<Double> uniqueZ = new ArrayList<Double>();
for (IFD ifd : ifds) {
MetamorphHandler zPlaneHandler = new MetamorphHandler();
String zComment = ifd.getComment();
if (zComment != null && zComment.startsWith("<MetaData>")) {
try {
XMLTools.parseXML(XMLTools.sanitizeXML(zComment), zPlaneHandler);
} catch (IOException e) {
}
}
zPositions = zPlaneHandler.getZPositions();
for (Double z : zPositions) {
if (!uniqueZ.contains(z))
uniqueZ.add(z);
}
}
if (uniqueZ.size() > 1 && uniqueZ.size() == getSizeZ()) {
BigDecimal lastZ = BigDecimal.valueOf(uniqueZ.get(uniqueZ.size() - 1));
BigDecimal firstZ = BigDecimal.valueOf(uniqueZ.get(0));
BigDecimal zRange = (lastZ.subtract(firstZ)).abs();
BigDecimal zSize = BigDecimal.valueOf((double) (getSizeZ() - 1));
MathContext mc = new MathContext(10, RoundingMode.HALF_UP);
stepSize = zRange.divide(zSize, mc).doubleValue();
}
}
Length physicalSizeZ = FormatTools.getPhysicalSizeZ(stepSize);
if (physicalSizeZ != null) {
store.setPixelsPhysicalSizeZ(physicalSizeZ, i);
}
if (handler.getLensNA() != 0 || handler.getLensRI() != 0) {
String objectiveID = MetadataTools.createLSID("Objective", 0, nextObjective);
store.setObjectiveID(objectiveID, 0, nextObjective);
if (handler.getLensNA() != 0) {
store.setObjectiveLensNA(handler.getLensNA(), 0, nextObjective);
}
store.setObjectiveSettingsID(objectiveID, i);
if (handler.getLensRI() != 0) {
store.setObjectiveSettingsRefractiveIndex(handler.getLensRI(), i);
}
nextObjective++;
}
int waveIndex = 0;
for (int c = 0; c < getEffectiveSizeC(); c++) {
if (firstSeriesChannels == null || (stageNames != null && stageNames.size() == getSeriesCount())) {
waveIndex = c;
} else if (firstSeriesChannels != null) {
int s = i % 2;
while (firstSeriesChannels[waveIndex] == (s == 1) && waveIndex < firstSeriesChannels.length) {
waveIndex++;
}
}
if (waveNames != null && waveIndex < waveNames.size()) {
store.setChannelName(waveNames.get(waveIndex).trim(), i, c);
}
if (handler.getBinning() != null)
binning = handler.getBinning();
if (binning != null) {
store.setDetectorSettingsBinning(getBinning(binning), i, c);
}
if (handler.getReadOutRate() != 0) {
store.setDetectorSettingsReadOutRate(new Frequency(handler.getReadOutRate(), UNITS.HERTZ), i, c);
}
if (gain == null) {
gain = handler.getGain();
}
if (gain != null) {
store.setDetectorSettingsGain(gain, i, c);
}
store.setDetectorSettingsID(detectorID, i, c);
if (wave != null && waveIndex < wave.length) {
Length wavelength = FormatTools.getWavelength(wave[waveIndex]);
if ((int) wave[waveIndex] >= 1) {
// link LightSource to Image
int laserIndex = i * getEffectiveSizeC() + c;
String lightSourceID = MetadataTools.createLSID("LightSource", 0, laserIndex);
store.setLaserID(lightSourceID, 0, laserIndex);
store.setChannelLightSourceSettingsID(lightSourceID, i, c);
store.setLaserType(getLaserType("Other"), 0, laserIndex);
store.setLaserLaserMedium(getLaserMedium("Other"), 0, laserIndex);
if (wavelength != null) {
store.setChannelLightSourceSettingsWavelength(wavelength, i, c);
}
}
}
waveIndex++;
}
timestamps = handler.getTimestamps();
for (int t = 0; t < timestamps.size(); t++) {
String date = DateTools.convertDate(DateTools.getTime(timestamps.get(t), SHORT_DATE_FORMAT, "."), DateTools.UNIX, SHORT_DATE_FORMAT + ".SSS");
addSeriesMetaList("timestamp", date);
}
long startDate = 0;
if (timestamps.size() > 0) {
startDate = DateTools.getTime(timestamps.get(0), SHORT_DATE_FORMAT, ".");
}
final Length positionX = handler.getStagePositionX();
final Length positionY = handler.getStagePositionY();
final List<Double> exposureTimes = handler.getExposures();
if (exposureTimes.size() == 0) {
for (int p = 0; p < getImageCount(); p++) {
exposureTimes.add(exposureTime);
}
} else if (exposureTimes.size() == 1 && exposureTimes.size() < getSizeC()) {
for (int c = 1; c < getSizeC(); c++) {
MetamorphHandler channelHandler = new MetamorphHandler();
String channelComment = getComment(i, c);
if (channelComment != null && channelComment.startsWith("<MetaData>")) {
try {
XMLTools.parseXML(XMLTools.sanitizeXML(channelComment), channelHandler);
} catch (IOException e) {
}
}
final List<Double> channelExpTime = channelHandler.getExposures();
exposureTimes.add(channelExpTime.get(0));
}
}
int lastFile = -1;
IFDList lastIFDs = null;
IFD lastIFD = null;
double distance = zStart;
TiffParser tp = null;
RandomAccessInputStream stream = null;
for (int p = 0; p < getImageCount(); p++) {
int[] coords = getZCTCoords(p);
Double deltaT = 0d;
Double expTime = exposureTime;
Double xmlZPosition = null;
int fileIndex = getIndex(0, coords[1], coords[2]) / getSizeZ();
if (fileIndex >= 0) {
String file = stks == null ? currentId : stks[i][fileIndex];
if (file != null) {
if (fileIndex != lastFile) {
if (stream != null) {
stream.close();
}
stream = new RandomAccessInputStream(file, 16);
tp = new TiffParser(stream);
tp.checkHeader();
IFDList f = tp.getIFDs();
if (f.size() > 0) {
lastFile = fileIndex;
lastIFDs = f;
} else {
file = null;
stks[i][fileIndex] = null;
}
}
}
if (file != null) {
lastIFD = lastIFDs.get(p % lastIFDs.size());
Object commentEntry = lastIFD.get(IFD.IMAGE_DESCRIPTION);
if (commentEntry != null) {
if (commentEntry instanceof String) {
comment = (String) commentEntry;
} else if (commentEntry instanceof TiffIFDEntry) {
comment = tp.getIFDValue((TiffIFDEntry) commentEntry).toString();
}
}
if (comment != null)
comment = comment.trim();
if (comment != null && comment.startsWith("<MetaData>")) {
String[] lines = comment.split("\n");
timestamps = new ArrayList<String>();
for (String line : lines) {
line = line.trim();
if (line.startsWith("<prop")) {
int firstQuote = line.indexOf("\"") + 1;
int lastQuote = line.lastIndexOf("\"");
String key = line.substring(firstQuote, line.indexOf("\"", firstQuote));
String value = line.substring(line.lastIndexOf("\"", lastQuote - 1) + 1, lastQuote);
if (key.equals("z-position")) {
xmlZPosition = new Double(value);
} else if (key.equals("acquisition-time-local")) {
timestamps.add(value);
}
}
}
}
}
}
int index = 0;
if (timestamps.size() > 0) {
if (coords[2] < timestamps.size())
index = coords[2];
String stamp = timestamps.get(index);
long ms = DateTools.getTime(stamp, SHORT_DATE_FORMAT, ".");
deltaT = (ms - startDate) / 1000.0;
} else if (internalStamps != null && p < internalStamps.length) {
long delta = internalStamps[p] - internalStamps[0];
deltaT = delta / 1000.0;
if (coords[2] < exposureTimes.size())
index = coords[2];
}
if (index == 0 && p > 0 && exposureTimes.size() > 0) {
index = coords[1] % exposureTimes.size();
}
if (index < exposureTimes.size()) {
expTime = exposureTimes.get(index);
}
if (deltaT != null) {
store.setPlaneDeltaT(new Time(deltaT, UNITS.SECOND), i, p);
}
if (expTime != null) {
store.setPlaneExposureTime(new Time(expTime, UNITS.SECOND), i, p);
}
if (stageX != null && p < stageX.length) {
store.setPlanePositionX(stageX[p], i, p);
} else if (positionX != null) {
store.setPlanePositionX(positionX, i, p);
}
if (stageY != null && p < stageY.length) {
store.setPlanePositionY(stageY[p], i, p);
} else if (positionY != null) {
store.setPlanePositionY(positionY, i, p);
}
if (zDistances != null && p < zDistances.length) {
if (p > 0) {
if (zDistances[p] != 0d)
distance += zDistances[p];
else
distance += zDistances[0];
}
final Length zPos = new Length(distance, UNITS.REFERENCEFRAME);
store.setPlanePositionZ(zPos, i, p);
} else if (xmlZPosition != null) {
final Length zPos = new Length(xmlZPosition, UNITS.REFERENCEFRAME);
store.setPlanePositionZ(zPos, i, p);
}
}
if (stream != null) {
stream.close();
}
}
setSeries(0);
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class NativeND2Reader method populateMetadataStore.
private void populateMetadataStore(ND2Handler handler) throws FormatException {
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this, true);
String filename = new Location(getCurrentFile()).getName();
if (handler != null) {
ArrayList<String> posNames = handler.getPositionNames();
int nameWidth = String.valueOf(getSeriesCount()).length();
for (int i = 0; i < getSeriesCount(); i++) {
String seriesSuffix = String.format("(series %0" + nameWidth + "d)", i + 1);
String suffix = (i < posNames.size() && !posNames.get(i).equals("")) ? posNames.get(i) : seriesSuffix;
String name = filename + " " + suffix;
store.setImageName(name.trim(), i);
}
}
colors = new int[getEffectiveSizeC()];
ArrayList<String> channelNames = null;
if (handler != null) {
channelNames = handler.getChannelNames();
if (channelNames.size() < getEffectiveSizeC() && backupHandler != null) {
channelNames = backupHandler.getChannelNames();
} else if (channelNames.size() < getEffectiveSizeC()) {
channelNames = textChannelNames;
}
for (int c = 0; c < getEffectiveSizeC(); c++) {
if (c < channelNames.size()) {
String channelName = channelNames.get(c);
Integer channelColor = channelColors.get(channelName);
colors[c] = channelColor == null ? 0 : channelColor.intValue();
}
}
}
if (getMetadataOptions().getMetadataLevel() == MetadataLevel.MINIMUM) {
return;
}
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
for (int i = 0; i < getSeriesCount(); i++) {
// link Instrument and Image
store.setImageInstrumentRef(instrumentID, i);
// set the channel color
for (int c = 0; c < getEffectiveSizeC(); c++) {
int red = colors[c] & 0xff;
int green = (colors[c] & 0xff00) >> 8;
int blue = (colors[c] & 0xff0000) >> 16;
// doing so can prevent the image from displaying correctly
if (red != 0 || green != 0 || blue != 0) {
// always set the alpha to 255, otherwise the colors may not appear
store.setChannelColor(new Color(red, green, blue, 255), i, c);
}
}
}
// populate Dimensions data
if (handler != null) {
for (int i = 0; i < getSeriesCount(); i++) {
double sizeX = handler.getPixelSizeX();
double sizeY = handler.getPixelSizeY();
double sizeZ = handler.getPixelSizeZ();
if (trueSizeX > 0) {
store.setPixelsPhysicalSizeX(FormatTools.getPhysicalSizeX(trueSizeX), i);
} else {
Length size = FormatTools.getPhysicalSizeX(sizeX);
if (size != null) {
store.setPixelsPhysicalSizeX(size, i);
}
}
if (trueSizeY > 0) {
store.setPixelsPhysicalSizeY(FormatTools.getPhysicalSizeY(trueSizeY), i);
} else if (trueSizeX > 0) {
// if the X size is set, assume X and Y are equal
store.setPixelsPhysicalSizeY(FormatTools.getPhysicalSizeY(trueSizeX), i);
} else {
Length size = FormatTools.getPhysicalSizeY(sizeY);
if (size == null) {
// if the X size is set, assume X and Y are equal
size = FormatTools.getPhysicalSizeY(sizeX);
}
if (size != null) {
store.setPixelsPhysicalSizeY(size, i);
}
}
if (trueSizeZ != null && trueSizeZ > 0) {
store.setPixelsPhysicalSizeZ(FormatTools.getPhysicalSizeZ(trueSizeZ), i);
} else {
Length size = FormatTools.getPhysicalSizeZ(sizeZ);
if (size != null) {
store.setPixelsPhysicalSizeZ(size, i);
}
}
}
}
// populate PlaneTiming and StagePosition data
if (handler != null && handler.getExposureTimes().size() > 0) {
exposureTime = handler.getExposureTimes();
}
int zcPlanes = getImageCount() / ((split ? getSizeC() : 1) * getSizeT());
for (int i = 0; i < getSeriesCount(); i++) {
if (tsT.size() > 0) {
setSeries(i);
for (int n = 0; n < getImageCount(); n++) {
int[] coords = getZCTCoords(n);
int stampIndex = getIndex(coords[0], split ? 0 : coords[1], 0);
stampIndex += (coords[2] * getSeriesCount() + i) * zcPlanes;
if (tsT.size() == getImageCount())
stampIndex = n;
else if (tsT.size() == getSizeZ()) {
stampIndex = coords[0];
}
if (stampIndex < tsT.size()) {
double stamp = tsT.get(stampIndex).doubleValue();
store.setPlaneDeltaT(new Time(stamp, UNITS.SECOND), i, n);
}
int index = i * getSizeC() + coords[1];
if (exposureTime.size() == getSizeC()) {
index = coords[1];
}
if (exposureTime != null && index < exposureTime.size() && exposureTime.get(index) != null) {
store.setPlaneExposureTime(new Time(exposureTime.get(index), UNITS.SECOND), i, n);
}
}
}
if (handler != null) {
if (posX == null)
posX = handler.getXPositions();
if (posY == null)
posY = handler.getYPositions();
if (posZ == null)
posZ = handler.getZPositions();
}
String pos = "for position";
for (int n = 0; n < getImageCount(); n++) {
int[] coords = getZCTCoords(n);
int index = coords[0];
index += (coords[2] * getSeriesCount() + i) * zcPlanes;
if (posX != null) {
if (index >= posX.size())
index = i;
if (index < posX.size()) {
String key = "X position ";
store.setPlanePositionX(posX.get(index), i, n);
addSeriesMetaList(key, posX.get(index));
addGlobalMetaList(key + pos, posX.get(index));
}
}
if (posY != null) {
if (index < posY.size()) {
String key = "Y position ";
store.setPlanePositionY(posY.get(index), i, n);
addSeriesMetaList(key, posY.get(index));
addGlobalMetaList(key + pos, posY.get(index));
}
}
if (posZ != null) {
if (index < posZ.size()) {
store.setPlanePositionZ(posZ.get(index), i, n);
String key = "Z position " + pos + ", plane";
addSeriesMetaList(key, posZ.get(index));
addGlobalMetaList(key, posZ.get(index));
}
}
}
}
if (handler == null) {
setSeries(0);
return;
}
String detectorID = MetadataTools.createLSID("Detector", 0, 0);
store.setDetectorID(detectorID, 0, 0);
store.setDetectorModel(handler.getCameraModel(), 0, 0);
store.setDetectorType(getDetectorType("Other"), 0, 0);
ArrayList<String> modality = handler.getModalities();
ArrayList<String> binning = handler.getBinnings();
ArrayList<Double> speed = handler.getSpeeds();
ArrayList<Double> gain = handler.getGains();
ArrayList<Double> temperature = handler.getTemperatures();
ArrayList<Double> exWave = handler.getExcitationWavelengths();
ArrayList<Double> emWave = handler.getEmissionWavelengths();
ArrayList<Integer> power = handler.getPowers();
ArrayList<Hashtable<String, String>> rois = handler.getROIs();
if (backupHandler != null) {
if (emWave.size() == 0) {
emWave = backupHandler.getEmissionWavelengths();
}
if (exWave.size() == 0) {
exWave = backupHandler.getExcitationWavelengths();
}
}
for (int i = 0; i < getSeriesCount(); i++) {
for (int c = 0; c < getEffectiveSizeC(); c++) {
int index = c;
Double pinholeSize = handler.getPinholeSize();
if (pinholeSize != null) {
store.setChannelPinholeSize(new Length(pinholeSize, UNITS.MICROMETER), i, c);
}
if (index < channelNames.size()) {
String channelName = channelNames.get(index);
store.setChannelName(channelName, i, c);
} else if (channelNames.size() >= getEffectiveSizeC()) {
store.setChannelName(channelNames.get(c), i, c);
}
if (index < modality.size()) {
store.setChannelAcquisitionMode(getAcquisitionMode(modality.get(index)), i, c);
}
if (index < emWave.size() || index < textEmissionWavelengths.size()) {
Double value = index < emWave.size() ? emWave.get(index) : textEmissionWavelengths.get(index);
Length emission = FormatTools.getEmissionWavelength(value);
if (emission != null) {
store.setChannelEmissionWavelength(emission, i, c);
}
} else if (emWave.size() > 0 || textEmissionWavelengths.size() > 0) {
store.setChannelColor(new Color(255, 255, 255, 255), i, c);
}
if (index < exWave.size()) {
Length excitation = FormatTools.getExcitationWavelength(exWave.get(index));
if (excitation != null) {
store.setChannelExcitationWavelength(excitation, i, c);
}
}
if (index < binning.size()) {
store.setDetectorSettingsBinning(getBinning(binning.get(index)), i, c);
}
if (index < gain.size()) {
store.setDetectorSettingsGain(gain.get(index), i, c);
}
if (index < speed.size()) {
store.setDetectorSettingsReadOutRate(new Frequency(speed.get(index), UNITS.HERTZ), i, c);
}
store.setDetectorSettingsID(detectorID, i, c);
}
}
for (int i = 0; i < getSeriesCount(); i++) {
if (i * getSizeC() < temperature.size()) {
Double temp = temperature.get(i * getSizeC());
store.setImagingEnvironmentTemperature(new Temperature(temp, UNITS.CELSIUS), i);
}
}
// populate DetectorSettings
Double voltage = handler.getVoltage();
if (voltage != null) {
store.setDetectorSettingsVoltage(new ElectricPotential(voltage, UNITS.VOLT), 0, 0);
}
// populate Objective
Double na = handler.getNumericalAperture();
if (na != null) {
store.setObjectiveLensNA(na, 0, 0);
}
Double mag = handler.getMagnification();
if (mag != null) {
store.setObjectiveCalibratedMagnification(mag, 0, 0);
}
store.setObjectiveModel(handler.getObjectiveModel(), 0, 0);
String immersion = handler.getImmersion();
if (immersion == null)
immersion = "Other";
store.setObjectiveImmersion(getImmersion(immersion), 0, 0);
String correction = handler.getCorrection();
if (correction == null || correction.length() == 0)
correction = "Other";
store.setObjectiveCorrection(getCorrection(correction), 0, 0);
// link Objective to Image
String objectiveID = MetadataTools.createLSID("Objective", 0, 0);
store.setObjectiveID(objectiveID, 0, 0);
if (refractiveIndex == null) {
refractiveIndex = handler.getRefractiveIndex();
}
for (int i = 0; i < getSeriesCount(); i++) {
store.setObjectiveSettingsID(objectiveID, i);
if (refractiveIndex != null) {
store.setObjectiveSettingsRefractiveIndex(refractiveIndex, i);
}
}
setSeries(0);
if (getMetadataOptions().getMetadataLevel() == MetadataLevel.NO_OVERLAYS) {
return;
}
handler.populateROIs(store);
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class OIRReader method initFile.
// -- Internal FormatReader API methods --
/* @see loci.formats.FormatReader#initFile(String) */
@Override
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
Location current = new Location(id).getAbsoluteFile();
Location parent = current.getParentFile();
ArrayList<String> extraFiles = new ArrayList<String>();
if (parent != null) {
String[] fileList = parent.list();
Arrays.sort(fileList);
String prefix = current.getName();
if (prefix.indexOf(".") > 0) {
prefix = prefix.substring(0, prefix.lastIndexOf("."));
} else if (!checkSuffix(id, "oir")) {
prefix = prefix.substring(0, prefix.lastIndexOf("_"));
}
for (String file : fileList) {
// look for files ending with an underscore plus a 5 digit number
if (file.startsWith(prefix + "_") && file.length() == prefix.length() + 6) {
try {
int index = Integer.parseInt(file.substring(file.lastIndexOf("_") + 1));
if (index != extraFiles.size() + 1) {
LOGGER.warn("Found file {} with index {}; expected index {}", file, index, extraFiles.size() + 1);
}
extraFiles.add(new Location(parent, file).getAbsolutePath());
} catch (NumberFormatException e) {
}
} else if (file.startsWith(prefix) && checkSuffix(file, "oir")) {
current = new Location(parent, file);
currentId = current.getAbsolutePath();
}
}
}
CoreMetadata m = core.get(0);
m.littleEndian = true;
m.sizeZ = 1;
m.sizeC = 1;
m.sizeT = 1;
m.indexed = true;
m.falseColor = true;
try (RandomAccessInputStream s = new RandomAccessInputStream(currentId, BUFFER_SIZE)) {
readPixelsFile(current.getAbsolutePath(), s);
}
for (String file : extraFiles) {
try (RandomAccessInputStream s = new RandomAccessInputStream(file, BUFFER_SIZE)) {
readPixelsFile(file, s);
}
}
m.sizeC *= channels.size();
m.imageCount = getSizeC() * getSizeZ() * getSizeT();
LOGGER.debug("blocks per plane = {}", blocksPerPlane);
LOGGER.debug("number of pixel blocks = {}", pixelBlocks.size());
if (blocksPerPlane * getImageCount() != pixelBlocks.size()) {
// if blocks are missing, set the Z and T dimensions to match the last
// plane for which at least one block exists
int maxZ = 0;
int maxT = 0;
for (String uid : pixelBlocks.keySet()) {
LOGGER.debug(" checking uid = {}", uid);
int thisZ = getZ(uid);
int thisT = getT(uid);
int block = getBlock(uid);
// only count through last full plane
if (block == blocksPerPlane - 1) {
if (thisZ > maxZ) {
maxZ = thisZ;
}
if (thisT > maxT) {
maxT = thisT;
}
if (thisZ < minZ) {
minZ = thisZ;
}
if (thisT < minT) {
minT = thisT;
}
}
}
m.sizeZ = (maxZ - minZ) + 1;
m.sizeT = (maxT - minT) + 1;
m.imageCount = getSizeC() * getSizeZ() * getSizeT();
} else {
minZ = 0;
minT = 0;
}
m.dimensionOrder = "XYC";
if (getSizeZ() == 1 || getSizeT() == 1) {
m.dimensionOrder += "ZT";
} else {
int zIndex = baseName.toLowerCase().indexOf("z");
int tIndex = baseName.toLowerCase().indexOf("t");
if (zIndex < tIndex) {
m.dimensionOrder += "TZ";
} else {
m.dimensionOrder += "ZT";
}
}
pixelUIDs = pixelBlocks.keySet().toArray(new String[pixelBlocks.size()]);
Arrays.sort(pixelUIDs, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
int lastUnderscore1 = s1.lastIndexOf("_");
int lastUnderscore2 = s2.lastIndexOf("_");
Integer block1 = new Integer(s1.substring(lastUnderscore1 + 1));
Integer block2 = new Integer(s2.substring(lastUnderscore2 + 1));
int underscore1 = s1.lastIndexOf("_", lastUnderscore1 - 1);
int underscore2 = s2.lastIndexOf("_", lastUnderscore2 - 1);
String prefix1 = s1.substring(0, underscore1);
String prefix2 = s2.substring(0, underscore2);
String channel1 = s1.substring(underscore1 + 1, lastUnderscore1);
String channel2 = s2.substring(underscore2 + 1, lastUnderscore2);
if (!prefix1.equals(prefix2)) {
return s1.compareTo(s2);
}
if (!channel1.equals(channel2)) {
Integer index1 = -1;
Integer index2 = -2;
for (int i = 0; i < channels.size(); i++) {
if (channels.get(i).id.equals(channel1)) {
index1 = i;
}
if (channels.get(i).id.equals(channel2)) {
index2 = i;
}
}
return index1.compareTo(index2);
}
return block1.compareTo(block2);
}
});
if (LOGGER.isTraceEnabled()) {
for (int i = 0; i < pixelUIDs.length; i++) {
LOGGER.trace("pixel UID #{} = {}", i, pixelUIDs[i]);
}
}
// populate original metadata
Hashtable<String, Object> tmpMeta = new Hashtable<String, Object>();
addMeta("Creation date", acquisitionDate, tmpMeta);
addMeta("Pixel Length X", physicalSizeX, tmpMeta);
addMeta("Pixel Length Y", physicalSizeY, tmpMeta);
addMeta("Z step", physicalSizeZ, tmpMeta);
for (Channel channel : channels) {
String prefix = "Channel " + channel.name + " ";
addMetaList(prefix + "ID", channel.id, tmpMeta);
addMetaList(prefix + "color", channel.color, tmpMeta);
addMetaList(prefix + "pinhole", channel.pinhole, tmpMeta);
addMetaList(prefix + "start wavelength", channel.excitation, tmpMeta);
addMetaList(prefix + "end wavelength", channel.emission, tmpMeta);
addMetaList(prefix + "linked laser index", channel.laserIndex, tmpMeta);
}
for (Objective objective : objectives) {
addMetaList("Objective Lens name", objective.name, tmpMeta);
addMetaList("Objective Lens magnification", objective.magnification, tmpMeta);
addMetaList("Objective Lens na", objective.na, tmpMeta);
addMetaList("Objective Lens wd", objective.wd, tmpMeta);
addMetaList("Objective Lens refractive index", objective.ri, tmpMeta);
addMetaList("Objective Lens immersion", objective.immersion, tmpMeta);
}
for (Laser laser : lasers) {
String prefix = "Laser " + laser.name + " ";
addMetaList(prefix + "ID", laser.id, tmpMeta);
addMetaList(prefix + "data ID", laser.dataId, tmpMeta);
addMetaList(prefix + "power", laser.power, tmpMeta);
addMetaList(prefix + "transmissivity", laser.transmissivity, tmpMeta);
addMetaList(prefix + "wavelength", laser.wavelength, tmpMeta);
}
for (Detector detector : detectors) {
addMetaList("Detector ID", detector.id, tmpMeta);
addMetaList("Detector linked channel ID", detector.channelId, tmpMeta);
addMetaList("Detector voltage", detector.voltage, tmpMeta);
addMetaList("Detector offset", detector.offset, tmpMeta);
addMetaList("Detector gain", detector.gain, tmpMeta);
}
// this ensures that global metadata keys will be sorted before series keys
MetadataTools.merge(tmpMeta, metadata, "- ");
// populate MetadataStore
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
store.setImageInstrumentRef(instrumentID, 0);
for (int i = 0; i < lasers.size(); i++) {
Laser l = lasers.get(i);
String lsid = MetadataTools.createLSID("LightSource", 0, i);
store.setLaserID(lsid, 0, i);
store.setLaserModel(l.id, 0, i);
if (l.wavelength != null) {
store.setLaserWavelength(FormatTools.getWavelength(l.wavelength, null), 0, i);
}
}
for (int i = 0; i < detectors.size(); i++) {
Detector detector = detectors.get(i);
String lsid = MetadataTools.createLSID("Detector", 0, i);
store.setDetectorID(lsid, 0, i);
store.setDetectorOffset(detector.offset, 0, i);
store.setDetectorVoltage(FormatTools.createElectricPotential(detector.voltage, UNITS.VOLT), 0, i);
store.setDetectorGain(detector.gain, 0, i);
}
for (int i = 0; i < objectives.size(); i++) {
Objective objective = objectives.get(i);
String lsid = MetadataTools.createLSID("Objective", 0, i);
store.setObjectiveID(lsid, 0, i);
store.setObjectiveModel(objective.name, 0, i);
store.setObjectiveNominalMagnification(objective.magnification, 0, i);
store.setObjectiveLensNA(objective.na, 0, i);
store.setObjectiveWorkingDistance(FormatTools.createLength(objective.wd, UNITS.MILLIMETRE), 0, i);
store.setObjectiveImmersion(objective.immersion, 0, i);
if (i == 0) {
store.setObjectiveSettingsID(lsid, 0);
store.setObjectiveSettingsRefractiveIndex(objective.ri, 0);
}
}
if (acquisitionDate != null) {
store.setImageAcquisitionDate(acquisitionDate, 0);
}
if (physicalSizeX != null) {
store.setPixelsPhysicalSizeX(physicalSizeX, 0);
}
if (physicalSizeY != null) {
store.setPixelsPhysicalSizeY(physicalSizeY, 0);
}
if (physicalSizeZ != null) {
store.setPixelsPhysicalSizeZ(physicalSizeZ, 0);
}
for (int c = 0; c < channels.size(); c++) {
Channel ch = channels.get(c);
store.setChannelName(ch.name, 0, c);
if (ch.color != null) {
store.setChannelColor(ch.color, 0, c);
}
if (ch.pinhole != null) {
store.setChannelPinholeSize(ch.pinhole, 0, c);
}
if (ch.emission != null) {
store.setChannelEmissionWavelength(ch.emission, 0, c);
}
if (ch.excitation != null) {
store.setChannelExcitationWavelength(ch.excitation, 0, c);
}
for (int d = 0; d < detectors.size(); d++) {
if (detectors.get(d).channelId.equals(ch.id)) {
store.setDetectorSettingsID(MetadataTools.createLSID("Detector", 0, d), 0, c);
}
}
if (ch.laserIndex >= 0 && ch.laserIndex < lasers.size()) {
String laserId = MetadataTools.createLSID("LightSource", 0, ch.laserIndex);
store.setChannelLightSourceSettingsID(laserId, 0, c);
}
}
}
use of loci.common.Location in project bioformats by openmicroscopy.
the class OperettaReader method isThisType.
/* @see loci.formats.IFormatReader#isThisType(String, boolean) */
@Override
public boolean isThisType(String name, boolean open) {
String localName = new Location(name).getName();
if (localName.equals(XML_FILE)) {
return true;
}
Location parent = new Location(name).getAbsoluteFile().getParentFile();
Location xml = new Location(parent, XML_FILE);
if (!xml.exists()) {
return false;
}
return super.isThisType(name, open);
}
Aggregations