def run(name, password, dataset_name, dataset_id, host, port):
conn = BlitzGateway(name, password, host=host, port=port)
try:
conn.connect()
roi_service = conn.getRoiService()
datasets = []
if dataset_id >= 0:
datasets.append(conn.getObject("Dataset", dataset_id))
else:
datasets = conn.getObjects("Dataset",
attributes={"name": dataset_name})
for dataset in datasets:
print(dataset.getId())
for image in dataset.listChildren():
result = roi_service.findByImage(image.getId(), None,
conn.SERVICE_OPTS)
if result is not None:
roi_ids = [roi.id.val for roi in result.rois]
if len(roi_ids) > 0:
print("Deleting %s ROIs..." % len(roi_ids))
conn.deleteObjects("Roi", roi_ids, wait=True)
except Exception as exc:
print("Error while deleting Rois: %s" % str(exc))
finally:
conn.close()
def main():
try:
conn = BlitzGateway(username, password, host=server, port=4064)
conn.connect() #Returns True when connected
updateService = conn.getUpdateService()
from omero.rtypes import rdouble, rint, rstring
images = conn.getObjects("Image",
opts={
'owner': owner_id,
'dataset': datasetID
})
for image in images:
imageId = image.getId()
roi_service = conn.getRoiService()
result = roi_service.findByImage(imageId, None)
for roi in result.rois:
print("ROI: ID:", roi.getId().getValue())
for s in roi.copyShapes():
if type(s) == omero.model.EllipseI:
ctr_x = s.getX().getValue()
ctr_y = s.getY().getValue()
x, y, w, h = rect_roi_frm_ctr(image, ctr_x, ctr_y,
width, height)
MAX_GFP = max_proj(image, max_ch, x, y, w, h)
BFZ9 = load_stack_plane(image, slc_ch, slc, x, y, w, h)
hstk = np.stack((MAX_GFP, BFZ9), axis=0)
tmp_str = 'output_' + str(imageId) + '_' + str(
roi.getId().getValue()) + '.tif'
output_hyperstack(hstk, tmp_str)
finally:
if conn:
conn.close()
omero.grid.DoubleColumn("lineLength", "", []),
omero.grid.StringColumn("shapeText", "", 64, []),
]
# create and initialize the table
table = conn.c.sf.sharedResources().newTable(1, "LineLengths%s" % str(random()))
table.initialize(columns)
# make a local array of our data (add it to table in one go)
imageIds = []
roiIds = []
shapeIds = []
theZs = []
theTs = []
lineLengths = []
shapeTexts = []
roiService = conn.getRoiService()
lengthsForImage = []
for image in dataset.listChildren():
result = roiService.findByImage(image.getId(), None)
for roi in result.rois:
for s in roi.copyShapes():
if type(s) == omero.model.LineI:
imageIds.append(image.getId())
roiIds.append(roi.getId().getValue())
shapeIds.append(s.getId().getValue())
theZs.append(s.getTheZ().getValue())
theTs.append(s.getTheT().getValue())
x1 = s.getX1().getValue()
x2 = s.getX2().getValue()
y1 = s.getY1().getValue()
y2 = s.getY2().getValue()
# create an ROI with a single polygon, setting colors and lineWidth
polygon = omero.model.PolygonI()
polygon.theZ = rint(z)
polygon.theT = rint(t)
polygon.fillColor = rint(rgba_to_int(255, 0, 255, 50))
polygon.strokeColor = rint(rgba_to_int(255, 255, 0))
polygon.strokeWidth = omero.model.LengthI(10, UnitsLength.PIXEL)
points = "10,20 50,150 200,200 250,75"
polygon.points = rstring(points)
polygon.textValue = rstring("test-Polygon")
create_roi(image, [polygon])
# Retrieve ROIs linked to an Image
# ================================
roi_service = conn.getRoiService()
result = roi_service.findByImage(imageId, None)
for roi in result.rois:
print("ROI: ID:", roi.getId().getValue())
for s in roi.copyShapes():
shape = {}
shape['id'] = s.getId().getValue()
shape['theT'] = s.getTheT().getValue()
shape['theZ'] = s.getTheZ().getValue()
if s.getTextValue():
shape['textValue'] = s.getTextValue().getValue()
if type(s) == omero.model.RectangleI:
shape['type'] = 'Rectangle'
shape['x'] = s.getX().getValue()
shape['y'] = s.getY().getValue()
shape['width'] = s.getWidth().getValue()
class TestSavedMasks(ITest):
def setup_method(self):
self.conn = BlitzGateway(client_obj=self.client)
def save_and_return_masks(self, im, masks):
roi = omero.model.RoiI()
for mask in masks:
roi.addShape(mask)
us = self.conn.getUpdateService()
roi.setImage(im._obj)
roi = us.saveAndReturnObject(roi)
assert roi
rois = self.conn.getRoiService().findByImage(im.id, None)
assert len(rois.rois) == 1
shapes = rois.rois[0].copyShapes()
assert len(shapes) == len(masks)
assert all((type(mask) == omero.model.MaskI) for mask in shapes)
return shapes
@pytest.mark.parametrize('args', [{}, {
'rgba': (255, 128, 64, 128),
'z': 1,
'c': 2,
't': 3,
'text': 'test'
}])
def test_mask_from_binary_image(self, binary_image, args):
im = self.conn.createImageFromNumpySeq(iter([binary_image]),
'omero-rois-integration')
# Reload
im = self.conn.getObject('Image', im.id)
px = im.getPrimaryPixels().getPlane()
mask = mask_from_binary_image(px, **args)
mask = self.save_and_return_masks(im, [mask])[0]
# The rest of this is more or less the same as the unit test
assert unwrap(mask.getWidth()) == 2
assert unwrap(mask.getHeight()) == 2
assert unwrap(mask.getX()) == 1
assert unwrap(mask.getY()) == 1
assert np.array_equal(np.frombuffer(mask.getBytes(), np.uint8),
np.array([224], dtype=np.uint8))
if args:
assert unwrap(mask.getTheZ()) == 1
assert unwrap(mask.getTheC()) == 2
assert unwrap(mask.getTheT()) == 3
assert unwrap(mask.getTextValue()) == 'test'
else:
assert unwrap(mask.getTheZ()) is None
assert unwrap(mask.getTheC()) is None
assert unwrap(mask.getTheT()) is None
assert unwrap(mask.getTextValue()) is None
def test_mask_from_binary_full_image(self):
binim = np.ones((4, 4), dtype=np.uint8)
im = self.conn.createImageFromNumpySeq(iter([binim]),
'omero-rois-integration')
# Reload
im = self.conn.getObject('Image', im.id)
px = im.getPrimaryPixels().getPlane()
mask = mask_from_binary_image(px)
mask = self.save_and_return_masks(im, [mask])[0]
# The rest of this is more or less the same as the unit test
assert unwrap(mask.getWidth()) == 4
assert unwrap(mask.getHeight()) == 4
assert np.array_equal(np.frombuffer(mask.getBytes(), np.uint8),
np.array([255, 255], dtype=np.uint8))
@pytest.mark.parametrize('args', [{}, {
'rgba': (255, 128, 64, 128),
'z': 1,
'c': 2,
't': 3,
'text': 'test'
}])
def test_masks_from_label_image(self, label_image, args):
im = self.conn.createImageFromNumpySeq(iter([label_image]),
'omero-rois-integration')
# Reload
im = self.conn.getObject('Image', im.id)
px = im.getPrimaryPixels().getPlane()
masks = masks_from_label_image(px, **args)
masks = self.save_and_return_masks(im, masks)
# The rest of this is more or less the same as the unit test
expected = (
# w, h, x, y, bytes
(2, 2, 1, 1, np.array([224], dtype=np.uint8)),
(2, 3, 2, 0, np.array([72], dtype=np.uint8)),
)
assert len(masks) == 2
for i, mask in enumerate(masks):
assert unwrap(mask.getWidth()) == expected[i][0]
assert unwrap(mask.getHeight()) == expected[i][1]
assert unwrap(mask.getX()) == expected[i][2]
assert unwrap(mask.getY()) == expected[i][3]
assert np.array_equal(np.frombuffer(mask.getBytes(), np.uint8),
expected[i][4])
if args:
assert unwrap(mask.getTheZ()) == 1
assert unwrap(mask.getTheC()) == 2
assert unwrap(mask.getTheT()) == 3
assert unwrap(mask.getTextValue()) == 'test'
else:
assert unwrap(mask.getTheZ()) is None
assert unwrap(mask.getTheC()) is None
assert unwrap(mask.getTheT()) is None
assert unwrap(mask.getTextValue()) is None
@pytest.mark.parametrize('args', [{}, {
'rgba': (255, 128, 64, 128),
'z': 1,
'c': 2,
't': 3,
'text': 'test'
}])
def test_empty_mask_from_binary_image(self, args):
empty_binary_image = np.array([[0]], dtype=np.uint8)
raise_on_no_mask = False
im = self.conn.createImageFromNumpySeq(iter([empty_binary_image]),
'omero-rois-integration')
# Reload
im = self.conn.getObject('Image', im.id)
px = im.getPrimaryPixels().getPlane()
mask = mask_from_binary_image(px,
raise_on_no_mask=raise_on_no_mask,
**args)
mask = self.save_and_return_masks(im, [mask])[0]
# The rest of this is more or less the same as the unit test
assert unwrap(mask.getWidth()) == 0
assert unwrap(mask.getHeight()) == 0
assert unwrap(mask.getX()) == 0
assert unwrap(mask.getY()) == 0
assert np.array_equal(np.frombuffer(mask.getBytes(), np.uint8), [])
if args:
assert unwrap(mask.getTheZ()) == 1
assert unwrap(mask.getTheC()) == 2
assert unwrap(mask.getTheT()) == 3
assert unwrap(mask.getTextValue()) == 'test'
else:
assert unwrap(mask.getTheZ()) is None
assert unwrap(mask.getTheC()) is None
assert unwrap(mask.getTheT()) is None
assert unwrap(mask.getTextValue()) is None
class OMEROConnection(object):
def __init__(self, args, configs):
self.args = args
self.configs = configs
self.connect_with = self.configs['CONNECT_WITH']
self.host = self.configs['OMERO_{}_HOST'.format(self.connect_with)]
self.user = self.configs['OMERO_{}_USER'.format(self.connect_with)]
self.password = self.configs['OMERO_{}_PASSWORD'.format(
self.connect_with)]
self.port = self.configs['OMERO_{}_PORT'.format(self.connect_with)]
def __enter__(self):
from omero.gateway import BlitzGateway # @UnresolvedImport
self.conn = BlitzGateway(host=self.host,
username=self.user,
passwd=self.password,
port=self.port)
self.connected = self.conn.connect()
# failed to connect
if not self.connected:
print_date(
"Unable to connect to host '{}' on port {} using user '{}'".
format(self.host, self.port, self.user))
print_date("Check that server is up")
sys.exit(1)
# keepalive
self.conn.c.enableKeepAlive(5)
self.omero_user = self.conn.getUser()
self.userId = self.omero_user.getId()
self.updateService = self.conn.getUpdateService()
self.roiService = self.conn.getRoiService()
return self
def __exit__(self, exc_type, exc_value, traceback): # @UnusedVariable
self.conn._closeSession()
if self.args.verbose:
print_date('Connection closed.')
self.connected = False
def list(self):
"""List images or ROIs
:return int count: the number of images/ROIs
"""
if self.args.images:
print_date("Listing images...")
images = self.images()
if self.args.summary:
pass
else:
print_date("Structuring output...")
image_view = ImageView(images)
print(image_view)
return len(images)
elif self.args.rois:
print_date("Listing ROIs...")
rois = self.rois()
if self.args.summary:
pass
else:
print_date("Structuring output...")
roi_view = ROIView(rois)
print(roi_view)
return len(rois)
@property
def projects(self):
if self.args.project is not None:
projects = self.conn.searchObjects(["Project"], self.args.project)
return projects
else:
return self.conn.listProjects(self.userId)
def datasets(self, project=None):
"""List the datasets associated with the current user
:param project: a project
:param bool in_project: are these datasets contained within a project?
"""
datasets = list()
if self.args.dataset is not None:
datasets += self.conn.searchObjects(["Dataset"], self.args.dataset)
else:
if project is not None:
projects = self.conn.searchObjects(["Project"], project)
for p in projects:
datasets += p.listChildren()
else:
params = omero.sys.ParametersI() # @UndefinedVariable
params.exp(self.userId)
datasets += self.conn.getObjects("Dataset", params=params)
return datasets
def images(self, project=None, dataset=None):
"""The list of images associated with the current user
If the image ID is specified only the required image is returned. (The project and dataset are ignored.)
Otherwise:
- If a project object is provided all images in all datasets in the project are returned. (The dataset is ignored.)
- If a project object and dataset object are provided then only those images in the project and dataset are return.
- If no project object is provided but a dataset object is provided then only those images in the dataset are returned.
:param str project: OMERO project name
:param str dataset: OMERO dataset name
:return list images: a list of OMERO ``Image`` objects
"""
# assertions
images = list()
print_date("Retrieving images...")
if self.args.image_id is not None:
try:
assert isinstance(self.args.image_id, int) or isinstance(
self.args.image_id, long)
except AssertionError:
print_date("Invalid type for image ID: {}".format(
type(self.args.image_id)))
sys.exit(1)
image = self.getImage(self.args.image_id)
if image is not None:
images.append(image)
elif self.args.image_name is not None:
images = self.conn.searchObjects(["Image"], self.args.image_name)
else:
if project is not None: # project specified
print_date(
"Searching for images in project '{}'".format(project))
# get all projects matching
projects = self.conn.searchObjects(["Project"], project)
# get all datasets in projects matching
datasets_in_projects = dict()
for p in projects:
for d in p.listChildren():
datasets_in_projects[d.getName()] = d
print_date("Found {} datasets in project '{}'".format(
len(datasets_in_projects), project))
# dataset specified
if dataset is not None:
print_date(
"Searching for images in dataset '{}'".format(dataset))
if dataset in datasets_in_projects.keys():
images += datasets_in_projects[dataset].listChildren()
else: # dataset not specified
print_date(
"Searching for images in all {} datasets".format(
len(datasets_in_projects)))
for dataset in datasets_in_projects.keys():
images += datasets_in_projects[dataset].listChildren()
else: # project not specified
# dataset specified
if dataset is not None:
print_date(
"Searching for images in dataset '{}'".format(dataset))
datasets = self.conn.searchObjects(["Dataset"], dataset)
for dataset in datasets:
images += dataset.listChildren()
else:
datasets = self.datasets()
print_date(
"Searching for images in all {} datasets".format(
len(datasets)))
for dataset in datasets:
images += dataset.listChildren()
print_date("Found {} image(s).".format(len(images)))
return images
def getImage(self, image_id):
"""Get the image with the image ID specified on the command line
:param int image_id: command line arguments
:return image: an image
:rtype image: ``OMEROImage``
"""
return self.conn.getObject("Image", image_id)
def rois(self, project=None, dataset=None):
"""Get an iterator over the ROIs associated with the specified image ID
:param int image_id: image ID
"""
rois = list()
print_date("Retrieving ROIs...")
if self.args.image_id is not None:
return self.getROIs(self.args.image_id)
else:
for image in self.images(project, dataset):
if image.getROICount() > 0:
rois.append((image, self.getROIs(image.getId())))
roi_count = sum(map(lambda r: len(r[1]), rois))
print_date("Found {:,} ROIs in {:,} images.".format(
roi_count, len(rois)))
return rois
def getROIs(self, image_id):
result = self.roiService.findByImage(image_id, None)
return result.rois
def attachRois(self, omero_rois):
"""Attach the rois from the iterable"""
non_rois = filter(lambda r: not isinstance(r, OMEROROI), omero_rois)
try:
assert len(non_rois) == 0
except AssertionError:
print_date("Found {:,} non-ROI objects".format(len(non_rois)))
return 1
for roi in omero_rois:
self.saveRoi(roi)
return os.EX_OK
# save
def saveRoi(self, roi):
"""Save the given ROI
:param roi: an ROI object
:type roi: `omero.model.Roi`
"""
import Ice
try:
self.updateService.saveObject(roi)
except Ice.MemoryLimitException as e: # @UndefinedVariable
print_date(str(e))
sys.exit(1)
# delete
def deleteRoi(self, roi_id):
"""
Delete the given ROI
:param roi: an ROI object
:type roi: `omero.model.Roi`
"""
from omero.callbacks import CmdCallbackI # @UnresolvedImport
handle = self.conn.deleteObjects("Roi", [roi_id],
deleteAnns=True,
deleteChildren=True)
callback = CmdCallbackI(self.conn.c, handle)
while not callback.block(500):
if self.args.verbose:
print_date(".", newline=False, incl_date=False)
time.sleep(2)
callback.close(True)
