def test_to_ndarray(self): a = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) # not within ROI of a and no fill value provided with self.assertRaises(AssertionError): a.to_ndarray(daisy.Roi((0, 0), (5, 5))) b = a.to_ndarray(daisy.Roi((0, 0), (1, 5))) compare = np.array([[0, 1, 2, 3, 4]]) b = a.to_ndarray(daisy.Roi((1, 0), (1, 5))) compare = np.array([[5, 6, 7, 8, 9]]) b = a.to_ndarray(daisy.Roi((0, 0), (2, 2))) compare = np.array([[0, 1], [5, 6]]) np.testing.assert_array_equal(b, compare) b = a.to_ndarray(daisy.Roi((0, 0), (5, 5)), fill_value=1) compare = np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]) np.testing.assert_array_equal(b, compare)
def test_intersect(self): a = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) b = a.intersect(daisy.Roi((1, 1), (10, 10))) assert b.roi == daisy.Roi((1, 1), (1, 4)) np.testing.assert_array_equal(b.to_ndarray(), [[6, 7, 8, 9]])
def __getitem__(self, roi: Roi) -> np.ndarray: snapped_roi = roi.snap_to_grid(self._source_array.voxel_size, mode="grow") resampled_array = daisy.Array( rescale( self._source_array[snapped_roi].astype(np.float32), self.scale, order=self.interp_order, anti_aliasing=self.interp_order != 0, ).astype(self.dtype), roi=snapped_roi, voxel_size=self.voxel_size, ) return resampled_array.to_ndarray(roi)
def visualize_npy(npy_file: Path, voxel_size): voxel_size = daisy.Coordinate(voxel_size) viewer = neuroglancer.Viewer() with viewer.txn() as s: v = np.load(npy_file) m = daisy.Array( v, daisy.Roi(daisy.Coordinate([0, 0, 0]), daisy.Coordinate(v.shape)), daisy.Coordinate([1, 1, 1]), ) add_layer(s, m, f"npy array") print(viewer) input("Hit ENTER to quit!")
def test_materialize(self): a = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) b = a[daisy.Roi((0, 0), (2, 2))] # underlying data did not change assert a.data.shape == b.data.shape assert b.shape == (2, 2) b.materialize() assert b.shape == (2, 2) assert b.data.shape == (2, 2)
def smooth(block, dataset, output, sigma=5): logger.debug("Block: %s" % block) # read data in block.read_roi daisy_array = dataset[block.read_roi] data = daisy_array.to_ndarray() logger.debug("Got data of shape %s" % str(data.shape)) # apply gaussian filter r = scipy.ndimage.gaussian_filter( data, sigma=sigma, mode='constant') # write result to output dataset in block.write_roi to_write = daisy.Array( data=r, roi=block.read_roi, voxel_size=dataset.voxel_size) output[block.write_roi] = to_write[block.write_roi] logger.debug("Done") return 0
def get_mask_data_in_roi(mask, roi, target_voxel_size): assert mask.voxel_size.is_multiple_of(target_voxel_size), ( "Can not upsample from %s to %s" % (mask.voxel_size, target_voxel_size)) aligned_roi = roi.snap_to_grid(mask.voxel_size, mode='grow') aligned_data = mask.to_ndarray(aligned_roi, fill_value=0) if mask.voxel_size == target_voxel_size: return aligned_data factor = mask.voxel_size/target_voxel_size upsampled_aligned_data = upsample(aligned_data, factor) upsampled_aligned_mask = daisy.Array( upsampled_aligned_data, roi=aligned_roi, voxel_size=target_voxel_size) return upsampled_aligned_mask.to_ndarray(roi)
def test_getitem(self): a = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) assert a[daisy.Coordinate((0, 0))] == 0 assert a[daisy.Coordinate((0, 1))] == 1 assert a[daisy.Coordinate((0, 2))] == 2 assert a[daisy.Coordinate((1, 0))] == 5 assert a[daisy.Coordinate((1, 1))] == 6 with self.assertRaises(AssertionError): a[daisy.Coordinate((1, 5))] with self.assertRaises(AssertionError): a[daisy.Coordinate((2, 5))] with self.assertRaises(AssertionError): a[daisy.Coordinate((-1, 0))] with self.assertRaises(AssertionError): a[daisy.Coordinate((0, -1))] b = a[daisy.Roi((1, 1), (1, 4))] with self.assertRaises(AssertionError): b[daisy.Coordinate((0, 0))] == 0 with self.assertRaises(AssertionError): b[daisy.Coordinate((0, 1))] == 1 with self.assertRaises(AssertionError): b[daisy.Coordinate((0, 2))] == 2 with self.assertRaises(AssertionError): b[daisy.Coordinate((1, 0))] == 5 assert b[daisy.Coordinate((1, 1))] == 6 assert b[daisy.Coordinate((1, 2))] == 7 assert b[daisy.Coordinate((1, 3))] == 8 assert b[daisy.Coordinate((1, 4))] == 9 with self.assertRaises(AssertionError): b[daisy.Coordinate((1, 5))] with self.assertRaises(AssertionError): b[daisy.Coordinate((2, 5))] with self.assertRaises(AssertionError): b[daisy.Coordinate((-1, 0))] with self.assertRaises(AssertionError): b[daisy.Coordinate((0, -1))]
def test_shape(self): # ROI fits data a1 = daisy.Array(np.zeros((10, )), daisy.Roi((0, ), (10, )), (1, )) a2 = daisy.Array(np.zeros((10, 10)), daisy.Roi((0, 0), (10, 10)), (1, 1)) a2_3 = daisy.Array(np.zeros((3, 10, 10)), daisy.Roi((0, 0), (10, 10)), (1, 1)) a5_3_2_1 = daisy.Array( np.zeros((1, 2, 3, 4, 4, 4, 4, 4)), daisy.Roi((0, 0, 0, 0, 0), (80, 80, 80, 80, 80)), (20, 20, 20, 20, 20)) assert a1.shape == (10, ) assert a2.shape == (10, 10) assert a2_3.shape == (3, 10, 10) assert a2_3.roi.dims() == 2 assert a5_3_2_1.shape == (1, 2, 3, 4, 4, 4, 4, 4) # ROI subset of data a1 = daisy.Array(np.zeros((20, )), daisy.Roi((0, ), (10, )), (1, )) a2 = daisy.Array(np.zeros((20, 20)), daisy.Roi((0, 0), (10, 10)), (1, 1)) a2_3 = daisy.Array(np.zeros((3, 20, 20)), daisy.Roi((0, 0), (10, 10)), (1, 1)) a5_3_2_1 = daisy.Array( np.zeros((1, 2, 3, 5, 5, 5, 5, 5)), daisy.Roi((0, 0, 0, 0, 0), (80, 80, 80, 80, 80)), (20, 20, 20, 20, 20)) assert a1.shape == (10, ) assert a2.shape == (10, 10) assert a2_3.shape == (3, 10, 10) assert a2_3.roi.dims() == 2 assert a5_3_2_1.shape == (1, 2, 3, 4, 4, 4, 4, 4)
def open_daisy(self): """ Open this dataset as a daisy array. """ data = daisy.open_ds(self.container, self.dataset) # Correct for datasets where the container does not have the voxel size if data.voxel_size != tuple(self.voxel_size): log.warn( "Container has different voxel size than dataset: "\ f"{data.voxel_size} != {self.voxel_size}") orig_shape = data.roi.get_shape() data = daisy.Array(data.data, daisy.Roi( data.roi.get_offset(), self.voxel_size * data.data.shape[-len(self.voxel_size):]), self.voxel_size, chunk_shape=data.chunk_shape) log.warn( "Reloaded container data with dataset voxel size, changing shape: "\ f"{orig_shape} => {data.roi.get_shape()}") return data
def test_minimal(self): labels = np.array([[[1, 1, 1, 2, 2, 3, 2, 2, 1, 140, 140, 0]]], dtype=np.uint64) roi = daisy.Roi((0, 0, 0), labels.shape) voxel_size = (1, 1, 1) block_size = (1, 1, 2) with tempfile.TemporaryDirectory() as tmpdir: a = daisy.Array(labels, roi=roi, voxel_size=voxel_size) b = daisy.prepare_ds(os.path.join(tmpdir, 'array_out.zarr'), '/volumes/b', total_roi=roi, voxel_size=voxel_size, write_size=block_size, dtype=np.uint64) b.data[:] = 0 segment.arrays.relabel_connected_components(a, b, block_size, 1) b = b.data[:].flatten() self.assertTrue(b[0] == b[1] == b[2]) self.assertTrue(b[3] == b[4]) self.assertTrue(b[6] == b[7]) self.assertTrue(b[9] == b[10]) self.assertTrue(b[2] != b[3]) self.assertTrue(b[4] != b[5]) self.assertTrue(b[5] != b[6]) self.assertTrue(b[7] != b[8]) self.assertTrue(b[8] != b[9]) self.assertTrue(b[10] != b[11])
labels_add = daisy.open_ds(filename, "volumes/labels_add") print(labels_add.roi) raw_fused = daisy.open_ds(filename, "volumes/raw_fused") print(raw_fused.roi) labels_fused = daisy.open_ds(filename, "volumes/labels_fused") print(labels_fused.roi) all_data = daisy.Array( data=np.array([ x.to_ndarray()[0, :, :, :] if len(x.data.shape) == 4 else x.to_ndarray() for x in [ raw_base, labels_base, raw_add, labels_add, raw_fused, labels_fused, ] ]), roi=daisy.Roi((0, ) + raw_base.roi.get_begin(), (6, ) + raw_base.roi.get_shape()), voxel_size=(1, ) + raw_base.voxel_size, ) inspect(all_data, all_data.roi) input()
def test_setitem(self): # set entirely with numpy array a = daisy.Array(np.zeros((2, 5)), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (2, 5))] = np.arange(0, 10).reshape(2, 5) assert a[daisy.Coordinate((0, 0))] == 0 assert a[daisy.Coordinate((0, 1))] == 1 assert a[daisy.Coordinate((0, 2))] == 2 assert a[daisy.Coordinate((1, 0))] == 5 assert a[daisy.Coordinate((1, 1))] == 6 assert a[daisy.Coordinate((1, 4))] == 9 # set entirely with numpy array and channels a = daisy.Array(np.zeros((3, 2, 5)), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (2, 5))] = np.arange(0, 3 * 10).reshape(3, 2, 5) np.testing.assert_array_equal(a[daisy.Coordinate((0, 0))], [0, 10, 20]) np.testing.assert_array_equal(a[daisy.Coordinate((0, 1))], [1, 11, 21]) np.testing.assert_array_equal(a[daisy.Coordinate((1, 4))], [9, 19, 29]) # set entirely with scalar a = daisy.Array(np.zeros((2, 5)), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (2, 5))] = 42 assert a[daisy.Coordinate((0, 0))] == 42 assert a[daisy.Coordinate((1, 4))] == 42 # set partially with scalar and channels a = daisy.Array( np.arange(0, 3 * 10).reshape(3, 2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (2, 2))] = 42 np.testing.assert_array_equal(a[daisy.Coordinate((0, 0))], [42, 42, 42]) np.testing.assert_array_equal(a[daisy.Coordinate((0, 1))], [42, 42, 42]) np.testing.assert_array_equal(a[daisy.Coordinate((0, 2))], [2, 12, 22]) np.testing.assert_array_equal(a[daisy.Coordinate((1, 2))], [7, 17, 27]) np.testing.assert_array_equal(a[daisy.Coordinate((1, 3))], [8, 18, 28]) np.testing.assert_array_equal(a[daisy.Coordinate((1, 4))], [9, 19, 29]) # set partially with Array a = daisy.Array(np.zeros((2, 5)), daisy.Roi((0, 0), (2, 5)), (1, 1)) b = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (1, 5))] = b[daisy.Roi((0, 0), (1, 5))] assert a[daisy.Coordinate((0, 0))] == 0 assert a[daisy.Coordinate((0, 1))] == 1 assert a[daisy.Coordinate((0, 2))] == 2 assert a[daisy.Coordinate((1, 0))] == 0 assert a[daisy.Coordinate((1, 1))] == 0 assert a[daisy.Coordinate((1, 4))] == 0 a = daisy.Array(np.zeros((2, 5)), daisy.Roi((0, 0), (2, 5)), (1, 1)) b = daisy.Array( np.arange(0, 10).reshape(2, 5), daisy.Roi((0, 0), (2, 5)), (1, 1)) a[daisy.Roi((0, 0), (1, 5))] = b[daisy.Roi((1, 0), (1, 5))] assert a[daisy.Coordinate((0, 0))] == 5 assert a[daisy.Coordinate((0, 1))] == 6 assert a[daisy.Coordinate((0, 4))] == 9 assert a[daisy.Coordinate((1, 0))] == 0 assert a[daisy.Coordinate((1, 1))] == 0 assert a[daisy.Coordinate((1, 2))] == 0 a[daisy.Roi((1, 0), (1, 5))] = b[daisy.Roi((0, 0), (1, 5))] assert a[daisy.Coordinate((0, 0))] == 5 assert a[daisy.Coordinate((0, 1))] == 6 assert a[daisy.Coordinate((0, 4))] == 9 assert a[daisy.Coordinate((1, 0))] == 0 assert a[daisy.Coordinate((1, 1))] == 1 assert a[daisy.Coordinate((1, 2))] == 2
def visualize_hdf5(hdf5_file: Path, voxel_size, mst=False, maxima_for=None, skip=None): path_list = str(hdf5_file.absolute()).split("/") setups_dir = Path("/", *path_list[:-3]) setup_config = DEFAULT_CONFIG try: setup_config.update( json.load((setups_dir / path_list[-3] / "config.json").open())) except: pass voxel_size = daisy.Coordinate(setup_config["VOXEL_SIZE"]) coordinate_scale = (setup_config["COORDINATE_SCALE"] * np.array(voxel_size) / max(voxel_size)) dataset = h5py.File(hdf5_file) volumes = list(dataset.get("volumes", {}).keys()) points = list(dataset.get("points", {}).keys()) points = set([p.split("-")[0] for p in points]) node_id = itertools.count(start=1) viewer = neuroglancer.Viewer() with viewer.txn() as s: for volume in volumes: if skip == volume: continue v = daisy.open_ds(str(hdf5_file.absolute()), f"volumes/{volume}") if len(v.shape) == 5: v.n_channel_dims -= 1 v.materialize() v.data = v.data[0] if v.dtype == np.int64: v.materialize() v.data = v.data.astype(np.uint64) if volume == maxima_for: v.materialize() max_filtered = maximum_filter(v.data, (3, 10, 10)) maxima = np.logical_and(max_filtered == v.data, v.data > 0.01) m = daisy.Array(maxima, v.roi, v.voxel_size) add_layer(s, m, f"{volume}-maxima") if volume == "embedding": offset = v.roi.get_offset() mst = get_embedding_mst( v.data, 1, coordinate_scale, offset / voxel_size, daisy.open_ds(str(hdf5_file.absolute()), f"volumes/fg_maxima").to_ndarray(), ) add_trees(s, mst, node_id, name="MST", visible=True) v.materialize() v.data = (v.data + 1) / 2 add_layer(s, v, volume, visible=False) for point_set in points: node_ids = dataset["points"][f"{point_set}-ids"] locations = dataset["points"][f"{point_set}-locations"] edges = dataset["points"][f"{point_set}-edges"] components = build_trees(node_ids, locations, edges, voxel_size) add_trees(s, components, node_id, name=point_set, visible=False) if mst and False: emst = h5py.File(hdf5_file)["emst"] edges_u = h5py.File(hdf5_file)["edges_u"] edges_v = h5py.File(hdf5_file)["edges_v"] alpha = setup_config["ALPHA"] coordinate_scale = setup_config["COORDINATE_SCALE"] offset = daisy.open_ds(str(hdf5_file.absolute()), f"volumes/gt_fg").roi.get_offset() mst_trees = build_trees_from_mst(emst, edges_u, edges_v, alpha, coordinate_scale, offset, voxel_size) add_trees(s, mst_trees, node_id, name="MST", visible=True) print(viewer) input("Hit ENTER to quit!")
def watershed_in_block( affs, block, context, rag_provider, fragments_out, num_voxels_in_block, mask=None, fragments_in_xy=False, epsilon_agglomerate=0.0, filter_fragments=0.0, min_seed_distance=10, replace_sections=None): ''' Args: filter_fragments (float): Filter fragments that have an average affinity lower than this value. min_seed_distance (int): Controls distance between seeds in the initial watershed. Reducing this value improves downsampled segmentation. ''' total_roi = affs.roi logger.debug("reading affs from %s", block.read_roi) affs = affs.intersect(block.read_roi) affs.materialize() if affs.dtype == np.uint8: logger.info("Assuming affinities are in [0,255]") max_affinity_value = 255.0 affs.data = affs.data.astype(np.float32) else: max_affinity_value = 1.0 if mask is not None: logger.debug("reading mask from %s", block.read_roi) mask_data = get_mask_data_in_roi(mask, affs.roi, affs.voxel_size) logger.debug("masking affinities") affs.data *= mask_data # extract fragments fragments_data, _ = watershed_from_affinities( affs.data, max_affinity_value, fragments_in_xy=fragments_in_xy, min_seed_distance=min_seed_distance) if mask is not None: fragments_data *= mask_data.astype(np.uint64) if filter_fragments > 0: if fragments_in_xy: average_affs = np.mean(affs.data[0:2]/max_affinity_value, axis=0) else: average_affs = np.mean(affs.data/max_affinity_value, axis=0) filtered_fragments = [] fragment_ids = np.unique(fragments_data) for fragment, mean in zip( fragment_ids, measurements.mean( average_affs, fragments_data, fragment_ids)): if mean < filter_fragments: filtered_fragments.append(fragment) filtered_fragments = np.array( filtered_fragments, dtype=fragments_data.dtype) replace = np.zeros_like(filtered_fragments) replace_values(fragments_data, filtered_fragments, replace, inplace=True) if epsilon_agglomerate > 0: logger.info( "Performing initial fragment agglomeration until %f", epsilon_agglomerate) generator = waterz.agglomerate( affs=affs.data/max_affinity_value, thresholds=[epsilon_agglomerate], fragments=fragments_data, scoring_function='OneMinus<HistogramQuantileAffinity<RegionGraphType, 25, ScoreValue, 256, false>>', discretize_queue=256, return_merge_history=False, return_region_graph=False) fragments_data[:] = next(generator) # cleanup generator for _ in generator: pass if replace_sections: logger.info("Replacing sections...") block_begin = block.write_roi.get_begin() shape = block.write_roi.get_shape() z_context = context[0]/affs.voxel_size[0] logger.info("Z context: %i",z_context) mapping = {} voxel_offset = block_begin[0]/affs.voxel_size[0] for i,j in zip( range(fragments_data.shape[0]), range(shape[0])): mapping[i] = i mapping[j] = int(voxel_offset + i) \ if block_begin[0] == total_roi.get_begin()[0] \ else int(voxel_offset + (i - z_context)) logging.info('Mapping: %s', mapping) replace = [k for k,v in mapping.items() if v in replace_sections] for r in replace: logger.info("Replacing mapped section %i with zero", r) fragments_data[r] = 0 #todo add key value replacement option fragments = daisy.Array(fragments_data, affs.roi, affs.voxel_size) # crop fragments to write_roi fragments = fragments[block.write_roi] fragments.materialize() max_id = fragments.data.max() # ensure we don't have IDs larger than the number of voxels (that would # break uniqueness of IDs below) if max_id > num_voxels_in_block: logger.warning( "fragments in %s have max ID %d, relabelling...", block.write_roi, max_id) fragments.data, max_id = relabel(fragments.data) assert max_id < num_voxels_in_block # ensure unique IDs id_bump = block.block_id[1]*num_voxels_in_block logger.debug("bumping fragment IDs by %i", id_bump) fragments.data[fragments.data>0] += id_bump fragment_ids = range(id_bump + 1, id_bump + 1 + int(max_id)) # store fragments logger.debug("writing fragments to %s", block.write_roi) fragments_out[block.write_roi] = fragments # following only makes a difference if fragments were found if max_id == 0: return # get fragment centers fragment_centers = { fragment: block.write_roi.get_offset() + affs.voxel_size*daisy.Coordinate(center) for fragment, center in zip( fragment_ids, measurements.center_of_mass(fragments.data, fragments.data, fragment_ids)) if not np.isnan(center[0]) } # store nodes rag = rag_provider[block.write_roi] rag.add_nodes_from([ (node, { 'center_z': c[0], 'center_y': c[1], 'center_x': c[2] } ) for node, c in fragment_centers.items() ]) rag.write_nodes(block.write_roi)
def inspect(raw, roi): print("Reading raw data...") raw_data = raw.to_ndarray(roi=roi, fill_value=0) return spimagine.volshow(raw_data, stackUnits=raw.voxel_size[1:][::-1]) if __name__ == "__main__": filename = sys.argv[1] ch1 = daisy.open_ds(filename, 'volumes/ch1') a_ch1 = daisy.open_ds(filename, 'volumes/a_ch1') b_ch1 = daisy.open_ds(filename, 'volumes/b_ch1') soft_mask = daisy.open_ds(filename, 'volumes/soft_mask') fused = daisy.Array(data=np.array( [x.to_ndarray() for x in [ch1, a_ch1, b_ch1, soft_mask]]), roi=daisy.Roi((0, ) + ch1.roi.get_begin(), (4, ) + ch1.roi.get_shape()), voxel_size=(1, ) + ch1.voxel_size) inspect(fused, fused.roi) input()
def test_dtype(self): for dtype in [np.float32, np.uint8, np.uint64]: assert daisy.Array(np.zeros((1, ), dtype=dtype), daisy.Roi((0, ), (1, )), (1, )).dtype == dtype
def watershed_in_block(affs, block, rag_provider, fragments_out, fragments_in_xy, epsilon_agglomerate, mask): total_roi = affs.roi logger.debug("reading affs from %s", block.read_roi) affs = affs.intersect(block.read_roi) affs.materialize() if mask is not None: logger.debug("reading mask from %s", block.read_roi) mask_data = get_mask_data_in_roi(mask, affs.roi, affs.voxel_size) logger.debug("masking affinities") affs.data *= mask_data # extract fragments fragments_data, n = watershed_from_affinities( affs.data, fragments_in_xy=fragments_in_xy, epsilon_agglomerate=epsilon_agglomerate) if mask is not None: fragments_data *= mask_data.astype(np.uint64) fragments = daisy.Array(fragments_data, affs.roi, affs.voxel_size) # crop fragments to write_roi fragments = fragments[block.write_roi] fragments.materialize() # ensure we don't have IDs larger than the number of voxels (that would # break uniqueness of IDs below) max_id = fragments.data.max() if max_id > block.write_roi.size(): logger.warning("fragments in %s have max ID %d, relabelling...", block.write_roi, max_id) fragments.data, n = relabel(fragments.data) # ensure unique IDs size_of_voxel = daisy.Roi((0, ) * affs.roi.dims(), affs.voxel_size).size() num_voxels_in_block = block.requested_write_roi.size() // size_of_voxel id_bump = block.block_id * num_voxels_in_block logger.debug("bumping fragment IDs by %i", id_bump) fragments.data[fragments.data > 0] += id_bump fragment_ids = range(id_bump + 1, id_bump + 1 + n) # store fragments logger.debug("writing fragments to %s", block.write_roi) fragments_out[block.write_roi] = fragments # following only makes a difference if fragments were found if n == 0: return # get fragment centers fragment_centers = { fragment: block.write_roi.get_offset() + affs.voxel_size * center for fragment, center in zip( fragment_ids, center_of_mass(fragments.data, fragments.data, fragment_ids)) if not np.isnan(center[0]) } # store nodes rag = rag_provider[block.write_roi] rag.add_nodes_from([(node, { 'center_z': c[0], 'center_y': c[1], 'center_x': c[2] }) for node, c in fragment_centers.items()]) rag.write_nodes(block.write_roi)
def test_constructor(self): data = np.zeros((10, 10, 10), dtype=np.float32) roi = daisy.Roi((0, 0, 0), (10, 10, 10)) # consistent configurations daisy.Array(data, roi, (1, 1, 1)) daisy.Array(data, roi, (1, 1, 2)) daisy.Array(data, roi, (1, 5, 2)) daisy.Array(data, roi, (10, 5, 2)) roi = daisy.Roi((1, 1, 1), (10, 10, 10)) daisy.Array(data, roi, (1, 1, 1), data_offset=(1, 1, 1)) roi = daisy.Roi((0, 0, 0), (20, 20, 20)) daisy.Array(data, roi, (2, 2, 2)) # dims don't match with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1)) # ROI not multiple of voxel size with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1, 3)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1, 4)) # ROI begin doesn't align with voxel size roi = daisy.Roi((1, 1, 1), (11, 11, 11)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1, 2)) # ROI shape doesn't align with voxel size roi = daisy.Roi((0, 0, 0), (11, 11, 11)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1, 2)) # ROI outside of provided data roi = daisy.Roi((0, 0, 0), (20, 20, 20)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (1, 1, 1)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (2, 2, 1)) with self.assertRaises(AssertionError): daisy.Array(data, roi, (2, 2, 2), data_offset=(0, 0, 2))
def __setitem__(self, roi: Roi, value: np.ndarray[Any, Any]): daisy.Array(self.data, self.roi, self.voxel_size)[roi] = value
def __getitem__(self, roi: Roi) -> np.ndarray[Any, Any]: data: np.ndarray[Any, Any] = daisy.Array( self.data, self.roi, self.voxel_size).to_ndarray(roi=roi) return data
def segment_in_block(array_in, array_out, num_voxels_in_block, block, tmpdir, segment_function): logger.debug("Segmenting in block %s", block) segmentation = segment_function(array_in, block.read_roi) print("========= block %d ====== " % block.block_id) print(segmentation) assert segmentation.dtype == np.uint64 id_bump = block.block_id * num_voxels_in_block segmentation += id_bump segmentation[segmentation == id_bump] = 0 logger.debug("Bumping segmentation IDs by %d", id_bump) # wrap segmentation into daisy array segmentation = daisy.Array(segmentation, roi=block.read_roi, voxel_size=array_in.voxel_size) # store segmentation in out array array_out[block.write_roi] = segmentation[block.write_roi] neighbor_roi = block.write_roi.grow(array_in.voxel_size, array_in.voxel_size) # clip segmentation to 1-voxel context segmentation = segmentation.to_ndarray(roi=neighbor_roi, fill_value=0) neighbors = array_out.to_ndarray(roi=neighbor_roi, fill_value=0) unique_pairs = [] for d in range(3): slices_neg = tuple( slice(None) if dd != d else slice(0, 1) for dd in range(3)) slices_pos = tuple( slice(None) if dd != d else slice(-1, None) for dd in range(3)) pairs_neg = np.array([ segmentation[slices_neg].flatten(), neighbors[slices_neg].flatten() ]) pairs_neg = pairs_neg.transpose() pairs_pos = np.array([ segmentation[slices_pos].flatten(), neighbors[slices_pos].flatten() ]) pairs_pos = pairs_pos.transpose() unique_pairs.append( np.unique(np.concatenate([pairs_neg, pairs_pos]), axis=0)) unique_pairs = np.concatenate(unique_pairs) zero_u = unique_pairs[:, 0] == 0 zero_v = unique_pairs[:, 1] == 0 non_zero_filter = np.logical_not(np.logical_or(zero_u, zero_v)) logger.debug("Matching pairs with neighbors: %s", unique_pairs) edges = unique_pairs[non_zero_filter] nodes = np.unique(edges) logger.debug("Final edges: %s", edges) logger.debug("Final nodes: %s", nodes) np.savez_compressed(os.path.join(tmpdir, 'block_%d.npz' % block.block_id), nodes=nodes, edges=edges)