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