def frangi( src: DataURI, dst: DataURI, scale_min: Float = 1.0, scale_max: Float = 4.0, scale_step: Float = 1.0, alpha: Float = 0.5, beta: Float = 0.5, gamma=15, ) -> "BLOB": from ..server.filtering.blob import compute_frangi map_blocks( compute_frangi, src, out=dst, scale_range=(scale_min, scale_max), scale_step=1.0, alpha=0.5, beta=0.5, gamma=15, dark_response=True, normalize=True, pad=max(4, int((scale_max * 2))), )
def wavelet( src: DataURI, dst: DataURI, threshold: Float = 64.0, level: Int = 1, wavelet: String = "sym3", hard: SmartBoolean = True, ) -> "WAVELET": from ..server.filtering import wavelet as wavelet_fn with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset_arr = DM.sources[0][:] result = wavelet_fn(src_dataset_arr, level=level, wavelet=str(wavelet), threshold=threshold, hard=hard) # map_blocks( # wavelet, # src, # level=level, # out=dst, # normalize=True, # wavelet="sym3", # threshold=threshold, # hard=hard, # pad=max(4, int(level * 2)), # ) map_blocks(pass_through, result, out=dst, normalize=False)
def label_postprocess( level_over: DataURI, level_base: DataURI, selected_label: Int, offset: Int, dst: DataURI, ): if level_over != 'None': src1 = DataModel.g.dataset_uri(level_over, group="annotations") with DatasetManager(src1, out=None, dtype="uint16", fillvalue=0) as DM: src1_dataset = DM.sources[0] anno1_level = src1_dataset[:] & 15 logger.info(f"Obtained over annotation level with labels {np.unique(anno1_level)}") src_base = DataModel.g.dataset_uri(level_base, group="annotations") with DatasetManager(src_base, out=None, dtype="uint16", fillvalue=0) as DM: src_base_dataset = DM.sources[0] anno_base_level = src_base_dataset[:] & 15 logger.info(f"Obtained base annotation level with labels {np.unique(anno_base_level)}") print(f"Selected label {selected_label}") #if int(selected_label) != -1: # anno_base_level = (anno_base_level == int(selected_label)) * 1.0 result = anno_base_level if level_over != 'None': result = anno_base_level * (1.0 - ((anno1_level > 0) * 1.0)) anno1_level[anno1_level == selected_label] += offset result += anno1_level map_blocks(pass_through, result, out=dst, normalize=False)
def find_connected_components(src: DataURI, dst: DataURI, pipelines_id: DataURI, label_index: Int, workspace: String) -> "SEGMENTATION": logger.debug( f"Finding connected components on segmentation: {pipelines_id}") print(f"{DataModel.g.current_workspace}") src = DataModel.g.dataset_uri(pipelines_id, group="pipelines") print(src) with DatasetManager(src, out=None, dtype="int32", fillvalue=0) as DM: src_dataset_arr = DM.sources[0][:] logger.debug(f"src_dataset shape {src_dataset_arr[:].shape}") single_label_level = (src_dataset_arr == label_index) * 1.0 bbs_tables, selected_entities = detect_blobs(single_label_level) print(bbs_tables) print(selected_entities) result_list = [] for i in range(len(bbs_tables[0])): result_list.append([ bbs_tables[0].iloc[i]["area"], bbs_tables[0].iloc[i]["z"], bbs_tables[0].iloc[i]["y"], bbs_tables[0].iloc[i]["x"], ]) map_blocks(pass_through, single_label_level, out=dst, normalize=False) print(result_list) return result_list
def supervoxels( src: DataURI, dst: DataURI, n_segments: Int = 10, compactness: Float = 20, spacing: FloatList = [1, 1, 1], multichannel: SmartBoolean = False, enforce_connectivity: SmartBoolean = False, out_dtype="int", ): with DatasetManager(src, out=None, dtype=out_dtype, fillvalue=0) as DM: src_data_arr = DM.sources[0][:] supervoxel_image = slic( src_data_arr, n_segments=n_segments, spacing=spacing, compactness=compactness, multichannel=False, ) print(supervoxel_image) def pass_through(x): return x map_blocks(pass_through, supervoxel_image, out=dst, normalize=False)
def merge_regions(src: DataURI, labels: DataURI, dst: DataURI, min_size: Float): """ API wrapper for `survos2.improc.regions.merge_small`. """ from ..improc.regions.ccl import merge_small map_blocks(merge_small, src, labels, out=dst, min_size=min_size)
def connected_components(src: DataURI, dst: DataURI, remap: SmartBoolean): """ API wrapper for `survos2.improc.regions.ccl3d`. """ from ..improc.regions.ccl import ccl3d map_blocks(ccl3d, src, out=dst, remap=remap)
def threshold(src: DataURI, dst: DataURI, thresh: Float = 0.5) -> "BASE": from ..server.filtering import threshold as threshold_fn with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset_arr = DM.sources[0][:] filtered = threshold_fn(src_dataset_arr, thresh=thresh) map_blocks(pass_through, filtered, out=dst, normalize=False)
def gaussian(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1) -> 'Denoising': """ API wrapper around `survos2.improc.features.gauss.gaussian`. """ from ..improc.features.gauss import gaussian map_blocks(gaussian, src, out=dst, sigma=sigma, normalize=True)
def supervoxels(src:DataURIList, dst:DataURI, shape:IntList=[10,10,10], compactness:Float=30, spacing:FloatList=[1,1,1]): """ API wrapper for `survos2.improc.regions.slic3d`. """ from ..improc.regions.slic import slic3d map_blocks(slic3d, *src, out=dst, sp_shape=shape, spacing=spacing, compactness=compactness, stack=True)
def rescale(src: DataURI, dst: DataURI) -> "BASE": logger.debug(f"Rescaling src {src}") with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset = DM.sources[0][:] filtered = rescale_denan(src_dataset) map_blocks(pass_through, filtered, out=dst, normalize=False)
def distance_transform_edt(src: DataURI, dst: DataURI) -> "MORPHOLOGY": from ..server.filtering import distance_transform_edt logger.debug(f"Calculating distance transform") with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset_arr = DM.sources[0][:] filtered = distance_transform_edt(src_dataset_arr) map_blocks(pass_through, filtered, out=dst, normalize=False)
def skeletonize(src: DataURI, dst: DataURI) -> "MORPHOLOGY": from ..server.filtering import skeletonize logger.debug(f"Calculating medial axis") with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset_arr = DM.sources[0][:] filtered = skeletonize(src_dataset_arr) map_blocks(pass_through, filtered, out=dst, normalize=False)
def spatial_gradient_3d(src: DataURI, dst: DataURI, dim: Int = 0) -> "EDGES": from ..server.filtering import spatial_gradient_3d map_blocks( spatial_gradient_3d, src, out=dst, dim=dim, normalize=True, )
def dilation(src: DataURI, dst: DataURI, num_iter: Int = 1) -> "MORPHOLOGY": from ..server.filtering import dilate map_blocks( dilate, src, num_iter=num_iter, out=dst, normalize=True, pad=max(4, int(num_iter * 2)), )
def closing(src: DataURI, dst: DataURI, num_iter: Int = 1) -> "MORPHOLOGY": from ..server.filtering import closing map_blocks( closing, src, num_iter=num_iter, out=dst, normalize=True, pad=max(4, int(num_iter * 2)), )
def structure_tensor_determinant(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1) -> "BLOB": from ..server.filtering.blob import compute_structure_tensor_determinant map_blocks( compute_structure_tensor_determinant, src, out=dst, sigma=sigma, pad=max(4, int((max(sigma) * 2))), normalize=True, )
def hessian_eigenvalues(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1) -> "BLOB": from ..server.filtering.blob import hessian_eigvals_image map_blocks( hessian_eigvals_image, src, out=dst, pad=max(4, int((max(sigma) * 2))), sigma=sigma, normalize=True, )
def gaussian_norm(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1) -> "NEIGHBORHOOD": from ..server.filtering.blur import gaussian_norm map_blocks( gaussian_norm, src, out=dst, sigma=sigma, pad=max(4, int((max(sigma) * 2))), normalize=True, )
def annotate_regions( workspace: String, level: String, region: DataURI, r: IntList, label: Int, full: SmartBoolean, parent_level: String, parent_label_idx: Int, bb: IntList, viewer_order: tuple, ): from survos2.api.annotate import annotate_regions ds = get_level(workspace, level, full) region = dataset_from_uri(region, mode="r") from survos2.frontend.frontend import get_level_from_server if parent_level != "-1" and parent_level != -1: parent_arr, parent_annotations_dataset = get_level_from_server( {"level_id": parent_level}, retrieval_mode="volume" ) parent_arr = parent_arr & 15 # print(f"Using parent dataset for masking {parent_annotations_dataset}") parent_mask = parent_arr == parent_label_idx else: # print("Not masking using parent level") parent_arr = None parent_mask = None logger.debug(f"BB in annotate_regions {bb}") anno = annotate_regions( ds, region, r=r, label=label, parent_mask=parent_mask, bb=bb, viewer_order=viewer_order, ) def pass_through(x): return x dst = DataModel.g.dataset_uri(level, group="annotations") map_blocks(pass_through, anno, out=dst, normalize=False) modified_ds = dataset_from_uri(dst, mode="r") modified = [1] modified_ds.set_attr("modified", modified)
def laplacian(src: DataURI, dst: DataURI, kernel_size: FloatOrVector = 1) -> "EDGES": from ..server.filtering import ndimage_laplacian map_blocks( ndimage_laplacian, src, out=dst, kernel_size=kernel_size, pad=max(4, int(max(kernel_size)) * 3), normalize=False, )
def total_variation(src: DataURI, dst: DataURI, lamda: Float = 10, max_iter: Int = 100) -> 'Denoising': """ API wrapper around `survos2.improc.features.tv.tvdenoising3d`. """ from ..improc.features.tv import tvdenoising3d map_blocks(tvdenoising3d, src, out=dst, lamda=lamda, max_iter=max_iter, normalize=True)
def median(src: DataURI, dst: DataURI, median_size: Int = 1, num_iter: Int = 1) -> "DENOISING": from ..server.filtering import median map_blocks( median, src, median_size=median_size, num_iter=num_iter, out=dst, pad=max(4, int((median_size * 2))), normalize=False, )
def gaussian_blur(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1) -> "DENOISING": from ..server.filtering import gaussian_blur_kornia if isinstance(sigma, numbers.Number): sigma = (sigma, sigma, sigma) map_blocks( gaussian_blur_kornia, src, out=dst, sigma=sigma, pad=max(4, int(max(sigma))), normalize=False, )
def difference_of_gaussians(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1, sigma_ratio: Float = 2) -> "EDGES": from ..server.filtering.edge import compute_difference_gaussians map_blocks( compute_difference_gaussians, src, out=dst, sigma=sigma, sigma_ratio=sigma_ratio, pad=max(4, int((max(sigma) * 3))), normalize=False, )
def predict_2d_unet( src: DataURI, dst: DataURI, workspace: String, anno_id: DataURI, feature_id: DataURI, model_path: str, no_of_planes: int ): logger.debug( f"Predict_2d_unet with feature {feature_id} in {no_of_planes} planes" ) src = DataModel.g.dataset_uri(anno_id, group="annotations") with DatasetManager(src, out=None, dtype="uint16", fillvalue=0) as DM: src_dataset = DM.sources[0] anno_level = src_dataset[:] & 15 logger.debug(f"Obtained annotation level with labels {np.unique(anno_level)}") src = DataModel.g.dataset_uri(feature_id, group="features") logger.debug(f"Getting features {src}") with DatasetManager(src, out=None, dtype="float32", fillvalue=0) as DM: src_dataset = DM.sources[0] logger.debug(f"Adding feature of shape {src_dataset.shape}") feature = src_dataset[:] logger.info( f"Predict_2d_unet with feature shape {feature.shape} using model {model_path}" ) from survos2.server.unet2d.unet2d import Unet2dPredictor from survos2.server.unet2d.data_utils import PredictionHDF5DataSlicer ws_object = ws.get(workspace) root_path = Path(ws_object.path, "unet2d") root_path.mkdir(exist_ok=True, parents=True) predictor = Unet2dPredictor(root_path) predictor.create_model_from_zip(Path(model_path)) now = datetime.now() dt_string = now.strftime("%d%m%Y_%H_%M_%S") slicer = PredictionHDF5DataSlicer(predictor, feature, clip_data=True) if no_of_planes == 1: segmentation = slicer.predict_1_way(root_path, output_prefix=dt_string) elif no_of_planes == 3: segmentation = slicer.predict_3_ways(root_path, output_prefix=dt_string) segmentation += np.ones_like(segmentation) def pass_through(x): return x map_blocks(pass_through, segmentation, out=dst, normalize=False)
def generate_supervoxels( dataset_feats: List[np.ndarray], filtered_stack: np.ndarray, dataset_feats_idx: int, slic_params: dict, ): """Generate a supervoxel volume image Arguments: dataset_feats {list of filtered volumes} -- list of filters of original input image volume filtered_stack {volume that is a stack of dataset_feats} -- reshaped version of dataset feats for rmeans dataset_feats_idx {int} -- index of the filter to use for supervoxel calculation slic_params {dict} -- Supervoxel generation parameters Returns: dataclass with all the information required for prediction """ from cuda_slic import slic logger.debug(f"Using feature idx {dataset_feats_idx} for supervoxels.") logger.debug( f"SRFeatures for supervoxels have shape {dataset_feats[dataset_feats_idx].shape}" ) logger.debug(f"Generating supervoxels with params: {slic_params}") block_z, block_x, block_y = dataset_feats[0].shape # Make a copy of the dictionary without the 'shape' parameter slic_params_copy = copy.deepcopy(slic_params) slic_params_copy.pop("shape", None) # map_blocks through Dask supervoxel_vol = map_blocks( slic, dataset_feats[dataset_feats_idx].astype(np.float32), **slic_params_copy, timeit=False, ) supervoxel_vol = supervoxel_vol.astype(np.uint32, copy=True) logger.debug( f"Finished slic with supervoxel vol of shape {supervoxel_vol.shape}") supervoxel_vol = supervoxel_vol[...] supervoxel_vol = np.asarray(supervoxel_vol) supervoxel_vol = np.nan_to_num(supervoxel_vol) logger.debug( f"Calling rmeans with filtered_stack { len(filtered_stack)} and supervoxel_vol {supervoxel_vol.shape}" ) supervoxel_features = rmeans(filtered_stack, supervoxel_vol) logger.debug( f"Finished rmeans with supervoxel_features of shape {supervoxel_features.shape}" ) supervoxel_rag = create_rag(np.array(supervoxel_vol), connectivity=6) logger.debug("MaxMin SV Feat: {} {}".format(np.max(supervoxel_vol), np.min(supervoxel_vol))) superregions = SRData(supervoxel_vol, supervoxel_features, supervoxel_rag) return superregions
def tvdenoise( src: DataURI, dst: DataURI, regularization_amount: Float = 0.001, pad: Int = 8, max_iter: Int = 100, ) -> "DENOISING": from ..server.filtering.blur import tvdenoise_kornia map_blocks( tvdenoise_kornia, src, out=dst, regularization_amount=regularization_amount, max_iter=max_iter, pad=pad, normalize=True, )
def supervoxels_chunked( src: DataURIList, dst: DataURI, n_segments: Int = 10, compactness: Float = 20, spacing: FloatList = [1, 1, 1], multichannel: SmartBoolean = False, enforce_connectivity: SmartBoolean = False, out_dtype="int", ): map_blocks( slic, *src, out=dst, n_segments=n_segments, spacing=spacing, compactness=compactness, multichannel=False, enforce_connectivity=True, stack=False, timeit=True, uses_gpu=False, out_dtype=out_dtype, relabel=True, ) with DatasetManager(dst, out=None, dtype=out_dtype, fillvalue=0) as DM: dst_dataset = DM.sources[0] supervoxel_image = dst_dataset[:] print(supervoxel_image.dtype) num_sv = len(np.unique(supervoxel_image)) print(f"Number of supervoxels created: {num_sv}") dst_dataset.set_attr("num_supervoxels", num_sv)
def gaussian_center(src: DataURI, dst: DataURI, sigma: FloatOrVector = 1): """ API wrapper around `survos2.improc.features.gauss.gaussian_center`. """ from ..improc.features.gauss import gaussian_center map_blocks(gaussian_center, src, out=dst, sigma=sigma, normalize=True)