def test_get_objects(self):
client = self.new_client()
image = self.create_test_image(100, 100, 1, 1, 1, client.getSession())
conn = BlitzGateway(client_obj=client)
params = {}
params["Data_Type"] = "Image"
params["IDs"] = [image.id.val]
objects, message = scriptUtil.get_objects(conn, params)
assert objects[0].id == image.id.val
assert message is ''
conn.close()
def copy_to_remote_omero(client, local_conn, script_params):
# TODO could maybe refactor to remove client
data_type = script_params["Data_Type"]
username = script_params["username"]
# password = client.getInput("password", unwrap=True)
password = keyring.get_password("omero", username)
# The managed_dir is where the local images are stored.
# TODO could pass this in instead of client?
managed_dir = client.sf.getConfigService().getConfigValue(
"omero.managed.dir")
# # Get the images or datasets
message = ""
objects, log_message = script_utils.get_objects(local_conn, script_params)
message += log_message
if not objects:
return message
try:
# Connect to remote omero
c, cli, remote_conn = connect_to_remote(password, username)
images = []
if data_type == 'Dataset':
# TODO handle multiple datasets
for ds in objects:
dataset_name = ds.getName()
target_dataset = "Dataset:name:" + dataset_name
# create new remote dataset
remote_ds = upload_dataset(cli, ds, remote_conn)
images.extend(list(ds.listChildren()))
if not images:
message += "No image found in dataset {}".format(
dataset_name)
return message
print("Processing {} images, in dataset {}".format(
len(images), dataset_name))
# TODO use remote_ds id, instead of target ds name
uploaded_image_ids = upload_images(cli, images, managed_dir,
target_dataset, remote_conn)
else:
images = objects
print("Processing %s images" % len(images))
uploaded_image_ids = upload_images(cli, images, managed_dir, None,
remote_conn)
finally:
close_remote_connection(c, cli, remote_conn)
# End of transferring images
message += "uploaded image ids: " + str(tuple(uploaded_image_ids))
print message
return message
def find_fileannotation(conn, script_params):
"""
Find the ilastik project file annotations either attached
to the image, dataset or project
Args:
conn (BlitzGateway): The OMERO connection
script_params (dict): The script parameters
Returns:
The first ilastik project file annotation found
Raises:
Exception: If no ilastik file annotation was found
"""
objects, log_message = script_utils.get_objects(conn, script_params)
for obj in objects:
for ann in obj.listAnnotations():
if ann.OMERO_TYPE == omero.model.FileAnnotationI:
if ann.getFile().getName().endswith(".ilp"):
return ann
for obj in objects:
if type(obj) == omero.gateway._ImageWrapper:
ds = obj.getParent()
for ann in ds.listAnnotations():
if ann.OMERO_TYPE == omero.model.FileAnnotationI:
if ann.getFile().getName().endswith(".ilp"):
return ann
pr = obj.getProject()
for ann in pr.listAnnotations():
if ann.OMERO_TYPE == omero.model.FileAnnotationI:
if ann.getFile().getName().endswith(".ilp"):
return ann
raise Exception("No ilastik project found!")
def load_images(conn, script_params):
"""
Load images specified by the script parameters
Args:
conn (BlitzGateway): The OMERO connection
script_params (dict): The script parameters
Returns:
list(ImageWrapper): The images
"""
objects, log_message = script_utils.get_objects(conn, script_params)
data_type = script_params["Data_Type"]
images = []
if data_type == 'Dataset':
for ds in objects:
images.extend(list(ds.listChildren()))
elif data_type == 'Project':
for p in objects:
for ds in p.listChildren():
images.extend(list(ds.listChildren()))
else:
images = objects
return images
def process_images(conn, script_params):
"""
Process the script params to make a list of channel_offsets, then iterate
through the images creating a new image from each with the specified
channel offsets
"""
message = ""
# Get the images
images, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not images:
return None, None, message
image_ids = [i.getId() for i in images]
# Get the channel offsets
channel_offsets = []
for i in range(1, 5):
p_name = "Channel_%s" % i
if script_params[p_name]:
index = i - 1 # UI channel index is 1-based - we want 0-based
x = "Channel%s_X_shift" % i in script_params and \
script_params["Channel%s_X_shift" % i] or 0
y = "Channel%s_Y_shift" % i in script_params and \
script_params["Channel%s_Y_shift" % i] or 0
z = "Channel%s_Z_shift" % i in script_params and \
script_params["Channel%s_Z_shift" % i] or 0
channel_offsets.append({'index': index, 'x': x, 'y': y, 'z': z})
dataset = None
if "New_Dataset_Name" in script_params:
# create new Dataset...
new_dataset_name = script_params["New_Dataset_Name"]
dataset = omero.gateway.DatasetWrapper(conn,
obj=omero.model.DatasetI())
dataset.setName(rstring(new_dataset_name))
dataset.save()
# add to parent Project
parent_ds = images[0].getParent()
project = parent_ds is not None and parent_ds.getParent() or None
if project is not None and project.canLink():
link = omero.model.ProjectDatasetLinkI()
link.parent = omero.model.ProjectI(project.getId(), False)
link.child = omero.model.DatasetI(dataset.getId(), False)
conn.getUpdateService().saveAndReturnObject(link)
# need to handle Datasets eventually - Just do images for now
new_images = []
links = []
for iId in image_ids:
new_img, link = new_image_with_channel_offsets(conn, iId,
channel_offsets,
dataset)
if new_img is not None:
new_images.append(new_img)
if link is not None:
links.append(link)
if not new_images:
message += "No image created."
else:
if len(new_images) == 1:
if not link:
link_message = " but could not be attached"
else:
link_message = ""
message += "New image created%s: %s." % (link_message,
new_images[0].getName())
elif len(new_images) > 1:
message += "%s new images created" % len(new_images)
if not len(links) == len(new_images):
message += " but some of them could not be attached."
else:
message += "."
return new_images, dataset, message
def roi_figure(conn, command_args):
"""
This processes the script parameters, adding defaults if needed.
Then calls a method to make the figure, and finally uploads and attaches
this to the primary image.
@param: session The OMERO session
@param: command_args Map of String:Object parameters for the script.
Objects are not rtypes, since getValue() was
called when the map was processed below.
But, list and map objects may contain rtypes (need
to call getValue())
@return: the id of the originalFileLink child. (ID object,
not value)
"""
log("ROI figure created by OMERO on %s" % date.today())
log("")
message = "" # message to be returned to the client
pixel_ids = []
image_ids = []
image_labels = []
# function for getting image labels.
def get_image_names(full_name, tags_list, pd_list):
name = full_name.split("/")[-1]
return [name]
# default function for getting labels is getName (or use datasets / tags)
if "Image_Labels" in command_args:
if command_args["Image_Labels"] == "Datasets":
def get_datasets(name, tags_list, pd_list):
return [dataset for project, dataset in pd_list]
get_labels = get_datasets
elif command_args["Image_Labels"] == "Tags":
def get_tags(name, tags_list, pd_list):
return tags_list
get_labels = get_tags
else:
get_labels = get_image_names
else:
get_labels = get_image_names
# Get the images
images, log_message = script_utils.get_objects(conn, command_args)
message += log_message
if not images:
return None, message
# Check for rectangular ROIs and filter images list
images = [image for image in images if image.getROICount("Rectangle") > 0]
if not images:
message += "No rectangle ROI found."
return None, message
# Attach figure to the first image
omero_image = images[0]
# process the list of images. If image_ids is not set, script can't run.
log("Image details:")
for image in images:
image_ids.append(image.getId())
pixel_ids.append(image.getPrimaryPixels().getId())
# a map of imageId : list of (project, dataset) names.
pd_map = figUtil.getDatasetsProjectsFromImages(conn.getQueryService(),
image_ids)
tag_map = figUtil.getTagsFromImages(conn.getMetadataService(), image_ids)
# Build a legend entry for each image
for image in images:
name = image.getName()
image_date = image.getAcquisitionDate()
iid = image.getId()
tags_list = tag_map[iid]
pd_list = pd_map[iid]
tags = ", ".join(tags_list)
pd_string = ", ".join(["%s/%s" % pd for pd in pd_list])
log(" Image: %s ID: %d" % (name, iid))
if image_date:
log(" Date: %s" % image_date)
else:
log(" Date: not set")
log(" Tags: %s" % tags)
log(" Project/Datasets: %s" % pd_string)
image_labels.append(get_labels(name, tags_list, pd_list))
# use the first image to define dimensions, channel colours etc.
size_x = omero_image.getSizeX()
size_y = omero_image.getSizeY()
size_z = omero_image.getSizeZ()
size_c = omero_image.getSizeC()
width = size_x
if "Width" in command_args:
w = command_args["Width"]
try:
width = int(w)
except ValueError:
log("Invalid width: %s Using default value: %d" % (str(w), size_x))
height = size_y
if "Height" in command_args:
h = command_args["Height"]
try:
height = int(h)
except ValueError:
log("Invalid height: %s Using default value" % (str(h), size_y))
log("Image dimensions for all panels (pixels): width: %d height: %d" %
(width, height))
merged_indexes = [] # the channels in the combined image,
merged_colours = {}
if "Merged_Colours" in command_args:
c_colour_map = command_args["Merged_Colours"]
for c in c_colour_map:
rgb = c_colour_map[c]
try:
rgb = int(rgb)
c_index = int(c)
except ValueError:
continue
rgba = image_utils.int_to_rgba(rgb)
merged_colours[c_index] = rgba
merged_indexes.append(c_index)
merged_indexes.sort()
# make sure we have some merged channels
if len(merged_indexes) == 0:
merged_indexes = range(size_c)
merged_indexes.reverse()
merged_names = False
if "Merged_Names" in command_args:
merged_names = command_args["Merged_Names"]
# Make channel-names map. If argument wasn't specified, name by index
channel_names = {}
if "Channel_Names" in command_args:
c_name_map = command_args["Channel_Names"]
for c in range(size_c):
if str(c) in c_name_map:
channel_names[c] = c_name_map[str(c)]
else:
channel_names[c] = str(c)
else:
for c in range(size_c):
channel_names[c] = str(c)
# Make split-indexes list. If no "Split_Indexes", show none:
# http://www.openmicroscopy.org/community/viewtopic.php?f=4&t=940
split_indexes = []
if "Split_Indexes" in command_args:
for index in command_args["Split_Indexes"]:
split_indexes.append(index)
colour_channels = True
key = "Split_Panels_Grey"
if key in command_args and command_args[key]:
colour_channels = False
algorithm = ProjectionType.MAXIMUMINTENSITY
if "Algorithm" in command_args:
a = command_args["Algorithm"]
if (a == "Mean Intensity"):
algorithm = ProjectionType.MEANINTENSITY
stepping = 1
if "Stepping" in command_args:
s = command_args["Stepping"]
if (0 < s < size_z):
stepping = s
scalebar = None
if "Scalebar" in command_args:
sb = command_args["Scalebar"]
try:
scalebar = int(sb)
if scalebar <= 0:
scalebar = None
else:
log("Scalebar is %d microns" % scalebar)
except ValueError:
log("Invalid value for scalebar: %s" % str(sb))
scalebar = None
overlay_colour = (255, 255, 255)
if "Overlay_Colour" in command_args:
r, g, b, a = OVERLAY_COLOURS[command_args["Overlay_Colour"]]
overlay_colour = (r, g, b)
roi_zoom = None
if "ROI_Zoom" in command_args:
roi_zoom = float(command_args["ROI_Zoom"])
if roi_zoom == 0:
roi_zoom = None
roi_label = "FigureROI"
if "ROI_Label" in command_args:
roi_label = command_args["ROI_Label"]
spacer = (width / 50) + 2
fig = get_split_view(conn, image_ids, pixel_ids, split_indexes,
channel_names, merged_names, colour_channels,
merged_indexes, merged_colours, width, height,
image_labels, spacer, algorithm, stepping, scalebar,
overlay_colour, roi_zoom, roi_label)
if fig is None:
log_message = "No figure produced"
log("\n" + log_message)
message += log_message
return None, message
log("")
fig_legend = "\n".join(log_strings)
format = command_args["Format"]
figure_name = "roi_figure"
if "Figure_Name" in command_args:
figure_name = command_args["Figure_Name"]
figure_name = os.path.basename(figure_name)
output = "localfile"
if format == 'PNG':
output = output + ".png"
figure_name = figure_name + ".png"
fig.save(output, "PNG")
mimetype = "image/png"
elif format == 'TIFF':
output = output + ".tiff"
figure_name = figure_name + ".tiff"
fig.save(output, "TIFF")
mimetype = "image/tiff"
else:
output = output + ".jpg"
figure_name = figure_name + ".jpg"
fig.save(output)
mimetype = "image/jpeg"
# Use util method to upload the figure 'output' to the server, attaching
# it to the omeroImage, adding the
# figLegend as the fileAnnotation description.
# Returns the id of the originalFileLink child. (ID object, not value)
namespace = NSCREATED + "/omero/figure_scripts/ROI_Split_Figure"
file_annotation, fa_message = script_utils.create_link_file_annotation(
conn,
output,
omero_image,
output="ROI Split figure",
mimetype=mimetype,
namespace=namespace,
description=fig_legend,
orig_file_path_and_name=figure_name)
message += fa_message
return file_annotation, message
def copy_to_remote_omero(client, local_conn, script_params):
# TODO could maybe refactor to remove client
data_type = script_params["Data_Type"]
username = script_params["Username"]
password = script_params["Password"]
image_format = script_params["Image_Format"]
global include_annos
include_annos = script_params["Include_Annotations"]
# The managed_dir is where the local images are stored.
# TODO could pass this in instead of client?
# This directory requires administrator privileges to access; which is why the
# script fails if it is run by a non admin-user
managed_dir = None
try:
managed_dir = client.sf.getConfigService().getConfigValue(
"omero.managed.dir")
except:
from os.path import expanduser
managed_dir = os.path.join(expanduser("~"), 'omero_data',
'ManagedRepository')
# # Get the images or datasets
message = ""
objects, log_message = script_utils.get_objects(local_conn, script_params)
message += log_message
if not objects:
return message
try:
# Connect to remote omero
c, cli, remote_conn = connect_to_remote(password, username)
images = []
if data_type == 'Dataset':
# TODO handle multiple datasets
for ds in objects:
dataset_name = ds.getName()
target_dataset = "Dataset:name:" + dataset_name
# create new remote dataset
uploaded_dataset_id = upload_dataset(cli, ds, remote_conn,
local_conn)
remote_ds = remote_conn.getObject("Dataset",
uploaded_dataset_id)
images.extend(list(ds.listChildren()))
if not images:
message += "No image found in dataset {}".format(
dataset_name)
return message
print(("Processing {} images, in dataset {}".format(
len(images), dataset_name)))
# TODO use remote_ds id, instead of target ds name
uploaded_image_ids = upload_images(cli, images, managed_dir,
target_dataset, remote_conn,
local_conn, remote_ds,
image_format)
else:
images = objects
print(("Processing %s images" % len(images)))
uploaded_image_ids = upload_images(cli, images, managed_dir, None,
remote_conn, local_conn, None,
image_format)
finally:
close_remote_connection(c, cli, remote_conn)
# End of transferring images
message += "uploaded image ids: " + str(tuple(uploaded_image_ids))
return message
def make_images_from_rois(conn, parameter_map):
"""
Processes the list of Image_IDs, either making a new image-stack or a new
dataset from each image, with new image planes coming from the regions in
Rectangular ROIs on the parent images.
"""
data_type = parameter_map["Data_Type"]
message = ""
# Get the images
objects, log_message = script_utils.get_objects(conn, parameter_map)
message += log_message
if not objects:
return None, message
# Concatenate images from datasets
if data_type == 'Image':
images = objects
else:
images = []
for ds in objects:
images += ds.listChildren()
# Check for rectangular ROIs and filter images list
images = [image for image in images if image.getROICount("Rectangle") > 0]
if not images:
message += "No rectangle ROI found."
return None, message
image_ids = [i.getId() for i in images]
new_images = []
new_datasets = []
links = []
for iid in image_ids:
new_image, new_dataset, link = process_image(conn, iid, parameter_map)
if new_image is not None:
if isinstance(new_image, list):
new_images.extend(new_image)
else:
new_images.append(new_image)
if new_dataset is not None:
new_datasets.append(new_dataset)
if link is not None:
if isinstance(link, list):
links.extend(link)
else:
links.append(link)
if new_images:
if len(new_images) > 1:
message += "Created %s new images" % len(new_images)
else:
message += "Created a new image"
else:
message += "No image created"
if new_datasets:
if len(new_datasets) > 1:
message += " and %s new datasets" % len(new_datasets)
else:
message += " and a new dataset"
if not links or not len(links) == len(new_images):
message += " but some images could not be attached"
message += "."
robj = (len(new_images) > 0) and new_images[0]._obj or None
return robj, message
def split_view_figure(conn, script_params):
"""
Processes the arguments, populating defaults if necessary. Prints the
details to log (fig-legend).
Even handles missing arguments that are not optional (from when this ran
from commandline with everything optional)
then calls make_split_view_figure() to make the figure, attaches it to the
Image as an 'originalFile' annotation, with fig-legend as the description.
@return: the id of the originalFileLink child. (ID object, not value)
"""
log("Split-View figure created by OMERO on %s" % date.today())
log("")
message = "" # message to be returned to the client
image_ids = []
pixel_ids = []
image_labels = []
# function for getting image labels.
def get_image_names(full_name, tags_list, pd_list):
name = full_name.split("/")[-1]
return [name.decode('utf8')]
# default function for getting labels is getName (or use datasets / tags)
if script_params["Image_Labels"] == "Datasets":
def get_datasets(name, tags_list, pd_list):
return [dataset.decode('utf8') for project, dataset in pd_list]
get_labels = get_datasets
elif script_params["Image_Labels"] == "Tags":
def get_tags(name, tags_list, pd_list):
return [t.decode('utf8') for t in tags_list]
get_labels = get_tags
else:
get_labels = get_image_names
# Get the images
images, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not images:
return None, message
# Attach figure to the first image
omero_image = images[0]
# process the list of images
log("Image details:")
for image in images:
image_ids.append(image.getId())
pixel_ids.append(image.getPrimaryPixels().getId())
# a map of imageId : list of (project, dataset) names.
pd_map = figUtil.getDatasetsProjectsFromImages(conn.getQueryService(),
image_ids)
tag_map = figUtil.getTagsFromImages(conn.getMetadataService(), image_ids)
# Build a legend entry for each image
for image in images:
name = image.getName()
image_date = image.getAcquisitionDate()
iid = image.getId()
tags_list = tag_map[iid]
pd_list = pd_map[iid]
tags = ", ".join(tags_list)
pd_string = ", ".join(["%s/%s" % pd for pd in pd_list])
log(" Image: %s ID: %d" % (name, iid))
if image_date:
log(" Date: %s" % image_date)
else:
log(" Date: not set")
log(" Tags: %s" % tags)
log(" Project/Datasets: %s" % pd_string)
image_labels.append(get_labels(name, tags_list, pd_list))
# use the first image to define dimensions, channel colours etc.
size_x = omero_image.getSizeX()
size_y = omero_image.getSizeY()
size_z = omero_image.getSizeZ()
size_c = omero_image.getSizeC()
# set image dimensions
z_start = -1
z_end = -1
if "Z_Start" in script_params:
z_start = script_params["Z_Start"]
if "Z_End" in script_params:
z_end = script_params["Z_End"]
width = "Width" in script_params and script_params["Width"] or size_x
height = "Height" in script_params and script_params["Height"] or size_y
log("Image dimensions for all panels (pixels): width: %d height: %d" %
(width, height))
# Make split-indexes list. If argument wasn't specified, include them all.
split_indexes = []
if "Split_Indexes" in script_params:
split_indexes = script_params["Split_Indexes"]
else:
split_indexes = range(size_c)
# Make channel-names map. If argument wasn't specified, name by index
channel_names = {}
for c in range(size_c):
channel_names[c] = str(c)
if "Channel_Names" in script_params:
c_name_map = script_params["Channel_Names"]
for c in c_name_map:
index = int(c)
channel_names[index] = c_name_map[c].decode('utf8')
merged_indexes = [] # the channels in the combined image,
merged_colours = {}
if "Merged_Colours" in script_params:
c_colour_map = script_params["Merged_Colours"]
for c in c_colour_map:
rgb = c_colour_map[c]
try:
rgb = int(rgb)
c_index = int(c)
except ValueError:
continue
rgba = image_utils.int_to_rgba(rgb)
merged_colours[c_index] = rgba
merged_indexes.append(c_index)
merged_indexes.sort()
else:
merged_indexes = range(size_c)
colour_channels = not script_params["Split_Panels_Grey"]
algorithm = ProjectionType.MAXIMUMINTENSITY
if "Mean Intensity" == script_params["Algorithm"]:
algorithm = ProjectionType.MEANINTENSITY
stepping = min(script_params["Stepping"], size_z)
scalebar = None
if "Scalebar" in script_params:
scalebar = script_params["Scalebar"]
log("Scalebar is %d microns" % scalebar)
r, g, b, a = OVERLAY_COLOURS[script_params["Overlay_Colour"]]
overlay_colour = (r, g, b)
merged_names = script_params["Merged_Names"]
fig = make_split_view_figure(conn, pixel_ids, z_start, z_end,
split_indexes, channel_names, colour_channels,
merged_indexes, merged_colours, merged_names,
width, height, image_labels, algorithm,
stepping, scalebar, overlay_colour)
fig_legend = "\n".join(log_strings)
figure_name = script_params["Figure_Name"]
figure_name = os.path.basename(figure_name)
output = "localfile"
format = script_params["Format"]
if format == 'PNG':
output = output + ".png"
figure_name = figure_name + ".png"
fig.save(output, "PNG")
mimetype = "image/png"
elif format == 'TIFF':
output = output + ".tiff"
figure_name = figure_name + ".tiff"
fig.save(output, "TIFF")
mimetype = "image/tiff"
else:
output = output + ".jpg"
figure_name = figure_name + ".jpg"
fig.save(output)
mimetype = "image/jpeg"
# Upload the figure 'output' to the server, creating a file annotation and
# attaching it to the omero_image, adding the
# fig_legend as the fileAnnotation description.
namespace = NSCREATED + "/omero/figure_scripts/Split_View_Figure"
file_annotation, fa_message = script_utils.create_link_file_annotation(
conn,
output,
omero_image,
output="Split view figure",
mimetype=mimetype,
namespace=namespace,
description=fig_legend,
orig_file_path_and_name=figure_name)
message += fa_message
return file_annotation, message
def process_images(conn, script_params):
line_width = script_params['Line_Width']
file_anns = []
message = ""
# Get the images
images, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not images:
return None, message
# Check for line and polyline ROIs and filter images list
images = [image for image in images if
image.getROICount(["Polyline", "Line"]) > 0]
if not images:
message += "No ROI containing line or polyline was found."
return None, message
for image in images:
c_names = []
colors = []
for ch in image.getChannels():
c_names.append(ch.getLabel())
colors.append(ch.getColor().getRGB())
size_c = image.getSizeC()
if 'Channels' in script_params:
script_params['Channels'] = [i-1 for i in
script_params['Channels']]
else:
script_params['Channels'] = range(size_c)
roi_service = conn.getRoiService()
result = roi_service.findByImage(image.getId(), None)
lines = []
polylines = []
for roi in result.rois:
roi_id = roi.getId().getValue()
for s in roi.copyShapes():
the_t = unwrap(s.getTheT())
the_z = unwrap(s.getTheZ())
z = 0
t = 0
if the_t is not None:
t = the_t
if the_z is not None:
z = the_z
# TODO: Add some filter of shapes e.g. text? / 'lines' only
# etc.
if type(s) == omero.model.LineI:
x1 = s.getX1().getValue()
x2 = s.getX2().getValue()
y1 = s.getY1().getValue()
y2 = s.getY2().getValue()
lines.append({'id': roi_id, 'theT': t, 'theZ': z,
'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2})
elif type(s) == omero.model.PolylineI:
v = s.getPoints().getValue()
points = roi_utils.points_string_to_xy_list(v)
polylines.append({'id': roi_id, 'theT': t, 'theZ': z,
'points': points})
if len(lines) == 0 and len(polylines) == 0:
continue
# prepare column headers, including line-id if we are going to output
# raw data.
line_id = script_params['Sum_or_Average'] == 'Average, with raw data' \
and 'Line, ' or ""
col_header = 'Image_ID, ROI_ID, Z, T, C, %sLine data %s of Line" \
" Width %s\n' % (line_id, script_params['Sum_or_Average'],
script_params['Line_Width'])
# prepare a csv file to write our data to...
file_name = "Plot_Profile_%s.csv" % image.getId()
with open(file_name, 'w') as f:
f.write(col_header)
if len(lines) > 0:
process_lines(conn, script_params, image, lines, line_width, f)
if len(polylines) > 0:
process_polylines(
conn, script_params, image, polylines, line_width, f)
file_ann, fa_message = script_utils.create_link_file_annotation(
conn, file_name, image, output="Line Plot csv (Excel) file",
mimetype="text/csv", description=None)
if file_ann:
file_anns.append(file_ann)
if not file_anns:
fa_message = "No Analysis files created. See 'Info' or 'Error' for"\
" more details"
elif len(file_anns) > 1:
fa_message = "Created %s csv (Excel) files" % len(file_anns)
message += fa_message
return file_anns, message
def make_thumbnail_figure(conn, script_params):
"""
Makes the figure using the parameters in @script_params, attaches the
figure to the parent Project/Dataset, and returns the file-annotation ID
@ returns Returns the id of the originalFileLink child. (ID object,
not value)
"""
log("Thumbnail figure created by OMERO")
log("")
message = ""
# Get the objects (images or datasets)
objects, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not objects:
return None, message
# Get parent
parent = None
if "Parent_ID" in script_params and len(script_params["IDs"]) > 1:
if script_params["Data_Type"] == "Image":
parent = conn.getObject("Dataset", script_params["Parent_ID"])
else:
parent = conn.getObject("Project", script_params["Parent_ID"])
if parent is None:
parent = objects[0] # Attach figure to the first object
parent_class = parent.OMERO_CLASS
log("Figure will be linked to %s%s: %s" %
(parent_class[0].lower(), parent_class[1:], parent.getName()))
tag_ids = []
if "Tag_IDs" in script_params:
tag_ids = script_params['Tag_IDs']
if len(tag_ids) == 0:
tag_ids = None
show_untagged = False
if (tag_ids):
show_untagged = script_params["Show_Untagged_Images"]
thumb_size = script_params["Thumbnail_Size"]
max_columns = script_params["Max_Columns"]
fig_height = 0
fig_width = 0
ds_canvases = []
if script_params["Data_Type"] == "Dataset":
for dataset in objects:
log("Dataset: %s ID: %d" %
(dataset.getName(), dataset.getId()))
images = list(dataset.listChildren())
title = dataset.getName().decode('utf8')
ds_canvas = paint_dataset_canvas(conn,
images,
title,
tag_ids,
show_untagged,
length=thumb_size,
col_count=max_columns)
if ds_canvas is None:
continue
ds_canvases.append(ds_canvas)
fig_height += ds_canvas.size[1]
fig_width = max(fig_width, ds_canvas.size[0])
else:
image_canvas = paint_dataset_canvas(conn,
objects,
"",
tag_ids,
show_untagged,
length=thumb_size,
col_count=max_columns)
ds_canvases.append(image_canvas)
fig_height += image_canvas.size[1]
fig_width = max(fig_width, image_canvas.size[0])
if len(ds_canvases) == 0:
message += "No figure created"
return None, message
figure = Image.new("RGB", (fig_width, fig_height), WHITE)
y = 0
for ds in ds_canvases:
image_utils.paste_image(ds, figure, 0, y)
y += ds.size[1]
log("")
fig_legend = "\n".join(log_lines)
format = script_params["Format"]
figure_name = script_params["Figure_Name"]
figure_name = os.path.basename(figure_name)
output = "localfile"
if format == 'PNG':
output = output + ".png"
figure_name = figure_name + ".png"
figure.save(output, "PNG")
mimetype = "image/png"
elif format == 'TIFF':
output = output + ".tiff"
figure_name = figure_name + ".tiff"
figure.save(output, "TIFF")
mimetype = "image/tiff"
else:
output = output + ".jpg"
figure_name = figure_name + ".jpg"
figure.save(output)
mimetype = "image/jpeg"
namespace = NSCREATED + "/omero/figure_scripts/Thumbnail_Figure"
file_annotation, fa_message = script_utils.create_link_file_annotation(
conn,
output,
parent,
output="Thumbnail figure",
mimetype=mimetype,
description=fig_legend,
namespace=namespace,
orig_file_path_and_name=figure_name)
message += fa_message
return file_annotation, message
def roi_figure(conn, command_args):
"""
This processes the script parameters, adding defaults if needed.
Then calls a method to make the figure, and finally uploads and attaches
this to the primary image.
@param: session The OMERO session
@param: command_args Map of String:Object parameters for the script.
Objects are not rtypes, since getValue() was
called when the map was processed below.
But, list and map objects may contain rtypes (need
to call getValue())
@return: the id of the originalFileLink child. (ID object,
not value)
"""
log("ROI figure created by OMERO on %s" % date.today())
log("")
message = "" # message to be returned to the client
pixel_ids = []
image_ids = []
image_labels = []
# function for getting image labels.
def get_image_names(full_name, tags_list, pd_list):
name = full_name.split("/")[-1]
return [name]
# default function for getting labels is getName (or use datasets / tags)
if "Image_Labels" in command_args:
if command_args["Image_Labels"] == "Datasets":
def get_datasets(name, tags_list, pd_list):
return [dataset for project, dataset in pd_list]
get_labels = get_datasets
elif command_args["Image_Labels"] == "Tags":
def get_tags(name, tags_list, pd_list):
return tags_list
get_labels = get_tags
else:
get_labels = get_image_names
else:
get_labels = get_image_names
# Get the images
images, log_message = script_utils.get_objects(conn, command_args)
message += log_message
if not images:
return None, message
# Check for rectangular ROIs and filter images list
images = [image for image in images if image.getROICount("Rectangle") > 0]
if not images:
message += "No rectangle ROI found."
return None, message
# Attach figure to the first image
omero_image = images[0]
# process the list of images
log("Image details:")
for image in images:
image_ids.append(image.getId())
pixel_ids.append(image.getPrimaryPixels().getId())
# a map of imageId : list of (project, dataset) names.
pd_map = figUtil.getDatasetsProjectsFromImages(conn.getQueryService(),
image_ids)
tag_map = figUtil.getTagsFromImages(conn.getMetadataService(), image_ids)
# Build a legend entry for each image
for image in images:
name = image.getName()
iid = image.getId()
image_date = image.getAcquisitionDate()
tags_list = tag_map[iid]
pd_list = pd_map[iid]
tags = ", ".join(tags_list)
pd_string = ", ".join(["%s/%s" % pd for pd in pd_list])
log(" Image: %s ID: %d" % (name, iid))
if image_date:
log(" Date: %s" % image_date)
else:
log(" Date: not set")
log(" Tags: %s" % tags)
log(" Project/Datasets: %s" % pd_string)
image_labels.append(get_labels(name, tags_list, pd_list))
# use the first image to define dimensions, channel colours etc.
size_x = omero_image.getSizeX()
size_y = omero_image.getSizeY()
size_z = omero_image.getSizeZ()
size_c = omero_image.getSizeC()
width = size_x
if "Width" in command_args:
w = command_args["Width"]
try:
width = int(w)
except ValueError:
log("Invalid width: %s Using default value: %d" % (str(w), size_x))
height = size_y
if "Height" in command_args:
h = command_args["Height"]
try:
height = int(h)
except ValueError:
log("Invalid height: %s Using default value" % (str(h), size_y))
log("Image dimensions for all panels (pixels): width: %d height: %d" %
(width, height))
# the channels in the combined image,
if "Merged_Channels" in command_args:
# convert to 0-based
merged_indexes = [c - 1 for c in command_args["Merged_Channels"]]
else:
merged_indexes = list(range(size_c)) # show all
merged_indexes.reverse()
# if no colours added, use existing rendering settings.
merged_colours = {}
# Actually, nicer to always use existing rendering settings.
# if "Merged_Colours" in commandArgs:
# for i, c in enumerate(commandArgs["Merged_Colours"]):
# if c in COLOURS:
# mergedColours[i] = COLOURS[c]
algorithm = ProjectionType.MAXIMUMINTENSITY
if "Algorithm" in command_args:
a = command_args["Algorithm"]
if (a == "Mean Intensity"):
algorithm = ProjectionType.MEANINTENSITY
stepping = 1
if "Stepping" in command_args:
s = command_args["Stepping"]
if (0 < s < size_z):
stepping = s
scalebar = None
if "Scalebar" in command_args:
sb = command_args["Scalebar"]
try:
scalebar = int(sb)
if scalebar <= 0:
scalebar = None
else:
log("Scalebar is %d microns" % scalebar)
except ValueError:
log("Invalid value for scalebar: %s" % str(sb))
scalebar = None
overlay_colour = (255, 255, 255)
if "Scalebar_Colour" in command_args:
if command_args["Scalebar_Colour"] in OVERLAY_COLOURS:
r, g, b, a = OVERLAY_COLOURS[command_args["Scalebar_Colour"]]
overlay_colour = (r, g, b)
roi_zoom = None
if "Roi_Zoom" in command_args:
roi_zoom = float(command_args["Roi_Zoom"])
if roi_zoom == 0:
roi_zoom = None
max_columns = None
if "Max_Columns" in command_args:
max_columns = command_args["Max_Columns"]
show_roi_duration = False
if "Show_ROI_Duration" in command_args:
show_roi_duration = command_args["Show_ROI_Duration"]
roi_label = "FigureROI"
if "Roi_Selection_Label" in command_args:
roi_label = command_args["Roi_Selection_Label"]
spacer = (width // 50) + 2
fig = get_split_view(conn, image_ids, pixel_ids, merged_indexes,
merged_colours, width, height, image_labels, spacer,
algorithm, stepping, scalebar, overlay_colour,
roi_zoom, max_columns, show_roi_duration, roi_label)
if fig is None:
log_message = "No figure produced"
log("\n" + log_message)
message += log_message
return None, message
fig_legend = "\n".join(log_strings)
format = command_args["Format"]
figure_name = "movieROIFigure"
if "Figure_Name" in command_args:
figure_name = command_args["Figure_Name"]
figure_name = os.path.basename(figure_name)
output = "localfile"
if format == 'PNG':
output = output + ".png"
figure_name = figure_name + ".png"
fig.save(output, "PNG")
mimetype = "image/png"
elif format == 'TIFF':
output = output + ".tiff"
figure_name = figure_name + ".tiff"
fig.save(output, "TIFF")
mimetype = "image/tiff"
else:
output = output + ".jpg"
figure_name = figure_name + ".jpg"
fig.save(output)
mimetype = "image/jpeg"
# Use util method to upload the figure 'output' to the server, attaching
# it to the omeroImage, adding the
# figLegend as the fileAnnotation description.
# Returns the id of the originalFileLink child. (ID object, not value)
namespace = NSCREATED + "/omero/figure_scripts/Movie_ROI_Figure"
file_annotation, fa_message = script_utils.create_link_file_annotation(
conn,
output,
omero_image,
output="Movie ROI figure",
mimetype=mimetype,
namespace=namespace,
description=fig_legend,
orig_file_path_and_name=figure_name)
message += fa_message
return file_annotation, message
def combine_images(conn, parameter_map):
# get the services we need
services = {}
services["containerService"] = conn.getContainerService()
services["renderingEngine"] = conn.createRenderingEngine()
services["queryService"] = conn.getQueryService()
services["pixelsService"] = conn.getPixelsService()
services["rawPixelStore"] = conn.c.sf.createRawPixelsStore()
services["rawPixelStoreUpload"] = conn.c.sf.createRawPixelsStore()
services["updateService"] = conn.getUpdateService()
services["rawFileStore"] = conn.createRawFileStore()
query_service = services["queryService"]
colour_map = {}
if "Channel_Colours" in parameter_map:
for c, colour in enumerate(parameter_map["Channel_Colours"]):
if colour in COLOURS:
colour_map[c] = COLOURS[colour]
# Get images or datasets
message = ""
objects, log_message = script_utils.get_objects(conn, parameter_map)
message += log_message
if not objects:
return None, message
# get the images IDs from list (in order) or dataset (sorted by name)
output_images = []
links = []
data_type = parameter_map["Data_Type"]
if data_type == "Image":
dataset = None
objects.sort(key=lambda x: (x.getName())) # Sort images by name
image_ids = [image.id for image in objects]
# get dataset from first image
query_string = "select i from Image i join fetch i.datasetLinks idl"\
" join fetch idl.parent where i.id in (%s)" % image_ids[0]
image = query_service.findByQuery(query_string, None)
if image:
for link in image.iterateDatasetLinks():
ds = link.parent
dataset = conn.getObject("Dataset", ds.getId().getValue())
break # only use 1st dataset
new_img, link = make_single_image(services, parameter_map, image_ids,
dataset, colour_map)
if new_img:
output_images.append(new_img)
if link:
links.append(link)
else:
for dataset in objects:
images = list(dataset.listChildren())
if not images:
continue
images.sort(key=lambda x: (x.getName()))
image_ids = [i.getId() for i in images]
new_img, link = make_single_image(services, parameter_map,
image_ids, dataset, colour_map)
if new_img:
output_images.append(new_img)
if link:
links.append(link)
# try and close any stateful services
for s in services:
try:
s.close()
except Exception:
pass
if output_images:
if len(output_images) > 1:
message += "%s new images created" % len(output_images)
else:
message += "New image created"
if not links or not len(links) == len(output_images):
message += " but could not be attached"
else:
message += "No image created"
message += "."
return output_images, message
def batch_image_export(conn, script_params):
# for params with default values, we can get the value directly
split_cs = script_params["Export_Individual_Channels"]
merged_cs = script_params["Export_Merged_Image"]
greyscale = script_params["Individual_Channels_Grey"]
data_type = script_params["Data_Type"]
folder_name = script_params["Folder_Name"]
folder_name = os.path.basename(folder_name)
format = script_params["Format"]
project_z = "Choose_Z_Section" in script_params and \
script_params["Choose_Z_Section"] == 'Max projection'
if (not split_cs) and (not merged_cs):
log("Not chosen to save Individual Channels OR Merged Image")
return
# check if we have these params
channel_names = []
if "Channel_Names" in script_params:
channel_names = script_params["Channel_Names"]
zoom_percent = None
if "Zoom" in script_params and script_params["Zoom"] != "100%":
zoom_percent = int(script_params["Zoom"][:-1])
# functions used below for each imaage.
def get_z_range(size_z, script_params):
z_range = None
if "Choose_Z_Section" in script_params:
z_choice = script_params["Choose_Z_Section"]
# NB: all Z indices in this script are 1-based
if z_choice == 'ALL Z planes':
z_range = (1, size_z + 1)
elif "OR_specify_Z_index" in script_params:
z_index = script_params["OR_specify_Z_index"]
z_index = min(z_index, size_z)
z_range = (z_index, )
elif "OR_specify_Z_start_AND..." in script_params and \
"...specify_Z_end" in script_params:
start = script_params["OR_specify_Z_start_AND..."]
start = min(start, size_z)
end = script_params["...specify_Z_end"]
end = min(end, size_z)
# in case user got z_start and z_end mixed up
z_start = min(start, end)
z_end = max(start, end)
if z_start == z_end:
z_range = (z_start, )
else:
z_range = (z_start, z_end + 1)
return z_range
def get_t_range(size_t, script_params):
t_range = None
if "Choose_T_Section" in script_params:
t_choice = script_params["Choose_T_Section"]
# NB: all T indices in this script are 1-based
if t_choice == 'ALL T planes':
t_range = (1, size_t + 1)
elif "OR_specify_T_index" in script_params:
t_index = script_params["OR_specify_T_index"]
t_index = min(t_index, size_t)
t_range = (t_index, )
elif "OR_specify_T_start_AND..." in script_params and \
"...specify_T_end" in script_params:
start = script_params["OR_specify_T_start_AND..."]
start = min(start, size_t)
end = script_params["...specify_T_end"]
end = min(end, size_t)
# in case user got t_start and t_end mixed up
t_start = min(start, end)
t_end = max(start, end)
if t_start == t_end:
t_range = (t_start, )
else:
t_range = (t_start, t_end + 1)
return t_range
# Get the images or datasets
message = ""
objects, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not objects:
return None, message
# Attach figure to the first image
parent = objects[0]
if data_type == 'Dataset':
images = []
for ds in objects:
images.extend(list(ds.listChildren()))
if not images:
message += "No image found in dataset(s)"
return None, message
else:
images = objects
log("Processing %s images" % len(images))
# somewhere to put images
curr_dir = os.getcwd()
exp_dir = os.path.join(curr_dir, folder_name)
try:
os.mkdir(exp_dir)
except OSError:
pass
# max size (default 12kx12k)
size = conn.getDownloadAsMaxSizeSetting()
size = int(size)
ids = []
# do the saving to disk
for img in images:
log("Processing image: ID %s: %s" % (img.id, img.getName()))
pixels = img.getPrimaryPixels()
if (pixels.getId() in ids):
continue
ids.append(pixels.getId())
if format == 'OME-TIFF':
if img._prepareRE().requiresPixelsPyramid():
log(" ** Can't export a 'Big' image to OME-TIFF. **")
if len(images) == 1:
return None, "Can't export a 'Big' image to %s." % format
continue
else:
save_as_ome_tiff(conn, img, folder_name)
else:
size_x = pixels.getSizeX()
size_y = pixels.getSizeY()
if size_x * size_y > size:
msg = "Can't export image over %s pixels. " \
"See 'omero.client.download_as.max_size'" % size
log(" ** %s. **" % msg)
if len(images) == 1:
return None, msg
continue
else:
log("Exporting image as %s: %s" % (format, img.getName()))
log("\n----------- Saving planes from image: '%s' ------------" %
img.getName())
size_c = img.getSizeC()
size_z = img.getSizeZ()
size_t = img.getSizeT()
z_range = get_z_range(size_z, script_params)
t_range = get_t_range(size_t, script_params)
log("Using:")
if z_range is None:
log(" Z-index: Last-viewed")
elif len(z_range) == 1:
log(" Z-index: %d" % z_range[0])
else:
log(" Z-range: %s-%s" % (z_range[0], z_range[1] - 1))
if project_z:
log(" Z-projection: ON")
if t_range is None:
log(" T-index: Last-viewed")
elif len(t_range) == 1:
log(" T-index: %d" % t_range[0])
else:
log(" T-range: %s-%s" % (t_range[0], t_range[1] - 1))
log(" Format: %s" % format)
if zoom_percent is None:
log(" Image Zoom: 100%")
else:
log(" Image Zoom: %s" % zoom_percent)
log(" Greyscale: %s" % greyscale)
log("Channel Rendering Settings:")
for ch in img.getChannels():
log(" %s: %d-%d" %
(ch.getLabel(), ch.getWindowStart(), ch.getWindowEnd()))
try:
save_planes_for_image(conn,
img,
size_c,
split_cs,
merged_cs,
channel_names,
z_range,
t_range,
greyscale,
zoom_percent,
project_z=project_z,
format=format,
folder_name=folder_name)
finally:
# Make sure we close Rendering Engine
img._re.close()
# write log for exported images (not needed for ome-tiff)
name = 'Batch_Image_Export.txt'
with open(os.path.join(exp_dir, name), 'w') as log_file:
for s in log_strings:
log_file.write(s)
log_file.write("\n")
if len(os.listdir(exp_dir)) == 0:
return None, "No files exported. See 'info' for more details"
# zip everything up (unless we've only got a single ome-tiff)
if format == 'OME-TIFF' and len(os.listdir(exp_dir)) == 1:
ometiff_ids = [t.id for t in parent.listAnnotations(ns=NSOMETIFF)]
conn.deleteObjects("Annotation", ometiff_ids)
export_file = os.path.join(folder_name, os.listdir(exp_dir)[0])
namespace = NSOMETIFF
output_display_name = "OME-TIFF"
mimetype = 'image/tiff'
else:
export_file = "%s.zip" % folder_name
compress(export_file, folder_name)
mimetype = 'application/zip'
output_display_name = "Batch export zip"
namespace = NSCREATED + "/omero/export_scripts/Batch_Image_Export"
file_annotation, ann_message = script_utils.create_link_file_annotation(
conn,
export_file,
parent,
output=output_display_name,
namespace=namespace,
mimetype=mimetype)
message += ann_message
return file_annotation, message
def datasets_to_plates(conn, script_params):
update_service = conn.getUpdateService()
message = ""
# Get the datasets ID
datasets, log_message = script_utils.get_objects(conn, script_params)
message += log_message
def has_images_linked_to_well(dataset):
params = omero.sys.ParametersI()
query = "select count(well) from Well as well "\
"left outer join well.wellSamples as ws " \
"left outer join ws.image as img "\
"where img.id in (:ids)"
params.addIds([i.getId() for i in dataset.listChildren()])
n_wells = unwrap(conn.getQueryService().projection(
query, params, conn.SERVICE_OPTS)[0])[0]
if n_wells > 0:
return True
else:
return False
# Exclude datasets containing images already linked to a well
n_datasets = len(datasets)
datasets = [x for x in datasets if not has_images_linked_to_well(x)]
if len(datasets) < n_datasets:
message += "Excluded %s out of %s dataset(s). " \
% (n_datasets - len(datasets), n_datasets)
# Return if all input dataset are not found or excluded
if not datasets:
return None, message
# Filter dataset IDs by permissions
ids = [ds.getId() for ds in datasets if ds.canLink()]
if len(ids) != len(datasets):
perm_ids = [str(ds.getId()) for ds in datasets if not ds.canLink()]
message += "You do not have the permissions to add the images from"\
" the dataset(s): %s." % ",".join(perm_ids)
if not ids:
return None, message
# find or create Screen if specified
screen = None
newscreen = None
if "Screen" in script_params and len(script_params["Screen"]) > 0:
s = script_params["Screen"]
# see if this is ID of existing screen
try:
screen_id = long(s)
screen = conn.getObject("Screen", screen_id)
except ValueError:
pass
# if not, create one
if screen is None:
newscreen = omero.model.ScreenI()
newscreen.name = rstring(s)
newscreen = update_service.saveAndReturnObject(newscreen)
screen = conn.getObject("Screen", newscreen.getId().getValue())
plates = []
links = []
deletes = []
for dataset_id in ids:
plate, link, delete_handle = dataset_to_plate(conn, script_params,
dataset_id, screen)
if plate is not None:
plates.append(plate)
if link is not None:
links.append(link)
if delete_handle is not None:
deletes.append(delete_handle)
# wait for any deletes to finish
for handle in deletes:
cb = omero.callbacks.DeleteCallbackI(conn.c, handle)
while True: # ms
if cb.block(100) is not None:
break
if newscreen:
message += "New screen created: %s." % newscreen.getName().getValue()
robj = newscreen
elif plates:
robj = plates[0]
else:
robj = None
if plates:
if len(plates) == 1:
plate = plates[0]
message += " New plate created: %s" % plate.getName().getValue()
else:
message += " %s plates created" % len(plates)
if len(plates) == len(links):
message += "."
else:
message += " but could not be attached."
else:
message += "No plate created."
return robj, message
def process_images(conn, script_params):
"""Process each image passed to script, generating new Kymograph images."""
line_width = script_params['Line_Width']
new_kymographs = []
message = ""
# Get the images
images, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not images:
return None, message
# Check for line and polyline ROIs and filter images list
images = [
image for image in images
if image.getROICount(["Polyline", "Line"]) > 0
]
if not images:
message += "No ROI containing line or polyline was found."
return None, message
for image in images:
if image.getSizeT() == 1:
continue
new_images = [] # kymographs derived from the current image.
c_names = []
colors = []
for ch in image.getChannels():
c_names.append(ch.getLabel())
colors.append(ch.getColor().getRGB())
size_t = image.getSizeT()
pixels = image.getPrimaryPixels()
dataset = image.getParent()
if dataset is not None and not dataset.canLink():
dataset = None
roi_service = conn.getRoiService()
result = roi_service.findByImage(image.getId(), None)
# kymograph strategy - Using Line and Polyline ROIs:
# NB: Use ALL time points unless >1 shape AND 'use_all_timepoints' =
# False
# If > 1 shape per time-point (per ROI), pick one!
# 1 - Single line. Use this shape for all time points
# 2 - Many lines. Use the first one to fix length. Subsequent lines to
# update start and direction
# 3 - Single polyline. Use this shape for all time points
# 4 - Many polylines. Use the first one to fix length.
for roi in result.rois:
lines = {} # map of theT: line
polylines = {} # map of theT: polyline
for s in roi.copyShapes():
if s is None:
continue
the_t = unwrap(s.getTheT())
the_z = unwrap(s.getTheZ())
z = 0
t = 0
if the_t is not None:
t = the_t
if the_z is not None:
z = the_z
# TODO: Add some filter of shapes. E.g. text? / 'lines' only
# etc.
if type(s) == omero.model.LineI:
x1 = s.getX1().getValue()
x2 = s.getX2().getValue()
y1 = s.getY1().getValue()
y2 = s.getY2().getValue()
lines[t] = {
'theZ': z,
'x1': x1,
'y1': y1,
'x2': x2,
'y2': y2
}
elif type(s) == omero.model.PolylineI:
v = s.getPoints().getValue()
points = points_string_to_xy_list(v)
polylines[t] = {'theZ': z, 'points': points}
if len(lines) > 0:
new_img = lines_kymograph(conn, script_params, image, lines,
line_width, dataset)
new_images.append(new_img)
lines = []
elif len(polylines) > 0:
new_img = polyline_kymograph(conn, script_params, image,
polylines, line_width, dataset)
new_images.append(new_img)
# look-up the interval for each time-point
t_interval = None
infos = list(pixels.copyPlaneInfo(theC=0, theT=size_t - 1, theZ=0))
if len(infos) > 0 and infos[0].getDeltaT() is not None:
duration = infos[0].getDeltaT(units="SECOND").getValue()
if size_t == 1:
t_interval = duration
else:
t_interval = duration / (size_t - 1)
elif pixels.timeIncrement is not None:
t_interval = pixels.timeIncrement
elif "Time_Increment" in script_params:
t_interval = script_params["Time_Increment"]
pixel_size = None
if pixels.physicalSizeX is not None:
pixel_size = pixels.physicalSizeX
elif "Pixel_Size" in script_params:
pixel_size = script_params['Pixel_Size']
# Save channel names and colors for each new image
for img in new_images:
for i, c in enumerate(img.getChannels()):
lc = c.getLogicalChannel()
lc.setName(c_names[i])
lc.save()
r, g, b = colors[i]
# need to reload channels to avoid optimistic lock on update
c_obj = conn.getQueryService().get("Channel", c.id)
c_obj.red = omero.rtypes.rint(r)
c_obj.green = omero.rtypes.rint(g)
c_obj.blue = omero.rtypes.rint(b)
c_obj.alpha = omero.rtypes.rint(255)
conn.getUpdateService().saveObject(c_obj)
img.resetRDefs() # reset based on colors above
# If we know pixel sizes, set them on the new image
if pixel_size is not None or t_interval is not None:
px = conn.getQueryService().get("Pixels", img.getPixelsId())
microm = getattr(omero.model.enums.UnitsLength, "MICROMETER")
if pixel_size is not None:
pixel_size = omero.model.LengthI(pixel_size, microm)
px.setPhysicalSizeX(pixel_size)
if t_interval is not None:
t_per_pixel = t_interval / line_width
t_per_pixel = omero.model.LengthI(t_per_pixel, microm)
px.setPhysicalSizeY(t_per_pixel)
conn.getUpdateService().saveObject(px)
new_kymographs.extend(new_images)
if not new_kymographs:
message += "No kymograph created. See 'Error' or 'Info' for details."
else:
if not dataset:
link_message = " but could not be attached"
else:
link_message = ""
if len(new_images) == 1:
message += "New kymograph created%s: %s." \
% (link_message, new_images[0].getName())
elif len(new_images) > 1:
message += "%s new kymographs created%s." \
% (len(new_images), link_message)
return new_kymographs, message
def process_images(conn, script_params):
file_anns = []
message = ""
# Get the images
images, log_message = script_utils.get_objects(conn, script_params)
message += log_message
if not images:
return None, message
# Check for line and polyline ROIs and filter images list
images = [
image for image in images
if image.getROICount(["Polyline", "Line"]) > 0
]
if not images:
message += "No ROI containing line or polyline was found."
return None, message
csv_data = []
for image in images:
if image.getSizeT() > 1:
message += "%s ID: %s appears to be a time-lapse Image," \
" not a kymograph." % (image.getName(), image.getId())
continue
roi_service = conn.getRoiService()
result = roi_service.findByImage(image.getId(), None)
secs_per_pixel_y = image.getPixelSizeY()
microns_per_pixel_x = image.getPixelSizeX()
if secs_per_pixel_y and microns_per_pixel_x:
microns_per_sec = microns_per_pixel_x / secs_per_pixel_y
else:
microns_per_sec = None
# for each line or polyline, create a row in csv table: y(t), x,
# dy(dt), dx, x/t (line), x/t (average)
col_names = "\nt_start (pixels), x_start (pixels), t_end (pixels)," \
" x_end (pixels), dt (pixels), dx (pixels), x/t, speed(um/sec)," \
"avg x/t, avg speed(um/sec)"
table_data = ""
for roi in result.rois:
for s in roi.copyShapes():
if s is None:
continue # seems possible in some situations
if type(s) == omero.model.LineI:
table_data += "\nLine ID: %s" % s.getId().getValue()
x1 = s.getX1().getValue()
x2 = s.getX2().getValue()
y1 = s.getY1().getValue()
y2 = s.getY2().getValue()
dx = abs(x1 - x2)
dy = abs(y1 - y2)
dx_per_y = float(dx) / dy
speed = ""
if microns_per_sec:
speed = dx_per_y * microns_per_sec
table_data += "\n"
table_data += ",".join([
str(x)
for x in (y1, x1, y2, x2, dy, dx, dx_per_y, speed)
])
elif type(s) == omero.model.PolylineI:
table_data += "\nPolyline ID: %s" % s.getId().getValue()
v = s.getPoints().getValue()
points = roi_utils.points_string_to_xy_list(v)
x_start, y_start = points[0]
for i in range(1, len(points)):
x1, y1 = points[i - 1]
x2, y2 = points[i]
dx = abs(x1 - x2)
dy = abs(y1 - y2)
dx_per_y = float(dx) / dy
av_x_per_y = abs(float(x2 - x_start) / (y2 - y_start))
speed = ""
avg_speed = ""
if microns_per_sec:
speed = dx_per_y * microns_per_sec
avg_speed = av_x_per_y * microns_per_sec
table_data += "\n"
table_data += ",".join([
str(x) for x in (y1, x1, y2, x2, dy, dx, dx_per_y,
speed, av_x_per_y, avg_speed)
])
# write table data to csv...
if len(table_data) > 0:
table_string = "Image ID:, %s," % image.getId()
table_string += "Name:, %s" % image.getName()
table_string += "\nsecsPerPixelY: %s" % secs_per_pixel_y
table_string += '\nmicronsPerPixelX: %s' % microns_per_pixel_x
table_string += "\n"
table_string += col_names
table_string += table_data
csv_data.append(table_string)
iids = [str(i.getId()) for i in images]
to_link_csv = [i.getId() for i in images if i.canAnnotate()]
csv_file_name = 'kymograph_velocities_%s.csv' % "-".join(iids)
with open(csv_file_name, 'w') as csv_file:
csv_file.write("\n \n".join(csv_data))
file_ann = conn.createFileAnnfromLocalFile(csv_file_name,
mimetype="text/csv")
fa_message = "Created Line Plot csv (Excel) file"
links = []
if len(to_link_csv) == 0:
fa_message += " but could not attach to images."
for iid in to_link_csv:
link = ImageAnnotationLinkI()
link.parent = ImageI(iid, False)
link.child = file_ann._obj
links.append(link)
if len(links) > 0:
links = conn.getUpdateService().saveAndReturnArray(links)
if file_ann:
file_anns.append(file_ann)
if not file_anns:
fa_message = "No Analysis files created. See 'Info' or 'Error'" \
" for more details"
elif len(file_anns) > 1:
fa_message = "Created %s csv (Excel) files" % len(file_anns)
message += fa_message
return file_anns, message
def movie_figure(conn, command_args):
"""
Makes the figure using the parameters in @command_args, attaches the figure
to the parent Project/Dataset, and returns the file-annotation ID
@param session The OMERO session
@param command_args Map of parameters for the script
@ returns Returns the id of the originalFileLink child. (ID
object, not value)
"""
log("Movie figure created by OMERO on %s" % date.today())
log("")
time_labels = {
"SECS_MILLIS": "seconds",
"SECS": "seconds",
"MINS": "minutes",
"HOURS": "hours",
"MINS_SECS": "mins:secs",
"HOURS_MINS": "hours:mins"
}
time_units = "SECS"
if "Time_Units" in command_args:
time_units = command_args["Time_Units"]
# convert from UI name to time_labels key
time_units = time_units.replace(" ", "_")
if time_units not in time_labels.keys():
time_units = "SECS"
log("Time units are in %s" % time_labels[time_units])
pixel_ids = []
image_ids = []
image_labels = []
message = "" # message to be returned to the client
# function for getting image labels.
def get_image_names(full_name, tags_list, pd_list):
name = full_name.split("/")[-1]
return [name]
# default function for getting labels is getName (or use datasets / tags)
if "Image_Labels" in command_args:
if command_args["Image_Labels"] == "Datasets":
def get_datasets(name, tags_list, pd_list):
return [dataset for project, dataset in pd_list]
get_labels = get_datasets
elif command_args["Image_Labels"] == "Tags":
def get_tags(name, tags_list, pd_list):
return tags_list
get_labels = get_tags
else:
get_labels = get_image_names
else:
get_labels = get_image_names
# Get the images
images, log_message = script_utils.get_objects(conn, command_args)
message += log_message
if not images:
return None, message
# Attach figure to the first image
omero_image = images[0]
# process the list of images
log("Image details:")
for image in images:
image_ids.append(image.getId())
pixel_ids.append(image.getPrimaryPixels().getId())
# a map of imageId : list of (project, dataset) names.
pd_map = figUtil.getDatasetsProjectsFromImages(conn.getQueryService(),
image_ids)
tag_map = figUtil.getTagsFromImages(conn.getMetadataService(), image_ids)
# Build a legend entry for each image
for image in images:
name = image.getName()
iid = image.getId()
image_date = image.getAcquisitionDate()
tags_list = tag_map[iid]
pd_list = pd_map[iid]
tags = ", ".join(tags_list)
pd_string = ", ".join(["%s/%s" % pd for pd in pd_list])
log(" Image: %s ID: %d" % (name, iid))
if image_date:
log(" Date: %s" % image_date)
else:
log(" Date: not set")
log(" Tags: %s" % tags)
log(" Project/Datasets: %s" % pd_string)
image_labels.append(get_labels(name, tags_list, pd_list))
# use the first image to define dimensions, channel colours etc.
size_x = omero_image.getSizeX()
size_y = omero_image.getSizeY()
size_z = omero_image.getSizeZ()
size_t = omero_image.getSizeT()
t_indexes = []
if "T_Indexes" in command_args:
for t in command_args["T_Indexes"]:
t_indexes.append(t)
if len(t_indexes) == 0: # if no t-indexes given, use all t-indices
t_indexes = range(size_t)
z_start = -1
z_end = -1
if "Z_Start" in command_args:
z_start = command_args["Z_Start"]
if "Z_End" in command_args:
z_end = command_args["Z_End"]
width = size_x
if "Width" in command_args:
width = command_args["Width"]
height = size_y
if "Height" in command_args:
height = command_args["Height"]
spacer = (width / 25) + 2
algorithm = ProjectionType.MAXIMUMINTENSITY
if "Algorithm" in command_args:
a = command_args["Algorithm"]
if (a == "Mean Intensity"):
algorithm = ProjectionType.MEANINTENSITY
stepping = 1
if "Stepping" in command_args:
s = command_args["Stepping"]
if (0 < s < size_z):
stepping = s
scalebar = None
if "Scalebar" in command_args:
sb = command_args["Scalebar"]
try:
scalebar = int(sb)
if scalebar <= 0:
scalebar = None
else:
log("Scalebar is %d microns" % scalebar)
except ValueError:
log("Invalid value for scalebar: %s" % str(sb))
scalebar = None
overlay_colour = (255, 255, 255)
if "Scalebar_Colour" in command_args:
r, g, b, a = OVERLAY_COLOURS[command_args["Scalebar_Colour"]]
overlay_colour = (r, g, b)
max_col_count = 10
if "Max_Columns" in command_args:
max_col_count = command_args["Max_Columns"]
figure = createmovie_figure(conn, pixel_ids, t_indexes, z_start, z_end,
width, height, spacer, algorithm, stepping,
scalebar, overlay_colour, time_units,
image_labels, max_col_count)
log("")
fig_legend = "\n".join(log_lines)
# print figLegend # bug fixing only
format = command_args["Format"]
figure_name = "movie_figure"
if "Figure_Name" in command_args:
figure_name = str(command_args["Figure_Name"])
figure_name = os.path.basename(figure_name)
output = "localfile"
if format == 'PNG':
output = output + ".png"
figure_name = figure_name + ".png"
figure.save(output, "PNG")
mimetype = "image/png"
elif format == 'TIFF':
output = output + ".tiff"
figure_name = figure_name + ".tiff"
figure.save(output, "TIFF")
mimetype = "image/tiff"
else:
output = output + ".jpg"
figure_name = figure_name + ".jpg"
figure.save(output)
mimetype = "image/jpeg"
namespace = NSCREATED + "/omero/figure_scripts/Movie_Figure"
file_annotation, fa_message = script_utils.create_link_file_annotation(
conn,
output,
omero_image,
output="Movie figure",
mimetype=mimetype,
namespace=namespace,
description=fig_legend,
orig_file_path_and_name=figure_name)
message += fa_message
return file_annotation, message
def write_movie(command_args, conn):
"""
Makes the movie.
@return Returns the file annotation
"""
log("Movie created by OMERO")
log("")
message = ""
session = conn.c.sf
update_service = session.getUpdateService()
raw_file_store = session.createRawFileStore()
# Get the images
images, log_message = script_utils.get_objects(conn, command_args)
message += log_message
if not images:
return None, message
# Get the first valid image (should be expanded to process the list)
omero_image = images[0]
if command_args["RenderingDef_ID"] >= 0:
rid = command_args["RenderingDef_ID"]
omero_image._prepareRenderingEngine(rdid=rid)
pixels = omero_image.getPrimaryPixels()
pixels_id = pixels.getId()
size_x = pixels.getSizeX()
size_y = pixels.getSizeY()
size_z = pixels.getSizeZ()
size_c = pixels.getSizeC()
size_t = pixels.getSizeT()
if (size_x is None or size_y is None or size_z is None or size_t is None or
size_c is None):
return
if (pixels.getPhysicalSizeX() is None):
command_args["Scalebar"] = 0
c_range = range(0, size_c)
c_windows = None
c_colours = None
if "ChannelsExtended" in command_args and \
valid_channels(command_args["ChannelsExtended"], size_c):
c_range = []
c_windows = []
c_colours = []
for c in command_args["ChannelsExtended"]:
m = re.match('^(?P<i>\d+)(\|(?P<ws>\d+)' +
'\:(?P<we>\d+))?(\$(?P<c>.+))?$', c)
if m is not None:
c_range.append(int(m.group('i'))-1)
c_windows.append([float(m.group('ws')), float(m.group('we'))])
c_colours.append(m.group('c'))
elif "Channels" in command_args and \
valid_channels(command_args["Channels"], size_c):
c_range = command_args["Channels"]
tz_list = calculate_ranges(size_z, size_t, command_args)
time_map = calculate_acquisition_time(conn, pixels_id, c_range, tz_list)
if (time_map is None):
command_args["Show_Time"] = False
if (time_map is not None):
if (len(time_map) == 0):
command_args["Show_Time"] = False
frame_no = 1
omero_image.setActiveChannels([x+1 for x in c_range],
c_windows, c_colours)
overlay_colour = (255, 255, 255)
if "Overlay_Colour" in command_args:
r, g, b, a = COLOURS[command_args["Overlay_Colour"]]
overlay_colour = (r, g, b)
canvas_colour = tuple(COLOURS[command_args["Canvas_Colour"]][:3])
mw = command_args["Min_Width"]
if mw < size_x:
mw = size_x
mh = command_args["Min_Height"]
if mh < size_y:
mh = size_y
ovlpos = None
canvas = None
if size_x < mw or size_y < mh:
ovlpos = ((mw-size_x) / 2, (mh-size_y) / 2)
canvas = Image.new("RGBA", (mw, mh), canvas_colour)
format = command_args["Format"]
file_names = []
# add intro...
if "Intro_Slide" in command_args and command_args["Intro_Slide"].id:
intro_duration = command_args["Intro_Duration"]
intro_file_id = command_args["Intro_Slide"].getId().getValue()
intro_filenames = write_intro_end_slides(
conn, command_args, intro_file_id, intro_duration, mw, mh)
file_names.extend(intro_filenames)
# prepare watermark
if "Watermark" in command_args and command_args["Watermark"].id:
watermark = prepare_watermark(conn, command_args, mw, mh)
# add movie frames...
for tz in tz_list:
t = tz[0]
z = tz[1]
image = omero_image.renderImage(z, t)
if ovlpos is not None:
image2 = canvas.copy()
image2.paste(image, ovlpos, image)
image = image2
if "Scalebar" in command_args and command_args["Scalebar"]:
image = add_scalebar(
command_args["Scalebar"], image, pixels, command_args)
plane_info = "z:"+str(z)+"t:"+str(t)
if "Show_Time" in command_args and command_args["Show_Time"]:
time = time_map[plane_info]
image = add_time_points(time, pixels, image, overlay_colour)
if "Show_Plane_Info" in command_args and \
command_args["Show_Plane_Info"]:
image = add_plane_info(z, t, pixels, image, overlay_colour)
if "Watermark" in command_args and command_args["Watermark"].id:
image = paste_watermark(image, watermark)
if format == QT:
filename = str(frame_no) + '.png'
image.save(filename, "PNG")
else:
filename = str(frame_no) + '.jpg'
image.save(filename, "JPEG")
file_names.append(filename)
frame_no += 1
# add exit frames... "outro"
# add intro...
if "Ending_Slide" in command_args and command_args["Ending_Slide"].id:
end_duration = command_args["Ending_Duration"]
end_file_id = command_args["Ending_Slide"].id.val
end_filenames = write_intro_end_slides(
conn, command_args, end_file_id, end_duration, mw, mh)
file_names.extend(end_filenames)
filelist = ",".join(file_names)
ext = format_map[format]
movie_name = "Movie"
if "Movie_Name" in command_args:
movie_name = command_args["Movie_Name"]
movie_name = os.path.basename(movie_name)
if not movie_name.endswith(".%s" % ext):
movie_name = "%s.%s" % (movie_name, ext)
# spaces etc in file name cause problems
movie_name = re.sub("[$&\;|\(\)<>' ]", "", movie_name)
frames_per_sec = 2
if "FPS" in command_args:
frames_per_sec = command_args["FPS"]
output = "localfile.%s" % ext
build_avi(mw, mh, filelist, frames_per_sec, output, format)
mimetype = format_mimetypes[format]
omero_image._re.close()
if not os.path.exists(output):
return None, "Failed to create movie file: %s" % output
if not command_args["Do_Link"]:
original_file = script_utils.create_file(
update_service, output, mimetype, movie_name)
script_utils.upload_file(raw_file_store, original_file, movie_name)
return original_file, message
namespace = NSCREATED + "/omero/export_scripts/Make_Movie"
file_annotation, ann_message = script_utils.create_link_file_annotation(
conn, output, omero_image, namespace=namespace,
mimetype=mimetype, orig_file_path_and_name=movie_name)
message += ann_message
return file_annotation._obj, message
