def segment_block(block_id, weight_edges=False, cached=False): import cremi_tools.segmentation as cseg raw_path = '/home/papec/Work/neurodata_hdd/fib25/raw/raw_block%i.h5' % block_id pmap_path = '/home/papec/Work/neurodata_hdd/fib25/pmaps/probs_squeezed_block%i.h5' % block_id ws_path = '/home/papec/Work/neurodata_hdd/fib25/watersheds/watershed_agglomerated_0.075000_block%i.h5' % block_id # load pmap and watersheds raw = vigra.readHDF5(raw_path, 'data').astype('float32') pmap = vigra.readHDF5(pmap_path, 'data') ws = vigra.readHDF5(ws_path, 'data') if cached: edge_probs = vigra.readHDF5('edge_probs_%i.h5' % block_id, 'data') rag = nrag.gridRag(ws, numberOfLabels=int(ws.max()) + 1) # TODO edge sizes else: # feature extractor and multicut feature_extractor = cseg.RandomForestFeatures('./rf.pkl', True) # make graph and costs rag, edge_probs, _, edge_sizes = feature_extractor(pmap, ws, raw=raw) vigra.writeHDF5(edge_probs, 'edge_probs_%i.h5' % block_id, 'data') graph = nifty.graph.undirectedGraph(rag.numberOfNodes) graph.insertEdges(rag.uvIds()) mc = cseg.Multicut('kernighan-lin', weight_edges=weight_edges) if weight_edges: costs = mc.probabilities_to_costs(edge_probs, edge_sizes) else: costs = mc.probabilities_to_costs(edge_probs) node_labels = mc(graph, costs) return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def _compute_mc(self, input_, feat_function, beta): # watershed and region adjacency graph ws, n_labels = self._compute_ws(input_) rag = nrag.gridRag(ws, numberOfLabels=n_labels, numberOfThreads=self.n_threads) if rag.numberOfEdges == 0: return np.zeros_like(ws) # features and features to costs feats = feat_function(rag, input_) probs, edge_len = feats[:, 0], feats[:, -1] costs = self._probs_to_costs(probs, edge_len, beta) # graph and multicut solver graph = nifty.graph.undirectedGraph(rag.numberOfNodes) graph.insertEdges(rag.uvIds()) objective = nmc.multicutObjective(graph, costs) solver = objective.kernighanLinFactory( warmStartGreedy=True).create(objective) # solve multicut and project back to segmentation # TODO time limit node_labels = solver.optimize() return nrag.projectScalarNodeDataToPixels( rag, node_labels, numberOfThreads=self.n_threads)
def agglomerate_wsdt(thresh=.1, size_thresh=500): f = z5py.File('/home/papec/Work/neurodata_hdd/scotts_blocks/data_test_small.n5') affs = 1. - f['predictions/full_affs'][:3, :] affs_xy = np.mean(affs[1:3], axis=0) affs_z = affs[0] wsdt = cseg.DTWatershed(0.2, 1.6) ws, max_id = wsdt(affs_xy) rag = nrag.gridRagStacked2D(ws.astype('uint32'), numberOfLabels=int(max_id + 1), dtype='uint32') features_z = nrag.accumulateEdgeStandardFeatures(rag, affs_z, keepZOnly=True, zDirection=2)[1] features_z = features_z[:, 0] edge_offset = rag.totalNumberOfInSliceEdges edge_sizes = rag.edgeLengths()[edge_offset:] uvs = rag.uvIds()[edge_offset:] assert len(features_z) == len(uvs) # TODO filter by edge overlap as well ! merge_edges = np.logical_and(features_z < thresh, edge_sizes > size_thresh) merge_nodes = uvs[merge_edges] ufd = nifty.ufd.ufd(rag.numberOfNodes) ufd.merge(merge_nodes) node_labels = ufd.elementLabeling() ws_merged = nrag.projectScalarNodeDataToPixels(rag, node_labels) raw = f['gray'][:] view([raw, affs.transpose((1, 2, 3, 0)), ws, ws_merged], ['raw', 'affs', 'ws', 'ws-merged'])
def debug_subresult(block_id=1): example_path = '/home/cpape/Work/data/isbi2012/cluster_example/isbi_train.n5' block_prefix = os.path.join(example_path, 's0', 'sub_graphs', 'block_') graph = ndist.Graph(os.path.join(example_path, 'graph')) block_path = block_prefix + str(block_id) nodes = ndist.loadNodes(block_path) inner_edges, outer_edges, sub_uvs = graph.extractSubgraphFromNodes(nodes) block_res_path = './tmp/subproblem_results/s0_block%i.npy' % block_id res = np.load(block_res_path) merge_edges = np.ones(graph.numberOfEdges, dtype='bool') merge_edges[res] = False merge_edges[outer_edges] = False uv_ids = graph.uvIds() n_nodes = int(uv_ids.max()) + 1 ufd = nifty.ufd.ufd(n_nodes) ufd.merge(uv_ids[merge_edges]) node_labels = ufd.elementLabeling() ws = z5py.File(example_path)['volumes/watersheds'][:] rag = nrag.gridRag(ws, numberOfLabels=n_nodes) seg = nrag.projectScalarNodeDataToPixels(rag, node_labels) view([ws, seg])
def mc(rag, probs): mc = cseg.Multicut('kernighan-lin', weight_edges=False) graph = nifty.graph.undirectedGraph(rag.numberOfNodes) graph.insertEdges(rag.uvIds()) costs = mc.probabilities_to_costs(probs) node_labels = mc(graph, costs) return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def segment_lmc(ws, affs, n_labels, offsets, return_merged_nodes=False): rag = nrag.gridRag(ws, numberOfLabels=n_labels, numberOfThreads=1) lifted_uvs, local_features, lifted_features = nrag.computeFeaturesAndNhFromAffinities( rag, affs, offsets, numberOfThreads=1) uv_ids = rag.uvIds() lmc = cseg.LiftedMulticut('kernighan-lin', weight_edges=False) local_costs = lmc.probabilities_to_costs(local_features[:, 0]) local_ignore = (uv_ids == 0).any(axis=1) local_costs[local_ignore] = 5 * local_costs.min() # we might not have lifted edges -> just solve multicut if len(lifted_uvs) == 1 and (lifted_uvs[0] == -1).any(): mc = cseg.Multicut('kernighan-lin', weight_edges=False) graph = nifty.graph.undirectedGraph(n_labels) graph.insertEdges(uv_ids) node_labels = mc(graph, local_costs) else: lifted_costs = lmc.probabilities_to_costs(lifted_features[:, 0]) lifted_ignore = (lifted_uvs == 0).any(axis=1) lifted_costs[lifted_ignore] = 5 * lifted_costs.min() node_labels = lmc(uv_ids, lifted_uvs, local_costs, lifted_costs) if return_merged_nodes: return get_merged_nodes(uv_ids, node_labels) else: return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def compute_mcrf_segments(ws, affs, n_labels, glia, offsets, rf, block_id): rag = nrag.gridRag(ws, numberOfLabels=int(n_labels), numberOfThreads=1) uv_ids = rag.uvIds() # we can have a single over-segment id for (small border) blocks # resulting in 0 edges if(uv_ids.shape[0] == 0): print("WARNING:, block", block_id, "contains only a single id, but is not masked") print("This is may be caused by an incorrect mask") return ws # TODO split features over different affinity ranges ? feats = np.concatenate([nrag.accumulateAffinityStandartFeatures(rag, affs, offsets, numberOfThreads=1), glia_features(rag, ws, glia)], axis=1) probs = rf.predict_proba(feats)[:, 1] mc = cseg.Multicut('kernighan-lin', weight_edges=False) costs = mc.probabilities_to_costs(probs) ignore_edges = (uv_ids == 0).any(axis=1) costs[ignore_edges] = 5 * costs.min() graph = nifty.graph.undirectedGraph(n_labels) graph.insertEdges(uv_ids) node_labels = mc(graph, costs) return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def __call__(self, input_): fragments = self.oversegmenter(input_) rag, probs, node_sizes, edge_sizes = self.extractor(input_, fragments) graph = nifty.graph.undirectedGraph(rag.numberOfNodes) graph.insertEdges(rag.uvIds()) costs = self.segmener.probabilities_to_costs(probs, edge_sizes) node_labels = self.segmenter(graph, costs, node_sizes, edge_sizes) return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def _project_result_to_segmentation(self, rag, mc_nodes, out): assert mc_nodes.shape[0] == rag.numberOfNodes mc_nodes, _, _ = vigra.analysis.relabelConsecutive(mc_nodes, start_label=1, keep_zeros=False) # if we have an ignore label, set it's node value to zero if PipelineParameter().ignoreSegLabel != -1: workflow_logger.info( "SegmentationWorkflow: Setting node values for ignore seg value: %i to 0." % PipelineParameter().ignoreSegLabel) mc_nodes[PipelineParameter().ignoreSegLabel] = 0 if np.dtype(self.dtype) != np.dtype(mc_nodes.dtype): self.dtype = mc_nodes.dtype nrag.projectScalarNodeDataToPixels(rag, mc_nodes, out.get(self.saveKey), PipelineParameter().nThreads)
def merge_fully_enclosed(segmentation, n_threads=8): rag = nrag.gridRag(segmentation, numberOfLabels=int(relabeled.max() + 1), numberOfThreads=n_threads) ufd = nifty.ufd.ufd(rag.numberOfNodes) nodes = np.unique(segmentation) for node in nodes: adjacency = [adj for adj in rag.nodeAdjacency(node)] if len(adjacency) == 1: ufd.merge(node, adjacency[0][0]) labeling = ufd.elementLabeling() return nrag.projectScalarNodeDataToPixels(rag, labeling)
def debug_reduce_problem(): example_path = '/home/cpape/Work/data/isbi2012/cluster_example/isbi_train.n5' node_labels = z5py.File(example_path)['s1']['node_labeling'][:] node_labels = np.concatenate((np.zeros(1, dtype='uint64'), node_labels)) n_nodes = len(node_labels) ws = z5py.File(example_path)['volumes/watersheds'][:] rag = nrag.gridRag(ws, numberOfLabels=n_nodes) seg = nrag.projectScalarNodeDataToPixels(rag, node_labels) view([ws, seg])
def export_object(project, name, ws=None, rag=None): # TODO check for consistency in ws and rag arguments if ws is None: ws, rag = load_watershed_and_rag(project) with h5py.File(project, 'r') as f: fg = f['carving/objects/%s/sv' % name][:].squeeze() node_labels = np.zeros(rag.numberOfNodes, dtype='uint32') node_labels[fg] = 1 seg = nrag.projectScalarNodeDataToPixels(rag, node_labels) return seg
def preagglomerate(affs, ws, n_labels, thresh=.95): offsets = [[-1, 0, 0], [0, -1, 0], [0, 0, -1], [-2, 0, 0], [0, -3, 0], [0, 0, -3], [-3, 0, 0], [0, -9, 0], [0, 0, -9], [-4, 0, 0], [0, -27, 0], [0, 0, -27]] rag = nrag.gridRag(ws, numberOfLabels=int(n_labels), numberOfThreads=1) probs = nrag.accumulateAffinityStandartFeatures(rag, affs, offsets, numberOfThreads=1)[:, 0] agglomerator = cseg.MalaClustering(thresh) g = nifty.graph.undirectedGraph(rag.numberOfNodes) g.insertEdges(rag.uvIds()) node_labels = agglomerator(g, probs) return nrag.projectScalarNodeDataToPixels(rag, node_labels), int( node_labels.max())
def project_node_labels_to_pixels(rag, node_labels, n_threads=None): """ Project label values for graph nodes back to pixels to obtain segmentation. Arguments: rag [RegionAdjacencyGraph] - region adjacency graph node_labels [np.ndarray] - array with node labels n_threads [int] - number of threads used, set to cpu count by default. (default: None) """ n_threads = multiprocessing.cpu_count() if n_threads is None else n_threads if len(node_labels) != rag.numberOfNodes: raise ValueError("Incompatible number of node labels: %i, %i" % (len(node_labels), rag.numberOfNodes)) seg = nrag.projectScalarNodeDataToPixels(rag, node_labels, numberOfThreads=n_threads) return seg
def agglomerate_sp(ws_path, prob_path, out_path, threshold): probs = vigra.readHDF5(prob_path, 'data') ws = vigra.readHDF5(ws_path, 'data') n_nodes = int(ws.max()) + 1 rag = nrag.gridRag(ws, numberOfLabels=n_nodes) graph = nifty.graph.undirectedGraph(n_nodes) graph.insertEdges(rag.uvIds()) agglomerator = cseg.MalaClustering(threshold) node_labeling = agglomerator(graph, probs) vigra.analysis.relabelConsecutive(node_labeling, out=node_labeling) seg = nrag.projectScalarNodeDataToPixels(rag, node_labeling) view([ws, seg]) vigra.writeHDF5(seg, out_path, 'data', compression='gzip')
def debug_costs(): example_path = '/home/cpape/Work/data/isbi2012/cluster_example/isbi_train.n5' costs = z5py.File(example_path)['costs'][:] edges = z5py.File(example_path)['graph/edges'][:] n_nodes = int(edges.max()) + 1 graph = nifty.graph.undirectedGraph(n_nodes) graph.insertEdges(edges) assert graph.numberOfEdges == len(costs) node_labels = multicut_kernighan_lin(graph, costs) ws = z5py.File(example_path)['volumes/watersheds'][:] rag = nrag.gridRag(ws, numberOfLabels=n_nodes) seg = nrag.projectScalarNodeDataToPixels(rag, node_labels) view([ws, seg])
def segment_sample(sample): aff_path = '%s' % sample print("Load affinities") affs = 1. - z5py.File(aff_path)['predictions/full_affs'][:] # affs = 1. - vigra.readHDF5('./sampleB+_affs_cut.h5', 'data') print("done") # TODO multi-threaded print("making oversegmentation") seg = make_oversegmentation(affs, 8) print("done") # for z in range(seg.shape[0]): # print(seg[z].min(), seg[z].max(), seg[z].max() - seg[z].min()) # quit() print("computing features") rag, lr_uvs, local_prob, lr_prob = compute_features(seg, affs) print("done") assert rag.numberOfEdges == len(local_prob) assert len(lr_uvs) == len(lr_prob) uvs = rag.uvIds() n_nodes = rag.numberOfNodes assert lr_uvs.max() + 1 == n_nodes print("compute mutex clustering") # TODO do I need to invert the lr weights ?! lr_prob = 1. - lr_prob t0 = time.time() node_labeling = nmws.computeMwsClustering(n_nodes, uvs.astype('uint32'), lr_uvs.astype('uint32'), local_prob, lr_prob) assert len(node_labeling) == n_nodes print("done in", time.time() - t0, "s") # get segmentation mws_seg = nrag.projectScalarNodeDataToPixels(rag, node_labeling) out_path = '' % sample vigra.writeHDF5(mws_seg, out_path, 'volumes/labels/neuron_ids', compression='gzip')
def check(segment_id, bb): path = '/g/arendt/pape/proofreading_fib/data.n5' key_raw = 'volumes/raw/s1' key_merged = 'volumes/merged/v1' key_frag = 'volumes/segmentation/data/s0' f = z5py.File(path) ds = f[key_frag] ds.n_threads = 8 frag = ds[bb] with open('./res.pkl', 'rb') as fres: res = pickle.load(fres) fragment_ids = res['ids'] assignments = res['assignments'] n_nodes = int(frag.max()) + 1 node_labels = np.zeros(n_nodes, dtype='uint64') node_labels[fragment_ids] = assignments print("Compute rag ...") rag = nrag.gridRag(frag, numberOfLabels=n_nodes, numberOfThreads=8) print("done") new_seg = nrag.projectScalarNodeDataToPixels(rag, node_labels) seed_fragments = [3523531, 3980164] mask_seeds = (frag == seed_fragments[0]).astype('uint32') mask_seeds[frag == seed_fragments[1]] = 2 ds = f[key_merged] ds.n_threads = 8 seg = ds[bb] mask_seg = (seg == segment_id).astype('uint32') ds = f[key_raw] ds.n_threads = 8 raw = ds[bb].astype('float32') view([raw, frag, seg, mask_seeds, mask_seg, new_seg], ['raw', 'fragments', 'segments', 'seed-mask', 'seg-mask', 'curated'])
def mc_from_costs(sample, out_key=None): path = '/home/papec/Work/neurodata_hdd/ntwrk_papec/cremi_warped/sampleA+.n5' # path = '/home/papec/Work/neurodata_hdd/ntwrk_papec/cluster_test_data/testdata1.n5' ws_key = 'segmentations/watershed' # data_key = 'predictions/full_affs' raw_key = 'raw' # first we calculate the graph and features ws = z5py.File(path)[ws_key][:].astype('uint32') rag = nrag.gridRag(ws, numberOfLabels=int(ws.max()) + 1) feature_path = '/home/papec/Work/neurodata_hdd/ntwrk_papec/cache/cremi_A+/tmp_files/features.n5' # feature_path = '/home/papec/Work/neurodata_hdd/ntwrk_papec/cluster_test_data/aff_features.n5' probs = 1. - z5py.File(feature_path)['features'][:, 0:1] probs = probs.squeeze() assert rag.numberOfEdges == len(probs), "%i, %i" % (rag.numberOfEdges, len(probs)) costs = cseg.transform_probabilities_to_costs(probs, edge_sizes=None) uv_ids = rag.uvIds() ignore_edges = (uv_ids == 0).any(axis=1) costs[ignore_edges] = 5 * costs.min() # finally, we run multicut cutter = cseg.Multicut("kernighan-lin") graph = nifty.graph.undirectedGraph(rag.numberOfNodes) graph.insertEdges(uv_ids) node_labels = cutter(graph, costs) segmentation = nrag.projectScalarNodeDataToPixels(rag, node_labels) if out_key is not None: f = z5py.File('./mc_%s.n5' % sample, use_zarr_format=False) ds = f.create_dataset(out_key, dtype='uint32', compression='gzip', shape=segmentation.shape, chunks=(64, 64, 64)) ds[:] = segmentation.astype('uint32') else: raw = z5py.File(path)[raw_key][:] view([raw, ws, segmentation])
def segment_mcrf(ws, affs, n_labels, offsets, rf, return_merged_nodes=False): rag = nrag.gridRag(ws, numberOfLabels=int(n_labels), numberOfThreads=1) feats = nrag.accumulateAffinityStandartFeatures(rag, affs, offsets, numberOfThreads=1) probs = rf.predict_proba(feats)[:, 1] uv_ids = rag.uvIds() mc = cseg.Multicut('kernighan-lin', weight_edges=False) costs = mc.probabilities_to_costs(probs) ignore_edges = (uv_ids == 0).any(axis=1) costs[ignore_edges] = 5 * costs.min() graph = nifty.graph.undirectedGraph(n_labels) graph.insertEdges(uv_ids) node_labels = mc(graph, costs) if return_merged_nodes: return get_merged_nodes(uv_ids, node_labels) else: return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def agglomerate_sp_eval(ws_path, gt_path, prob_path): probs = vigra.readHDF5(prob_path, 'data') ws = vigra.readHDF5(ws_path, 'data') n_nodes = int(ws.max()) + 1 rag = nrag.gridRag(ws, numberOfLabels=n_nodes) # _, node_sizes = np.unique(ws, return_counts=True) # edge_sizes = nrag.accumulateEdgeMeanAndLength(rag, np.zeros(rag.shape, dtype='float32'))[:, 1] graph = nifty.graph.undirectedGraph(n_nodes) graph.insertEdges(rag.uvIds()) gt = Volume(vigra.readHDF5(gt_path, 'data')) # node_factor = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1][::-1] node_factor = [.025, .05, .075, .1, .15, .2, .25, .4, .5] for nf in node_factor: # FIXME agglomerative clustering segfaults # n_target_nodes = int(nf * n_nodes) # agglomerator = cseg.AgglomerativeClustering(n_target_nodes) # node_labeling = agglomerator(graph, probs, edge_sizes=edge_sizes, node_sizes=node_sizes) agglomerator = cseg.MalaClustering(nf) node_labeling = agglomerator(graph, probs) vigra.analysis.relabelConsecutive(node_labeling, out=node_labeling) seg = nrag.projectScalarNodeDataToPixels(rag, node_labeling) seg = Volume(seg) metrics = NeuronIds(gt) vi_s, vi_m = metrics.voi(seg) are = metrics.adapted_rand(seg) print("Evaluation for reduction", nf) print("Voi - Split ", vi_s) print("Voi - Merge ", vi_m) print("Adapted Rand", are) print("N-Nodes:", int(node_labeling.max() + 1), '/', n_nodes)
def gt_projection(block_id): ws_path = '/home/papec/Work/neurodata_hdd/fib25/watersheds/watershed_block%i.h5' % block_id ws = vigra.readHDF5(ws_path, 'data') ws = vigra.analysis.labelVolume(ws.astype('uint32')) gt = vigra.readHDF5('/home/papec/Work/neurodata_hdd/fib25/gt/gt_block%i.h5' % block_id, 'data') rag = nrag.gridRag(ws, numberOfLabels=int(ws.max()) + 1) labeling = nrag.gridRagAccumulateLabels(rag, gt) projected = Volume(nrag.projectScalarNodeDataToPixels(rag, labeling)) metrics = NeuronIds(Volume(gt)) vi_s, vi_m = metrics.voi(projected) are = metrics.adapted_rand(projected) print(vi_s) print(vi_m) print(are) print() os.remove(ws_path) vigra.writeHDF5(ws, ws_path, 'data', compression='gzip')
def _agglomerate_block(blocking, block_id, ds_in, ds_out, config): fu.log("start processing block %i" % block_id) have_ignore_label = config['have_ignore_label'] use_mala_agglomeration = config.get('use_mala_agglomeration', True) threshold = config.get('threshold', 0.9) size_regularizer = config.get('size_regularizer', .5) invert_inputs = config.get('invert_inputs', False) offsets = config.get('offsets', None) bb = vu.block_to_bb(blocking.getBlock(block_id)) # load the segmentation / output seg = ds_out[bb] # check if this block is empty if np.sum(seg) == 0: fu.log_block_success(block_id) return # load the input data ndim_in = ds_in.ndim if ndim_in == 4: assert offsets is not None assert len(offsets) <= ds_in.shape[0] bb_in = (slice(0, len(offsets)),) + bb input_ = vu.normalize(ds_in[bb_in]) else: assert offsets is None input_ = vu.normalize(ds_in[bb]) if invert_inputs: input_ = 1. - input_ id_offset = int(seg[seg != 0].min()) # relabel the segmentation _, max_id, _ = relabelConsecutive(seg, out=seg, keep_zeros=True, start_label=1) seg = seg.astype('uint32') # construct rag rag = nrag.gridRag(seg, numberOfLabels=max_id + 1, numberOfThreads=1) # extract edge features if offsets is None: edge_features = nrag.accumulateEdgeMeanAndLength(rag, input_, numberOfThreads=1) else: edge_features = nrag.accumulateAffinityStandartFeatures(rag, input_, offsets, numberOfThreads=1) edge_features, edge_sizes = edge_features[:, 0], edge_features[:, -1] uv_ids = rag.uvIds() # set edges to ignore label to be maximally repulsive if have_ignore_label: ignore_mask = (uv_ids == 0).any(axis=1) edge_features[ignore_mask] = 1 # build undirected graph n_nodes = rag.numberOfNodes graph = nifty.graph.undirectedGraph(n_nodes) graph.insertEdges(uv_ids) if use_mala_agglomeration: node_labels = mala_clustering(graph, edge_features, edge_sizes, threshold) else: node_ids, node_sizes = np.unique(seg, return_counts=True) if node_ids[0] != 0: node_sizes = np.concatenate([np.array([0]), node_sizes]) n_stop = int(threshold * n_nodes) node_labels = agglomerative_clustering(graph, edge_features, node_sizes, edge_sizes, n_stop, size_regularizer) # run clusteting node_labels, max_id, _ = relabelConsecutive(node_labels, start_label=1, keep_zeros=True) fu.log("reduced number of labels from %i to %i" % (n_nodes, max_id + 1)) # project node labels back to segmentation seg = nrag.projectScalarNodeDataToPixels(rag, node_labels, numberOfThreads=1) seg = seg.astype('uint64') # add offset back to segmentation seg[seg != 0] += id_offset ds_out[bb] = seg # log block success fu.log_block_success(block_id)
def merge_along_skeletons(block_id, in_key, out_key, n_threads): path = '/nrs/saalfeld/lauritzen/0%i/workspace.n5' % block_id key1 = '/'.join(('filtered', 'segmentations', in_key)) label_file = os.path.join(path, key1) # find false splits according to skeletons and the nodes that have to # be merged to fix it skeleton_file = os.path.join(path, 'skeletons') metrics = build_skeleton_metrics(label_file, skeleton_file, n_threads) skeleton_merges = metrics.mergeFalseSplitNodes(n_threads) n_labels = z5py.File(label_file).attrs['maxId'] + 1 # get new node labeling with ufd ufd = nifty.ufd.ufd(n_labels) for _, merge_nodes in skeleton_merges.items(): merge_nodes = np.array([mn for mn in merge_nodes]) ufd.merge(merge_nodes) node_labels = ufd.elementLabeling() # TODO make sure 0 is mapped to zero vigra.analysis.relabelConsecutive(node_labels, out=node_labels, keep_zeros=True, start_label=1) labels = nz5.datasetWrapper('uint64', label_file) block_shape = [25, 256, 256] rag_file = './rag.npy' if not os.path.exists(rag_file): print("Computing RAG...") rag = nrag.gridRagZ5(labels, numberOfLabels=int(n_labels), numberOfThreads=n_threads, dtype='uint64', blockShape=block_shape) np.save(rag_file, rag.serialize()) print("... done") else: ragser = np.load(rag_file) rag = nrag.gridRagZ5(labels, numberOfLabels=int(n_labels), serialization=ragser, dtype='uint64') f_out = z5py.File(path) key2 = '/'.join(('filtered', 'segmentations', out_key)) if key2 not in f_out: f_out.create_dataset(key2, dtype='uint64', compression='gzip', shape=z5py.File(path)[key1].shape, chunks=z5py.File(path)[key1].chunks) out_file = os.path.join(path, key2) out = nz5.datasetWrapper('uint64', out_file) print("Projecting to pixels...") nrag.projectScalarNodeDataToPixels(graph=rag, nodeData=node_labels, pixelData=out, blockShape=block_shape, numberOfThreads=n_threads) print("... done") z5py.File(path)[key2].attrs['maxId'] = n_labels - 1
# Agglomeration: print("Agglomerating...") c_graph = nifty.graph.edgeContractionGraph( rag, nifty.graph.EdgeContractionGraphCallback()) uv_ids_to_merge = uv_ids[edges_to_be_merged, :] for u, v in uv_ids_to_merge: repr_u = c_graph.findRepresentativeNode(u) repr_v = c_graph.findRepresentativeNode(v) if repr_u != repr_v: repr_edge = c_graph.findRepresentativeEdge( rag.findEdge(u, v)) c_graph.contractEdge(repr_edge) node_labels = np.array([ c_graph.findRepresentativeNode(u) for u in rag.nodes() ]) segm = nrag.projectScalarNodeDataToPixels(rag, node_labels) else: postfix = "_relabeled" assert gt_segm.shape == segm.shape # Find connected components gt_ignore_mask = gt_segm == 0 segm += 1 segm[gt_ignore_mask] = 0 segm = vigra.analysis.labelVolumeWithBackground( segm.astype('uint32')) if COMPUTE_NEW_SCORES: from segmfriends.utils.various import cremi_score
def lmc(rag, lifted_uvs, local_features, lifted_features): lmc = cseg.LiftedMulticut('kernighan-lin', weight_edges=False) local_costs = lmc.probabilities_to_costs(local_features) lifted_costs = lmc.probabilities_to_costs(lifted_features) node_labels = lmc(rag.uvIds(), lifted_uvs, local_costs, lifted_costs) return nrag.projectScalarNodeDataToPixels(rag, node_labels)
def mws_clustering(rag, lifted_uvs, local_features, lifted_features): import nifty.mws as nmws node_labels = nmws.computeMwsClustering(rag.numberOfNodes, rag.uvIds(), lifted_uvs, local_features[:, 0], 1. - lifted_features[:, 0]) return nrag.projectScalarNodeDataToPixels(rag, node_labels)