@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);
}
}
/* @see loci.formats.FormatReader#initFile(String) */
protected void initFile(String id) throws FormatException, IOException {
// make sure we have the experiment file
id = locateExperimentFile(id);
super.initFile(id);
Location dir = new Location(id).getAbsoluteFile().getParentFile();
for (String file : dir.list(true)) {
Location f = new Location(dir, file);
if (!f.isDirectory()) {
if (checkSuffix(file, META_EXT)) {
metadataFiles.add(f.getAbsolutePath());
}
}
}
// parse Experiment metadata
IniList experiment = readMetaData(id);
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
objective = experiment.getTable("Geometry").get("Name");
IniTable camera = experiment.getTable("Camera");
binning = camera.get("BinX") + "x" + camera.get("BinY");
parseChannelData(dir);
addGlobalMeta("Objective", objective);
addGlobalMeta("Camera binning", binning);
}
Vector<String> uniqueRows = new Vector<String>();
Vector<String> uniqueColumns = new Vector<String>();
for (String well : wellLabels) {
String row = well.substring(0, 1).trim();
String column = well.substring(1).trim();
if (!uniqueRows.contains(row) && row.length() > 0) uniqueRows.add(row);
if (!uniqueColumns.contains(column) && column.length() > 0) {
uniqueColumns.add(column);
}
}
int nSlices = getSizeZ() == 0 ? 1 : getSizeZ();
int nTimepoints = getSizeT();
int nWells = wellLabels.size();
int nChannels = getSizeC() == 0 ? channelNames.size() : getSizeC();
if (nChannels == 0) nChannels = 1;
tiffs = getTiffs(dir.getAbsolutePath());
reader = new MinimalTiffReader();
reader.setId(tiffs[0][0]);
int sizeX = reader.getSizeX();
int sizeY = reader.getSizeY();
int pixelType = reader.getPixelType();
boolean rgb = reader.isRGB();
boolean interleaved = reader.isInterleaved();
boolean indexed = reader.isIndexed();
boolean littleEndian = reader.isLittleEndian();
if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
IniParser parser = new IniParser();
for (String metadataFile : metadataFiles) {
String filename = new Location(metadataFile).getName();
if (!checkSuffix(metadataFile, "txt")) {
String data = DataTools.readFile(metadataFile);
IniList ini = parser.parseINI(new BufferedReader(new StringReader(data)));
HashMap<String, String> h = ini.flattenIntoHashMap();
for (String key : h.keySet()) {
addGlobalMeta(filename + " " + key, h.get(key));
}
}
}
}
for (int i = 0; i < getSeriesCount(); i++) {
core[i] = new CoreMetadata();
core[i].sizeC = nChannels;
core[i].sizeZ = nSlices;
core[i].sizeT = nTimepoints;
core[i].sizeX = sizeX / fieldCols;
core[i].sizeY = sizeY / fieldRows;
core[i].pixelType = pixelType;
core[i].rgb = rgb;
core[i].interleaved = interleaved;
core[i].indexed = indexed;
core[i].littleEndian = littleEndian;
core[i].dimensionOrder = "XYZTC";
core[i].imageCount = nSlices * nTimepoints * nChannels;
}
MetadataStore store = makeFilterMetadata();
boolean populatePlanes = getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM;
MetadataTools.populatePixels(store, this, populatePlanes);
String plateAcqID = MetadataTools.createLSID("PlateAcquisition", 0, 0);
store.setPlateAcquisitionID(plateAcqID, 0, 0);
if (fieldRows * fieldCols > 0) {
store.setPlateAcquisitionMaximumFieldCount(new PositiveInteger(fieldRows * fieldCols), 0, 0);
} else {
LOGGER.warn("Expected positive value for MaximumFieldCount; got {}", fieldRows * fieldCols);
}
for (int row = 0; row < wellRows; row++) {
for (int col = 0; col < wellCols; col++) {
int index = row * wellCols + col;
store.setWellID(MetadataTools.createLSID("Well", 0, index), 0, index);
store.setWellRow(new NonNegativeInteger(row), 0, index);
store.setWellColumn(new NonNegativeInteger(col), 0, index);
}
}
for (int i = 0; i < getSeriesCount(); i++) {
int well = i / (fieldRows * fieldCols);
int field = i % (fieldRows * fieldCols);
MetadataTools.setDefaultCreationDate(store, tiffs[well][0], i);
String name = wellLabels.get(well);
String row = name.substring(0, 1);
Integer col = Integer.parseInt(name.substring(1));
int index = (row.charAt(0) - 'A') * wellCols + col - 1;
String wellSampleID = MetadataTools.createLSID("WellSample", 0, index, field);
store.setWellSampleID(wellSampleID, 0, index, field);
store.setWellSampleIndex(new NonNegativeInteger(i), 0, index, field);
String imageID = MetadataTools.createLSID("Image", i);
store.setWellSampleImageRef(imageID, 0, index, field);
store.setImageID(imageID, i);
store.setImageName(name + " Field #" + (field + 1), i);
store.setPlateAcquisitionWellSampleRef(wellSampleID, 0, 0, i);
}
MetadataLevel level = getMetadataOptions().getMetadataLevel();
if (level != MetadataLevel.MINIMUM) {
String instrumentID = MetadataTools.createLSID("Instrument", 0);
store.setInstrumentID(instrumentID, 0);
String objectiveID = MetadataTools.createLSID("Objective", 0, 0);
store.setObjectiveID(objectiveID, 0, 0);
if (objective != null) {
String[] tokens = objective.split(" ");
String mag = tokens[0].replaceAll("[xX]", "");
String na = null;
int naIndex = 0;
for (int i = 0; i < tokens.length; i++) {
if (tokens[i].equals("NA")) {
naIndex = i + 1;
na = tokens[naIndex];
break;
}
}
Integer magnification = new Integer(mag);
if (magnification > 0) {
store.setObjectiveNominalMagnification(new PositiveInteger(magnification), 0, 0);
} else {
LOGGER.warn("Expected positive value for NominalMagnification; got {}", magnification);
}
if (na != null) {
na = na.substring(0, 1) + "." + na.substring(1);
store.setObjectiveLensNA(new Double(na), 0, 0);
}
if (naIndex + 1 < tokens.length) {
store.setObjectiveManufacturer(tokens[naIndex + 1], 0, 0);
}
}
// populate LogicalChannel data
for (int i = 0; i < getSeriesCount(); i++) {
store.setImageInstrumentRef(instrumentID, i);
store.setObjectiveSettingsID(objectiveID, i);
for (int c = 0; c < getSizeC(); c++) {
store.setChannelName(channelNames.get(c), i, c);
if (emWave[c] > 0) {
store.setChannelEmissionWavelength(new PositiveInteger(emWave[c]), i, c);
} else {
LOGGER.warn("Expected positive value for EmissionWavelength; got {}", emWave[c]);
}
if (exWave[c] > 0) {
store.setChannelExcitationWavelength(new PositiveInteger(exWave[c]), i, c);
} else {
LOGGER.warn("Expected positive value for ExcitationWavelength; got {}", exWave[c]);
}
String detectorID = MetadataTools.createLSID("Detector", 0, c);
store.setDetectorID(detectorID, 0, c);
store.setDetectorSettingsID(detectorID, i, c);
store.setDetectorSettingsGain(gain[c], i, c);
store.setDetectorSettingsOffset(offset[c], i, c);
store.setDetectorSettingsBinning(getBinning(binning), i, c);
}
long firstPlane = 0;
for (int p = 0; p < getImageCount(); p++) {
int[] zct = getZCTCoords(p);
store.setPlaneExposureTime(exposure[zct[1]], i, p);
String file = getFilename(i, p);
if (file != null) {
long plane = getTimestamp(file);
if (p == 0) {
firstPlane = plane;
}
double timestamp = (plane - firstPlane) / 1000.0;
store.setPlaneDeltaT(timestamp, i, p);
}
}
}
store.setPlateID(MetadataTools.createLSID("Plate", 0), 0);
store.setPlateRowNamingConvention(getNamingConvention("Letter"), 0);
store.setPlateColumnNamingConvention(getNamingConvention("Number"), 0);
store.setPlateName(plateName, 0);
store.setPlateDescription(plateDescription, 0);
if (level != MetadataLevel.NO_OVERLAYS) {
parseROIs(store);
}
}
}
