def extract_images_or_rois(parameters):
# work at image level or ROIs by term
images = ImageInstanceCollection()
if parameters.cytomine_id_images is not None:
id_images = parse_domain_list(parameters.cytomine_id_images)
images.extend([ImageInstance().fetch(_id) for _id in id_images])
else:
images = images.fetch_with_filter("project",
parameters.cytomine_id_project)
slides = [
CytomineSlide(img, parameters.cytomine_zoom_level) for img in images
]
if parameters.cytomine_id_roi_term is None:
return slides
# fetch ROI annotations, all users
collection = AnnotationCollection(
terms=[parameters.cytomine_id_roi_term],
reviewed=parameters.cytomine_reviewed_roi,
project=parameters.cytomine_id_project,
showWKT=True,
includeAlgo=True).fetch()
slides_map = {slide.image_instance.id: slide for slide in slides}
regions = list()
for annotation in collection:
if annotation.image not in slides_map:
continue
slide = slides_map[annotation.image]
regions.append(
get_iip_window_from_annotation(slide, annotation,
parameters.cytomine_zoom_level))
return regions
def upload_annotation(self, predicted_data, project_id):
self.cj.job.update(progress=95, statusComment="Uploading annotations")
annotations = AnnotationCollection()
components = ObjectFinder(predicted_data).find_components()
locations = []
for component in components:
location = Polygon(component[0], component[1])
if location.is_valid:
locations.append(location)
else:
fixed = fix_geometry(location)
if fixed.is_valid and not fixed.is_empty:
locations.append(fixed)
for idx, loc in enumerate(locations):
if not loc.is_valid:
fixed = fix_geometry(loc)
if fixed.is_valid and not fixed.is_empty:
loc[idx] = fixed
annotations.extend([
create_annotation_from_location(loc, self.image_instance.id,
self.image_instance.height,
project_id) for loc in locations
])
annotations.save(chunk=20)
def _load_rectangles(job: Job, image_id: str, term: int,
detections: dict) -> None:
progress = 10
job.update(
progress=progress,
status=Job.RUNNING,
statusComment=
f"Uploading detections of type rectangles to image {image_id} with terms {term}"
)
rectangles = _generate_rectangles(detections)
# Upload annotations to server
delta = 85 / len(rectangles)
annotations = AnnotationCollection()
for rectangle in rectangles:
annotations.append(
Annotation(location=rectangle.wkt,
id_image=image_id,
id_terms=[term]))
progress += delta
job.update(progress=int(progress), status=Job.RUNNING)
annotations.save()
progress = 100
job.update(progress=progress,
status=Job.TERMINATED,
statusComment="All detections have been uploaded")
def create_track_from_slices(image,
slices,
depth2slice,
id_project,
track_prefix="object",
label=None,
upload_group_id=False,
depth="time"):
"""Create an annotation track from a list of AnnotationSlice
Parameters
----------
image: ImageInstance
The image instance in which the track is added
slices: iterable (of AnnotationSlice)
The polygon slices of the objects to draw
depth2slice: dict
A dictionary mapping the depths of the image instance with their respective SliceInstance
id_project: int
Project identifier
track_prefix: str (default: "object")
A prefix for the track name
label: int|str (default: None)
A label for the track
upload_group_id: bool
True to upload the group identifier
depth: str
Which depth field to read in the AnnotationSlice if both are present. One of {'time', 'depth'}.
Returns
-------
saved_tracks: TrackCollection
The saved track objects
annotations: AnnotationCollection
The annotations associated with the traped. The collection is NOT saved.
"""
if label is None and len(slices) > 0:
label = slices[0].label
track = Track(name="{}-{}".format(track_prefix, label),
id_image=image.id,
color=None if upload_group_id else DEFAULT_COLOR).save()
if upload_group_id:
Property(track, key="label", value=label).save()
collection = AnnotationCollection()
for _slice in slices:
collection.append(
Annotation(
location=change_referential(p=_slice.polygon,
height=image.height).wkt,
id_image=image.id,
id_project=id_project,
id_tracks=[track.id],
slice=depth2slice[_slice.depth if _slice.time is None
or depth == "depth" else _slice.time].id))
return track, collection
def mask_convert(mask,
image,
project_id,
mask_2d_fn,
mask_3d_fn,
track_prefix,
upload_group_id=False):
"""Generic function to convert a mask into an annotation collection
Parameters
----------
mask: ndarray
image: ImageInstance
project_id: int
mask_2d_fn: callable
mask_3d_fn: callable
track_prefix: str
upload_group_id: bool
Returns
-------
tracks: TrackCollection
Tracks, which have been saved
annotations: AnnotationCollection
Annotation which have NOT been saved
"""
tracks = TrackCollection()
annotations = AnnotationCollection()
if mask.ndim == 2:
slices = mask_2d_fn(mask)
annotations.extend([
create_annotation_from_slice(s,
image.id,
image.height,
project_id,
upload_group_id=upload_group_id)
for s in slices
])
elif mask.ndim == 3:
slices = mask_3d_fn(mask)
depth_to_slice = get_depth_to_slice(image)
for obj_id, obj in enumerate(slices):
track, curr_annotations = create_track_from_slices(
image,
obj,
label=obj_id,
depth2slice=depth_to_slice,
track_prefix=track_prefix,
id_project=project_id,
upload_group_id=upload_group_id)
tracks.append(track)
annotations.extend(curr_annotations)
else:
raise ValueError("Only supports 2D or 3D output images...")
return tracks, annotations
def extract_tiled_annotations(in_tiles, out_path, nj, label_merging=False):
"""
in_images: iterable
List of BiaflowsTile
out_path: str
Path of output tiles
nj: BiaflowsJob
A BIAflows job object
label_merging: bool
True for merging only polygons having the same label. False for merging based on geometry only
"""
# regroup tiles by original images
grouped_tiles = defaultdict(list)
for in_tile in in_tiles:
grouped_tiles[in_tile.in_image.original_filename].append(in_tile)
default_tile_builder = DefaultTileBuilder()
annotations = AnnotationCollection()
for tiles in grouped_tiles.values():
# recreate the topology
in_image = tiles[0].in_image
topology = BiaflowsSldcImage(in_image, is_2d=True).tile_topology(
default_tile_builder,
max_width=nj.flags["tile_width"],
max_height=nj.flags["tile_height"],
overlap=nj.flags["tile_overlap"])
# extract polygons for each tile
ids, polygons, labels = list(), list(), list()
label = -1
for tile in tiles:
out_tile_path = os.path.join(out_path, tile.filename)
slices = mask_to_objects_2d(imread(out_tile_path),
offset=tile.tile.abs_offset[::-1])
ids.append(tile.tile.identifier)
polygons.append([s.polygon for s in slices])
labels.append([s.label for s in slices])
# save label for use after merging
if len(slices) > 0:
label = slices[0]
# merge
merged = SemanticMerger(tolerance=1).merge(
ids, polygons, topology, labels=labels if label_merging else None)
if label_merging:
merged = merged[0]
annotations.extend([
create_annotation_from_slice(
_slice=AnnotationSlice(p, label),
id_image=in_image.object.id,
image_height=in_image.object.height,
id_project=nj.project.id,
) for p in merged
])
return annotations
def main(argv):
with CytomineJob.from_cli(argv) as job:
model_path = os.path.join(str(Path.home()), "models", "thyroid-unet")
model_filepath = pick_model(model_path, job.parameters.tile_size,
job.parameters.cytomine_zoom_level)
device = torch.device(job.parameters.device)
unet = Unet(job.parameters.init_fmaps, n_classes=1)
unet.load_state_dict(torch.load(model_filepath, map_location=device))
unet.to(device)
unet.eval()
segmenter = UNetSegmenter(device=job.parameters.device,
unet=unet,
classes=[0, 1],
threshold=job.parameters.threshold)
working_path = os.path.join(str(Path.home()), "tmp")
tile_builder = CytomineTileBuilder(working_path)
builder = SSLWorkflowBuilder()
builder.set_n_jobs(1)
builder.set_overlap(job.parameters.tile_overlap)
builder.set_tile_size(job.parameters.tile_size,
job.parameters.tile_size)
builder.set_tile_builder(tile_builder)
builder.set_border_tiles(Workflow.BORDER_TILES_EXTEND)
builder.set_background_class(0)
builder.set_distance_tolerance(1)
builder.set_seg_batch_size(job.parameters.batch_size)
builder.set_segmenter(segmenter)
workflow = builder.get()
slide = CytomineSlide(img_instance=ImageInstance().fetch(
job.parameters.cytomine_id_image),
zoom_level=job.parameters.cytomine_zoom_level)
results = workflow.process(slide)
print("-------------------------")
print(len(results))
print("-------------------------")
collection = AnnotationCollection()
for obj in results:
wkt = shift_poly(obj.polygon,
slide,
zoom_level=job.parameters.cytomine_zoom_level).wkt
collection.append(
Annotation(location=wkt,
id_image=job.parameters.cytomine_id_image,
id_terms=[154005477],
id_project=job.project.id))
collection.save(n_workers=job.parameters.n_jobs)
return {}
def run():
"""
Deletes all the annotations from an image, but those created by a software
Example:
python main.py --cytomine_host 'localhost-core' --cytomine_public_key 'b6ebb23c-00ff-427b-be24-87b2a82490df' --cytomine_private_key '6812f09b-3f33-4938-82ca-b23032d377fd' --cytomine_id_image_instance 347 --cytomine_id_user 61 --cytomine_id_project 154
python main.py --cytomine_host 'localhost-core' --cytomine_public_key 'b6ebb23c-00ff-427b-be24-87b2a82490df' --cytomine_private_key '6812f09b-3f33-4938-82ca-b23032d377fd' --cytomine_id_image_instance 3643 --cytomine_id_user 61 --cytomine_id_project 154
python main.py --cytomine_host 'localhost-core' --cytomine_public_key 'd2be8bd7-2b0b-40c3-9e81-5ad5765568f3' --cytomine_private_key '6dfe27d7-2ad1-4ca2-8ee9-6321ec3f1318' --cytomine_id_image_instance 2140 --cytomine_id_user 58 --cytomine_id_project 197
"""
parser = ArgumentParser(prog="Cytomine Python client example")
# Cytomine
parser.add_argument('--cytomine_host',
dest='host',
default='demo.cytomine.be',
help="The Cytomine host")
parser.add_argument('--cytomine_public_key',
dest='public_key',
help="The Cytomine public key")
parser.add_argument('--cytomine_private_key',
dest='private_key',
help="The Cytomine private key")
parser.add_argument('--cytomine_id_image_instance',
dest='id_image_instance',
help="The image with annotations to delete")
parser.add_argument('--cytomine_id_user',
dest='id_user',
help="The user with annotations to delete")
parser.add_argument('--cytomine_id_project',
dest='id_project',
help="The project with annotations to delete")
params, _ = parser.parse_known_args(sys.argv[1:])
with Cytomine(host=params.host,
public_key=params.public_key,
private_key=params.private_key,
verbose=logging.INFO) as cytomine:
# Get the list of annotations
annotations = AnnotationCollection()
annotations.image = params.id_image_instance
# NOTE: use userjob id to retrieve annotations from the job. However, they
# cannot be deleted.
annotations.user = params.id_user
annotations.project = params.id_project
annotations.fetch()
print(annotations)
for annotation in annotations:
annotation.delete()
def extract_images_or_rois(parameters):
id_annotations = parse_domain_list(parameters.cytomine_roi_annotations)
# if ROI annotations are provided
if len(id_annotations) > 0:
image_cache = dict() # maps ImageInstance id with CytomineSlide object
zones = list()
for id_annot in id_annotations:
annotation = Annotation().fetch(id_annot)
if annotation.image not in image_cache:
image_cache[annotation.image] = CytomineSlide(
annotation.image, parameters.cytomine_zoom_level)
window = get_iip_window_from_annotation(
image_cache[annotation.image], annotation,
parameters.cytomine_zoom_level)
zones.append(window)
return zones
# work at image level or ROIs by term
images = ImageInstanceCollection()
if parameters.cytomine_id_images is not None:
id_images = parse_domain_list(parameters.cytomine_id_images)
images.extend([ImageInstance().fetch(_id) for _id in id_images])
else:
images = images.fetch_with_filter("project",
parameters.cytomine_id_project)
slides = [
CytomineSlide(img, parameters.cytomine_zoom_level) for img in images
]
if parameters.cytomine_id_roi_term is None:
return slides
# fetch ROI annotations
collection = AnnotationCollection(
terms=[parameters.cytomine_id_roi_term],
reviewed=parameters.cytomine_reviewed_roi,
showWKT=True)
collection.fetch_with_filter(project=parameters.cytomine_id_project)
slides_map = {slide.image_instance.id: slide for slide in slides}
regions = list()
for annotation in collection:
if annotation.image not in slides_map:
continue
slide = slides_map[annotation.image]
regions.append(
get_iip_window_from_annotation(slide, annotation,
parameters.cytomine_zoom_level))
return regions
def run(cyto_job, parameters):
job = cyto_job.job
project_id = cyto_job.project
term_id = parameters.terms_list
logging.info(f"########### Parameters = {str(parameters)}")
logging.info(f"########### Term {str(term_id)}")
logging.info(f"########### Project {str(project_id)}")
annotations = AnnotationCollection()
annotations.project = project_id
annotations.terms = [term_id]
annotations.fetch()
progress = 0
progress_delta = 1.0 / (1.50 * len(annotations))
job.update(
progress=progress,
statusComment=f"Converting annotations from project {project_id}")
new_annotations = AnnotationCollection()
for a in annotations:
if a.location is None:
a.fetch()
new_annotations.append(
Annotation(a.location, a.image, a.term, a.project))
new_annotations.save(chunk=None)
job.update(progress=0.25, statusComment=f"Deleting old annotations...")
for a in annotations:
a.delete()
progress += progress_delta
job.update(progress=progress)
def extract_annotations_prttrk(out_path, in_image, project_id, track_prefix,
**kwargs):
"""
Parameters:
-----------
out_path: str
in_image: BiaflowsCytomineInput
project_id: int
name_prefix: str
kwargs: dict
"""
image = in_image.object
path = os.path.join(out_path, in_image.filename)
data, dim_order, _ = imread(path, return_order=True)
ndim = get_dimensionality(dim_order)
if ndim != 3:
raise ValueError(
"Annotation extraction for object tracking does not support masks with more than 3 dims..."
)
slices = mask_to_points_3d(data, time=True, assume_unique_labels=True)
time_to_image = get_depth_to_slice(image)
tracks = TrackCollection()
annotations = AnnotationCollection()
for slice_group in slices:
curr_tracks, curr_annots = create_tracking_from_slice_group(
image,
slice_group,
slice2point=lambda _slice: _slice.polygon,
depth2slice=time_to_image,
id_project=project_id,
upload_object=False,
track_prefix=track_prefix + "-particle",
upload_group_id=True)
tracks.extend(curr_tracks)
annotations.extend(curr_annots)
return tracks, annotations
def main(argv):
parser = ArgumentParser()
parser.add_argument(*_cytomine_parameter_name_synonyms("project_id"),
dest="project_id",
type=int,
help="The Cytomine project id.",
required=True)
parser.add_argument(
"-i",
"--ignore-existing",
action="store_true",
dest="ignore_existing",
help=
"Ignore existing ground truth annotation associated with the project. If not specified,"
" current annotations will be deleted before uploading the new ones.")
parser.set_defaults(ignore_existing=False)
options, _ = parser.parse_known_args(argv)
with Cytomine.connect_from_cli(argv) as cytomine:
project = Project().fetch(options.project_id)
print("Project '{}' (#{}): discipline '{}'".format(
project.name, project.id, project.disciplineShortName))
if not options.ignore_existing:
annotations = AnnotationCollection()
annotations.project = project.id
annotations.user = cytomine.current_user.id
annotations.fetch()
delete_collection(annotations, "annotation")
tracks = TrackCollection()
tracks.project = project.id
tracks.user = cytomine.current_user.id
tracks.fetch_with_filter("project", project.id)
tracks._data = [
t for t in tracks.data() if t.name.startswith("gt-")
]
delete_collection(tracks, "track")
fake_job = FakeJob(project)
home = Path.home()
in_path = os.path.join(home, "data", "in")
gt_path = os.path.join(home, "data", "gt")
os.makedirs(in_path)
os.makedirs(gt_path)
in_images, gt_images = download_images(fake_job,
in_path,
gt_path,
gt_suffix="_lbl")
if project.disciplineShortName == "TreTrc":
# ground truth is contained in swc files so need to
# convert them into masks beforehand
print("TreTrc problem: start converting SWC to masks")
download_attached(in_images, gt_path, do_download=True)
alternate_gt_path = os.path.join(home, "data", "altgt")
os.makedirs(alternate_gt_path)
for in_image in in_images:
swc_filepath = in_image.attached[0].filepath
im_size = imageio.volread(
in_image.filepath).shape # Size is Depth,Height,Width
im_size = im_size[::
-1] # Invert the size order to Width,Height,Depth
swc_to_tiff_stack(input_path=swc_filepath,
output_path=os.path.join(
alternate_gt_path, in_image.filename),
im_size=im_size)
gt_path = alternate_gt_path
is_2d = guess_dims(gt_path)
print("Image detected as {}".format("2d" if is_2d else ">2d"))
upload_data(problemclass=project.disciplineShortName,
nj=fake_job,
inputs=in_images,
out_path=gt_path,
is_2d=is_2d,
projection=-1)
def main(argv):
base_path = str(Path.home())
#Available filters
filters = {
'binary': BinaryFilter(),
'adaptive': AdaptiveThresholdFilter(),
'otsu': OtsuFilter()
}
#Connect to Cytomine
with CytomineJob.from_cli(argv) as cj:
cj.job.update(status=Job.RUNNING,
progress=0,
statusComment="Initialisation...")
working_path = os.path.join(base_path, "data", str(cj.job.id))
if not os.path.exists(working_path):
os.makedirs(working_path)
filter = filters.get(cj.parameters.cytomine_filter)
#Initiatlize the reader to browse the whole image
whole_slide = WholeSlide(
cj.get_image_instance(cj.parameters.cytomine_id_image, True))
reader = CytomineReader(whole_slide,
window_position=Bounds(
0, 0, cj.parameters.cytomine_tile_size,
cj.parameters.cytomine_tile_size),
zoom=cj.parameters.cytomine_zoom_level,
overlap=cj.parameters.cytomine_tile_overlap)
reader.window_position = Bounds(0, 0, reader.window_position.width,
reader.window_position.height)
#Browse the slide using reader
i = 0
geometries = []
cj.job.update(progress=1, status_comment="Browsing big image...")
while True:
#Read next tile
reader.read()
image = reader.data
#Saving tile image locally
tile_filename = "%s/image-%d-zoom-%d-tile-%d-x-%d-y-%d.png" % (
working_path, cj.parameters.cytomine_id_image,
cj.parameters.cytomine_zoom_level, i, reader.window_position.x,
reader.window_position.y)
image.save(tile_filename, "PNG")
#Apply filtering
cv_image = np.array(reader.result())
filtered_cv_image = filter.process(cv_image)
i += 1
#Detect connected components
components = ObjectFinder(filtered_cv_image).find_components()
#Convert local coordinates (from the tile image) to global coordinates (the whole slide)
components = whole_slide.convert_to_real_coordinates(
components, reader.window_position, reader.zoom)
geometries.extend(
get_geometries(components, cj.parameters.cytomine_min_area,
cj.parameters.cytomine_max_area))
#Upload annotations (geometries corresponding to connected components) to Cytomine core
#Upload each geometry and predicted term
annotations = AnnotationCollection()
for geometry in geometries:
pol = shapely.wkt.loads(geometry)
if pol.is_valid:
annotations.append(
Annotation(
location=geometry,
id_image=cj.parameters.cytomine_id_image,
id_project=cj.parameters.cytomine_id_project,
id_terms=[
cj.parameters.cytomine_id_predicted_term
]))
#Batches of 100 annotations
if len(annotations) % 100 == 0:
annotations.save()
annotations = AnnotationCollection()
annotations.save()
geometries = []
if not reader.next(): break
cj.job.update(progress=50,
status_comment=
"Detection done, starting Union over whole big image...")
#Perform Union of geometries (because geometries are computed locally in each tile but objects (e.g. cell clusters) might overlap several tiles)
host = cj.parameters.cytomine_host.replace("http://", "")
unioncommand = "groovy -cp \"/lib/jars/*\" /app/union4.groovy http://%s %s %s %d %d %d %d %d %d %d %d %d %d" % (
host,
cj._public_key,
cj._private_key,
cj.parameters.cytomine_id_image,
cj.job.userJob,
cj.parameters.cytomine_id_predicted_term, #union_term
cj.parameters.cytomine_union_min_length, #union_minlength,
cj.parameters.cytomine_union_bufferoverlap, #union_bufferoverlap,
cj.parameters.
cytomine_union_min_point_for_simplify, #union_minPointForSimplify,
cj.parameters.cytomine_union_min_point, #union_minPoint,
cj.parameters.cytomine_union_max_point, #union_maxPoint,
cj.parameters.cytomine_union_nb_zones_width, #union_nbzonesWidth,
cj.parameters.cytomine_union_nb_zones_height
) #union_nbzonesHeight)
os.chdir(base_path)
print(unioncommand)
os.system(unioncommand)
cj.job.update(status=Job.TERMINATED,
progress=100,
statusComment="Finished.")
help="The Cytomine private key")
parser.add_argument('--cytomine_id_image_instance',
dest='id_image_instance',
help="The image in which we work")
parser.add_argument('--cytomine_id_roi_term',
dest='id_roi_term',
help="The term that represents regions of interest")
parser.add_argument('--cytomine_id_object_term',
dest='id_object_term',
help="The term that represents objects")
params, other = parser.parse_known_args(sys.argv[1:])
with Cytomine(host=params.host,
public_key=params.public_key,
private_key=params.private_key) as cytomine:
roi_annotations = AnnotationCollection()
roi_annotations.image = params.id_image_instance
roi_annotations.term = params.id_roi_term
roi_annotations.fetch()
print(roi_annotations)
for roi_annotation in roi_annotations:
included_annotations = AnnotationCollection()
included_annotations.image = params.id_image_instance
included_annotations.term = params.id_object_term
included_annotations.annotation = roi_annotation.id
included_annotations.fetch()
print("Number of annotations of term {} included in ROI {}: {}".
format(params.id_object_term, roi_annotation.id,
len(included_annotations)))
def main(argv):
with CytomineJob.from_cli(argv) as cj:
cj.job.update(progress=1, statusComment="Initialisation")
cj.log(str(cj.parameters))
term_ids = [cj.parameters.cytomine_id_predicted_term] \
if hasattr(cj.parameters, "cytomine_id_predicted_term") else None
image_ids = [
int(image_id)
for image_id in cj.parameters.cytomine_id_images.split(",")
]
images = ImageInstanceCollection().fetch_with_filter(
"project", cj.parameters.cytomine_id_project)
images = [image for image in images if image.id in image_ids]
tile_size = cj.parameters.tile_size
tile_overlap = cj.parameters.tile_overlap
filter_func = _get_filter(cj.parameters.filter)
projection = cj.parameters.projection
if projection not in ('min', 'max', 'average'):
raise ValueError("Projection {} is not found".format(projection))
cj.log("Filter: {}".format(cj.parameters.filter))
cj.log("Projection: {}".format(projection))
for image in cj.monitor(images,
prefix="Running detection on image",
start=5,
end=99):
def worker_tile_func(tile):
window = tile.np_image
threshold = filter_func(window)
return window, threshold
cj.log("Get tiles for image {}".format(image.instanceFilename))
sldc_image = CytomineProjectionSlide(image, projection)
tile_builder = CytomineProjectionTileBuilder("/tmp")
topology = sldc_image.tile_topology(tile_builder, tile_size,
tile_size, tile_overlap)
results = generic_parallel(topology, worker_tile_func)
thresholds = list()
for result in results:
tile, output = result
window, threshold = output
thresholds.append(threshold)
global_threshold = int(np.mean(thresholds))
cj.log("Mean threshold is {}".format(global_threshold))
def worker_annotations_func(tile):
filtered = img_as_uint(tile.np_image > global_threshold)
return mask_to_objects_2d(filtered, offset=tile.abs_offset)
cj.log(
"Extract annotations from filtered tiles for image {}".format(
image.instanceFilename))
results = generic_parallel(topology, worker_annotations_func)
ids, geometries = list(), list()
for result in results:
tile, tile_geometries = result
# Workaround for slow SemanticMerger but geometries shouldn't be filtered at this stage.
tile_geometries = [
g for g in tile_geometries
if g.area > cj.parameters.min_area
]
ids.append(tile.identifier)
geometries.append(tile_geometries)
cj.log("Merge annotations from filtered tiles for image {}".format(
image.instanceFilename))
merged_geometries = SemanticMerger(tolerance=1).merge(
ids, geometries, topology)
cj.log("{} merged geometries".format(len(merged_geometries)))
if cj.parameters.annotation_slices == 'median':
# By default, if no slice is given, an annotation is added to the median slice
slice_ids = [None]
else:
slices = SliceInstanceCollection().fetch_with_filter(
"imageinstance", image.id)
if cj.parameters.annotation_slices == 'first':
slice_ids = [slices[0].id]
else:
slice_ids = [sl.id for sl in slices]
ac = AnnotationCollection()
for geometry in merged_geometries:
if geometry.area > cj.parameters.min_area:
for slice_id in slice_ids:
ac.append(
Annotation(location=change_referential(
geometry, image.height).wkt,
id_image=image.id,
id_terms=term_ids,
id_slice=slice_id))
ac.save()
cj.job.update(statusComment="Finished.", progress=100)
def predict(argv):
parser = ArgumentParser(prog="Extra-Trees Object Counter Predictor")
# Cytomine
parser.add_argument('--cytomine_host', dest='cytomine_host',
default='demo.cytomine.be', help="The Cytomine host")
parser.add_argument('--cytomine_public_key', dest='cytomine_public_key',
help="The Cytomine public key")
parser.add_argument('--cytomine_private_key', dest='cytomine_private_key',
help="The Cytomine private key")
parser.add_argument('--cytomine_base_path', dest='cytomine_base_path',
default='/api/', help="The Cytomine base path")
parser.add_argument('--cytomine_working_path', dest='cytomine_working_path',
default=None, help="The working directory (eg: /tmp)")
parser.add_argument('--cytomine_id_software', dest='cytomine_software', type=int,
help="The Cytomine software identifier")
parser.add_argument('--cytomine_id_project', dest='cytomine_project', type=int,
help="The Cytomine project identifier")
# Objects
parser.add_argument('--cytomine_object_term', dest='cytomine_object_term', type=int,
help="The Cytomine identifier of object term")
# Post-processing
parser.add_argument('--post_threshold', dest='post_threshold', type=float,
help="Post-processing discarding threshold")
parser.add_argument('--post_sigma', dest='post_sigma', type=float,
help="Std-dev of Gauss filter applied to smooth prediction")
parser.add_argument('--post_min_dist', dest='post_min_dist', type=int,
help="Minimum distance between two peaks")
# ROI
parser.add_argument('--annotation', dest='annotation', type=str, action='append', default=[])
parser.add_argument('--image', dest='image', type=str, action='append', default=[])
# Execution
parser.add_argument('--n_jobs', dest='n_jobs', type=int, default=1, help="Number of jobs")
parser.add_argument('--verbose', '-v', dest='verbose', type=int, default=0, help="Level of verbosity")
parser.add_argument('--model_id_job', dest='model_id_job', type=str, default=None, help="Model job ID")
parser.add_argument('--model_file', dest="model_file", type=str, default=None, help="Model file")
params, other = parser.parse_known_args(argv)
if params.cytomine_working_path is None:
params.cytomine_working_path = os.path.join(tempfile.gettempdir(), "cytomine")
make_dirs(params.cytomine_working_path)
params.model_id_job = str2int(params.model_id_job)
params.image = [str2int(i) for i in params.image]
params.annotation = [str2int(i) for i in params.annotation]
# Initialize logger
logger = StandardOutputLogger(params.verbose)
for key, val in sorted(vars(params).iteritems()):
logger.info("[PARAMETER] {}: {}".format(key, val))
# Start job
with CytomineJob(params.cytomine_host,
params.cytomine_public_key,
params.cytomine_private_key,
params.cytomine_software,
params.cytomine_project,
parameters=vars(params),
working_path=params.cytomine_working_path,
base_path=params.cytomine_base_path,
verbose=(params.verbose >= Logger.DEBUG)) as job:
cytomine = job
cytomine.update_job_status(job.job, status_comment="Starting...", progress=0)
cytomine.update_job_status(job.job, status_comment="Loading model...", progress=1)
logger.i("Loading model...")
if params.model_file:
model_file = params.model_file
else:
model_job = cytomine.get_job(params.model_id_job)
model_file = os.path.join(params.cytomine_working_path, "models", str(model_job.software),
"{}.pkl".format(model_job.id))
with open(model_file, 'rb') as f:
estimator = pickle.load(f)
predict_params = vars(params).copy()
predict_params.pop("image", None)
predict_params.pop("annotation", None)
estimator.set_params(**predict_params)
cytomine.update_job_status(job.job, status_comment="Dumping annotations/images to predict...", progress=3)
logger.i("Dumping annotations/images to predict...")
if params.annotation[0] is not None:
annots = [cytomine.get_annotation(id) for id in params.annotation]
annots_collection = AnnotationCollection()
annots_collection._data = annots
crops = cytomine.dump_annotations(annotations=annots_collection,
dest_path=os.path.join(params.cytomine_working_path, "crops",
str(params.cytomine_project)),
desired_zoom=0,
get_image_url_func=Annotation.get_annotation_alpha_crop_url)
X = crops.data()
elif params.image[0] is not None:
image_instances = [cytomine.get_image_instance(id) for id in params.image]
image_instances = cytomine.dump_project_images(id_project=params.cytomine_project,
dest_path="/imageinstances/",
image_instances=image_instances,
max_size=True)
X = image_instances
else:
X = []
logger.d("X size: {} samples".format(len(X)))
for i, x in enumerate(X):
logger.i("Predicting ID {}...".format(x.id))
cytomine.update_job_status(job.job, status_comment="Predicting ID {}...".format(x.id),
progress=5 + np.ceil(i / len(X)) * 95)
y = estimator.predict([x.filename])
y = estimator.postprocessing([y], **estimator.filter_sk_params(estimator.postprocessing))
logger.i("Uploading annotations...")
cytomine.update_job_status(job.job, status_comment="Uploading annotations...")
upload_annotations(cytomine, x, y, term=params.cytomine_object_term)
logger.i("Finished.")
cytomine.update_job_status(job.job, status_comment="Finished.", progress=100)
def extract_annotations_objdet(out_path,
in_image,
project_id,
track_prefix,
is_csv=False,
generate_mask=False,
result_file_suffix=".tif",
has_headers=False,
parse_fn=None,
**kwargs):
"""
Parameters:
-----------
out_path: str
in_image: BiaflowsCytomineInput
project_id: int
is_csv: bool
True if the output data are stored in a csv file
generate_mask: bool
If result is in a CSV, True for generating a mask based on the points in the csv. Ignored if is_csv is False.
The mask file is generated in out_path with the name "{in_image.id}.png".
result_file_suffix: str
Suffix of the result filename (prefix being the image id).
has_headers: bool
True if the csv contains some headers (ignored if is_csv is False)
parse_fn: callable
A function for extracting coordinates from the csv file (already separated) line.
track_prefix: str
kwargs: dict
"""
image = in_image.object
file = str(image.id) + result_file_suffix
path = os.path.join(out_path, file)
tracks = TrackCollection()
annotations = AnnotationCollection()
if not os.path.isfile(path):
print("No output file at '{}' for image with id:{}.".format(
path, image.id),
file=sys.stderr)
return annotations
# whether the points are stored in a csv or a mask
if is_csv: # only 2d
if parse_fn is None:
raise ValueError(
"parse_fn shouldn't be 'None' when result file is a CSV.")
points = csv_to_points(path,
has_headers=has_headers,
parse_fn=parse_fn)
annotations.extend([
create_annotation_from_slice(point,
image.id,
image.height,
project_id,
upload_group_id=False)
for point in points
])
if generate_mask:
image, dim_order, _ = imread(in_image.filepath, return_order=True)
mask = slices_to_mask(points, image.shape).squeeze()
imwrite_ome(os.path.join(out_path, in_image.filename),
mask,
dim_order=dim_order)
else:
# points stored in a mask
data, dim_order, _ = imread(path)
tracks, annotations = mask_convert(
data,
image,
project_id,
mask_2d_fn=mask_to_points_2d,
mask_3d_fn=lambda m: mask_to_points_3d(
m, time=False, assume_unique_labels=False),
track_prefix=track_prefix + "-object",
upload_group_id=get_dimensionality(dim_order) > 2)
return tracks, annotations
def run(self):
self.super_admin = Cytomine.get_instance().current_user
connect_as(self.super_admin, True)
users = UserCollection().fetch()
users_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("user-collection")
][0]
remote_users = UserCollection()
for u in json.load(open(os.path.join(self.working_path, users_json))):
remote_users.append(User().populate(u))
roles = ["project_manager", "project_contributor", "ontology_creator"]
if self.with_images:
roles += ["image_creator", "image_reviewer"]
if self.with_userannotations:
roles += ["userannotation_creator", "userannotationterm_creator"]
roles = set(roles)
remote_users = [
u for u in remote_users
if len(roles.intersection(set(u.roles))) > 0
]
for remote_user in remote_users:
user = find_first(
[u for u in users if u.username == remote_user.username])
if not user:
user = copy.copy(remote_user)
if not user.password:
user.password = random_string(8)
if not self.with_original_date:
user.created = None
user.updated = None
user.save()
self.id_mapping[remote_user.id] = user.id
# --------------------------------------------------------------------------------------------------------------
logging.info("1/ Import ontology and terms")
"""
Import the ontology with terms and relation terms that are stored in pickled files in working_path.
If the ontology exists (same name and same terms), the existing one is used.
Otherwise, an ontology with an available name is created with new terms and corresponding relationships.
"""
ontologies = OntologyCollection().fetch()
ontology_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("ontology")
][0]
remote_ontology = Ontology().populate(
json.load(open(os.path.join(self.working_path, ontology_json))))
remote_ontology.name = remote_ontology.name.strip()
terms = TermCollection().fetch()
terms_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("term-collection")
]
remote_terms = TermCollection()
if len(terms_json) > 0:
for t in json.load(
open(os.path.join(self.working_path, terms_json[0]))):
remote_terms.append(Term().populate(t))
def ontology_exists():
compatible_ontology = find_first([
o for o in ontologies
if o.name == remote_ontology.name.strip()
])
if compatible_ontology:
set1 = set((t.name, t.color) for t in terms
if t.ontology == compatible_ontology.id)
difference = [
term for term in remote_terms
if (term.name, term.color) not in set1
]
if len(difference) == 0:
return True, compatible_ontology
return False, None
else:
return True, None
i = 1
remote_name = remote_ontology.name
found, existing_ontology = ontology_exists()
while not found:
remote_ontology.name = "{} ({})".format(remote_name, i)
found, existing_ontology = ontology_exists()
i += 1
# SWITCH to ontology creator user
connect_as(User().fetch(self.id_mapping[remote_ontology.user]))
if not existing_ontology:
ontology = copy.copy(remote_ontology)
ontology.user = self.id_mapping[remote_ontology.user]
if not self.with_original_date:
ontology.created = None
ontology.updated = None
ontology.save()
self.id_mapping[remote_ontology.id] = ontology.id
logging.info("Ontology imported: {}".format(ontology))
for remote_term in remote_terms:
logging.info("Importing term: {}".format(remote_term))
term = copy.copy(remote_term)
term.ontology = self.id_mapping[term.ontology]
term.parent = None
if not self.with_original_date:
term.created = None
term.updated = None
term.save()
self.id_mapping[remote_term.id] = term.id
logging.info("Term imported: {}".format(term))
remote_relation_terms = [(term.parent, term.id)
for term in remote_terms]
for relation in remote_relation_terms:
parent, child = relation
if parent:
rt = RelationTerm(self.id_mapping[parent],
self.id_mapping[child]).save()
logging.info("Relation term imported: {}".format(rt))
else:
self.id_mapping[remote_ontology.id] = existing_ontology.id
ontology_terms = [
t for t in terms if t.ontology == existing_ontology.id
]
for remote_term in remote_terms:
self.id_mapping[remote_term.id] = find_first([
t for t in ontology_terms if t.name == remote_term.name
]).id
logging.info(
"Ontology already encoded: {}".format(existing_ontology))
# SWITCH USER
connect_as(self.super_admin, True)
# --------------------------------------------------------------------------------------------------------------
logging.info("2/ Import project")
"""
Import the project (i.e. the Cytomine Project domain) stored in pickled file in working_path.
If a project with the same name already exists, append a (x) suffix where x is an increasing number.
"""
projects = ProjectCollection().fetch()
project_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("project")
][0]
remote_project = Project().populate(
json.load(open(os.path.join(self.working_path, project_json))))
remote_project.name = remote_project.name.strip()
def available_name():
i = 1
existing_names = [o.name for o in projects]
new_name = project.name
while new_name in existing_names:
new_name = "{} ({})".format(project.name, i)
i += 1
return new_name
project = copy.copy(remote_project)
project.name = available_name()
project.discipline = None
project.ontology = self.id_mapping[project.ontology]
project_contributors = [
u for u in remote_users if "project_contributor" in u.roles
]
project.users = [self.id_mapping[u.id] for u in project_contributors]
project_managers = [
u for u in remote_users if "project_manager" in u.roles
]
project.admins = [self.id_mapping[u.id] for u in project_managers]
if not self.with_original_date:
project.created = None
project.updated = None
project.save()
self.id_mapping[remote_project.id] = project.id
logging.info("Project imported: {}".format(project))
# --------------------------------------------------------------------------------------------------------------
logging.info("3/ Import images")
storages = StorageCollection().fetch()
abstract_images = AbstractImageCollection().fetch()
images_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("imageinstance-collection")
]
remote_images = ImageInstanceCollection()
if len(images_json) > 0:
for i in json.load(
open(os.path.join(self.working_path, images_json[0]))):
remote_images.append(ImageInstance().populate(i))
remote_images_dict = {}
for remote_image in remote_images:
image = copy.copy(remote_image)
# Fix old image name due to urllib3 limitation
remote_image.originalFilename = bytes(
remote_image.originalFilename,
'utf-8').decode('ascii', 'ignore')
if remote_image.originalFilename not in remote_images_dict.keys():
remote_images_dict[remote_image.originalFilename] = [
remote_image
]
else:
remote_images_dict[remote_image.originalFilename].append(
remote_image)
logging.info("Importing image: {}".format(remote_image))
# SWITCH user to image creator user
connect_as(User().fetch(self.id_mapping[remote_image.user]))
# Get its storage
storage = find_first([
s for s in storages
if s.user == Cytomine.get_instance().current_user.id
])
if not storage:
storage = storages[0]
# Check if image is already in its storage
abstract_image = find_first([
ai for ai in abstract_images
if ai.originalFilename == remote_image.originalFilename and
ai.width == remote_image.width and ai.height == remote_image.
height and ai.resolution == remote_image.resolution
])
if abstract_image:
logging.info(
"== Found corresponding abstract image. Linking to project."
)
ImageInstance(abstract_image.id,
self.id_mapping[remote_project.id]).save()
else:
logging.info("== New image starting to upload & deploy")
filename = os.path.join(
self.working_path, "images",
image.originalFilename.replace("/", "-"))
Cytomine.get_instance().upload_image(
self.host_upload, filename, storage.id,
self.id_mapping[remote_project.id])
time.sleep(0.8)
# SWITCH USER
connect_as(self.super_admin, True)
# Waiting for all images...
n_new_images = -1
new_images = None
count = 0
while n_new_images != len(
remote_images) and count < len(remote_images) * 5:
new_images = ImageInstanceCollection().fetch_with_filter(
"project", self.id_mapping[remote_project.id])
n_new_images = len(new_images)
if count > 0:
time.sleep(5)
count = count + 1
print("All images have been deployed. Fixing image-instances...")
# Fix image instances meta-data:
for new_image in new_images:
remote_image = remote_images_dict[new_image.originalFilename].pop()
if self.with_original_date:
new_image.created = remote_image.created
new_image.updated = remote_image.updated
new_image.reviewStart = remote_image.reviewStart if hasattr(
remote_image, 'reviewStart') else None
new_image.reviewStop = remote_image.reviewStop if hasattr(
remote_image, 'reviewStop') else None
new_image.reviewUser = self.id_mapping[
remote_image.reviewUser] if hasattr(
remote_image,
'reviewUser') and remote_image.reviewUser else None
new_image.instanceFilename = remote_image.instanceFilename
new_image.update()
self.id_mapping[remote_image.id] = new_image.id
self.id_mapping[remote_image.baseImage] = new_image.baseImage
new_abstract = AbstractImage().fetch(new_image.baseImage)
if self.with_original_date:
new_abstract.created = remote_image.created
new_abstract.updated = remote_image.updated
if new_abstract.resolution is None:
new_abstract.resolution = remote_image.resolution
if new_abstract.magnification is None:
new_abstract.magnification = remote_image.magnification
new_abstract.update()
print("All image-instances have been fixed.")
# --------------------------------------------------------------------------------------------------------------
logging.info("4/ Import user annotations")
annots_json = [
f for f in os.listdir(self.working_path) if f.endswith(".json")
and f.startswith("user-annotation-collection")
]
remote_annots = AnnotationCollection()
if len(annots_json) > 0:
for a in json.load(
open(os.path.join(self.working_path, annots_json[0]))):
remote_annots.append(Annotation().populate(a))
def _add_annotation(remote_annotation, id_mapping, with_original_date):
if remote_annotation.project not in id_mapping.keys() \
or remote_annotation.image not in id_mapping.keys():
return
annotation = copy.copy(remote_annotation)
annotation.project = id_mapping[remote_annotation.project]
annotation.image = id_mapping[remote_annotation.image]
annotation.user = id_mapping[remote_annotation.user]
annotation.term = [id_mapping[t] for t in remote_annotation.term]
if not with_original_date:
annotation.created = None
annotation.updated = None
annotation.save()
for user in [
u for u in remote_users if "userannotation_creator" in u.roles
]:
remote_annots_for_user = [
a for a in remote_annots if a.user == user.id
]
# SWITCH to annotation creator user
connect_as(User().fetch(self.id_mapping[user.id]))
Parallel(n_jobs=-1, backend="threading")(
delayed(_add_annotation)(remote_annotation, self.id_mapping,
self.with_original_date)
for remote_annotation in remote_annots_for_user)
# SWITCH back to admin
connect_as(self.super_admin, True)
# --------------------------------------------------------------------------------------------------------------
logging.info(
"5/ Import metadata (properties, attached files, description)")
obj = Model()
obj.id = -1
obj.class_ = ""
properties_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("properties")
]
for property_json in properties_json:
for remote_prop in json.load(
open(os.path.join(self.working_path, property_json))):
prop = Property(obj).populate(remote_prop)
prop.domainIdent = self.id_mapping[prop.domainIdent]
prop.save()
attached_files_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("attached-files")
]
for attached_file_json in attached_files_json:
for remote_af in json.load(
open(os.path.join(self.working_path, attached_file_json))):
af = AttachedFile(obj).populate(remote_af)
af.domainIdent = self.id_mapping[af.domainIdent]
af.filename = os.path.join(self.working_path, "attached_files",
remote_af.filename)
af.save()
descriptions_json = [
f for f in os.listdir(self.working_path)
if f.endswith(".json") and f.startswith("description")
]
for description_json in descriptions_json:
desc = Description(obj).populate(
json.load(
open(os.path.join(self.working_path, description_json))))
desc.domainIdent = self.id_mapping[desc.domainIdent]
desc._object.class_ = desc.domainClassName
desc._object.id = desc.domainIdent
desc.save()
def main():
with CytomineJob.from_cli(sys.argv) as conn:
conn.job.update(status=Job.RUNNING,
progress=0,
status_comment="Initialization of the training phase")
# 1. Create working directories on the machine:
# - WORKING_PATH/in: input images
# - WORKING_PATH/out: output images
# - WORKING_PATH/ground_truth: ground truth images
# - WORKING_PATH/tmp: temporary path
base_path = "{}".format(os.getenv("HOME"))
gt_suffix = "_lbl"
working_path = os.path.join(base_path, str(conn.job.id))
in_path = os.path.join(working_path, "in/")
in_txt = os.path.join(in_path, 'txt/')
out_path = os.path.join(working_path, "out/")
gt_path = os.path.join(working_path, "ground_truth/")
tmp_path = os.path.join(working_path, "tmp/")
if not os.path.exists(working_path):
os.makedirs(working_path)
os.makedirs(in_path)
os.makedirs(out_path)
os.makedirs(gt_path)
os.makedirs(tmp_path)
os.makedirs(in_txt)
# 2. Download the images (first input, then ground truth image)
conn.job.update(
progress=10,
statusComment="Downloading images (to {})...".format(in_path))
print(conn.parameters)
images = ImageInstanceCollection().fetch_with_filter(
"project", conn.parameters.cytomine_id_project)
xpos = {}
ypos = {}
terms = {}
for image in images:
image.dump(dest_pattern=in_path.rstrip('/') + '/%d.%s' %
(image.id, 'jpg'))
annotations = AnnotationCollection()
annotations.project = conn.parameters.cytomine_id_project
annotations.showWKT = True
annotations.showMeta = True
annotations.showGIS = True
annotations.showTerm = True
annotations.image = image.id
annotations.fetch()
for ann in annotations:
l = ann.location
if l.rfind('POINT') == -1:
pol = shapely.wkt.loads(l)
poi = pol.centroid
else:
poi = shapely.wkt.loads(l)
(cx, cy) = poi.xy
xpos[(ann.term[0], image.id)] = int(cx[0])
ypos[(ann.term[0], image.id)] = image.height - int(cy[0])
terms[ann.term[0]] = 1
for image in images:
F = open(in_txt + '%d.txt' % image.id, 'w')
for t in terms.keys():
if (t, image.id) in xpos:
F.write('%d %d %d %f %f\n' %
(t, xpos[(t, image.id)], ypos[(t, image.id)],
xpos[(t, image.id)] / float(image.width),
ypos[(t, image.id)] / float(image.height)))
F.close()
depths = 1. / (2.**np.arange(conn.parameters.model_depth))
(xc, yc, xr, yr, ims, t_to_i, i_to_t) = getallcoords(in_txt)
if conn.parameters.cytomine_id_terms == 'all':
term_list = t_to_i.keys()
else:
term_list = [
int(term)
for term in conn.parameters.cytomine_id_terms.split(',')
]
if conn.parameters.cytomine_training_images == 'all':
tr_im = ims
else:
tr_im = [
int(id_im) for id_im in
conn.parameters.cytomine_training_images.split(',')
]
DATA = None
REP = None
be = 0
#leprogres = 10
#pr_spacing = 90/len(term_list)
#print(term_list)
sfinal = ""
for id_term in conn.monitor(term_list,
start=10,
end=90,
period=0.05,
prefix="Model building for terms..."):
sfinal += "%d " % id_term
(xc, yc, xr, yr) = getcoordsim(in_txt, id_term, tr_im)
nimages = np.max(xc.shape)
mx = np.mean(xr)
my = np.mean(yr)
P = np.zeros((2, nimages))
P[0, :] = xr
P[1, :] = yr
cm = np.cov(P)
passe = False
# additional parameters
feature_parameters = None
if conn.parameters.model_feature_type.lower() == 'gaussian':
std_matrix = np.eye(2) * (
conn.parameters.model_feature_gaussian_std**2)
feature_parameters = np.round(
np.random.multivariate_normal(
[0, 0], std_matrix,
conn.parameters.model_feature_gaussian_n)).astype(int)
elif conn.parameters.model_feature_type.lower() == 'haar':
W = conn.parameters.model_wsize
n = conn.parameters.model_feature_haar_n / (
5 * conn.parameters.model_depth)
h2 = generate_2_horizontal(W, n)
v2 = generate_2_vertical(W, n)
h3 = generate_3_horizontal(W, n)
v3 = generate_3_vertical(W, n)
sq = generate_square(W, n)
feature_parameters = (h2, v2, h3, v3, sq)
for times in range(conn.parameters.model_ntimes):
if times == 0:
rangrange = 0
else:
rangrange = conn.parameters.model_angle
T = build_datasets_rot_mp(
in_path, tr_im, xc, yc, conn.parameters.model_R,
conn.parameters.model_RMAX, conn.parameters.model_P,
conn.parameters.model_step, rangrange,
conn.parameters.model_wsize,
conn.parameters.model_feature_type, feature_parameters,
depths, nimages, 'jpg', conn.parameters.model_njobs)
for i in range(len(T)):
(data, rep, img) = T[i]
(height, width) = data.shape
if not passe:
passe = True
DATA = np.zeros((height * (len(T) + 100) *
conn.parameters.model_ntimes, width))
REP = np.zeros(height * (len(T) + 100) *
conn.parameters.model_ntimes)
b = 0
be = height
DATA[b:be, :] = data
REP[b:be] = rep
b = be
be = be + height
REP = REP[0:b]
DATA = DATA[0:b, :]
clf = ExtraTreesClassifier(
n_jobs=conn.parameters.model_njobs,
n_estimators=conn.parameters.model_ntrees)
clf = clf.fit(DATA, REP)
parameters_hash = {}
parameters_hash[
'cytomine_id_terms'] = conn.parameters.cytomine_id_terms
parameters_hash['model_R'] = conn.parameters.model_R
parameters_hash['model_RMAX'] = conn.parameters.model_RMAX
parameters_hash['model_P'] = conn.parameters.model_P
parameters_hash['model_npred'] = conn.parameters.model_npred
parameters_hash['model_ntrees'] = conn.parameters.model_ntrees
parameters_hash['model_ntimes'] = conn.parameters.model_ntimes
parameters_hash['model_angle'] = conn.parameters.model_angle
parameters_hash['model_depth'] = conn.parameters.model_depth
parameters_hash['model_step'] = conn.parameters.model_step
parameters_hash['window_size'] = conn.parameters.model_wsize
parameters_hash[
'feature_type'] = conn.parameters.model_feature_type
parameters_hash[
'feature_haar_n'] = conn.parameters.model_feature_haar_n
parameters_hash[
'feature_gaussian_n'] = conn.parameters.model_feature_gaussian_n
parameters_hash[
'feature_gaussian_std'] = conn.parameters.model_feature_gaussian_std
model_filename = joblib.dump(clf,
os.path.join(
out_path,
'%d_model.joblib' % (id_term)),
compress=3)[0]
cov_filename = joblib.dump([mx, my, cm],
os.path.join(
out_path,
'%d_cov.joblib' % (id_term)),
compress=3)[0]
parameter_filename = joblib.dump(
parameters_hash,
os.path.join(out_path, '%d_parameters.joblib' % id_term),
compress=3)[0]
AttachedFile(
conn.job,
domainIdent=conn.job.id,
filename=model_filename,
domainClassName="be.cytomine.processing.Job").upload()
AttachedFile(
conn.job,
domainIdent=conn.job.id,
filename=cov_filename,
domainClassName="be.cytomine.processing.Job").upload()
AttachedFile(
conn.job,
domainIndent=conn.job.id,
filename=parameter_filename,
domainClassName="be.cytomine.processing.Job").upload()
if conn.parameters.model_feature_type == 'haar' or conn.parameters.model_feature_type == 'gaussian':
add_filename = joblib.dump(
feature_parameters,
out_path.rstrip('/') + '/' + '%d_fparameters.joblib' %
(id_term))[0]
AttachedFile(
conn.job,
domainIdent=conn.job.id,
filename=add_filename,
domainClassName="be.cytomine.processing.Job").upload()
Property(conn.job, key="id_terms", value=sfinal.rstrip(" ")).save()
conn.job.update(progress=100,
status=Job.TERMINATED,
statusComment="Job terminated.")
def main(argv):
with CytomineJob.from_cli(argv) as cj:
# use only images from the current project
cj.job.update(progress=1, statusComment="Preparing execution")
# extract images to process
if cj.parameters.cytomine_zoom_level > 0 and (
cj.parameters.cytomine_tile_size != 256
or cj.parameters.cytomine_tile_overlap != 0):
raise ValueError(
"when using zoom_level > 0, tile size should be 256 "
"(given {}) and overlap should be 0 (given {})".format(
cj.parameters.cytomine_tile_size,
cj.parameters.cytomine_tile_overlap))
cj.job.update(
progress=1,
statusComment="Preparing execution (creating folders,...).")
# working path
root_path = str(Path.home())
working_path = os.path.join(root_path, "images")
os.makedirs(working_path, exist_ok=True)
# load training information
cj.job.update(progress=5,
statusComment="Extract properties from training job.")
train_job = Job().fetch(cj.parameters.cytomine_id_job)
properties = PropertyCollection(train_job).fetch().as_dict()
binary = str2bool(properties["binary"].value)
classes = parse_domain_list(properties["classes"].value)
cj.job.update(progress=10, statusComment="Download the model file.")
attached_files = AttachedFileCollection(train_job).fetch()
model_file = attached_files.find_by_attribute("filename",
"model.joblib")
model_filepath = os.path.join(root_path, "model.joblib")
model_file.download(model_filepath, override=True)
pyxit = joblib.load(model_filepath)
# set n_jobs
pyxit.base_estimator.n_jobs = cj.parameters.n_jobs
pyxit.n_jobs = cj.parameters.n_jobs
cj.job.update(progress=45, statusComment="Build workflow.")
builder = SSLWorkflowBuilder()
builder.set_tile_size(cj.parameters.cytomine_tile_size,
cj.parameters.cytomine_tile_size)
builder.set_overlap(cj.parameters.cytomine_tile_overlap)
builder.set_tile_builder(
CytomineTileBuilder(working_path, n_jobs=cj.parameters.n_jobs))
builder.set_logger(StandardOutputLogger(level=Logger.INFO))
builder.set_n_jobs(1)
builder.set_background_class(0)
# value 0 will prevent merging but still requires to run the merging check
# procedure (inefficient)
builder.set_distance_tolerance(2 if cj.parameters.union_enabled else 0)
builder.set_segmenter(
ExtraTreesSegmenter(
pyxit=pyxit,
classes=classes,
prediction_step=cj.parameters.pyxit_prediction_step,
background=0,
min_std=cj.parameters.tile_filter_min_stddev,
max_mean=cj.parameters.tile_filter_max_mean))
workflow = builder.get()
area_checker = AnnotationAreaChecker(
min_area=cj.parameters.min_annotation_area,
max_area=cj.parameters.max_annotation_area)
def get_term(label):
if binary:
if "cytomine_id_predict_term" not in cj.parameters:
return []
else:
return [int(cj.parameters.cytomine_id_predict_term)]
# multi-class
return [label]
zones = extract_images_or_rois(cj.parameters)
for zone in cj.monitor(zones,
start=50,
end=90,
period=0.05,
prefix="Segmenting images/ROIs"):
results = workflow.process(zone)
annotations = AnnotationCollection()
for obj in results:
if not area_checker.check(obj.polygon):
continue
polygon = obj.polygon
if isinstance(zone, ImageWindow):
polygon = affine_transform(
polygon,
[1, 0, 0, 1, zone.abs_offset_x, zone.abs_offset_y])
polygon = change_referential(polygon, zone.base_image.height)
if cj.parameters.cytomine_zoom_level > 0:
zoom_mult = (2**cj.parameters.cytomine_zoom_level)
polygon = affine_transform(
polygon, [zoom_mult, 0, 0, zoom_mult, 0, 0])
annotations.append(
Annotation(location=polygon.wkt,
id_terms=get_term(obj.label),
id_project=cj.project.id,
id_image=zone.base_image.image_instance.id))
annotations.save()
cj.job.update(status=Job.TERMINATED,
status_comment="Finish",
progress=100)
def extract_annotations_objtrk(out_path, in_image, project_id, track_prefix,
**kwargs):
"""
out_path: str
in_image: BiaflowsCytomineInput
project_id: int
track_prefix: str
kwargs: dict
"""
image = in_image.object
path = os.path.join(out_path, in_image.filename)
data, dim_order, _ = imread(path, return_order=True)
ndim = get_dimensionality(dim_order)
if ndim < 3:
raise ValueError(
"Object tracking should be at least 3D (only {} spatial dimension(s) found)"
.format(ndim))
tracks = TrackCollection()
annotations = AnnotationCollection()
if ndim == 3:
slices = mask_to_objects_3d(data, time=True, assume_unique_labels=True)
time_to_image = get_depth_to_slice(image)
for slice_group in slices:
curr_tracks, curr_annots = create_tracking_from_slice_group(
image,
slice_group,
slice2point=lambda _slice: _slice.polygon.centroid,
depth2slice=time_to_image,
id_project=project_id,
upload_object=True,
upload_group_id=True,
track_prefix=track_prefix + "-object")
tracks.extend(curr_tracks)
annotations.extend(curr_annots)
elif ndim == 4:
objects = mask_to_objects_3dt(mask=data)
depths_to_image = get_depth_to_slice(image, depth=("time", "depth"))
# TODO add tracking lines one way or another
for time_steps in objects:
label = time_steps[0][0].label
track = Track(name="{}-{}".format(track_prefix, label),
id_image=image.id,
color=DEFAULT_COLOR).save()
Property(track, key="label", value=label).save()
annotations.extend([
Annotation(location=change_referential(
p=slice.polygon, height=image.height).wkt,
id_image=image.id,
id_project=project_id,
id_tracks=[track.id],
slice=depths_to_image[(slice.time, slice.depth)].id)
for slices in time_steps for slice in slices
])
tracks.append(track)
else:
raise ValueError(
"Annotation extraction for object tracking does not support masks with more than 4 dims..."
)
return tracks, annotations
def upload_data(problemclass,
nj,
inputs,
out_path,
monitor_params=None,
**kwargs):
"""Upload annotations or any other related results to the server.
Parameters
----------
problemclass: str
The problem class
nj: CytomineJob|BiaflowsJob
The CytomineJob or BiaflowsJob object. Ignored if do_export is True.
inputs: list
Input data as returned by the prepare_data
out_path: str
Output path
monitor_params: dict|None
A dictionnary of parameters to be passed to the data upload loop monitor.
kwargs: dict
Additional parameters for:
* ObjDet/SptCnt: see function 'extract_annotations_objdet'
* ObjSeg: see function 'extract_annotations_objseg'
"""
if "is_2d" in kwargs:
warnings.warn(
"As of version 0.9.3, the 'is_2d' parameter is not needed anymore in function 'upload_data' and "
"is now ignored.", DeprecationWarning)
if not nj.flags["do_upload_annotations"]:
return
if nj.flags["tiling"] and (problemclass != CLASS_OBJSEG
and problemclass != CLASS_PIXCLA):
print(
"Annot. upload is only supported for one of {ObjSeg, PixCla} in 2D when tiling is enabled.. skipping !"
)
return
if monitor_params is None:
monitor_params = dict()
annotations = AnnotationCollection()
if nj.flags["tiling"]:
annotations.extend(
extract_tiled_annotations(
inputs,
out_path,
nj,
label_merging=problemclass == CLASS_PIXCLA))
else:
if problemclass == CLASS_OBJSEG:
extract_fn = extract_annotations_objseg
elif problemclass == CLASS_PIXCLA:
extract_fn = extract_annotations_pixcla
elif problemclass == CLASS_OBJDET or problemclass == CLASS_SPTCNT or problemclass == CLASS_LNDDET:
extract_fn = extract_annotations_objdet
elif problemclass == CLASS_LOOTRC or problemclass == CLASS_TRETRC:
extract_fn = extract_annotations_lootrc
elif problemclass == CLASS_PRTTRK:
extract_fn = extract_annotations_prttrk
elif problemclass == CLASS_OBJTRK:
extract_fn = extract_annotations_objtrk
else:
raise NotImplementedError(
"Upload data does not support problem class '{}' yet.".format(
problemclass))
tracks = TrackCollection()
monitor_params["prefix"] = "Extract masks/points/... from output data"
for in_image in nj.monitor(inputs, **monitor_params):
curr_tracks, curr_annots = extract_fn(out_path,
in_image,
nj.project.id,
track_prefix=str(nj.job.id),
**kwargs)
tracks.extend(curr_tracks)
annotations.extend(curr_annots)
nj.job.update(
statusComment="Upload extracted annotations (total: {})".format(
len(annotations)))
annotations.save(chunk=20, n_workers=min(4, cpu_count() * 2))
def main(argv):
with CytomineJob.from_cli(argv) as conn:
conn.job.update(status=Job.RUNNING,
progress=0,
statusComment="Initialization...")
# base_path = "{}".format(os.getenv("HOME")) # Mandatory for Singularity
base_path = "/home/mmu/Desktop"
working_path = os.path.join(base_path, str(conn.job.id))
#Loading pre-trained Stardist model
np.random.seed(17)
lbl_cmap = random_label_cmap()
#Stardist H&E model downloaded from https://github.com/mpicbg-csbd/stardist/issues/46
#Stardist H&E model downloaded from https://drive.switch.ch/index.php/s/LTYaIud7w6lCyuI
model = StarDist2D(
None, name='2D_versatile_HE', basedir='/models/'
) #use local model file in ~/models/2D_versatile_HE/
#Select images to process
images = ImageInstanceCollection().fetch_with_filter(
"project", conn.parameters.cytomine_id_project)
list_imgs = []
if conn.parameters.cytomine_id_images == 'all':
for image in images:
list_imgs.append(int(image.id))
else:
list_imgs = [
int(id_img)
for id_img in conn.parameters.cytomine_id_images.split(',')
]
#Go over images
for id_image in conn.monitor(list_imgs,
prefix="Running detection on image",
period=0.1):
#Dump ROI annotations in img from Cytomine server to local images
#conn.job.update(status=Job.RUNNING, progress=0, statusComment="Fetching ROI annotations...")
roi_annotations = AnnotationCollection()
roi_annotations.project = conn.parameters.cytomine_id_project
roi_annotations.term = conn.parameters.cytomine_id_roi_term
roi_annotations.image = id_image #conn.parameters.cytomine_id_image
roi_annotations.showWKT = True
roi_annotations.fetch()
print(roi_annotations)
#Go over ROI in this image
#for roi in conn.monitor(roi_annotations, prefix="Running detection on ROI", period=0.1):
for roi in roi_annotations:
#Get Cytomine ROI coordinates for remapping to whole-slide
#Cytomine cartesian coordinate system, (0,0) is bottom left corner
print(
"----------------------------ROI------------------------------"
)
roi_geometry = wkt.loads(roi.location)
print("ROI Geometry from Shapely: {}".format(roi_geometry))
print("ROI Bounds")
print(roi_geometry.bounds)
minx = roi_geometry.bounds[0]
miny = roi_geometry.bounds[3]
#Dump ROI image into local PNG file
roi_path = os.path.join(
working_path,
str(roi_annotations.project) + '/' +
str(roi_annotations.image) + '/' + str(roi.id))
roi_png_filename = os.path.join(roi_path + '/' + str(roi.id) +
'.png')
print("roi_png_filename: %s" % roi_png_filename)
roi.dump(dest_pattern=roi_png_filename, mask=True, alpha=True)
#roi.dump(dest_pattern=os.path.join(roi_path,"{id}.png"), mask=True, alpha=True)
#Stardist works with TIFF images without alpha channel, flattening PNG alpha mask to TIFF RGB
im = Image.open(roi_png_filename)
bg = Image.new("RGB", im.size, (255, 255, 255))
bg.paste(im, mask=im.split()[3])
roi_tif_filename = os.path.join(roi_path + '/' + str(roi.id) +
'.tif')
bg.save(roi_tif_filename, quality=100)
X_files = sorted(glob(roi_path + '/' + str(roi.id) + '*.tif'))
X = list(map(imread, X_files))
n_channel = 3 if X[0].ndim == 3 else X[0].shape[-1]
axis_norm = (
0, 1
) # normalize channels independently (0,1,2) normalize channels jointly
if n_channel > 1:
print("Normalizing image channels %s." %
('jointly' if axis_norm is None or 2 in axis_norm
else 'independently'))
#Going over ROI images in ROI directory (in our case: one ROI per directory)
for x in range(0, len(X)):
print("------------------- Processing ROI file %d: %s" %
(x, roi_tif_filename))
img = normalize(X[x],
conn.parameters.stardist_norm_perc_low,
conn.parameters.stardist_norm_perc_high,
axis=axis_norm)
#Stardist model prediction with thresholds
labels, details = model.predict_instances(
img,
prob_thresh=conn.parameters.stardist_prob_t,
nms_thresh=conn.parameters.stardist_nms_t)
print("Number of detected polygons: %d" %
len(details['coord']))
cytomine_annotations = AnnotationCollection()
#Go over detections in this ROI, convert and upload to Cytomine
for pos, polygroup in enumerate(details['coord'], start=1):
#Converting to Shapely annotation
points = list()
for i in range(len(polygroup[0])):
#Cytomine cartesian coordinate system, (0,0) is bottom left corner
#Mapping Stardist polygon detection coordinates to Cytomine ROI in whole slide image
p = Point(minx + polygroup[1][i],
miny - polygroup[0][i])
points.append(p)
annotation = Polygon(points)
#Append to Annotation collection
cytomine_annotations.append(
Annotation(
location=annotation.wkt,
id_image=
id_image, #conn.parameters.cytomine_id_image,
id_project=conn.parameters.cytomine_id_project,
id_terms=[
conn.parameters.cytomine_id_cell_term
]))
print(".", end='', flush=True)
#Send Annotation Collection (for this ROI) to Cytomine server in one http request
ca = cytomine_annotations.save()
conn.job.update(status=Job.TERMINATED,
progress=100,
statusComment="Finished.")
def run(self):
logging.info("Export will be done in directory {}".format(self.project_path))
os.makedirs(self.project_path)
if self.with_metadata or self.with_annotation_metadata:
self.attached_file_path = os.path.join(self.project_path, "attached_files")
os.makedirs(self.attached_file_path)
# --------------------------------------------------------------------------------------------------------------
logging.info("1/ Export project {}".format(self.project.id))
self.save_object(self.project)
logging.info("1.1/ Export project managers")
admins = UserCollection(admin=True).fetch_with_filter("project", self.project.id)
for admin in admins:
self.save_user(admin, "project_manager")
logging.info("1.2/ Export project contributors")
users = UserCollection().fetch_with_filter("project", self.project.id)
for user in users:
self.save_user(user, "project_contributor")
if self.with_metadata:
logging.info("1.3/ Export project metadata")
self.export_metadata([self.project])
# --------------------------------------------------------------------------------------------------------------
logging.info("2/ Export ontology {}".format(self.project.ontology))
ontology = Ontology().fetch(self.project.ontology)
self.save_object(ontology)
logging.info("2.1/ Export ontology creator")
user = User().fetch(ontology.user)
self.save_user(user, "ontology_creator")
if self.with_metadata:
logging.info("2.2/ Export ontology metadata")
self.export_metadata([ontology])
# --------------------------------------------------------------------------------------------------------------
logging.info("3/ Export terms")
terms = TermCollection().fetch_with_filter("project", self.project.id)
self.save_object(terms)
if self.with_metadata:
logging.info("3.1/ Export term metadata")
self.export_metadata(terms)
# --------------------------------------------------------------------------------------------------------------
logging.info("4/ Export images")
images = ImageInstanceCollection().fetch_with_filter("project", self.project.id)
self.save_object(images)
if self.with_image_download:
image_path = os.path.join(self.project_path, "images")
os.makedirs(image_path)
def _download_image(image, path):
logging.info("Download file for image {}".format(image))
image.download(os.path.join(path, image.originalFilename), override=False, parent=True)
# Temporary use threading as backend, as we need to connect to Cytomine in every other processes.
Parallel(n_jobs=-1, backend="threading")(delayed(_download_image)(image, image_path) for image in images)
logging.info("4.1/ Export image creator users")
image_users = set([image.user for image in images])
for image_user in image_users:
user = User().fetch(image_user)
self.save_user(user, "image_creator")
logging.info("4.2/ Export image reviewer users")
image_users = set([image.reviewUser for image in images if image.reviewUser])
for image_user in image_users:
user = User().fetch(image_user)
self.save_user(user, "image_reviewer")
if self.with_metadata:
logging.info("4.3/ Export image metadata")
self.export_metadata(images)
# --------------------------------------------------------------------------------------------------------------
logging.info("4/ Export user annotations")
user_annotations = AnnotationCollection(showWKT=True, showTerm=True, project=self.project.id).fetch()
self.save_object(user_annotations, filename="user-annotation-collection")
logging.info("4.1/ Export user annotation creator users")
annotation_users = set([annotation.user for annotation in user_annotations])
for annotation_user in annotation_users:
user = User().fetch(annotation_user)
self.save_user(user, "userannotation_creator")
logging.info("4.2/ Export user annotation term creator users")
annotation_users = set()
for annotation in user_annotations:
annotation_users = annotation_users.union(*[
set(item['user']) for item in annotation.userByTerm if annotation.userByTerm
])
for annotation_user in annotation_users:
user = User().fetch(annotation_user)
self.save_user(user, "userannotationterm_creator")
if self.with_annotation_metadata:
logging.info("4.3/ Export user annotation metadata")
self.export_metadata(user_annotations)
# --------------------------------------------------------------------------------------------------------------
logging.info("5/ Export users")
if self.anonymize:
for i, user in enumerate(self.users):
user.username = "******".format(i + 1)
user.firstname = "Anonymized"
user.lastname = "User {}".format(i + 1)
user.email = "anonymous{}@unknown.com".format(i + 1)
self.save_object(self.users)
# Disabled due to core issue.
# if self.with_metadata:
# logging.info("5.1/ Export user metadata")
# self.export_metadata(self.users)
# --------------------------------------------------------------------------------------------------------------
if self.with_image_groups:
logging.info("6/ Export image groups")
image_groups = ImageGroupCollection().fetch_with_filter("project", self.project.id)
self.save_object(image_groups)
if self.with_metadata:
logging.info("6.1/ Export image group metadata")
self.export_metadata(image_groups)
if self.with_image_download:
image_group_path = os.path.join(self.project_path, "imagegroups")
os.makedirs(image_group_path)
for image_group in image_groups:
image_group.download(os.path.join(image_group_path, image_group.name), override=False, parent=True)
image_sequences = ImageGroupImageInstanceCollection()
for image_group in image_groups:
image_sequences += ImageGroupImageInstanceCollection().fetch_with_filter("imagegroup", image_group.id)
self.save_object(image_sequences)
# --------------------------------------------------------------------------------------------------------------
logging.info("Finished.")
def main(argv):
print(argv)
with CytomineJob.from_cli(argv) as cj:
images = ImageInstanceCollection().fetch_with_filter("project", cj.parameters.cytomine_id_project)
for image in cj.monitor(images, prefix="Running detection on image", period=0.1):
# Resize image if needed
resize_ratio = max(image.width, image.height) / cj.parameters.max_image_size
if resize_ratio < 1:
resize_ratio = 1
resized_width = int(image.width / resize_ratio)
resized_height = int(image.height / resize_ratio)
image.dump(dest_pattern="/tmp/{id}.jpg", max_size=max(resized_width, resized_height), bits=image.bitDepth)
img = cv2.imread(image.filename, cv2.IMREAD_GRAYSCALE)
thresholded_img = cv2.adaptiveThreshold(img, 2**image.bitDepth, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, cj.parameters.threshold_blocksize,
cj.parameters.threshold_constant)
kernel = np.ones((5, 5), np.uint8)
eroded_img = cv2.erode(thresholded_img, kernel, iterations=cj.parameters.erode_iterations)
dilated_img = cv2.dilate(eroded_img, kernel, iterations=cj.parameters.dilate_iterations)
extension = 10
extended_img = cv2.copyMakeBorder(dilated_img, extension, extension, extension, extension,
cv2.BORDER_CONSTANT, value=2**image.bitDepth)
components = find_components(extended_img)
zoom_factor = image.width / float(resized_width)
for i, component in enumerate(components):
converted = []
for point in component[0]:
x = int((point[0] - extension) * zoom_factor)
y = int(image.height - ((point[1] - extension) * zoom_factor))
converted.append((x, y))
components[i] = Polygon(converted)
# Find largest component (whole image)
largest = max(components, key=attrgetter('area'))
components.remove(largest)
# Only keep components greater than 5% of whole image
min_area = int(0.05 * image.width * image.height)
annotations = AnnotationCollection()
for component in components:
if component.area > min_area:
annotations.append(Annotation(location=component.wkt, id_image=image.id,
id_terms=[cj.parameters.cytomine_id_predicted_term],
id_project=cj.parameters.cytomine_id_project))
if len(annotations) % 100 == 0:
annotations.save()
annotations = AnnotationCollection()
annotations.save()
cj.job.update(statusComment="Finished.")
def end_successful_import(self, path: Path, image: Image, *args, **kwargs):
uf = self.get_uf(path)
ai = AbstractImage()
ai.uploadedFile = uf.id
ai.originalFilename = uf.originalFilename
ai.width = image.width
ai.height = image.height
ai.depth = image.depth
ai.duration = image.duration
ai.channels = image.n_intrinsic_channels
ai.extrinsicChannels = image.n_channels
if image.physical_size_x:
ai.physicalSizeX = round(
convert_quantity(image.physical_size_x, "micrometers"), 6)
if image.physical_size_y:
ai.physicalSizeY = round(
convert_quantity(image.physical_size_y, "micrometers"), 6)
if image.physical_size_z:
ai.physicalSizeZ = round(
convert_quantity(image.physical_size_z, "micrometers"), 6)
if image.frame_rate:
ai.fps = round(convert_quantity(image.frame_rate, "Hz"), 6)
ai.magnification = parse_int(image.objective.nominal_magnification)
ai.bitPerSample = dtype_to_bits(image.pixel_type)
ai.samplePerPixel = image.n_channels / image.n_intrinsic_channels
ai.save()
self.abstract_images.append(ai)
asc = AbstractSliceCollection()
set_channel_names = image.n_intrinsic_channels == image.n_channels
for c in range(image.n_intrinsic_channels):
name = None
color = None
if set_channel_names:
name = image.channels[c].suggested_name
color = image.channels[c].hex_color
for z in range(image.depth):
for t in range(image.duration):
mime = "image/pyrtiff" # TODO: remove
asc.append(
AbstractSlice(ai.id,
uf.id,
mime,
c,
z,
t,
channelName=name,
channelColor=color))
asc.save()
properties = PropertyCollection(ai)
for metadata in image.raw_metadata.values():
if metadata.value is not None and str(metadata.value) != '':
properties.append(
Property(ai, metadata.namespaced_key, str(metadata.value)))
try:
properties.save()
except CollectionPartialUploadException:
pass # TODO: improve handling of this exception, but prevent to fail the import
uf.status = UploadedFile.DEPLOYED
uf.update()
properties = PropertyCollection(ai)
for k, v in self.user_properties:
if v is not None and str(v) != '':
properties.append(Property(ai, k, v))
try:
properties.save()
except CollectionPartialUploadException:
pass # TODO: improve handling of this exception, but prevent to fail the import
instances = []
for p in self.projects:
instances.append(ImageInstance(ai.id, p.id).save())
self.images.append((ai, instances))
# TODO: temporary add annotations for backwards compatibility.
# BUT it should be done by core when an image instance is created.
if image.n_planes == 1 and len(instances) > 0:
# TODO: currently only supports metadata annots on 2D images
metadata_annots = image.annotations
if len(metadata_annots) > 0:
metadata_terms = [
ma.terms for ma in metadata_annots if len(ma.terms) > 0
]
metadata_terms = set(flatten(metadata_terms))
for instance in instances:
project_id = instance.project
project = self.projects.find_by_attribute('id', project_id)
ontology_id = project.ontology # noqa
ontology_terms = TermCollection().fetch_with_filter(
"project", project_id)
terms_id_mapping = {t.name: t.id for t in ontology_terms}
for metadata_term in metadata_terms:
if metadata_term not in terms_id_mapping:
# TODO: user must have ontology rights !
term = Term(name=metadata_term,
id_ontology=ontology_id,
color="#AAAAAA").save()
terms_id_mapping[term.name] = term.id
annots = AnnotationCollection()
for metadata_annot in metadata_annots:
term_ids = [
terms_id_mapping[t] for t in metadata_annot.terms
]
properties = [
dict(key=k, value=v)
for k, v in metadata_annot.properties.items()
]
annots.append(
Annotation(location=metadata_annot.wkt,
id_image=instance.id,
id_terms=term_ids
if len(term_ids) > 0 else None,
properties=properties
if len(properties) > 0 else None,
user=uf.user))
try:
annots.save()
except CollectionPartialUploadException:
pass
"If unset, all images in the project are used.",
default=None)
parser.add_argument('--cytomine_id_job')
params, _ = parser.parse_known_args(sys.argv[1:])
with Cytomine(params.cytomine_host, params.cytomine_public_key,
params.cytomine_private_key) as c:
id_tags_for_images = params.cytomine_id_tags_for_images
id_project = params.cytomine_id_project
image_tags = id_tags_for_images if id_tags_for_images else None
images = ImageInstanceCollection(tags=image_tags).fetch_with_filter(
"project", id_project)
image_ids = [image.id for image in images]
groundtruths = AnnotationCollection()
groundtruths.showTerm = True
groundtruths.showWKT = True
groundtruths.images = image_ids
groundtruths.fetch()
predictions = AnnotationCollection()
predictions.showTerm = True
predictions.showWKT = True
predictions.images = image_ids
predictions.job = params.cytomine_id_job
predictions.fetch()
print("There are {} groundtruths and {} predictions".format(
len(groundtruths), len(predictions)))
def run(argv):
# CytomineJob.from_cli() uses the descriptor.json to automatically create the ArgumentParser
with CytomineJob.from_cli(argv) as cj:
cj.job.update(statusComment="Initialization...")
id_project = cj.parameters.cytomine_id_project
id_terms = cj.parameters.cytomine_id_terms
id_tags_for_images = cj.parameters.cytomine_id_tags_for_images
working_path = cj.parameters.working_path
terms = TermCollection().fetch_with_filter("project", id_project)
if id_terms:
filtered_term_ids = [
int(id_term) for id_term in id_terms.split(',')
]
filtered_terms = TermCollection()
for term in terms:
if term.id in filtered_term_ids:
filtered_terms.append(term)
else:
filtered_terms = terms
# Associate YOLO class index to Cytomine term
classes_filename = os.path.join(working_path, CLASSES_FILENAME)
with open(classes_filename, 'r') as f:
classes = f.readlines()
indexes_terms = {}
for i, _class in enumerate(classes):
_class = _class.strip()
indexes_terms[i] = filtered_terms.find_by_attribute(
"name", _class)
cj.job.update(statusComment="Open model...", progress=1)
# TODO...
cj.job.update(statusComment="Predictions...", progress=5)
images = ImageInstanceCollection(
tags=id_tags_for_images).fetch_with_filter("project", id_project)
for image in images:
print("Prediction for image {}".format(image.instanceFilename))
# TODO: get predictions from YOLO
# TODO: I suppose here for the sake of the demo that the output format is the same as input, which is not sure
# <class> <x_center> <y_center> <width> <height> <proba>
sample_predictions = [(0, 0.604000000000, 0.493846153846,
0.105600000000, 0.461538461538, 0.9),
(0, 0.409200000000, 0.606153846154,
0.050400000000, 0.095384615385, 0.5)]
ac = AnnotationCollection()
for pred in sample_predictions:
_class, xcenter, ycenter, width, height, proba = pred
term_ids = [indexes_terms[_class].id
] if _class in indexes_terms.keys() else None
if term_ids is None:
print("No term found for class {}".format(_class))
geometry = yolo_to_geometry((xcenter, ycenter, width, height),
image.width, image.height)
properties = [{"key": "probability", "value": proba}]
ac.append(
Annotation(id_image=image.id,
id_terms=term_ids,
location=geometry.wkt,
properties=properties))
ac.save()
cj.job.update(statusComment="Finished", progress=100)
f_csv = csv.reader(csvfile, delimiter=str(','), quotechar=str('|'))
headers = next(f_csv)
for row in f_csv:
image_id = row[0]
tissue = row[1]
dye = row[2]
id2info[image_id] = (tissue, dye)
with Cytomine(host=params.host,
public_key=params.public_key,
private_key=params.private_key,
verbose=logging.INFO) as cytomine:
annotations = AnnotationCollection()
annotations.project = params.id_project
annotations.showWKT = True
annotations.showMeta = True
annotations.showGIS = True
annotations.fetch()
print(annotations)
for annotation in annotations:
print(
"ID: {} | Image: {} | Project: {} | Term: {} | User: {} | Area: {} | Perimeter: {} | WKT: {}"
.format(annotation.id, annotation.image, annotation.project,
annotation.term, annotation.user, annotation.area,
annotation.perimeter, annotation.location))
annot = Annotation().fetch(annotation.id)
def create_tracking_from_slice_group(image,
slices,
slice2point,
depth2slice,
id_project,
upload_object=False,
track_prefix="object",
label=None,
upload_group_id=False):
"""Create a set of tracks and annotations to represent a tracked element. A trackline is created to reflect the
movement of the object in the image. Optionally the object's polygon can also be uploaded.
Parameters
----------
image: ImageInstance
An ImageInstance
slices: list of AnnotationSlice
A list of AnnotationSlice of one object
slice2point: callable
A function that transform a slice into its representative point to be used for generating the tracking line
depth2slice: dict
Maps time step with corresponding SliceInstance
id_project: int
Project identifier
upload_object: bool
True if the object should be uploaded as well (the trackline is uploaded in any case)
track_prefix: str
A prefix for the track name
label: int (default: None)
The label of the tracked object
upload_group_id: bool
True for uploading the object label with the track
Returns
-------
saved_tracks: TrackCollection
The saved track objects
annotations: AnnotationCollection
The annotations associated with the traped. The collection is NOT saved.
"""
if label is None and len(slices) > 0:
label = slices[0].label
# create tracks
tracks = TrackCollection()
object_track = Track(
"{}-{}".format(track_prefix, label),
image.id,
color=None if upload_group_id else DEFAULT_COLOR).save()
trackline_track = Track(
"{}-{}-trackline".format(track_prefix, label),
image.id,
color=None if upload_group_id else DEFAULT_COLOR).save()
tracks.extend([object_track, trackline_track])
if upload_group_id:
Property(object_track, key="label", value=int(label)).save()
Property(trackline_track, key="label", value=int(label)).save()
# create actual annotations
annotations = AnnotationCollection()
sorted_group = sorted(slices, key=lambda s: s.time)
prev_line = []
for _slice in sorted_group:
point = slice2point(_slice)
if point.is_empty: # skip empty points
continue
if len(prev_line) == 0 or not prev_line[-1].equals(point):
prev_line.append(point)
if len(prev_line) == 1:
polygon = slice2point(_slice)
else:
polygon = LineString(prev_line)
depth = _slice.time if _slice.depth is None else _slice.depth
annotations.append(
Annotation(location=change_referential(polygon, image.height).wkt,
id_image=image.id,
slice=depth2slice[depth].id,
id_project=id_project,
id_tracks=[trackline_track.id]))
if upload_object:
annotations.append(
Annotation(location=change_referential(_slice.polygon,
image.height).wkt,
id_image=image.id,
slice=depth2slice[depth].id,
id_project=id_project,
id_tracks=[object_track.id]))
return tracks, annotations