def segment_mc(pred, seg, delta): rag = feats.compute_rag(seg) edge_probs = embed.edge_probabilities_from_embeddings( pred, seg, rag, delta) edge_sizes = feats.compute_boundary_mean_and_length(rag, pred[0])[:, 1] costs = mc.transform_probabilities_to_costs(edge_probs, edge_sizes=edge_sizes) mc_seg = mc.multicut_kernighan_lin(rag, costs) mc_seg = feats.project_node_labels_to_pixels(rag, mc_seg) return mc_seg
def supervoxel_merging(mem, sv, beta=0.5, verbose=False): rag = feats.compute_rag(sv) costs = feats.compute_boundary_features(rag, mem)[:, 0] edge_sizes = feats.compute_boundary_mean_and_length(rag, mem)[:, 1] costs = mc.transform_probabilities_to_costs(costs, edge_sizes=edge_sizes, beta=beta) node_labels = mc.multicut_kernighan_lin(rag, costs) segmentation = feats.project_node_labels_to_pixels(rag, node_labels) return segmentation
def segment_volume_lmc_from_seg(boundary_pmaps, nuclei_seg, threshold=0.4, sigma=2.0, sp_min_size=100): watershed = distance_transform_watershed(boundary_pmaps, threshold, sigma, min_size=sp_min_size)[0] # compute the region adjacency graph rag = compute_rag(watershed) # compute the edge costs features = compute_boundary_mean_and_length(rag, boundary_pmaps) costs, sizes = features[:, 0], features[:, 1] # transform the edge costs from [0, 1] to [-inf, inf], which is # necessary for the multicut. This is done by intepreting the values # as probabilities for an edge being 'true' and then taking the negative log-likelihood. # in addition, we weight the costs by the size of the corresponding edge # we choose a boundary bias smaller than 0.5 in order to # decrease the degree of over segmentation boundary_bias = .6 costs = transform_probabilities_to_costs(costs, edge_sizes=sizes, beta=boundary_bias) max_cost = np.abs(np.max(costs)) lifted_uvs, lifted_costs = lifted_problem_from_segmentation( rag, watershed, nuclei_seg, overlap_threshold=0.2, graph_depth=4, same_segment_cost=5 * max_cost, different_segment_cost=-5 * max_cost) # solve the full lifted problem using the kernighan lin approximation introduced in # http://openaccess.thecvf.com/content_iccv_2015/html/Keuper_Efficient_Decomposition_of_ICCV_2015_paper.html node_labels = lmc.lifted_multicut_kernighan_lin(rag, costs, lifted_uvs, lifted_costs) lifted_segmentation = project_node_labels_to_pixels(rag, node_labels) return lifted_segmentation
affs = np.transpose(affs.cpu().numpy(), (1, 0, 2, 3)) gt_affs = np.transpose(gt_affs.cpu().numpy(), (1, 0, 2, 3)) seg = seg.cpu().numpy() gt_seg = gt_seg.cpu().numpy() boundary_input = np.mean(affs, axis=0) gt_boundary_input = np.mean(gt_affs, axis=0) rag = feats.compute_rag(seg) # edges rag.uvIds() [[1, 2], ...] costs = feats.compute_affinity_features(rag, affs, offsets)[:, 0] gt_costs = calculate_gt_edge_costs(rag.uvIds(), seg.squeeze(), gt_seg.squeeze()) edge_sizes = feats.compute_boundary_mean_and_length(rag, boundary_input)[:, 1] gt_edge_sizes = feats.compute_boundary_mean_and_length(rag, gt_boundary_input)[:, 1] costs = mc.transform_probabilities_to_costs(costs, edge_sizes=edge_sizes) gt_costs = mc.transform_probabilities_to_costs(gt_costs, edge_sizes=edge_sizes) node_labels = mc.multicut_kernighan_lin(rag, costs) gt_node_labels = mc.multicut_kernighan_lin(rag, gt_costs) segmentation = feats.project_node_labels_to_pixels(rag, node_labels) gt_segmentation = feats.project_node_labels_to_pixels(rag, gt_node_labels) plt.imshow( np.concatenate( (gt_segmentation.squeeze(), segmentation.squeeze(), seg.squeeze()), axis=1)) plt.show()
def refine_seg(raw, seeds, restrict_to_seeds=True, restrict_to_bb=False, return_intermediates=False): pred = get_prediction(raw, cache=False) n_threads = 1 # make watershed ws, _ = stacked_watershed(pred, threshold=.5, sigma_seeds=1., n_threads=n_threads) rag = compute_rag(ws, n_threads=n_threads) edge_feats = compute_boundary_mean_and_length(rag, pred, n_threads=n_threads) edge_feats, edge_sizes = edge_feats[:, 0], edge_feats[:, 1] z_edges = compute_z_edge_mask(rag, ws) edge_costs = compute_edge_costs(edge_feats, beta=.4, weighting_scheme='xyz', edge_sizes=edge_sizes, z_edge_mask=z_edges) # make seeds and map them to edges bb = tuple( slice(sh // 2 - ha // 2, sh // 2 + ha // 2) for sh, ha in zip(pred.shape, seeds.shape)) seeds[seeds < 0] = 0 seeds = vigra.analysis.labelVolumeWithBackground(seeds.astype('uint32')) seed_ids = np.unique(seeds) seed_mask = binary_erosion(seeds, iterations=2) seeds_new = seeds.copy() seeds_new[~seed_mask] = 0 seed_ids_new = np.unique(seeds_new) for seed_id in seed_ids: if seed_id in seed_ids_new: continue seeds_new[seeds == seed_id] = seed_id seeds_full = np.zeros(pred.shape, dtype=seeds.dtype) seeds_full[bb] = seeds seeds = seeds_full seed_labels = compute_maximum_label_overlap(ws, seeds, ignore_zeros=True) edge_ids = rag.uvIds() labels_u = seed_labels[edge_ids[:, 0]] labels_v = seed_labels[edge_ids[:, 1]] seed_mask = np.logical_and(labels_u != 0, labels_v != 0) same_seed = np.logical_and(seed_mask, labels_u == labels_v) diff_seed = np.logical_and(seed_mask, labels_u != labels_v) max_att = edge_costs.max() + .1 max_rep = edge_costs.min() - .1 edge_costs[same_seed] = max_att edge_costs[diff_seed] = max_rep # run multicut node_labels = multicut_kernighan_lin(rag, edge_costs) if restrict_to_seeds: seed_nodes = np.unique(node_labels[seed_labels > 0]) node_labels[~np.isin(node_labels, seed_nodes)] = 0 vigra.analysis.relabelConsecutive(node_labels, out=node_labels) seg = project_node_labels_to_pixels(rag, node_labels, n_threads=n_threads) if restrict_to_bb: bb_mask = np.zeros(seg.shape, dtype='bool') bb_mask[bb] = 1 seg[~bb_mask] = 0 if return_intermediates: return pred, ws, seeds, seg else: return seg