/* @see BaseTiffReader#initMetadataStore() */
protected void initMetadataStore() throws FormatException {
super.initMetadataStore();
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this, true);
if (date != null) {
date = DateTools.formatDate(date, DATE_FORMAT);
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), 0);
}
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
store.setImageDescription(MAGIC_STRING, 0);
if (scaling > 0) {
store.setPixelsPhysicalSizeX(new PositiveFloat(scaling), 0);
store.setPixelsPhysicalSizeY(new PositiveFloat(scaling), 0);
} else {
LOGGER.warn("Expected positive value for PhysicalSize; got {}", scaling);
}
String instrument = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrument, 0);
store.setImageInstrumentRef(instrument, 0);
store.setObjectiveID(MetadataTools.createLSID("Objective", 0, 0), 0, 0);
if (magnification > 0) {
store.setObjectiveNominalMagnification(new PositiveInteger(magnification), 0, 0);
} else {
LOGGER.warn("Expected positive value for NominalMagnification; got {}", magnification);
}
store.setObjectiveImmersion(getImmersion(immersion), 0, 0);
String detector = MetadataTools.createLSID("Detector", 0, 0);
store.setDetectorID(detector, 0, 0);
store.setDetectorModel(cameraType + " " + cameraName, 0, 0);
store.setDetectorType(getDetectorType("CCD"), 0, 0);
for (int i = 0; i < getSizeC(); i++) {
store.setDetectorSettingsID(detector, 0, i);
store.setDetectorSettingsBinning(getBinning(binning), 0, i);
}
for (int i = 0; i < getImageCount(); i++) {
int[] zct = getZCTCoords(i);
store.setPlaneExposureTime(exposureTimes.get(zct[1]) / 1000000, 0, i);
}
}
}
/* @see loci.formats.FormatReader#initFile(String) */
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
in = new RandomAccessInputStream(id);
CoreMetadata m = core.get(0);
m.littleEndian = true;
in.order(isLittleEndian());
while (in.getFilePointer() < MAX_HEADER_SIZE) {
readVariable();
}
in.seek(pixelsOffset);
m.sizeX = in.readShort();
pixelsOffset += 2;
m.sizeY = getSizeX();
m.pixelType = FormatTools.UINT16;
m.sizeZ = 1;
m.sizeC = 1;
m.sizeT = 1;
m.imageCount = 1;
m.dimensionOrder = "XYZCT";
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
if (date != null) {
date = DateTools.formatDate(date, "MMM dd yyyy HH:mm:ssSSS");
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), 0);
}
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
store.setImageDescription(comment, 0);
PositiveFloat sizeX = FormatTools.getPhysicalSizeX((double) xSize / getSizeX());
PositiveFloat sizeY = FormatTools.getPhysicalSizeY((double) xSize / getSizeY());
if (sizeX != null) {
store.setPixelsPhysicalSizeX(sizeX, 0);
}
if (sizeY != null) {
store.setPixelsPhysicalSizeY(sizeY, 0);
}
}
}
/**
* Populates the metadata store using the data parsed in {@link #initStandardMetadata()} along
* with some further parsing done in the method itself.
*
* <p>All calls to the active <code>MetadataStore</code> should be made in this method and
* <b>only</b> in this method. This is especially important for sub-classes that override the
* getters for pixel set array size, etc.
*/
protected void initMetadataStore() throws FormatException {
LOGGER.info("Populating OME metadata");
// the metadata store we're working with
MetadataStore store = makeFilterMetadata();
IFD firstIFD = ifds.get(0);
IFD exif = null;
if (ifds.get(0).containsKey(IFD.EXIF)) {
try {
IFDList exifIFDs = tiffParser.getExifIFDs();
if (exifIFDs.size() > 0) {
exif = exifIFDs.get(0);
}
tiffParser.fillInIFD(exif);
} catch (IOException e) {
LOGGER.debug("Could not read EXIF IFDs", e);
}
}
MetadataTools.populatePixels(store, this, exif != null);
// format the creation date to ISO 8601
String creationDate = getImageCreationDate();
String date = DateTools.formatDate(creationDate, DATE_FORMATS);
if (creationDate != null && date == null) {
LOGGER.warn("unknown creation date format: {}", creationDate);
}
creationDate = date;
// populate Image
if (creationDate != null) {
store.setImageAcquisitionDate(new Timestamp(creationDate), 0);
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
// populate Experimenter
String artist = firstIFD.getIFDTextValue(IFD.ARTIST);
if (artist != null) {
String firstName = null, lastName = null;
int ndx = artist.indexOf(" ");
if (ndx < 0) lastName = artist;
else {
firstName = artist.substring(0, ndx);
lastName = artist.substring(ndx + 1);
}
String email = firstIFD.getIFDStringValue(IFD.HOST_COMPUTER);
store.setExperimenterFirstName(firstName, 0);
store.setExperimenterLastName(lastName, 0);
store.setExperimenterEmail(email, 0);
store.setExperimenterID(MetadataTools.createLSID("Experimenter", 0), 0);
}
store.setImageDescription(firstIFD.getComment(), 0);
// set the X and Y pixel dimensions
double pixX = firstIFD.getXResolution();
double pixY = firstIFD.getYResolution();
PositiveFloat sizeX = FormatTools.getPhysicalSizeX(pixX);
PositiveFloat sizeY = FormatTools.getPhysicalSizeY(pixY);
if (sizeX != null) {
store.setPixelsPhysicalSizeX(sizeX, 0);
}
if (sizeY != null) {
store.setPixelsPhysicalSizeY(sizeY, 0);
}
store.setPixelsPhysicalSizeZ(null, 0);
if (exif != null) {
if (exif.containsKey(IFD.EXPOSURE_TIME)) {
Object exp = exif.get(IFD.EXPOSURE_TIME);
if (exp instanceof TiffRational) {
Double exposure = ((TiffRational) exp).doubleValue();
for (int i = 0; i < getImageCount(); i++) {
store.setPlaneExposureTime(exposure, 0, i);
}
}
}
}
}
}
/* @see loci.formats.FormatReader#initFile(String) */
public void initFile(String id) throws FormatException, IOException {
super.initFile(id);
in = new RandomAccessInputStream(id);
MetadataLevel level = getMetadataOptions().getMetadataLevel();
LOGGER.info("Reading header");
// check endianness
in.seek(ENDIANNESS_OFFSET);
core[0].littleEndian = in.read() == 68;
// read dimension information from 1024 byte header
in.seek(0);
in.order(isLittleEndian());
core[0].sizeX = in.readInt();
core[0].sizeY = in.readInt();
core[0].sizeZ = in.readInt();
// We are using BigInteger here because of the very real possiblity
// of not just an int overflow but also a long overflow when multiplying
// sizeX * sizeY * sizeZ.
BigInteger v = BigInteger.valueOf(getSizeX());
v = v.multiply(BigInteger.valueOf(getSizeY()));
v = v.multiply(BigInteger.valueOf(getSizeZ()));
if (getSizeX() < 0
|| getSizeY() < 0
|| getSizeZ() < 0
|| (v.compareTo(BigInteger.valueOf(in.length())) > 0)) {
LOGGER.debug("Detected endianness is wrong, swapping");
core[0].littleEndian = !isLittleEndian();
in.seek(0);
in.order(isLittleEndian());
core[0].sizeX = in.readInt();
core[0].sizeY = in.readInt();
core[0].sizeZ = in.readInt();
}
core[0].sizeC = 1;
int mode = in.readInt();
switch (mode) {
case 0:
core[0].pixelType = FormatTools.UINT8;
break;
case 1:
core[0].pixelType = FormatTools.INT16;
break;
case 6:
core[0].pixelType = FormatTools.UINT16;
break;
case 2:
core[0].pixelType = FormatTools.FLOAT;
break;
case 3:
core[0].pixelType = FormatTools.UINT32;
break;
case 4:
core[0].pixelType = FormatTools.DOUBLE;
break;
case 16:
core[0].sizeC = 3;
core[0].pixelType = FormatTools.UINT16;
break;
}
in.skipBytes(12);
// pixel size = xlen / mx
double xSize = 0d, ySize = 0d, zSize = 0d;
if (level != MetadataLevel.MINIMUM) {
int mx = in.readInt();
int my = in.readInt();
int mz = in.readInt();
// physical sizes are stored in ångströms, we want them in µm
xSize = (in.readFloat() / mx) / 10000.0;
ySize = (in.readFloat() / my) / 10000.0;
zSize = (in.readFloat() / mz) / 10000.0;
addGlobalMeta("Pixel size (X)", xSize);
addGlobalMeta("Pixel size (Y)", ySize);
addGlobalMeta("Pixel size (Z)", zSize);
addGlobalMeta("Alpha angle", in.readFloat());
addGlobalMeta("Beta angle", in.readFloat());
addGlobalMeta("Gamma angle", in.readFloat());
in.skipBytes(12);
// min, max and mean pixel values
} else in.skipBytes(48);
double minValue = in.readFloat();
double maxValue = in.readFloat();
addGlobalMeta("Minimum pixel value", minValue);
addGlobalMeta("Maximum pixel value", maxValue);
addGlobalMeta("Mean pixel value", in.readFloat());
int bytes = FormatTools.getBytesPerPixel(getPixelType());
double range = Math.pow(2, bytes * 8) - 1;
double pixelTypeMin = 0;
boolean signed = FormatTools.isSigned(getPixelType());
if (signed) {
pixelTypeMin -= (range / 2);
}
double pixelTypeMax = pixelTypeMin + range;
if (pixelTypeMax < maxValue || pixelTypeMin > minValue && signed) {
// make the pixel type unsigned
switch (getPixelType()) {
case FormatTools.INT8:
core[0].pixelType = FormatTools.UINT8;
break;
case FormatTools.INT16:
core[0].pixelType = FormatTools.UINT16;
break;
case FormatTools.INT32:
core[0].pixelType = FormatTools.UINT32;
break;
}
}
in.skipBytes(4);
extHeaderSize = in.readInt();
if (level != MetadataLevel.MINIMUM) {
in.skipBytes(64);
int idtype = in.readShort();
String type = "unknown";
if (idtype >= 0 && idtype < TYPES.length) type = TYPES[idtype];
addGlobalMeta("Series type", type);
addGlobalMeta("Lens", in.readShort());
addGlobalMeta("ND1", in.readShort());
addGlobalMeta("ND2", in.readShort());
addGlobalMeta("VD1", in.readShort());
addGlobalMeta("VD2", in.readShort());
for (int i = 0; i < 6; i++) {
addGlobalMeta("Angle " + (i + 1), in.readFloat());
}
in.skipBytes(24);
addGlobalMeta("Number of useful labels", in.readInt());
for (int i = 0; i < 10; i++) {
addGlobalMeta("Label " + (i + 1), in.readString(80));
}
}
LOGGER.info("Populating metadata");
core[0].sizeT = 1;
core[0].dimensionOrder = "XYZTC";
core[0].imageCount = getSizeZ();
core[0].rgb = false;
core[0].interleaved = true;
core[0].indexed = false;
core[0].falseColor = false;
core[0].metadataComplete = true;
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
if (level != MetadataLevel.MINIMUM) {
if (xSize - Constants.EPSILON > 0) {
store.setPixelsPhysicalSizeX(new PositiveFloat(xSize), 0);
} else {
LOGGER.warn("xSize {} not a positive float skipping", xSize);
}
if (ySize - Constants.EPSILON > 0) {
store.setPixelsPhysicalSizeY(new PositiveFloat(ySize), 0);
} else {
LOGGER.warn("ySize {} not a positive float skipping", ySize);
}
if (zSize - Constants.EPSILON > 0) {
store.setPixelsPhysicalSizeZ(new PositiveFloat(zSize), 0);
} else {
LOGGER.warn("zSize {} not a positive float skipping", zSize);
}
}
}
@Override
protected void initFile(String id) throws FormatException, IOException {
LOGGER.debug("OmeroReader.initFile({})", id);
super.initFile(id);
if (!id.startsWith("omero:")) {
throw new IllegalArgumentException("Not an OMERO id: " + id);
}
// parse credentials from id string
LOGGER.info("Parsing credentials");
String address = server, user = username, pass = password;
int port = thePort;
long iid = -1;
final String[] tokens = id.substring(6).split("\n");
for (String token : tokens) {
final int equals = token.indexOf("=");
if (equals < 0) continue;
final String key = token.substring(0, equals);
final String val = token.substring(equals + 1);
if (key.equals("server")) address = val;
else if (key.equals("user")) user = val;
else if (key.equals("pass")) pass = val;
else if (key.equals("port")) {
try {
port = Integer.parseInt(val);
} catch (NumberFormatException exc) {
}
} else if (key.equals("session")) {
sessionID = val;
} else if (key.equals("groupName")) {
group = val;
} else if (key.equals("groupID")) {
groupID = new Long(val);
} else if (key.equals("iid")) {
try {
iid = Long.parseLong(val);
} catch (NumberFormatException exc) {
}
}
}
if (address == null) {
throw new FormatException("Invalid server address");
}
if (user == null && sessionID == null) {
throw new FormatException("Invalid username");
}
if (pass == null && sessionID == null) {
throw new FormatException("Invalid password");
}
if (iid < 0) {
throw new FormatException("Invalid image ID");
}
try {
// authenticate with OMERO server
LOGGER.info("Logging in");
client = new omero.client(address, port);
ServiceFactoryPrx serviceFactory = null;
if (user != null && pass != null) {
serviceFactory = client.createSession(user, pass);
} else {
serviceFactory = client.createSession(sessionID, sessionID);
}
if (!encrypted) {
client = client.createClient(false);
serviceFactory = client.getSession();
}
if (group != null || groupID != null) {
IAdminPrx iAdmin = serviceFactory.getAdminService();
IQueryPrx iQuery = serviceFactory.getQueryService();
EventContext eventContext = iAdmin.getEventContext();
ExperimenterGroup defaultGroup = iAdmin.getDefaultGroup(eventContext.userId);
if (!defaultGroup.getName().getValue().equals(group)
&& !new Long(defaultGroup.getId().getValue()).equals(groupID)) {
Experimenter exp = iAdmin.getExperimenter(eventContext.userId);
ParametersI p = new ParametersI();
p.addId(eventContext.userId);
List<IObject> groupList =
iQuery.findAllByQuery(
"select distinct g from ExperimenterGroup as g "
+ "join fetch g.groupExperimenterMap as map "
+ "join fetch map.parent e "
+ "left outer join fetch map.child u "
+ "left outer join fetch u.groupExperimenterMap m2 "
+ "left outer join fetch m2.parent p "
+ "where g.id in "
+ " (select m.parent from GroupExperimenterMap m "
+ " where m.child.id = :id )",
p);
Iterator<IObject> i = groupList.iterator();
ExperimenterGroup g = null;
boolean in = false;
while (i.hasNext()) {
g = (ExperimenterGroup) i.next();
if (g.getName().getValue().equals(group)
|| new Long(g.getId().getValue()).equals(groupID)) {
in = true;
groupID = g.getId().getValue();
break;
}
}
if (in) {
iAdmin.setDefaultGroup(exp, iAdmin.getGroup(groupID));
serviceFactory.setSecurityContext(new ExperimenterGroupI(groupID, false));
}
}
}
// get raw pixels store and pixels
store = serviceFactory.createRawPixelsStore();
final GatewayPrx gateway = serviceFactory.createGateway();
img = gateway.getImage(iid);
if (img == null) {
throw new FormatException(
"Could not find Image with ID=" + iid + " in group '" + group + "'.");
}
long pixelsId = img.getPixels(0).getId().getValue();
store.setPixelsId(pixelsId, false);
pix = gateway.getPixels(pixelsId);
final int sizeX = pix.getSizeX().getValue();
final int sizeY = pix.getSizeY().getValue();
final int sizeZ = pix.getSizeZ().getValue();
final int sizeC = pix.getSizeC().getValue();
final int sizeT = pix.getSizeT().getValue();
final String pixelType = pix.getPixelsType().getValue().getValue();
// populate metadata
LOGGER.info("Populating metadata");
core[0].sizeX = sizeX;
core[0].sizeY = sizeY;
core[0].sizeZ = sizeZ;
core[0].sizeC = sizeC;
core[0].sizeT = sizeT;
core[0].rgb = false;
core[0].littleEndian = false;
core[0].dimensionOrder = "XYZCT";
core[0].imageCount = sizeZ * sizeC * sizeT;
core[0].pixelType = FormatTools.pixelTypeFromString(pixelType);
RDouble x = pix.getPhysicalSizeX();
Double px = x == null ? null : x.getValue();
RDouble y = pix.getPhysicalSizeY();
Double py = y == null ? null : y.getValue();
RDouble z = pix.getPhysicalSizeZ();
Double pz = z == null ? null : z.getValue();
RDouble t = pix.getTimeIncrement();
Double time = t == null ? null : t.getValue();
RString imageName = img.getName();
String name = imageName == null ? null : imageName.getValue();
if (name != null) {
currentId = name;
} else {
currentId = "Image ID " + iid;
}
RString imgDescription = img.getDescription();
String description = imgDescription == null ? null : imgDescription.getValue();
RTime date = img.getAcquisitionDate();
MetadataStore store = getMetadataStore();
MetadataTools.populatePixels(store, this);
store.setImageName(name, 0);
store.setImageDescription(description, 0);
if (date != null) {
store.setImageAcquisitionDate(
new Timestamp(DateTools.convertDate(date.getValue(), (int) DateTools.UNIX_EPOCH)), 0);
}
if (px != null && px > 0) {
store.setPixelsPhysicalSizeX(new PositiveFloat(px), 0);
}
if (py != null && py > 0) {
store.setPixelsPhysicalSizeY(new PositiveFloat(py), 0);
}
if (pz != null && pz > 0) {
store.setPixelsPhysicalSizeZ(new PositiveFloat(pz), 0);
}
if (time != null) {
store.setPixelsTimeIncrement(time, 0);
}
List<Channel> channels = pix.copyChannels();
for (int c = 0; c < channels.size(); c++) {
LogicalChannel channel = channels.get(c).getLogicalChannel();
RInt emWave = channel.getEmissionWave();
RInt exWave = channel.getExcitationWave();
RDouble pinholeSize = channel.getPinHoleSize();
RString cname = channel.getName();
Integer emission = emWave == null ? null : emWave.getValue();
Integer excitation = exWave == null ? null : exWave.getValue();
String channelName = cname == null ? null : cname.getValue();
Double pinhole = pinholeSize == null ? null : pinholeSize.getValue();
if (channelName != null) {
store.setChannelName(channelName, 0, c);
}
if (pinhole != null) {
store.setChannelPinholeSize(pinhole, 0, c);
}
if (emission != null && emission > 0) {
store.setChannelEmissionWavelength(new PositiveInteger(emission), 0, c);
}
if (excitation != null && excitation > 0) {
store.setChannelExcitationWavelength(new PositiveInteger(excitation), 0, c);
}
}
} catch (CannotCreateSessionException e) {
throw new FormatException(e);
} catch (PermissionDeniedException e) {
throw new FormatException(e);
} catch (ServerError e) {
throw new FormatException(e);
}
}
private void populateMetadata() throws FormatException, IOException {
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this, true);
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
for (int i = 0; i < positions.size(); i++) {
Position p = positions.get(i);
if (p.time != null) {
String date = DateTools.formatDate(p.time, DATE_FORMAT);
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), i);
}
}
if (positions.size() > 1) {
Location parent = new Location(p.metadataFile).getParentFile();
store.setImageName(parent.getName(), i);
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
store.setImageDescription(p.comment, i);
// link Instrument and Image
store.setImageInstrumentRef(instrumentID, i);
for (int c = 0; c < p.channels.length; c++) {
store.setChannelName(p.channels[c], i, c);
}
if (p.pixelSize != null && p.pixelSize > 0) {
store.setPixelsPhysicalSizeX(new PositiveFloat(p.pixelSize), i);
store.setPixelsPhysicalSizeY(new PositiveFloat(p.pixelSize), i);
} else {
LOGGER.warn("Expected positive value for PhysicalSizeX; got {}", p.pixelSize);
}
if (p.sliceThickness != null && p.sliceThickness > 0) {
store.setPixelsPhysicalSizeZ(new PositiveFloat(p.sliceThickness), i);
} else {
LOGGER.warn("Expected positive value for PhysicalSizeZ; got {}", p.sliceThickness);
}
int nextStamp = 0;
for (int q = 0; q < getImageCount(); q++) {
store.setPlaneExposureTime(p.exposureTime, i, q);
String tiff = positions.get(getSeries()).getFile(q);
if (tiff != null && new Location(tiff).exists() && nextStamp < p.timestamps.length) {
store.setPlaneDeltaT(p.timestamps[nextStamp++], i, q);
}
}
String serialNumber = p.detectorID;
p.detectorID = MetadataTools.createLSID("Detector", 0, i);
for (int c = 0; c < p.channels.length; c++) {
store.setDetectorSettingsBinning(getBinning(p.binning), i, c);
store.setDetectorSettingsGain(new Double(p.gain), i, c);
if (c < p.voltage.size()) {
store.setDetectorSettingsVoltage(p.voltage.get(c), i, c);
}
store.setDetectorSettingsID(p.detectorID, i, c);
}
store.setDetectorID(p.detectorID, 0, i);
if (p.detectorModel != null) {
store.setDetectorModel(p.detectorModel, 0, i);
}
if (serialNumber != null) {
store.setDetectorSerialNumber(serialNumber, 0, i);
}
if (p.detectorManufacturer != null) {
store.setDetectorManufacturer(p.detectorManufacturer, 0, i);
}
if (p.cameraMode == null) p.cameraMode = "Other";
store.setDetectorType(getDetectorType(p.cameraMode), 0, i);
store.setImagingEnvironmentTemperature(p.temperature, i);
}
}
}
/* @see loci.formats.FormatReader#initFile(String) */
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
Vector<String> uniqueChannels = new Vector<String>();
Vector<Double> uniqueZs = new Vector<Double>();
Vector<Double> stageX = new Vector<Double>();
Vector<Double> stageY = new Vector<Double>();
String filename = id.substring(id.lastIndexOf(File.separator) + 1);
filename = filename.substring(0, filename.indexOf("."));
boolean integerFilename = true;
try {
Integer.parseInt(filename);
} catch (NumberFormatException e) {
integerFilename = false;
}
if (integerFilename
&& ifds.size() == 1
&& ifds.get(0).getIFDIntValue(IFD.NEW_SUBFILE_TYPE) == 2) {
// look for other files in the dataset
findTIFFs();
String stageLabel = null;
for (String tiff : files) {
MetamorphHandler handler = new MetamorphHandler();
parseFile(tiff, handler);
String label = handler.getStageLabel();
if (stageLabel == null) {
stageLabel = label;
} else if (!label.equals(stageLabel)) {
break;
}
if (!uniqueChannels.contains(handler.getChannelName())) {
uniqueChannels.add(handler.getChannelName());
}
Vector<Double> zPositions = handler.getZPositions();
Double pos = Math.rint(zPositions.get(0));
if (!uniqueZs.contains(pos)) {
uniqueZs.add(pos);
}
}
MetamorphHandler handler = new MetamorphHandler();
parseFile(files[files.length - 1], handler);
String lastStageLabel = handler.getStageLabel();
int lastField = getField(lastStageLabel);
int lastWellRow = getWellRow(lastStageLabel);
int lastWellColumn = getWellColumn(lastStageLabel);
int field = getField(stageLabel);
int fieldRow = getWellRow(stageLabel);
int fieldColumn = getWellColumn(stageLabel);
wellCount = lastField - field + 1;
fieldRowCount = lastWellRow - fieldRow + 1;
fieldColumnCount = lastWellColumn - fieldColumn + 1;
core[0].sizeC = uniqueChannels.size();
core[0].sizeZ = uniqueZs.size();
} else {
files = new String[] {id};
wellCount = 1;
fieldRowCount = 1;
fieldColumnCount = 1;
core[0].sizeC = 0;
}
// parse XML comment
MetamorphHandler handler = new MetamorphHandler(getGlobalMetadata());
Vector<Double> xPositions = new Vector<Double>();
Vector<Double> yPositions = new Vector<Double>();
for (IFD ifd : ifds) {
String xml = XMLTools.sanitizeXML(ifd.getComment());
XMLTools.parseXML(xml, handler);
double x = handler.getStagePositionX();
double y = handler.getStagePositionY();
if (xPositions.size() == 0) {
xPositions.add(x);
yPositions.add(y);
} else {
double previousX = xPositions.get(xPositions.size() - 1);
double previousY = yPositions.get(yPositions.size() - 1);
if (Math.abs(previousX - x) > 0.21 || Math.abs(previousY - y) > 0.21) {
xPositions.add(x);
yPositions.add(y);
}
}
}
if (xPositions.size() > 1) {
fieldRowCount = xPositions.size();
}
Vector<Integer> wavelengths = handler.getWavelengths();
Vector<Double> zPositions = handler.getZPositions();
// calculate axis sizes
Vector<Integer> uniqueC = new Vector<Integer>();
for (Integer c : wavelengths) {
if (!uniqueC.contains(c)) {
uniqueC.add(c);
}
}
int effectiveC = uniqueC.size();
if (effectiveC == 0) effectiveC = 1;
if (getSizeC() == 0) core[0].sizeC = 1;
int samples = ifds.get(0).getSamplesPerPixel();
core[0].sizeC *= effectiveC * samples;
Vector<Double> uniqueZ = new Vector<Double>();
for (Double z : zPositions) {
if (!uniqueZ.contains(z)) uniqueZ.add(z);
}
if (getSizeZ() == 0) core[0].sizeZ = 1;
core[0].sizeZ *= uniqueZ.size();
int totalPlanes = files.length * ifds.size();
effectiveC = getSizeC() / samples;
core[0].sizeT =
totalPlanes / (wellCount * fieldRowCount * fieldColumnCount * getSizeZ() * effectiveC);
if (getSizeT() == 0) core[0].sizeT = 1;
int seriesCount = wellCount * fieldRowCount * fieldColumnCount;
if (seriesCount > 1 && getSizeZ() > totalPlanes / seriesCount) {
core[0].sizeZ = 1;
core[0].sizeT = totalPlanes / (seriesCount * getSizeT() * effectiveC);
}
core[0].imageCount = getSizeZ() * getSizeT() * effectiveC;
if (seriesCount > 1) {
CoreMetadata oldCore = core[0];
core = new CoreMetadata[seriesCount];
for (int i = 0; i < seriesCount; i++) {
core[i] = oldCore;
}
}
for (int s = 0; s < wellCount * fieldRowCount * fieldColumnCount; s++) {
if (files.length > 1) {
int[] lengths =
new int[] {
getSizeZ(),
getEffectiveSizeC(),
fieldColumnCount,
fieldRowCount,
wellCount,
getSizeT()
};
Well well = getWell(s);
int[] position = new int[] {0, 0, well.fieldCol, well.fieldRow, well.well, 0};
int fileIndex = FormatTools.positionToRaster(lengths, position);
parseFile(files[fileIndex], handler);
stageX.add(handler.getStagePositionX());
stageY.add(handler.getStagePositionY());
} else {
stageX.add(xPositions.get(s));
stageY.add(yPositions.get(s));
}
}
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
store.setPlateRowNamingConvention(NamingConvention.LETTER, 0);
store.setPlateColumnNamingConvention(NamingConvention.NUMBER, 0);
for (int well = 0; well < wellCount; well++) {
store.setWellID(MetadataTools.createLSID("Well", 0, well), 0, well);
store.setWellRow(new NonNegativeInteger(0), 0, well);
store.setWellColumn(new NonNegativeInteger(well), 0, well);
for (int row = 0; row < fieldRowCount; row++) {
for (int col = 0; col < fieldColumnCount; col++) {
int field = row * fieldColumnCount + col;
String wellSampleID = MetadataTools.createLSID("WellSample", 0, well, field);
store.setWellSampleID(wellSampleID, 0, well, field);
int seriesIndex = getSeriesIndex(row, col, well);
String imageID = MetadataTools.createLSID("Image", seriesIndex);
store.setImageID(imageID, seriesIndex);
store.setWellSampleImageRef(imageID, 0, well, field);
store.setWellSampleIndex(new NonNegativeInteger(seriesIndex), 0, well, field);
}
}
}
for (int s = 0; s < seriesCount; s++) {
setSeries(s);
Well well = getWell(s);
String name = handler.getImageName();
if (seriesCount > 1) {
name =
"Field "
+ (char) (well.fieldRow + 'A')
+ (well.fieldCol + 1)
+ ", Well "
+ (well.well + 1)
+ ": "
+ name;
}
store.setImageName(name, s);
String date = DateTools.formatDate(handler.getDate(), DateTools.ISO8601_FORMAT);
store.setImageAcquiredDate(date, s);
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
Vector<String> timestamps = handler.getTimestamps();
Vector<Double> exposures = handler.getExposures();
for (int i = 0; i < timestamps.size(); i++) {
long timestamp = DateTools.getTime(timestamps.get(i), DATE_FORMAT);
addSeriesMeta("timestamp " + i, timestamp);
}
for (int i = 0; i < exposures.size(); i++) {
addSeriesMeta("exposure time " + i + " (ms)", exposures.get(i).floatValue() * 1000);
}
long startDate = 0;
if (timestamps.size() > 0) {
startDate = DateTools.getTime(timestamps.get(0), DATE_FORMAT);
}
store.setImageDescription("", s);
int image = 0;
for (int c = 0; c < getEffectiveSizeC(); c++) {
for (int t = 0; t < getSizeT(); t++) {
store.setPlaneTheZ(new NonNegativeInteger(0), s, image);
store.setPlaneTheC(new NonNegativeInteger(c), s, image);
store.setPlaneTheT(new NonNegativeInteger(t), s, image);
if (t < timestamps.size()) {
String stamp = timestamps.get(t);
long ms = DateTools.getTime(stamp, DATE_FORMAT);
store.setPlaneDeltaT((ms - startDate) / 1000.0, s, image);
}
if (image < exposures.size()) {
store.setPlaneExposureTime(exposures.get(image), s, image);
}
if (s < stageX.size()) {
store.setPlanePositionX(stageX.get(s), s, image);
}
if (s < stageY.size()) {
store.setPlanePositionY(stageY.get(s), s, image);
}
image++;
}
}
store.setImagingEnvironmentTemperature(handler.getTemperature(), s);
store.setPixelsPhysicalSizeX(new PositiveFloat(handler.getPixelSizeX()), s);
store.setPixelsPhysicalSizeY(new PositiveFloat(handler.getPixelSizeY()), s);
for (int c = 0; c < getEffectiveSizeC(); c++) {
if (uniqueChannels.size() > c) {
store.setChannelName(uniqueChannels.get(c), s, c);
} else store.setChannelName(handler.getChannelName(), s, c);
}
}
}
}
/* @see loci.formats.FormatReader#initFile(String) */
protected void initFile(String id) throws FormatException, IOException {
super.initFile(id);
in = new RandomAccessInputStream(id);
core[0].littleEndian = true;
in.order(isLittleEndian());
String comment = null;
MetadataLevel level = getMetadataOptions().getMetadataLevel();
if (level != MetadataLevel.MINIMUM) {
in.seek(49);
comment = in.readString(33);
}
in.seek(211);
int year = in.readInt();
int month = in.readInt();
int day = in.readInt();
int hour = in.readInt();
int min = in.readInt();
String date = year + "-" + month + "-" + day + "T" + hour + ":" + min;
date = DateTools.formatDate(date, "yyyy-MM-dd'T'HH:mm");
in.skipBytes(8);
double xSize = in.readInt() / 100d;
double ySize = in.readInt() / 100d;
double zSize = in.readInt() / 100d;
core[0].sizeX = in.readInt();
core[0].sizeY = in.readInt();
if (level != MetadataLevel.MINIMUM) {
double tunnelCurrent = in.readInt() / 1000d;
double sampleVolts = in.readInt() / 1000d;
in.skipBytes(180);
int originalZMax = in.readInt();
int originalZMin = in.readInt();
int zMax = in.readInt();
int zMin = in.readInt();
addGlobalMeta("Comment", comment);
addGlobalMeta("X size (in um)", xSize);
addGlobalMeta("Y size (in um)", ySize);
addGlobalMeta("Z size (in um)", zSize);
addGlobalMeta("Tunnel current (in amps)", tunnelCurrent);
addGlobalMeta("Sample volts", sampleVolts);
addGlobalMeta("Acquisition date", date);
}
core[0].pixelType = FormatTools.INT16;
core[0].sizeC = 1;
core[0].sizeZ = 1;
core[0].sizeT = 1;
core[0].imageCount = 1;
core[0].dimensionOrder = "XYZCT";
core[0].rgb = false;
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), 0);
}
if (level != MetadataLevel.MINIMUM) {
store.setImageDescription(comment, 0);
if (xSize > 0) {
store.setPixelsPhysicalSizeX(new PositiveFloat((double) xSize / getSizeX()), 0);
} else {
LOGGER.warn(
"Expected positive value for PhysicalSizeX; got {}", (double) xSize / getSizeX());
}
if (ySize > 0) {
store.setPixelsPhysicalSizeY(new PositiveFloat((double) ySize / getSizeY()), 0);
} else {
LOGGER.warn(
"Expected positive value for PhysicalSizeY; got {}", (double) ySize / getSizeY());
}
}
}
/* @see BaseTiffReader#initMetadataStore() */
@Override
protected void initMetadataStore() throws FormatException {
super.initMetadataStore();
MetadataStore store = makeFilterMetadata();
MetadataTools.populatePixels(store, this);
if (date != null) {
date = DateTools.formatDate(date, DATE_FORMAT);
if (date != null) {
store.setImageAcquisitionDate(new Timestamp(date), 0);
}
}
if (imageName != null) {
store.setImageName(imageName, 0);
}
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
if (imageDescription != null) {
store.setImageDescription(imageDescription, 0);
}
if (userName != null) {
store.setExperimenterID(MetadataTools.createLSID("Experimenter", 0), 0);
store.setExperimenterLastName(userName, 0);
}
if (microscopeModel != null) {
String instrument = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrument, 0);
store.setImageInstrumentRef(instrument, 0);
store.setMicroscopeModel(microscopeModel, 0);
}
if (detectors != null && detectors.size() > 0) {
String instrument = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrument, 0);
store.setImageInstrumentRef(instrument, 0);
for (int i = 0; i < detectors.size(); i++) {
String detectorID = MetadataTools.createLSID("Detector", 0, i);
store.setDetectorID(detectorID, 0, i);
store.setDetectorModel(detectors.get(i), 0, i);
store.setDetectorType(getDetectorType("Other"), 0, i);
}
}
if (magnification != null) {
store.setObjectiveID(MetadataTools.createLSID("Objective", 0, 0), 0, 0);
store.setObjectiveNominalMagnification(magnification, 0, 0);
store.setObjectiveCorrection(getCorrection("Other"), 0, 0);
store.setObjectiveImmersion(getImmersion("Other"), 0, 0);
}
store.setStageLabelX(stageX, 0);
store.setStageLabelY(stageY, 0);
store.setStageLabelZ(stageZ, 0);
store.setStageLabelName("", 0);
Length physicalSizeX = FormatTools.getPhysicalSizeX(sizeX);
Length physicalSizeY = FormatTools.getPhysicalSizeY(sizeY);
if (physicalSizeX != null) {
store.setPixelsPhysicalSizeX(physicalSizeX, 0);
}
if (physicalSizeY != null) {
store.setPixelsPhysicalSizeY(physicalSizeY, 0);
}
if (timeIncrement != null) {
store.setPixelsTimeIncrement(new Time(timeIncrement, UNITS.S), 0);
}
}
}