def profile_projections( self, axis=None, csv=False, csv_dest_pattern="projections-annotation-{id}.csv"): """ Get profile projections (min, max, average) for the given annotation. Parameters ---------- axis The axis along which the projections (min, max, average) are performed. By default last axis is used. To project along spatial X, Y axes, use special value "xy" or "spatial". csv True to return result in a CSV file. csv_dest_pattern The CSV destination pattern. """ if self.id is None: raise ValueError("Cannot review an annotation with no ID.") uri = "{}/{}/profile/projections.{}".format(self.callback_identifier, self.id, "csv" if csv else "json") if csv: pattern = re.compile("{(.*?)}") destination = re.sub( pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), csv_dest_pattern) return Cytomine.get_instance().download_file( uri, destination, payload={"axis": axis}) data = Cytomine.get_instance().get(uri, {"axis": axis}) return data['collection'] if "collection" in data else data
def update(self, id=None, **attributes): Cytomine.get_instance().log( "Job (id:{job_id}) status update: \"{statusComment}\" (status: {status}, progress: {progress}%)" .format(job_id=self.id, statusComment=attributes.get("statusComment", self.statusComment), status=_HUMAN_READABLE_JOB_STATUS[attributes.get( "status", self.status)], progress=attributes.get("progress", self.progress))) return super(Job, self).update(id=id, **attributes)
def merge(self, id_other_annotation_group): if self.id is None: raise ValueError("Cannot merge an annotaiton group with no ID.") return Cytomine.get_instance().post( "annotationgroup/{}/annotationgroup/{}/merge.json".format( self.id, id_other_annotation_group))
def rectangle(self, x, y, width, height): uri = "imagegroupHDF5/{}/{}/{}/{}/{}/rectangle.json".format(self.id, x, y, width, height) collection = Cytomine.get_instance().get(uri)["collection"] spectrum = np.array([data["spectra"] for data in collection]) spectrum = np.expand_dims(spectrum, axis=1) _, _, depth = spectrum.shape return spectrum.reshape((width, height, depth))
def fetch(self, id=None): if self.id is None and id is None: raise ValueError("Cannot fetch a model with no ID.") if id is not None: self.id = id return Cytomine.get_instance().get_model(self, self.query_parameters)
def save(self, chunk=15, n_workers=0): """ chunk: int|None Maximum number of object to send at once in a single HTTP request. None for sending them all at once. n_workers: int Number of threads to use for sending chunked requests (ignored if chunk is None). Value 0 for using as many threads as cpus on the machine. """ if chunk is None: return Cytomine.get_instance().post_collection(self) elif isinstance(chunk, int): def upload_fn(collection): if not isinstance(collection, Collection): _tmp = self.__class__(self._model) _tmp.extend(collection) collection = _tmp return Cytomine.get_instance().post_collection(collection) results = generic_chunk_parallel(self, worker_fn=upload_fn, chunk_size=chunk, n_workers=n_workers) added, failed = list(), list() for (start, end), success in results: (added if success else failed).extend(self[start:end]) if len(added) != len(self): raise CollectionPartialUploadException( "Some annotations could not be uploaded", created=added, failed=failed) return True else: raise ValueError( "Invalid value '{}' for chunk parameter.".format(chunk))
def delete(self, id=None): if self.id is None and id is None: raise ValueError("Cannot delete a model with no ID.") if id is not None: self.id = id return Cytomine.get_instance().delete_model(self)
def download(self, dest_pattern="{originalFilename}", override=True, parent=False): """ Download the original image. Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. parent : bool, optional True to download image parent if the abstract image is a part of a multidimensional file. Returns ------- downloaded : bool True if everything happens correctly, False otherwise. """ if self.id is None: raise ValueError("Cannot dump an annotation with no ID.") pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) parameters = {"parent": parent} destination = os.path.dirname(dest_pattern) if not os.path.exists(destination): os.makedirs(destination) return Cytomine.get_instance().download_file("{}/{}/download".format(self.callback_identifier, self.id), dest_pattern, override, parameters)
def profile(self): if self.id is None: raise ValueError("Cannot review an annotation with no ID.") data = Cytomine.get_instance().get("{}/{}/profile.json".format( self.callback_identifier, self.id)) return data['collection'] if "collection" in data else data
def image_servers(self): if not self._image_servers: data = Cytomine.get_instance().get( "{}/{}/imageservers.json".format(self.callback_identifier, self.id)) self._image_servers = data["imageServersURLs"] return self._image_servers
def download(self, dest_pattern="{originalFilename}", override=True, parent=False): """ Download the original image. Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. parent : bool, optional True to download image parent if the abstract image is a part of a multidimensional file. Returns ------- downloaded : bool True if everything happens correctly, False otherwise. """ if self.id is None: raise ValueError("Cannot dump an annotation with no ID.") pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) parameters = {"parent": parent} destination = os.path.dirname(dest_pattern) if not os.path.exists(destination): os.makedirs(destination) return Cytomine.get_instance().download_file("{}/{}/download".format(self.callback_identifier, self.id), dest_pattern, override, parameters)
def _fetch(self, append_mode=False): if len(self._filters) == 0 and None not in self._allowed_filters: raise ValueError( "This collection cannot be fetched without a filter.") return Cytomine.get_instance().get_collection(self, self.parameters, append_mode)
def upload(self, filename): if self.is_new(): raise ValueError("Cannot upload file if not existing ID.") return Cytomine.get_instance().upload_file( self, filename, uri="{}/{}/upload".format(self.callback_identifier, self.id))
def review(self, id_terms=None): if self.id is None: raise ValueError("Cannot review an annotation with no ID.") if not id_terms: id_terms = [] data = {"id": self.id, "terms": id_terms} return Cytomine.get_instance().post("{}/{}/review.json".format(self.callback_identifier, self.id), data)
def rectangle(self, x, y, width, height): uri = "imagegroupHDF5/{}/{}/{}/{}/{}/rectangle.json".format( self.id, x, y, width, height) collection = Cytomine.get_instance().get(uri)["collection"] spectrum = np.array([data["spectra"] for data in collection]) spectrum = np.expand_dims(spectrum, axis=1) _, _, depth = spectrum.shape return spectrum.reshape((width, height, depth))
def dump_crops(self, dest_pattern, n_workers=0, override=True, **dump_params): """Download the crops of the annotations Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. n_workers: int Number of workers to use (default: uses all the available processors) dump_params: dict Parameters for dumping the annotations (see Annotation.dump) Returns ------- annotations: AnnotationCollection Annotations that have been successfully downloaded (containing a `filenames` attribute) """ def dump_crop(an): if is_false( an.dump(dest_pattern=dest_pattern, override=override, **dump_params)): return False else: return an results = generic_download(self, download_instance_fn=dump_crop, n_workers=n_workers) # check errors count_fail = 0 failed = list() for in_annot, out_annot in results: if is_false(out_annot): count_fail += 1 failed.append(in_annot.id) logger = Cytomine.get_instance().logger if count_fail > 0: n_annots = len(self) ratio = 100 * count_fail / float(n_annots) logger.info( "Failed to download crops for {}/{} annotations ({:3.2f} %).". format(count_fail, n_annots, ratio)) logger.debug( "Annotation with crop download failure: {}".format(failed)) collection = AnnotationCollection() collection.extend( [an for _, an in results if not isinstance(an, bool) or an]) return collection
def execute(self): if self.is_new(): raise ValueError("Cannot execute job if no ID was provided.") response = Cytomine.get_instance().post(uri="{}/{}/execute.json" .format(self.callback_identifier, self.id), data=self.to_json(), query_parameters={id: self.id}) self.populate(response) return self
def download(self, destination="{filename}", override=False): if self.is_new(): raise ValueError("Cannot download file if not existing ID.") pattern = re.compile("{(.*?)}") destination = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), destination) return Cytomine.get_instance().download_file("{}/{}/download".format(self.callback_identifier, self.id), destination, override)
def update(self, id=None, **attributes): if self.id is None and id is None: raise ValueError("Cannot update a model with no ID.") if id is not None: self.id = id if attributes: self.populate(attributes) return Cytomine.get_instance().put_model(self)
def execute(self): if self.is_new(): raise ValueError("Cannot execute job if no ID was provided.") response = Cytomine.get_instance().post( uri="{}/{}/execute.json".format(self.callback_identifier, self.id), data=self.to_json(), query_parameters={id: self.id}) self.populate(response) return self
def upload(self): return Cytomine.get_instance().upload_file(self, self.filename, query_parameters={ "domainClassName": self.domainClassName, "domainIdent": self.domainIdent })
def review(self, id_terms=None): if self.id is None: raise ValueError("Cannot review an annotation with no ID.") if not id_terms: id_terms = [] data = {"id": self.id, "terms": id_terms} return Cytomine.get_instance().post( "{}/{}/review.json".format(self.callback_identifier, self.id), data)
def fetch(self, id=None, key=None): if self.id is None and id is None and self.key is None and key is None: raise ValueError("Cannot fetch a model with no ID and no key.") if id is not None: self.id = id if key is not None: self.key = key self._by_key = True model = Cytomine.get_instance().get_model(self, self.query_parameters) self._by_key = False return model
def fetch(self, id=None, key=None): if self.id is None and id is None and self.key is None and key is None: raise ValueError("Cannot fetch a model with no ID and no key.") if id is not None: self.id = id if key is not None: self.key = key self._by_key = True model = Cytomine.get_instance().get_model(self, self.query_parameters) self._by_key = False return model
def reference_slice(self): if self.id is None: raise ValueError( "Cannot get the reference slice of an image with no ID.") if not self._reference_slice: data = Cytomine.get_instance().get( "imageinstance/{}/sliceinstance/reference.json".format( self.id)) self._reference_slice = SliceInstance().populate( data) if data else False return self._reference_slice
def fetch(self, id_user=None, id_role=None): self.id = -1 if self.user is None and id_user is None: raise ValueError("Cannot fetch a model with no user ID.") elif self.role is None and id_role is None: raise ValueError("Cannot fetch a model with no role ID.") if id_user is not None: self.user = id_user if id_role is not None: self.role = id_role return Cytomine.get_instance().get_model(self, self.query_parameters)
def fetch(self, id_annotation=None, id_term=None): self.id = -1 if self.annotation is None and id_annotation is None: raise ValueError("Cannot fetch a model with no annotation ID.") elif self.term is None and id_term is None: raise ValueError("Cannot fetch a model with no term ID.") if id_annotation is not None: self.annotation = id_annotation if id_term is not None: self.term = id_term return Cytomine.get_instance().get_model(self, self.query_parameters)
def fetch(self, id_user=None, id_role=None): self.id = -1 if self.user is None and id_user is None: raise ValueError("Cannot fetch a model with no user ID.") elif self.role is None and id_role is None: raise ValueError("Cannot fetch a model with no role ID.") if id_user is not None: self.user = id_user if id_role is not None: self.role = id_role return Cytomine.get_instance().get_model(self, self.query_parameters)
def fetch(self, id_term1=None, id_term2=None): self.id = -1 if self.term1 is None and id_term1 is None: raise ValueError("Cannot fetch a model with no term 1 ID.") elif self.term2 is None and id_term2 is None: raise ValueError("Cannot fetch a model with no term 2 ID.") if id_term1 is not None: self.term1 = id_term1 if id_term2 is not None: self.term2 = id_term2 return Cytomine.get_instance().get_model(self, self.query_parameters)
def fetch(self, id_term1=None, id_term2=None): self.id = -1 if self.term1 is None and id_term1 is None: raise ValueError("Cannot fetch a model with no term 1 ID.") elif self.term2 is None and id_term2 is None: raise ValueError("Cannot fetch a model with no term 2 ID.") if id_term1 is not None: self.term1 = id_term1 if id_term2 is not None: self.term2 = id_term2 return Cytomine.get_instance().get_model(self, self.query_parameters)
def fetch(self, id_annotation=None, id_track=None): self.id = -1 if self.annotationIdent is None and id_annotation is None: raise ValueError("Cannot fetch a model with no annotation ID.") elif self.track is None and id_track is None: raise ValueError("Cannot fetch a model with no term ID.") if id_annotation is not None: self.annotationIdent = id_annotation if id_track is not None: self.track = id_track return Cytomine.get_instance().get_model(self, self.query_parameters)
def profile(self, x, y, width=None, height=None): import numpy as np from shapely.geometry import Point, box geometry = box(x, y, x + width, y + height) if (width and height) else Point(x, y) uri = "{}/{}/profile.json".format(self.callback_identifier, self.id) data = Cytomine.get_instance().get(uri, {"geometry": geometry}) if width and height: data = data["collection"] depth = len(data[0]["profile"]) profile = np.empty((height, width, depth), dtype=np.uint) for p in data: row = p["point"][1] - y col = p["point"][0] - x profile[row, col, :] = p["profile"] return profile else: return np.asarray([[data["profile"]]])
def dump(self, dest_pattern="{id}.jpg", override=True, max_size=None, bits=8, contrast=None, gamma=None, colormap=None, inverse=None): """ Download the image with optional image modifications. Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. max_size : int, tuple, optional Maximum size (width or height) of returned image. None to get original size. bits : int (8,16,32) or str ("max"), optional Bit depth (bit per channel) of returned image. "max" returns the original image bit depth contrast : float, optional Optional contrast applied on returned image. gamma : float, optional Optional gamma applied on returned image. colormap : int, optional Cytomine identifier of a colormap to apply on returned image. inverse : bool, optional True to inverse color mapping, False otherwise. Returns ------- downloaded : bool True if everything happens correctly, False otherwise. As a side effect, object attribute "filename" is filled with downloaded file path. """ if self.id is None: raise ValueError("Cannot dump an annotation with no ID.") pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) destination = os.path.dirname(dest_pattern) filename, extension = os.path.splitext(os.path.basename(dest_pattern)) extension = extension[1:] if extension not in ("jpg", "png", "tif", "tiff"): extension = "jpg" if not os.path.exists(destination): os.makedirs(destination) if isinstance(max_size, tuple) or max_size is None: max_size = max(self.width, self.height) parameters = { "maxSize": max_size, "contrast": contrast, "gamma": gamma, "colormap": colormap, "inverse": inverse, "bits": bits } file_path = os.path.join(destination, "{}.{}".format(filename, extension)) url = self.preview[:self.preview.index("?")] url = url.replace(".png", ".{}".format(extension)) result = Cytomine.get_instance().download_file(url, file_path, override, parameters) if result: self.filename = file_path return result
def _fetch(self, append_mode=False): if len(self._filters) == 0 and None not in self._allowed_filters: raise ValueError("This collection cannot be fetched without a filter.") return Cytomine.get_instance().get_collection(self, self.parameters, append_mode)
def characteristics(self): uri = "imagegroup/{}/characteristics.json".format(self.id) return Cytomine.get_instance().get(uri)
def pixel(self, x, y): uri = "imagegroupHDF5/{}/{}/{}/pixel.json".format(self.id, x, y) return np.asarray([[Cytomine.get_instance().get(uri)["spectra"]]])
def upload(self): return Cytomine.get_instance().upload_file(self, self.filename, query_parameters={"domainClassName": self.domainClassName, "domainIdent": self.domainIdent})
def signature(self): return Cytomine.get_instance().get("signature.json")
def dump(self, dest_pattern="{id}.jpg", override=True, mask=False, alpha=False, bits=8, zoom=None, max_size=None, increase_area=None, contrast=None, gamma=None, colormap=None, inverse=None): """ Download the annotation crop, with optional image modifications. Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. mask : bool, optional True if a binary mask based on given annotations must be returned, False otherwise. alpha : bool, optional True if image background (outside annotations) must be transparent, False otherwise. zoom : int, optional Optional image zoom number bits : int (8,16,32) or str ("max"), optional Bit depth (bit per channel) of returned image. "max" returns the original image bit depth max_size : int, tuple, optional Maximum size (width or height) of returned image. None to get original size. increase_area : float, optional Increase the crop size. For example, an annotation whose bounding box size is (w,h) will have a crop dimension of (w*increase_area, h*increase_area). contrast : float, optional Optional contrast applied on returned image. gamma : float, optional Optional gamma applied on returned image. colormap : int, optional Cytomine identifier of a colormap to apply on returned image. inverse : bool, optional True to inverse color mapping, False otherwise. Returns ------- downloaded : bool True if everything happens correctly, False otherwise. As a side effect, object attribute "filename" is filled with downloaded file path. """ if self.id is None: raise ValueError("Cannot dump an annotation with no ID.") pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) destination = os.path.dirname(dest_pattern) filename, extension = os.path.splitext(os.path.basename(dest_pattern)) extension = extension[1:] if extension not in ("jpg", "png", "tif", "tiff"): extension = "jpg" if not os.path.exists(destination): os.makedirs(destination) parameters = { "zoom": zoom, "maxSize": max_size, "increaseArea": increase_area, "contrast": contrast, "gamma": gamma, "colormap": colormap, "inverse": inverse, "bits": bits } if mask and alpha: image = "alphamask" if extension == "jpg": extension = "png" elif mask: image = "mask" else: image = "crop" file_path = os.path.join(destination, "{}.{}".format(filename, extension)) url = self.cropURL.replace("crop.jpg", "{}.{}".format(image, extension)) result = Cytomine.get_instance().download_file(url, file_path, override, parameters) if result: self.filename = file_path return result
def keys(self): # Only works if you are superadmin. if hasattr(self, "id") and self.id: return Cytomine.get_instance().get("user/{}/keys.json".format(self.id))
def characteristics(self): uri = "imagegroup/{}/characteristics.json".format(self.id) return Cytomine.get_instance().get(uri)
def image_servers(self): if not self._image_servers: data = Cytomine.get_instance().get("abstractimage/{}/imageservers.json".format(self.baseImage)) self._image_servers = data["imageServersURLs"] return self._image_servers
def image_servers(self): if not self._image_servers: data = Cytomine.get_instance().get("{}/{}/imageservers.json".format(self.callback_identifier, self.id)) self._image_servers = data["imageServersURLs"] return self._image_servers
def pixel(self, x, y): uri = "imagegroupHDF5/{}/{}/{}/pixel.json".format(self.id, x, y) return np.asarray([[Cytomine.get_instance().get(uri)["spectra"]]])
def dump(self, dest_pattern="{id}.jpg", override=True, max_size=None, bits=8, contrast=None, gamma=None, colormap=None, inverse=None): """ Download the image with optional image modifications. Parameters ---------- dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. max_size : int, tuple, optional Maximum size (width or height) of returned image. None to get original size. bits : int (8,16,32) or str ("max"), optional Bit depth (bit per channel) of returned image. "max" returns the original image bit depth contrast : float, optional Optional contrast applied on returned image. gamma : float, optional Optional gamma applied on returned image. colormap : int, optional Cytomine identifier of a colormap to apply on returned image. inverse : bool, optional True to inverse color mapping, False otherwise. Returns ------- downloaded : bool True if everything happens correctly, False otherwise. As a side effect, object attribute "filename" is filled with downloaded file path. """ if self.id is None: raise ValueError("Cannot dump an annotation with no ID.") pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) destination = os.path.dirname(dest_pattern) filename, extension = os.path.splitext(os.path.basename(dest_pattern)) extension = extension[1:] if extension not in ("jpg", "png", "tif", "tiff"): extension = "jpg" if not os.path.exists(destination): os.makedirs(destination) if isinstance(max_size, tuple) or max_size is None: max_size = max(self.width, self.height) parameters = { "maxSize": max_size, "contrast": contrast, "gamma": gamma, "colormap": colormap, "inverse": inverse, "bits": bits } file_path = os.path.join(destination, "{}.{}".format(filename, extension)) url = self.preview[:self.preview.index("?")] url = url.replace(".png", ".{}".format(extension)) result = Cytomine.get_instance().download_file(url, file_path, override, parameters) if result: self.filename = file_path return result
def save(self): return Cytomine.get_instance().post_collection(self)
def keys(self): return Cytomine.get_instance().get("userkey/{}/keys.json".format(self.publicKey))
def image_servers(self): if not self._image_servers: data = Cytomine.get_instance().get("abstractimage/{}/imageservers.json".format(self.baseImage)) self._image_servers = data["imageServersURLs"] return self._image_servers
def window(self, x, y, w, h, dest_pattern="{id}-{x}-{y}-{w}-{h}.jpg", override=True, mask=None, alpha=None, bits=8, annotations=None, terms=None, users=None, reviewed=None): """ Extract a window (rectangle) from an image and download it. Parameters ---------- x : int The X position of window top-left corner. 0 is image left. y : int The Y position of window top-left corner. 0 is image top. w : int The window width h : int The window height dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. mask : bool, optional True if a binary mask based on given annotations must be returned, False otherwise. alpha : bool, optional True if image background (outside annotations) must be transparent, False otherwise. bits : int (8/16/32), optional Optional output bit depth of returned images annotations : list of int, optional If mask=True or alpha=True, annotation identifiers that must be taken into account for masking terms : list of int, optional If mask=True or alpha=True, term identifiers that must be taken into account for masking users : list of int, optional If mask=True or alpha=True, user identifiers that must be taken into account for masking reviewed : bool, optional If mask=True or alpha=True, indicate if only reviewed annotations mut be taken into account for masking Returns ------- downloaded : bool True if everything happens correctly, False otherwise. """ self.x = x self.y = y self.w = w self.h = h pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) del self.x del self.y del self.w del self.h destination = os.path.dirname(dest_pattern) filename, extension = os.path.splitext(os.path.basename(dest_pattern)) extension = extension[1:] if extension not in ("jpg", "png", "tif", "tiff"): extension = "jpg" if not os.path.exists(destination): os.makedirs(destination) if mask is None and alpha is None: alphamask = None elif mask and alpha: alphamask = True if extension == "jpg": extension = "png" else: alphamask = False # Temporary fix due to Cytomine-core if mask is not None: mask = str(mask).lower() if alphamask is not None: alphamask = str(alphamask).lower() # === parameters = { "annotations": ",".join(str(item) for item in annotations) if annotations else None, "terms": ",".join(str(item) for item in terms) if terms else None, "users": ",".join(str(item) for item in users) if users else None, "reviewed": reviewed, "bits": bits, "mask": mask, "alphaMask": alphamask } file_path = os.path.join(destination, "{}.{}".format(filename, extension)) return Cytomine.get_instance().download_file("{}/{}/window-{}-{}-{}-{}.{}".format( self.callback_identifier, self.id, x, y, w, h, extension), file_path, override, parameters)
def save(self): self.id = None return Cytomine.get_instance().post_model(self)
def fetch(self, id=None): if id is not None: self.id = id return Cytomine.get_instance().get_model(self, self.query_parameters)
def window(self, x, y, w, h, dest_pattern="{id}-{x}-{y}-{w}-{h}.jpg", override=True, mask=None, alpha=None, bits=8, annotations=None, terms=None, users=None, reviewed=None): """ Extract a window (rectangle) from an image and download it. Parameters ---------- x : int The X position of window top-left corner. 0 is image left. y : int The Y position of window top-left corner. 0 is image top. w : int The window width h : int The window height dest_pattern : str, optional Destination path for the downloaded image. "{X}" patterns are replaced by the value of X attribute if it exists. override : bool, optional True if a file with same name can be overrided by the new file. mask : bool, optional True if a binary mask based on given annotations must be returned, False otherwise. alpha : bool, optional True if image background (outside annotations) must be transparent, False otherwise. bits : int (8/16/32), optional Optional output bit depth of returned images annotations : list of int, optional If mask=True or alpha=True, annotation identifiers that must be taken into account for masking terms : list of int, optional If mask=True or alpha=True, term identifiers that must be taken into account for masking users : list of int, optional If mask=True or alpha=True, user identifiers that must be taken into account for masking reviewed : bool, optional If mask=True or alpha=True, indicate if only reviewed annotations mut be taken into account for masking Returns ------- downloaded : bool True if everything happens correctly, False otherwise. """ self.x = x self.y = y self.w = w self.h = h pattern = re.compile("{(.*?)}") dest_pattern = re.sub(pattern, lambda m: str(getattr(self, str(m.group(0))[1:-1], "_")), dest_pattern) del self.x del self.y del self.w del self.h destination = os.path.dirname(dest_pattern) filename, extension = os.path.splitext(os.path.basename(dest_pattern)) extension = extension[1:] if extension not in ("jpg", "png", "tif", "tiff"): extension = "jpg" if not os.path.exists(destination): os.makedirs(destination) if mask is None and alpha is None: alphamask = None elif mask and alpha: alphamask = True if extension == "jpg": extension = "png" else: alphamask = False # Temporary fix due to Cytomine-core if mask is not None: mask = str(mask).lower() if alphamask is not None: alphamask = str(alphamask).lower() # === parameters = { "annotations": ",".join(str(item) for item in annotations) if annotations else None, "terms": ",".join(str(item) for item in terms) if terms else None, "users": ",".join(str(item) for item in users) if users else None, "reviewed": reviewed, "bits": bits, "mask": mask, "alphaMask": alphamask } file_path = os.path.join(destination, "{}.{}".format(filename, extension)) return Cytomine.get_instance().download_file("{}/{}/window-{}-{}-{}-{}.{}".format( self.callback_identifier, self.id, x, y, w, h, extension), file_path, override, parameters)
def upload(self, filename): if self.is_new(): raise ValueError("Cannot upload file if not existing ID.") return Cytomine.get_instance().upload_file(self, filename, uri="{}/{}/upload".format(self.callback_identifier, self.id))