def test_2d_bf(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_bf = random_walker(data, labels, beta=90, mode="bf") assert (labels_bf[25:45, 40:60] == 2).all() full_prob_bf = random_walker(data, labels, beta=90, mode="bf", return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() return data, labels_bf, full_prob_bf
def test_length2_spacing(): # If this passes without raising an exception (warnings OK), the new # spacing code is working properly. np.random.seed(42) img = np.ones((10, 10)) + 0.2 * np.random.normal(size=(10, 10)) labels = np.zeros((10, 10), dtype=np.uint8) labels[2, 4] = 1 labels[6, 8] = 4 random_walker(img, labels, spacing=(1., 2.))
def test_2d_cg_mg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_cg_mg = random_walker(data, labels, beta=90, mode="cg_mg") assert (labels_cg_mg[25:45, 40:60] == 2).all() full_prob = random_walker(data, labels, beta=90, mode="cg_mg", return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() return data, labels_cg_mg
def test_multispectral_2d(): lx, ly = 70, 100 data, labels = make_2d_syntheticdata(lx, ly) data2 = data.copy() data.shape += (1,) data = data.repeat(2, axis=2) # Result should be identical multi_labels = random_walker(data, labels, mode='cg', multichannel=True) single_labels = random_walker(data2, labels, mode='cg') assert (multi_labels.reshape(labels.shape)[25:45, 40:60] == 2).all() return data, multi_labels, single_labels, labels
def test_multispectral_2d(): lx, ly = 70, 100 data, labels = make_2d_syntheticdata(lx, ly) data = data[..., np.newaxis].repeat(2, axis=-1) # Expect identical output multi_labels = random_walker(data, labels, mode='cg', multichannel=True) assert data[..., 0].shape == labels.shape single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[25:45, 40:60] == 2).all() assert data[..., 0].shape == labels.shape return data, multi_labels, single_labels, labels
def test_multispectral_3d(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) data.shape += (1,) data = data.repeat(2, axis=3) # Result should be identical multi_labels = random_walker(data, labels, mode='cg', multichannel=True) single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() assert (single_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() return data, multi_labels, single_labels, labels
def test_multispectral_3d(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) data = data[..., np.newaxis].repeat(2, axis=-1) # Expect identical output multi_labels = random_walker(data, labels, mode='cg', multichannel=True) assert data[..., 0].shape == labels.shape single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() assert (single_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() assert data[..., 0].shape == labels.shape return data, multi_labels, single_labels, labels
def test_spacing_1(): n = 30 lx, ly, lz = n, n, n data, _ = make_3d_syntheticdata(lx, ly, lz) # Rescale `data` along Y axis # `resize` is not yet 3D capable, so this must be done by looping in 2D. data_aniso = np.zeros((n, n * 2, n)) for i, yz in enumerate(data): data_aniso[i, :, :] = resize(yz, (n * 2, n), mode='constant', anti_aliasing=False) # Generate new labels small_l = int(lx // 5) labels_aniso = np.zeros_like(data_aniso) labels_aniso[lx // 5, ly // 5, lz // 5] = 1 labels_aniso[lx // 2 + small_l // 4, ly - small_l // 2, lz // 2 - small_l // 4] = 2 # Test with `spacing` kwarg # First, anisotropic along Y with expected_warnings(['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): labels_aniso = random_walker(data_aniso, labels_aniso, mode='cg', spacing=(1., 2., 1.)) assert (labels_aniso[13:17, 26:34, 13:17] == 2).all() # Rescale `data` along X axis # `resize` is not yet 3D capable, so this must be done by looping in 2D. data_aniso = np.zeros((n, n * 2, n)) for i in range(data.shape[1]): data_aniso[i, :, :] = resize(data[:, 1, :], (n * 2, n), mode='constant', anti_aliasing=False) # Generate new labels small_l = int(lx // 5) labels_aniso2 = np.zeros_like(data_aniso) labels_aniso2[lx // 5, ly // 5, lz // 5] = 1 labels_aniso2[lx - small_l // 2, ly // 2 + small_l // 4, lz // 2 - small_l // 4] = 2 # Anisotropic along X with expected_warnings(['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): labels_aniso2 = random_walker(data_aniso, labels_aniso2, mode='cg', spacing=(2., 1., 1.)) assert (labels_aniso2[26:34, 13:17, 13:17] == 2).all()
def test_2d_cg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_cg = random_walker(data, labels, beta=90, mode='cg') assert (labels_cg[25:45, 40:60] == 2).all() assert data.shape == labels.shape full_prob = random_walker(data, labels, beta=90, mode='cg', return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() assert data.shape == labels.shape return data, labels_cg
def test_trivial_cases(): # When all voxels are labeled img = np.ones((10, 10)) labels = np.ones((10, 10)) pass_through = random_walker(img, labels) np.testing.assert_array_equal(pass_through, labels) # When all voxels are labeled AND return_full_prob is True labels[:, :5] = 3 expected = np.concatenate(((labels == 1)[..., np.newaxis], (labels == 3)[..., np.newaxis]), axis=2) test = random_walker(img, labels, return_full_prob=True) np.testing.assert_array_equal(test, expected)
def test_2d_cg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) with expected_warnings(['"cg" mode' + '|' + SCIPY_EXPECTED]): labels_cg = random_walker(data, labels, beta=90, mode='cg') assert (labels_cg[25:45, 40:60] == 2).all() assert data.shape == labels.shape with expected_warnings(['"cg" mode' + '|' + SCIPY_EXPECTED]): full_prob = random_walker(data, labels, beta=90, mode='cg', return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() assert data.shape == labels.shape return data, labels_cg
def test_multispectral_2d(): lx, ly = 70, 100 data, labels = make_2d_syntheticdata(lx, ly) data = data[..., np.newaxis].repeat(2, axis=-1) # Expect identical output with expected_warnings(['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): multi_labels = random_walker(data, labels, mode='cg', multichannel=True) assert data[..., 0].shape == labels.shape with expected_warnings(['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[25:45, 40:60] == 2).all() assert data[..., 0].shape == labels.shape return data, multi_labels, single_labels, labels
def cluster_by_diffusion(data): markers = np.zeros(data.shape, dtype=np.uint) markers[data < -0.00] = 1 markers[data > 0.03] = 2 labels2 = random_walker(data, markers, beta=10, mode='bf') return labels2
def start(): # Generate noisy synthetic data data = microstructure(l=128) data += 0.35 * np.random.randn(*data.shape) markers = np.zeros(data.shape, dtype=np.uint) markers[data < -0.3] = 1 markers[data > 1.3] = 2 # Run random walker algorithm labels = random_walker(data, markers, beta=10, mode='bf') # Plot results fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(8, 3.2)) ax1.imshow(data, cmap='gray', interpolation='nearest') ax1.axis('off') ax1.set_title('Noisy data') ax2.imshow(markers, cmap='hot', interpolation='nearest') ax2.axis('off') ax2.set_title('Markers') ax3.imshow(labels, cmap='gray', interpolation='nearest') ax3.axis('off') ax3.set_title('Segmentation') fig.subplots_adjust(hspace=0.01, wspace=0.01, top=1, bottom=0, left=0, right=1) plt.show()
def test_2d_bf(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_bf = random_walker(data, labels, beta=90, mode="bf") assert (labels_bf[25:45, 40:60] == 2).all() assert data.shape == labels.shape full_prob_bf = random_walker(data, labels, beta=90, mode="bf", return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() assert data.shape == labels.shape # Now test with more than two labels labels[55, 80] = 3 full_prob_bf = random_walker(data, labels, beta=90, mode="bf", return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() assert len(full_prob_bf) == 3 assert data.shape == labels.shape
def test_2d_cg_mg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() return data, labels_cg_mg
def segment_out_cells(base): # TODO: try using OTSU for GFP thresholding sel_elem = disk(2) gfp_collector = np.sum(base, axis=0) gfp_clustering_markers = np.zeros(gfp_collector.shape, dtype=np.uint8) # random walker segment gfp_clustering_markers[gfp_collector > np.mean(gfp_collector) * 2] = 2 gfp_clustering_markers[gfp_collector < np.mean(gfp_collector) * 0.20] = 1 labels = random_walker(gfp_collector, gfp_clustering_markers, beta=10, mode='bf') # round up the labels and set the background to 0 from 1 labels = closing(labels, sel_elem) labels -= 1 # prepare distances for the watershed distance = ndi.distance_transform_edt(labels) local_maxi = peak_local_max(distance, indices=False, # we want the image mask, not peak position min_distance=10, # about half of a bud with our size threshold_abs=10, # allows to clear the noise labels=labels) # we fuse the labels that are close together that escaped the min distance in local_maxi local_maxi = ndi.convolve(local_maxi, np.ones((5, 5)), mode='constant', cval=0.0) # finish the watershed expanded_maxi_markers = ndi.label(local_maxi, structure=np.ones((3, 3)))[0] segmented_cells_labels = watershed(-distance, expanded_maxi_markers, mask=labels) # log debugging data running_debug_frame.gfp_collector = gfp_collector running_debug_frame.gfp_clustering_markers = gfp_clustering_markers running_debug_frame.labels = labels running_debug_frame.segmented_cells_labels = segmented_cells_labels return gfp_collector, segmented_cells_labels
def _automatic_localization(self): """ Automatic localization made by Tomas Ryba. """ # seeds = self.get_seeds_using_class_1(class1) liver = self.data3d * (self.segmentation != 0) print('analyzing histogram...') class1 = tools.analyse_histogram(self.data3d, roi=self.segmentation != 0) # sed3.sed3(self.data3d, seeds=class1).show() print('getting seeds...') seeds = self.get_seeds_using_prob_class1( liver, class1, thresholdType='percOfMaxDist', percT=0.3) # sed3.sed3(self.data3d, seeds=seeds).show() print('Starting random walker...') rw = random_walker(liver, seeds, mode='cg_mg') print('...finished.') label_l = self.data['slab']['lesions'] lessions = rw == 2 sed3.sed3(self.data3d, contour=lessions).show() lessions = self.filter_objects(lessions) self.segmentation = np.where(lessions, label_l, self.segmentation)
def test_3d(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) labels = random_walker(data, labels, mode='cg') assert (labels.reshape(data.shape)[13:17, 13:17, 13:17] == 2).all() return data, labels
def test_2d_cg_mg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) expected = 'scipy.sparse.sparsetools|%s' % PYAMG_SCIPY_EXPECTED with expected_warnings([expected]): labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() assert data.shape == labels.shape with expected_warnings([expected]): full_prob = random_walker(data, labels, beta=90, mode='cg_mg', return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() assert data.shape == labels.shape return data, labels_cg_mg
def test_spacing_0(): n = 30 lx, ly, lz = n, n, n data, _ = make_3d_syntheticdata(lx, ly, lz) # Rescale `data` along Z axis data_aniso = np.zeros((n, n, n // 2)) for i, yz in enumerate(data): data_aniso[i, :, :] = resize(yz, (n, n // 2), mode='constant', anti_aliasing=False) # Generate new labels small_l = int(lx // 5) labels_aniso = np.zeros_like(data_aniso) labels_aniso[lx // 5, ly // 5, lz // 5] = 1 labels_aniso[lx // 2 + small_l // 4, ly // 2 - small_l // 4, lz // 4 - small_l // 8] = 2 # Test with `spacing` kwarg with expected_warnings(['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): labels_aniso = random_walker(data_aniso, labels_aniso, mode='cg', spacing=(1., 1., 0.5)) assert (labels_aniso[13:17, 13:17, 7:9] == 2).all()
def test_reorder_labels(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels[labels == 2] = 4 labels_bf = random_walker(data, labels, beta=90, mode='bf') assert (labels_bf[25:45, 40:60] == 2).all() return data, labels_bf
def test_types(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) data = 255 * (data - data.min()) / (data.max() - data.min()) data = data.astype(np.uint8) labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() return data, labels_cg_mg
def test_2d_inactive(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels[10:20, 10:20] = -1 labels[46:50, 33:38] = -2 labels = random_walker(data, labels, beta=90) assert (labels.reshape((lx, ly))[25:45, 40:60] == 2).all() return data, labels
def test_3d(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) with expected_warnings(['"cg" mode' + '|' + SCIPY_EXPECTED]): labels = random_walker(data, labels, mode='cg') assert (labels.reshape(data.shape)[13:17, 13:17, 13:17] == 2).all() assert data.shape == labels.shape return data, labels
def test_isolated_seeds(): np.random.seed(0) a = np.random.random((7, 7)) mask = - np.ones(a.shape) # This pixel is an isolated seed mask[1, 1] = 1 # Unlabeled pixels mask[3:, 3:] = 0 # Seeds connected to unlabeled pixels mask[4, 4] = 2 mask[6, 6] = 1 # Test that no error is raised, and that labels of isolated seeds are OK res = random_walker(a, mask) assert res[1, 1] == 1 res = random_walker(a, mask, return_full_prob=True) assert res[0, 1, 1] == 1 assert res[1, 1, 1] == 0
def test_2d_cg_mg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) anticipated_warnings = [ 'scipy.sparse.sparsetools|%s' % PYAMG_OR_SCIPY_WARNING, NUMPY_MATRIX_WARNING] with expected_warnings(anticipated_warnings): labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() assert data.shape == labels.shape with expected_warnings(anticipated_warnings): full_prob = random_walker(data, labels, beta=90, mode='cg_mg', return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() assert data.shape == labels.shape return data, labels_cg_mg
def test_3d_inactive(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) old_labels = np.copy(labels) labels[5:25, 26:29, 26:29] = -1 after_labels = np.copy(labels) labels = random_walker(data, labels, mode='cg') assert (labels.reshape(data.shape)[13:17, 13:17, 13:17] == 2).all() return data, labels, old_labels, after_labels
def test_reorder_labels(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels[labels == 2] = 4 with expected_warnings([NUMPY_MATRIX_WARNING]): labels_bf = random_walker(data, labels, beta=90, mode='bf') assert (labels_bf[25:45, 40:60] == 2).all() assert data.shape == labels.shape return data, labels_bf
def test_types(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) data = 255 * (data - data.min()) // (data.max() - data.min()) data = data.astype(np.uint8) with expected_warnings([PYAMG_SCIPY_EXPECTED]): labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() assert data.shape == labels.shape return data, labels_cg_mg
def binarize_img(im, thrs1, thrs2, max_iter): start_time = time.time() markers = np.zeros_like(im) markers[im > thrs1] = 1 markers[im < thrs2] = 2 t = random_walker(im, markers, beta=100) global count print("count", count, " of ", max_iter, f" %: {count/max_iter:.2f}", "| time (min): ", (time.time() - start_time) / 60) count += 1 return t < 2
def test_multispectral_3d(dtype): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) data = data.astype(dtype, copy=False) data = data[..., np.newaxis].repeat(2, axis=-1) # Expect identical output with expected_warnings( ['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): multi_labels = random_walker(data, labels, mode='cg', multichannel=True) assert data[..., 0].shape == labels.shape with expected_warnings( ['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() assert (single_labels.reshape(labels.shape)[13:17, 13:17, 13:17] == 2).all() assert data[..., 0].shape == labels.shape return data, multi_labels, single_labels, labels
def test_2d_cg_mg(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) anticipated_warnings = [ 'scipy.sparse.sparsetools|%s' % PYAMG_OR_SCIPY_WARNING, NUMPY_MATRIX_WARNING ] with expected_warnings(anticipated_warnings): labels_cg_mg = random_walker(data, labels, beta=90, mode='cg_mg') assert (labels_cg_mg[25:45, 40:60] == 2).all() assert data.shape == labels.shape with expected_warnings(anticipated_warnings): full_prob = random_walker(data, labels, beta=90, mode='cg_mg', return_full_prob=True) assert (full_prob[1, 25:45, 40:60] >= full_prob[0, 25:45, 40:60]).all() assert data.shape == labels.shape return data, labels_cg_mg
def run(self, ips, snap, img, para=None): msk = np.zeros_like(img) msk[img > para['thr2']] = 1 msk[img < para['thr1']] = 2 msk = random_walker(snap, msk, beta=para['beta'], mode=para['mode'], tol=para['tol']) == 1 ips.lut = self.buflut if para['out'] == 'mask': img[~msk], img[msk] = ips.range else: img[binary_dilation(msk) ^ msk] = ips.range[1]
def RandomWalker(data, marker_mask): data = rescale_intensity(data.astype('float'), in_range=(0,255), out_range=(0,1)) data = rescale_intensity(data, in_range=(-0.35, 1 + 0.35), out_range=(-1, 1)) # The range of the binary image spans over (-1, 1). # We choose the hottest and the coldest pixels as markers. markers = np.zeros(data.shape, dtype=np.uint) markers[data < -0.95] = 1; markers[data > 0.95] = 2 # Run random walker algorithm labels = random_walker(data, markers, beta=10, mode='bf')
def compute_cell_bmap(cell_probs): output = cell_probs output2 = output[::2, ::2] local_maxi = peak_local_max(output2, indices=False, min_distance=5) markers = ndi.label(local_maxi)[0] markers[output2 < 0.01] = -1 segments = random_walker(output2, markers, tol=0.01) segments = resize(segments, output.shape, order=0, preserve_range=True) #segments = watershed(-output, markers) gx = convolve2d(segments, np.array([[1, 0, -1]]), mode='same') gx[0, :] = 0 gx[-1, :] = 0 gx[:, 0] = 0 gx[:, -1] = 0 gy = convolve2d(segments, np.array([[1, 0, -1]]).T, mode='same') gy[0, :] = 0 gy[-1, :] = 0 gy[:, 0] = 0 gy[:, -1] = 0 gmag = np.sqrt(gx**2 + gy**2) gmag = gmag > 0 D = {} P = {} y, x = np.where(gmag) for i in range(y.size): nearby_labels = np.unique(segments[y[i] - 1:y[i] + 2, x[i] - 1:x[i] + 2]) t = tuple(nearby_labels) if t in D.keys(): D[t].append([y[i], x[i]]) P[t].append( np.min(cell_probs[y[i] - 1:y[i] + 2, x[i] - 1:x[i] + 2])) else: D[t] = [[y[i], x[i]]] P[t] = [np.min(cell_probs[y[i] - 1:y[i] + 2, x[i] - 1:x[i] + 2])] bmap = np.zeros(cell_probs.shape) for t in D.keys(): coords = np.array(D[t]) #if 2-way boundary: if len(t) < 3: score = np.mean(np.array(P[t])) else: perms = permutations(t, 2) perms = [np.mean(P[t]) for t in perms if t in P.keys()] score = np.min(perms) bmap[coords[:, 0], coords[:, 1]] = 1 - score bmap[0, :] = 1 bmap[-1, :] = 1 bmap[:, 0] = 1 bmap[:, -1] = 1 return bmap
def test_3d_inactive(): n = 30 lx, ly, lz = n, n, n data, labels = make_3d_syntheticdata(lx, ly, lz) old_labels = np.copy(labels) labels[5:25, 26:29, 26:29] = -1 after_labels = np.copy(labels) with expected_warnings(['"cg" mode|CObject type' + '|' + SCIPY_EXPECTED]): labels = random_walker(data, labels, mode='cg') assert (labels.reshape(data.shape)[13:17, 13:17, 13:17] == 2).all() assert data.shape == labels.shape return data, labels, old_labels, after_labels
def test_isolated_area(): np.random.seed(0) a = np.random.random((7, 7)) mask = -np.ones(a.shape) # This pixel is an isolated seed mask[1, 1] = 0 # Unlabeled pixels mask[3:, 3:] = 0 # Seeds connected to unlabeled pixels mask[4, 4] = 2 mask[6, 6] = 1 # Test that no error is raised, and that labels of isolated seeds are OK with expected_warnings( [NUMPY_MATRIX_WARNING, 'The probability range is outside']): res = random_walker(a, mask) assert res[1, 1] == 0 with expected_warnings( [NUMPY_MATRIX_WARNING, 'The probability range is outside']): res = random_walker(a, mask, return_full_prob=True) assert res[0, 1, 1] == 0 assert res[1, 1, 1] == 0
def segment(img, markers): """Segment image.""" logging.info('Segmenting: %s', array_info(img)) logging.info('...with markers: %s', array_info(markers)) d = dict( # beta=10, # Default is 130. mode='cg_mg', # mode=None, multichannel=True, spacing=img.spacing, ) labels = segmentation.random_walker(img, markers, **d) return labels
def robust_binarize(base_image, _dilation=0, heterogeity_size=10, feature_size=50): """ Robust binarization algorithm based off random walker clustering :param base_image: :param _dilation: if set to anything other than 0, would perform a morphological dilation using this parameter value as size :param heterogeity_size: size of the feature (px) that the method will try to eliminate by smoothing :param feature_size: size of the feature (px) that the method will try to segment out :return: binary_labels """ if np.percentile(base_image, 99) < 0.20: if np.percentile(base_image, 99) > 0: mult = 0.20 / np.percentile( base_image, 99) # poissonean background assumptions else: mult = 1000. / np.sum(base_image) base_image = base_image * mult base_image[base_image > 1] = 1 clustering_markers = np.zeros(base_image.shape, dtype=np.uint8) selem = disk(heterogeity_size) smooth = gaussian_filter(base_image, heterogeity_size, mode='constant') smooth_median = median(smooth, selem) uniform_median = median(base_image, selem) selem2 = disk(feature_size) local_otsu = rank.otsu(smooth_median, selem2) uniform_median_otsu = rank.otsu(uniform_median, selem2) clustering_markers[smooth_median < local_otsu * 0.9] = 1 clustering_markers[smooth_median > local_otsu * 1.1] = 2 # dbg.random_walker_debug(smooth_median, clustering_markers) # dbg.robust_binarize_debug(base_image, smooth_median, smooth_median, local_otsu, clustering_markers, # 0, uniform_median, uniform_median_otsu) binary_labels = random_walker( smooth_median, clustering_markers, beta=10, mode='bf') - 1 if _dilation: selem = disk(_dilation) binary_labels = dilation(binary_labels, selem) # dbg.robust_binarize_debug(binary_labels, base_image) # dbg.voronoi_debug(binary_labels, local_maxi, dist, segmented_cells_labels) # dbg.Kristen_robust_binarize(binary_labels, base_image) return binary_labels
def test_trivial_cases(): # When all voxels are labeled img = np.ones((10, 10)) labels = np.ones((10, 10)) with expected_warnings(["Returning provided labels"]): pass_through = random_walker(img, labels) np.testing.assert_array_equal(pass_through, labels) # When all voxels are labeled AND return_full_prob is True labels[:, :5] = 3 expected = np.concatenate( ((labels == 1)[..., np.newaxis], (labels == 3)[..., np.newaxis]), axis=2) with expected_warnings(["Returning provided labels"]): test = random_walker(img, labels, return_full_prob=True) np.testing.assert_array_equal(test, expected) # Unlabeled voxels not connected to seed, so nothing can be done img = np.full((10, 10), False) object_A = np.array([(6, 7), (6, 8), (7, 7), (7, 8)]) object_B = np.array([(3, 1), (4, 1), (2, 2), (3, 2), (4, 2), (2, 3), (3, 3)]) for x, y in np.vstack((object_A, object_B)): img[y][x] = True markers = np.zeros((10, 10), dtype=np.int8) for x, y in object_B: markers[y][x] = 1 markers[img == 0] = -1 with expected_warnings(["All unlabeled pixels are isolated"]): output_labels = random_walker(img, markers) assert np.all(output_labels[markers == 1] == 1) # Here 0-labeled pixels could not be determined (no connexion to seed) assert np.all(output_labels[markers == 0] == -1) with expected_warnings(["All unlabeled pixels are isolated"]): test = random_walker(img, markers, return_full_prob=True)
def randomwalk_seg(rgb_img, mask, safe_zone_len, beta, num_points): start = time.time() se = np.ones((safe_zone_len, safe_zone_len)) rand_fore_points = morphology.binary_erosion(mask, se) rand_back_points = morphology.binary_erosion(mask == 0, se) if num_points < 0: labels = rand_fore_points * 1.0 + 2.0 * rand_back_points random_walker_mask = random_walker(rgb_img, labels, beta=beta, multichannel=True) == 1 else: #sampling point fore_points = segh.get_sample_point(rgb_img, num_points, grow_fore_points) back_points = segh.get_sample_point(rgb_img, num_points, grow_back_points) labels = np.zeros((m, n)) for p in fore_points: i, j = p[-2], p[-1] labels[i, j] = 1 for p in back_points: i, j = p[-2], p[-1] labels[i, j] = 2 random_walker_mask = random_walker(rgb_img, labels, beta=beta, multichannel=True) == 1 print('size ', random_walker_mask.shape, ' Random Walk processing time ', time.time() - start) return random_walker_mask
def test_2d_bf(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) with expected_warnings([NUMPY_MATRIX_WARNING]): labels_bf = random_walker(data, labels, beta=90, mode='bf') assert (labels_bf[25:45, 40:60] == 2).all() assert data.shape == labels.shape with expected_warnings([NUMPY_MATRIX_WARNING]): full_prob_bf = random_walker(data, labels, beta=90, mode='bf', return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() assert data.shape == labels.shape # Now test with more than two labels labels[55, 80] = 3 with expected_warnings([NUMPY_MATRIX_WARNING]): full_prob_bf = random_walker(data, labels, beta=90, mode='bf', return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() assert len(full_prob_bf) == 3 assert data.shape == labels.shape
def test_2d_bf(): lx = 70 ly = 100 data, labels = make_2d_syntheticdata(lx, ly) labels_bf = random_walker(data, labels, beta=90, mode='bf') assert (labels_bf[25:45, 40:60] == 2).all() full_prob_bf = random_walker(data, labels, beta=90, mode='bf', return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() # Now test with more than two labels labels[55, 80] = 3 full_prob_bf = random_walker(data, labels, beta=90, mode='bf', return_full_prob=True) assert (full_prob_bf[1, 25:45, 40:60] >= full_prob_bf[0, 25:45, 40:60]).all() assert len(full_prob_bf) == 3
def apply_random_walker(image): upper_bound = np.max(image) img_as_float = image / upper_bound img_as_float *= 2 img_as_float -= 1 # print(img_as_float.max(), img_as_float.min()) # print(image.min(), image.max()) markers = np.zeros(img_as_float.shape, dtype=np.uint) markers[img_as_float < -0.90] = 1 markers[img_as_float > 0.90] = 2 return random_walker(img_as_float, markers, beta=10, mode='bf')
def seg(img): # xg = img[:,:,1] xg = np.copy(img) cv2.imshow('img', xg) cv2.waitKey() cv2.destroyAllWindows() a, b = np.histogram(img.flatten(), bins=30, range=[15, 255]) idx = a.argmax() range_S = b[idx] range_B = b[-1] # range_S_2 = b[-5] # range_B_2 = b[-1] tmp = np.zeros_like(img) tmp[(img >= range_S) * (img <= range_B)] = 255 # tmp[(img >= range_S_2) *(img <= range_B_2)] = 255 cv2.imshow('test', tmp) cv2.waitKey() cv2.destroyAllWindows() m1 = xg.mean() mask = np.zeros_like(xg) mask[xg > m1] = 1 # cv2.imshow('img', mask) cv2.waitKey() cv2.destroyAllWindows() canny = cv2.Canny(img, 20, 60) * mask cv2.imshow('canny', canny) cv2.waitKey() cv2.destroyAllWindows() closed = np.zeros_like(canny) closed[canny > 0] = 1 closed[mask == 0] = 2 closed[(img >= range_S) * (img <= range_B)] = 2 image_segmented = random_walker(xg, closed, beta=20, mode='bf') #, beta=1 image_segmented[image_segmented == 2] = 0 image_segmented = image_segmented.astype(np.uint8) * 255 # closed = cv2.erode(image_segmented, None, iterations=2) cv2.imshow('img res', image_segmented) cv2.waitKey() cv2.destroyAllWindows() return image_segmented
def test_multispectral_2d(dtype, channel_axis): lx, ly = 70, 100 data, labels = make_2d_syntheticdata(lx, ly) data = data.astype(dtype, copy=False) data = data[..., np.newaxis].repeat(2, axis=-1) # Expect identical output data = np.moveaxis(data, -1, channel_axis) with expected_warnings([ '"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING, 'The probability range is outside' ]): multi_labels = random_walker(data, labels, mode='cg', channel_axis=channel_axis) data = np.moveaxis(data, channel_axis, -1) assert data[..., 0].shape == labels.shape with expected_warnings( ['"cg" mode' + '|' + SCIPY_RANK_WARNING, NUMPY_MATRIX_WARNING]): single_labels = random_walker(data[..., 0], labels, mode='cg') assert (multi_labels.reshape(labels.shape)[25:45, 40:60] == 2).all() assert data[..., 0].shape == labels.shape return data, multi_labels, single_labels, labels
def draw(self, event): x, y = event.xdata, event.ydata x, y = int(x), int(y) # print('x=%1.2f, y=%1.2f' % (x, y)) imd = np.sqrt((self.xx-y)**2 + (self.yy-x)**2) <= self.r if event.button == 1: self.im_markers[imd] = 1 elif event.button == 3: self.im_markers[imd] = 2 elif event.button == 2: self.im_labels = random_walker(self.im, self.im_markers, beta=10, mode='cg_mg') # 'bf' self.ax3.imshow(self.im_labels, cmap='gray', interpolation='nearest') self.ax2.imshow(self.im_markers, cmap='magma', interpolation='nearest') plt.draw()
def test_walker_binary(): unet, mrcnn, annot = get_images() annot_mask = np.where(annot > 0, 1, 0) unet_mask = np.where(unet > 0, 1, 0) mrcnn_mask = np.where(mrcnn > 0, 1, 0) unet_seed, mrcnn_seed = erode_images(unet, mrcnn, 6, 6) labels = np.where(unet_seed + mrcnn_seed > 0, 1, 0) labels[unet_mask + mrcnn_mask == 0] = 2 data = np.dstack((unet, mrcnn)) final = random_walker(data, labels, beta=30, mode='bf') final[final == 2] = 0 imwrite('unet.png', unet_mask * 255) imwrite('mrcnn.png', mrcnn_mask * 255) imwrite('final_.png', final * 255) imwrite('annot.png', annot_mask * 255)
def produceRandomWalkerSegmentationNoContrast(filename): image = utils.readImageGrayscaled(filename) utils.saveImageSegment(filename, 'original_gs', image) markers = np.zeros(image.shape, dtype=np.uint8) markers[image < 0.25] = 2 markers[image > 0.5] = 1 image_segmented = seg.random_walker(image, markers) utils.saveImageSegment(filename, 'rand_walk_unsupervised', image_segmented) merged = image + image_segmented utils.saveImageSegment(filename, 'merge_rand_walk_unsupervised', merged) utils.saveImageSegmentResult(filename, 'rand_walk_unsupervised', merged)
def get_labels(prediction): def _get_reduced_maxima(pred): markers = [] distance = ndi.distance_transform_edt(pred) distance_ordinal = distance - np.min(distance) distance_ordinal = distance_ordinal / np.max(distance_ordinal) markers.append(ndi.label(distance_ordinal)[0]) markers.append( ndi.label( ndi.distance_transform_edt(distance_ordinal >= 0.1 * 1.0))[0]) # markers.append(ndi.label(ndi.distance_transform_edt(distance_ordinal >= 0.5 * 1.0))[0]) # markers.append(ndi.label(ndi.distance_transform_edt(distance_ordinal >= 0.75 * 1.0))[0]) final_markers = ndi.label( ndi.distance_transform_edt(distance_ordinal >= 0.5 * 1.0))[0] # # Calculate mean cell size cell_sums = [] for c_id in np.unique(final_markers)[1:]: cell_sums.append(np.sum(c_id == final_markers * 1.0)) mean_sum = np.mean(cell_sums) # Reduce centroid size for marker in markers[::-1]: transition_markers = marker * (final_markers > 0) for c_id in np.unique(marker)[1:]: cell_seg = (marker == c_id) * 1.0 if np.sum(cell_seg * (transition_markers > 0 * 1.0)) <= mean_sum * 0.3: final_markers = ndi.label((final_markers > 0) * 1.0 + (marker == c_id) * 1.0)[0] return final_markers, mean_sum pred, ind = get_expanded_boundary(prediction) markers, mean_sum = _get_reduced_maxima(pred) markers = get_normal_boundary(markers, ind) markers = markers * (prediction > 0 * 1.0) - 1 * (prediction == 0 * 1.0) wa = random_walker(prediction, markers) wa = wa * (wa != -1) # Remove small cell artifacts wa_2 = np.zeros(np.shape(wa)) for c_id in np.unique(wa)[1:]: if np.sum((c_id == wa) * 1.0) >= mean_sum * 0.1: wa_2 += (c_id == wa) * c_id wa = wa_2 return wa
def get_regions(img): denoised=restoration.denoise_bilateral(img.astype('uint16'), # sigma_range=0.01, sigma_spatial=15, multichannel=False) smoothened = filters.median(denoised,np.ones((4,4))) markers = np.zeros(smoothened.shape, dtype=np.uint) # otsu works only for only for multi-channel images # markers[smoothened < filters.threshold_otsu(smoothened)] = 1 # markers[smoothened > filters.threshold_otsu(smoothened)] = 2 markers[smoothened < filters.median(smoothened)] = 1 markers[smoothened > filters.median(smoothened)] = 2 labels = random_walker(smoothened, markers, beta=10, mode='bf') regions= measure.label(labels) return regions, denoised, smoothened,markers
def random_walker_binarize(base_image, _dilation=0): gfp_clustering_markers = np.zeros(base_image.shape, dtype=np.uint8) # To try: add a grey area around the boundary between black and white gfp_clustering_markers[base_image > np.mean(base_image) * 2] = 2 gfp_clustering_markers[base_image < np.mean(base_image) * 0.20] = 1 binary_labels = random_walker( base_image, gfp_clustering_markers, beta=10, mode='bf') - 1 if _dilation: selem = disk(_dilation) binary_labels = dilation(binary_labels, selem) return binary_labels
def label_particles_walker(im, min_thresh=0.3, max_thresh=0.5, sigma=3): """ label_particles_walker(image, min_thresh=0.3, max_thresh=0.5) Returns the labels for an image. Segments using random_walker method. keyword arguments: image -- The image in which to find particles min_thresh -- The lower limit for binary threshold max_thresh -- The upper limit for binary threshold """ if sigma > 0: im = gaussian_filter(im, sigma) labels = np.zeros_like(im) labels[im < min_thresh * im.max()] = 1 labels[im > max_thresh * im.max()] = 2 return segmentation.random_walker(im, labels)
def background_generator(): size_x = 50 size_y = 50 n_labels = 2 image_rgb = np.random.uniform(0.9, 1, (size_x, size_y, 3)) labels = np.random.randint(n_labels + 1, size=( size_x, size_y)) * np.random.randint(0, 2, size=(size_x, size_y)) # segment random image segments = random_walker(image_rgb, labels, multichannel=True, beta=250, copy=False, spacing=[50, 10]) for color_index in np.unique(segments): image_rgb[segments == color_index] = np.random.uniform(0, 1, 3) # transform segmented image so it is large, preserving blobs, and blurry image_rgb = rescale(image_rgb, 2, anti_aliasing=False, multichannel=True) image_rgb = gaussian(image_rgb, sigma=2, multichannel=True) image_hsv = color.rgb2hsv(image_rgb) buffer = 0.05 hsv_index = 1 for _ in range(10000): rand_x, rand_y = np.random.choice( image_hsv.shape[0]), np.random.choice(image_hsv.shape[1]) orig_rgb = image_rgb[rand_x, rand_y] rand_value = image_hsv[rand_x, rand_y, hsv_index] x, y = np.where((rand_value * (1 + buffer) >= image_hsv[:, :, hsv_index]) & (rand_value * (1 - buffer) < image_hsv[:, :, hsv_index])) if len(x) == 0: continue idx = np.random.choice(len(x)) update_rgb = image_rgb[x[idx], y[idx]] image_rgb[x[idx], y[idx]] = orig_rgb image_rgb[rand_x, rand_y] = update_rgb return image_rgb
def watershedPower(input_file, output_file, seeds_file, algo, mult, geod): image_name = "figure_1.png" seeds_name = seeds_file sigma = 0.35 fimage_read = open(image_name, 'rb') fimage_seeds = open(seeds_name, 'rb') image_read = read_pgm(fimage_read) seeds = read_pgm(fimage_seeds) rs = rowsize(fimage_read) cs = colsize(fimage_read) N = rs * cs M = rs * (cs - 1) + (rs - 1) * cs #number of edges nblabels = 2 j = 0 for i in range(0, rs * cs): if seeds[i] > 155: index_seeds[j] = i index_labels[j] = 1 j += 1 if seeds[i] < 100: index_seeds[j] = i index_labels[j] = 2 j += 1 size_seeds = j markers = np.zeros(image.shape, dtype=np.uint) markers[image < -0.95] = 1 markers[image > 0.95] = 2 matrixedges = [[0 for col in range(2)] for row in range((cs - 1) * rs + (rs - 1) * cs)] edges = compute_edges(matrixedges, rs, cs) weights = [] normal_weights = grey_weights_PW(image_name, edges, index_seeds, size_seeds, weights, quicksort) output = PowerWatershed_q2(edges, weights, normal_weights, max_weight, index_seeds, index_labels, size_seeds, rs, cs, ds, nblabels, quicksort, img_proba) labels = random_walker(image, markers, beta=10, mode='bf')
def test_walker_label(): unet, mrcnn, annot = get_images() unet_seed, mrcnn_seed = erode_images(unet, mrcnn, 6, 6) annot_mask = np.where(annot > 0, 1, 0) unet_mask = np.where(unet > 0, 1, 0) mrcnn_mask = np.where(mrcnn > 0, 1, 0) labels = np.where(unet_seed + mrcnn_seed > 0, 1, 0) labels = label(labels) labels, _, _ = relabel_sequential(labels, offset=2) labels[unet_mask + mrcnn_mask == 0] = 1 data = np.dstack((unet, mrcnn)) final = random_walker(data, labels, beta=50, mode='bf') final[final == 1] = 0 imwrite('unet.png', unet_mask*255) imwrite('mrcnn.png', mrcnn_mask*255) imwrite('final_.png', final*255) imwrite('annot.png', annot_mask * 255) return final
def add_missed_blobs(full_mask, labeled_mask, edges): missed_mask = full_mask & ~(labeled_mask > 0) missed_mask = drop_small_blobs(missed_mask, 2) # bodies must be larger than 1-pixel if edges is not None: missed_markers = label(missed_mask & ~edges) else: missed_markers = label(missed_mask) if missed_markers.max() > 0: missed_markers[missed_mask == 0] = -1 missed_labels = random_walker(missed_mask, missed_markers) missed_labels[missed_labels <= 0] = 0 missed_labels = np.where(missed_labels > 0, missed_labels + labeled_mask.max(), 0) final_labels = np.add(labeled_mask, missed_labels) else: final_labels = labeled_mask return final_labels
def rondomwalker_seg(distance, threshold=2.0): if isinstance(distance, Variable): distance = distance.data if isinstance(distance, torch.FloatTensor) or isinstance( distance, torch.cuda.FloatTensor): distance = distance.cpu().numpy() #print(type(distance)) distance = np.squeeze(distance) distance = gaussian(distance / np.max(distance), sigma=0.6, mode='reflect') markers = distance > 0.039 markers = skimage.morphology.label(markers) seg_labels = random_walker(-distance, markers,\ beta=25000, mode='cg_mg') #seg_labels = watershed(-distance, markers) #axes[1].plot(coordinates[:, 1], coordinates[:, 0], 'r.') return seg_labels
def img_random_walker(data, lower_q=0.9, upper_q=0.98, val_beta=10, val_mode='bf'): labels = [] if not isinstance(data, list): raise Exception('Argument data must be a list type') for x in data: ones = np.ones(x.shape) markers = np.zeros(x.shape) markers[x < np.quantile(x, lower_q)] = 1 markers[x > np.quantile(x, upper_q)] = 2 labels.append( random_walker(x, markers, beta=val_beta, mode=val_mode) - ones) return labels