def testGridGraphSegmentationFelzenszwalbSegmentation(): dataRGB = numpy.random.random([3,3,3]).astype(numpy.float32) dataRGB = taggedView(dataRGB,'xyc') data = numpy.random.random([3,3]).astype(numpy.float32) edata = numpy.random.random([3*2-1,3*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(g0,edata) labels = graphs.felzenszwalbSegmentation(graph=g0,edgeWeights=ew,k=1.0,nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 5 data = numpy.random.random([3,3,3]).astype(numpy.float32) edata = numpy.random.random([3*2-1,3*2-1,3*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(g0,edata) labels = graphs.felzenszwalbSegmentation(graph=g0,edgeWeights=ew,k=1.0,nodeNumStop=15) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 15
def testGridGraphSegmentationFelzenszwalbSegmentation(): dataRGB = numpy.random.random([3, 3, 3]).astype(numpy.float32) dataRGB = taggedView(dataRGB, 'xyc') data = numpy.random.random([3, 3]).astype(numpy.float32) edata = numpy.random.random([3 * 2 - 1, 3 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(g0, edata) labels = graphs.felzenszwalbSegmentation(graph=g0, edgeWeights=ew, k=1.0, nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 5 data = numpy.random.random([3, 3, 3]).astype(numpy.float32) edata = numpy.random.random([3 * 2 - 1, 3 * 2 - 1, 3 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(g0, edata) labels = graphs.felzenszwalbSegmentation(graph=g0, edgeWeights=ew, k=1.0, nodeNumStop=15) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 15
def testGridGraphWatersheds(): data = numpy.random.random([10, 10, 10]).astype(numpy.float32) edata = numpy.random.random([10 * 2 - 1, 10 * 2 - 1, 10 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0, image=edata) # generate seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0, nodeWeights=data) # node weighted watershed seeds labelsNodeWeightedA = graphs.nodeWeightedWatersheds(graph=g0, nodeWeights=data, seeds=seeds) # node weighted watershed seeds labelsNodeWeightedB = graphs.nodeWeightedWatersheds(graph=g0, nodeWeights=data) # edge weighted watershed seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0, nodeWeights=data) labelsEdgeWeighted = graphs.edgeWeightedWatersheds(graph=g0, edgeWeights=ew, seeds=seeds) assert numpy.array_equal(labelsNodeWeightedA, labelsNodeWeightedB) data = numpy.random.random([10, 10]).astype(numpy.float32) edata = numpy.random.random([10 * 2 - 1, 10 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0, image=edata) # generate seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0, nodeWeights=data) # node weighted watershed seeds labelsNodeWeightedA = graphs.nodeWeightedWatersheds(graph=g0, nodeWeights=data, seeds=seeds) # node weighted watershed seeds labelsNodeWeightedB = graphs.nodeWeightedWatersheds(graph=g0, nodeWeights=data) # edge weighted watershed seeds labelsEdgeWeighted = graphs.edgeWeightedWatersheds(graph=g0, edgeWeights=ew, seeds=seeds) assert numpy.array_equal(labelsNodeWeightedA, labelsNodeWeightedB)
def testGridGraphAgglomerativeClustering(): dataRGB = numpy.random.random([10, 10, 3]).astype(numpy.float32) dataRGB = vigra.taggedView(dataRGB, 'xyc') data = numpy.random.random([10, 10]).astype(numpy.float32) edata = numpy.random.random([10 * 2 - 1, 10 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0, image=edata) #ew = taggedView(ew,'xyz') labels = graphs.agglomerativeClustering(graph=g0, edgeWeights=ew, nodeFeatures=dataRGB, nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 5 labels = graphs.agglomerativeClustering(graph=g0, edgeWeights=ew, nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 5 dataRGB = numpy.random.random([10, 10, 10, 3]).astype(numpy.float32) dataRGB = vigra.taggedView(dataRGB, 'xyzc') data = numpy.random.random([10, 10, 10]).astype(numpy.float32) edata = numpy.random.random([10 * 2 - 1, 10 * 2 - 1, 10 * 2 - 1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0, image=edata) #ew = taggedView(ew,'xyz') labels = graphs.agglomerativeClustering(graph=g0, edgeWeights=ew, nodeFeatures=dataRGB, nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 5 labels = graphs.agglomerativeClustering(graph=g0, edgeWeights=ew, nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0, labels=labels) assert g1.nodeNum == 5
def labels_to_dense_gt(labels_path, probs): import vigra.graphs as vgraph labels = vol_to_vol(labels_path) gt = np.zeros_like(labels, dtype=np.uint32) offset = 0 for z in xrange(gt.shape[2]): hmap = vigra.filters.gaussianSmoothing(probs[:, :, z], 2.) seeds = vigra.analysis.labelImageWithBackground(labels[:, :, z]) gt[:, :, z], _ = vigra.analysis.watershedsNew(hmap, seeds=seeds) gt[:, :, z][gt[:, :, z] != 0] += offset offset = gt[:, :, z].max() # bring to 0 based indexing gt -= 1 # remove isolated segments rag_global = vgraph.regionAdjacencyGraph(vgraph.gridGraph(gt.shape[0:3]), gt) node_to_node = np.concatenate([ np.arange(rag_global.nodeNum, dtype=np.uint32)[:, None] for _ in range(2) ], axis=1) for z in xrange(gt.shape[2]): rag_local = vgraph.regionAdjacencyGraph( vgraph.gridGraph(gt.shape[0:2]), gt[:, :, z]) for node in rag_local.nodeIter(): neighbour_nodes = [] for nnode in rag_local.neighbourNodeIter(node): neighbour_nodes.append(nnode) if len(neighbour_nodes) == 1: node_coordinates = np.where(gt == node.id) if not 0 in node_coordinates[0] and not 511 in node_coordinates[ 0] and not 0 in node_coordinates[ 1] and not 511 in node_coordinates[1]: node_to_node[node.id] = neighbour_nodes[0].id gt_cleaned = rag_global.projectLabelsToBaseGraph(node_to_node)[:, :, :, 0] return gt_cleaned
def calc_edge_features(self, feature_matrix=None): grid_graph = graphs.gridGraph(self._data.shape) if feature_matrix is None: edge_features = graphs.edgeFeaturesFromImage(grid_graph, self._data) else: edge_features = graphs.edgeFeaturesFromImage(grid_graph, feature_matrix) self._edge_features = self._rag.accumulateEdgeFeatures(edge_features)
def testGridGraphAgglomerativeClustering(): dataRGB = numpy.random.random([10,10,3]).astype(numpy.float32) dataRGB = vigra.taggedView(dataRGB,'xyc') data = numpy.random.random([10,10]).astype(numpy.float32) edata = numpy.random.random([10*2-1,10*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0,image=edata) #ew = taggedView(ew,'xyz') labels = graphs.agglomerativeClustering(graph=g0,edgeWeights=ew,nodeFeatures=dataRGB,nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 5 labels = graphs.agglomerativeClustering(graph=g0,edgeWeights=ew,nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 5 dataRGB = numpy.random.random([10,10,10,3]).astype(numpy.float32) dataRGB = vigra.taggedView(dataRGB,'xyzc') data = numpy.random.random([10,10,10]).astype(numpy.float32) edata = numpy.random.random([10*2-1,10*2-1,10*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0,image=edata) #ew = taggedView(ew,'xyz') labels = graphs.agglomerativeClustering(graph=g0,edgeWeights=ew,nodeFeatures=dataRGB,nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 5 labels = graphs.agglomerativeClustering(graph=g0,edgeWeights=ew,nodeNumStop=5) g1 = graphs.regionAdjacencyGraph(graph=g0,labels=labels) assert g1.nodeNum == 5
def pmapSizeFilter(neuroCCBinaryPmap, minSize): """ keywords: neuroCCBinaryPmap: zero where membranes are one where neurons are """ shape = neuroCCBinaryPmap.shape # get the connected components neuroCCMap = vigra.analysis.labelVolume(neuroCCBinaryPmap) print "min max",neuroCCMap.min(), neuroCCMap.max() assert neuroCCMap.min() == 1 neuroCCMap -= 1 # get region adjacency graph from super-pixel labels gridGraph = graphs.gridGraph(shape[0:3]) rag = graphs.regionAdjacencyGraph(gridGraph, neuroCCMap) # get all sizes nodeSizes = rag.nodeSize() # nodeColoring print "neuroCCBinaryPmap",neuroCCBinaryPmap.dtype,neuroCCBinaryPmap.shape nodeColor = rag.accumulateNodeFeatures(neuroCCBinaryPmap.astype('float32')) # find to small nodes toSmallNodesIds = numpy.where(nodeSizes<minSize)[0] toSmallNodesSizes = nodeSizes[toSmallNodesIds] toSmallNodesColor = nodeColor[toSmallNodesIds] sortedIndices = numpy.argsort(toSmallNodesSizes) sortedIndices.shape,sortedIndices toSmallNodesIds = toSmallNodesIds[sortedIndices] # todo (impl degree map as numpy array) for nid in toSmallNodesIds: neigbours = [] for n in rag.neighbourNodeIter(rag.nodeFromId(nid)): neigbours.append(n) if len(neigbours)==1: # flip color nodeColor[nid] = int(not bool(nodeColor[nid])) pixelColor = rag.projectNodeFeaturesToGridGraph(nodeColor) return pixelColor,neuroCCBinaryPmap
def testGridGraphWatersheds(): data = numpy.random.random([10,10,10]).astype(numpy.float32) edata = numpy.random.random([10*2-1,10*2-1,10*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0,image=edata) # generate seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0,nodeWeights=data) # node weighted watershed seeds labelsNodeWeightedA = graphs.nodeWeightedWatersheds(graph=g0,nodeWeights=data,seeds=seeds) # node weighted watershed seeds labelsNodeWeightedB = graphs.nodeWeightedWatersheds(graph=g0,nodeWeights=data) # edge weighted watershed seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0,nodeWeights=data) labelsEdgeWeighted = graphs.edgeWeightedWatersheds(graph=g0,edgeWeights=ew,seeds=seeds) assert numpy.array_equal(labelsNodeWeightedA,labelsNodeWeightedB) data = numpy.random.random([10,10]).astype(numpy.float32) edata = numpy.random.random([10*2-1,10*2-1]).astype(numpy.float32) g0 = graphs.gridGraph(data.shape) ew = graphs.edgeFeaturesFromInterpolatedImage(graph=g0,image=edata) # generate seeds seeds = graphs.nodeWeightedWatershedsSeeds(graph=g0,nodeWeights=data) # node weighted watershed seeds labelsNodeWeightedA = graphs.nodeWeightedWatersheds(graph=g0,nodeWeights=data,seeds=seeds) # node weighted watershed seeds labelsNodeWeightedB = graphs.nodeWeightedWatersheds(graph=g0,nodeWeights=data) # edge weighted watershed seeds labelsEdgeWeighted = graphs.edgeWeightedWatersheds(graph=g0,edgeWeights=ew,seeds=seeds) assert numpy.array_equal(labelsNodeWeightedA,labelsNodeWeightedB)
def pmapSizeFilter(neuroCCBinaryPmap, minSize): """ keywords: neuroCCBinaryPmap: zero where membranes are one where neurons are """ shape = neuroCCBinaryPmap.shape # get the connected components neuroCCMap = vigra.analysis.labelVolume(neuroCCBinaryPmap) print "min max", neuroCCMap.min(), neuroCCMap.max() assert neuroCCMap.min() == 1 neuroCCMap -= 1 # get region adjacency graph from super-pixel labels gridGraph = graphs.gridGraph(shape[0:3]) rag = graphs.regionAdjacencyGraph(gridGraph, neuroCCMap) # get all sizes nodeSizes = rag.nodeSize() # nodeColoring print "neuroCCBinaryPmap", neuroCCBinaryPmap.dtype, neuroCCBinaryPmap.shape nodeColor = rag.accumulateNodeFeatures(neuroCCBinaryPmap.astype('float32')) # find to small nodes toSmallNodesIds = numpy.where(nodeSizes < minSize)[0] toSmallNodesSizes = nodeSizes[toSmallNodesIds] toSmallNodesColor = nodeColor[toSmallNodesIds] sortedIndices = numpy.argsort(toSmallNodesSizes) sortedIndices.shape, sortedIndices toSmallNodesIds = toSmallNodesIds[sortedIndices] # todo (impl degree map as numpy array) for nid in toSmallNodesIds: neigbours = [] for n in rag.neighbourNodeIter(rag.nodeFromId(nid)): neigbours.append(n) if len(neigbours) == 1: # flip color nodeColor[nid] = int(not bool(nodeColor[nid])) pixelColor = rag.projectNodeFeaturesToGridGraph(nodeColor) return pixelColor, neuroCCBinaryPmap
def get_segmentation(predict, pmin=0.5, minMemb=10, minSeg=10, sigMin=6, sigWeights=1, sigSmooth=0.1, cleanCloseSeeds=True, returnSeedsOnly=False, edgeLengths=None,nodeFeatures=None, nodeSizes=None, nodeLabels=None, nodeNumStop=None, beta=0, metric='l1', wardness=0.2, out=None): """ Get segmentation through watershed and agglomerative clustering :param predict: prediction map :return: segmentation map """ #use watershed and save superpixels map super_pixels = wsDtSegmentation(predict, pmin, minMemb, minSeg, sigMin, sigWeights, cleanCloseSeeds, returnSeedsOnly) # seeds = wsDtSegmentation(predict, pmin, minMemb, minSeg, sigMin, sigWeights, cleanCloseSeeds, True) # save_h5(seeds, "/home/stamylew/delme/seeds.h5", "data") print print "#Nodes in superpixels", len(np.unique(super_pixels)) # save_h5(super_pixels, "/home/stamylew/delme/super_pixels.h5", "data") #smooth prediction map probs = vf.gaussianSmoothing(predict, sigSmooth) # save_h5(probs, "/home/stamylew/delme/probs.h5", "data") #make grid graph grid_graph = vg.gridGraph(super_pixels.shape, False) grid_graph_edge_indicator = vg.edgeFeaturesFromImage(grid_graph, probs) #make region adjacency graph rag = vg.regionAdjacencyGraph(grid_graph, super_pixels) #accumulate edge features from grid graph node map edge_weights = rag.accumulateEdgeFeatures(grid_graph_edge_indicator) edge_weights_tag = "mean of the probabilities" #do agglomerative clustering labels = vg.agglomerativeClustering(rag, edge_weights, edgeLengths, nodeFeatures, nodeSizes, nodeLabels, nodeNumStop, beta, metric, wardness, out) #segmentation data wsDt_data = np.zeros((8,1)) wsDt_data[:,0] = (pmin, minMemb, minSeg, sigMin, sigWeights, sigSmooth, cleanCloseSeeds, returnSeedsOnly) agglCl_data = edge_weights_tag, str(edgeLengths), str(nodeFeatures), str(nodeSizes), str(nodeLabels), str(nodeNumStop), \ str(beta), metric, str(wardness), str(out) #project labels back to data segmentation = rag.projectLabelsToBaseGraph(labels) print "#nodes in segmentation", len(np.unique(segmentation)) # save_h5(segmentation, "/home/stamylew/delme/segmap.h5", "data", None) print "seg", np.unique(segmentation) return segmentation, super_pixels, wsDt_data, agglCl_data
def shortest_paths(indicator, pairs, bounds=None, hfp=None): # Crate the grid graph and shortest path objects gridgr = graphs.gridGraph(indicator.shape) indicator = indicator.astype(np.float32) gridgr_edgeind = graphs.edgeFeaturesFromImage(gridgr, indicator) instance = graphs.ShortestPathPathDijkstra(gridgr) # Initialize paths image pathsim = np.zeros(indicator.shape) # Initialize list of path coordinates paths = [] for pair in pairs: source = pair[0] target = pair[1] if hfp is not None: hfp.logging('Calculating path from {} to {}', source, target) targetNode = gridgr.coordinateToNode(target) sourceNode = gridgr.coordinateToNode(source) instance.run(gridgr_edgeind, sourceNode, target=targetNode) path = instance.path(pathType='coordinates') if path.any(): # Do not forget to correct for the offset caused by cropping! if bounds is not None: paths.append(path + [bounds[0].start, bounds[1].start, bounds[2].start]) else: paths.append(path) pathindices = np.swapaxes(path, 0, 1) pathsim[pathindices[0], pathindices[1], pathindices[2]] = 1 return paths, pathsim
def shortest_paths(indicator, pairs, n_threads=1): """ This function was copied from processing_lib.py :param indicator: :return: """ gridgr = graphs.gridGraph(indicator.shape) gridgr_edgeind = graphs.implicitMeanEdgeMap(gridgr, indicator.astype('float32')) def single_path(pair, instance=None): source = pair[0] target = pair[1] print 'Calculating path from {} to {}'.format(source, target) if instance == None: instance = graphs.ShortestPathPathDijkstra(gridgr) targetNode = gridgr.coordinateToNode(target) sourceNode = gridgr.coordinateToNode(source) instance.run(gridgr_edgeind, sourceNode, target=targetNode) path = instance.path(pathType='coordinates') if path.any(): return path if n_threads > 1: print "Multi-threaded w/ n-threads = ", n_threads with futures.ThreadPoolExecutor(max_workers=n_threads) as executor: tasks = [executor.submit(single_path, pair) for pair in pairs] paths = [t.result() for t in tasks] else: print "Single threaded" instance = graphs.ShortestPathPathDijkstra(gridgr) paths = [single_path(pair, instance) for pair in pairs] return paths
print "write thinned pmap transform" vigra.impex.writeHDF5(res, opt['thinnedDistTransformPMap1'], "data") skneuro.addHocViewer(grayData, segData) if False: print "make the graph and save it" print "read segmentation" seg = vigra.impex.readHDF5(opt['oversegL0'], "data") segData.append([seg, "seg"]) gridGraph = graphs.gridGraph(seg.shape[0:3]) print "make rag" # get region adjacency graph from super-pixel labels rag = graphs.regionAdjacencyGraph(gridGraph, seg, isDense=False) print "save rag to file" rag.writeHDF5(opt['ragL0'],'data') if False: print "accumulate edge weights and save them" print "load rag"
def calculate_distances(): """ compute distances between color markers instead of existing synapses markers of the same color should be in the same neuron """ files_2d = glob.glob(inputdir + d2_pattern) files_2d = sorted(files_2d, key=str.lower) files_3d = glob.glob(inputdir + d3_pattern) files_3d = sorted(files_3d, key=str.lower) files_markers = glob.glob(inputdir + marker_pattern) files_markers = sorted(files_markers, key=str.lower) debug_dirs = glob.glob(debugdir) debug_dirs = sorted(debug_dirs, key=str.lower) files_raw = glob.glob(inputdir + raw_pattern) files_raw = sorted(files_raw, key=str.lower) #print files_2d, files_3d, files_markers, debug_dirs, files_raw first = 0 last = 4 all_distances_same = [] all_distances_diff = [] nsamesame = 0 nsamediff = 0 ndiffdiff = 0 ndiffsame = 0 for f2name, f3name, mname, ddir, rawname in zip(files_2d[first:last], files_3d[first:last], files_markers[first:last], debug_dirs[first:last], files_raw[first:last]): print "processing files:" print f2name print f3name print mname print ddir print rawname tempGraph = Graph() edgeIndicators = [] instances = [] if debug_images: rawim = vigra.readImage(rawname) vigra.impex.writeImage(rawim, ddir + "/raw.tiff") #print "processing files:", f2name, f3name, mname f2 = h5py.File(f2name) f3 = h5py.File(f3name) if use_2d_only: d2 = f2["exported_data"][5, :, :, 0] d3 = f2["exported_data"][5, :, :, 2] else: d2 = f2["exported_data"][..., 0] d3 = f3["exported_data"][5, :, :, 2] # 5 because we only want the central slice, there are 11 in total d3 = d3.swapaxes(0, 1) # print d2.shape, d3.shape combined = d2 + d3 if use_2d_only: #convert to float combined = combined.astype(numpy.float32) combined = combined/255. markedNodes = extractMarkedNodes(mname) # print opUpsample = OpUpsampleByTwo(graph=tempGraph) combined = numpy.reshape(combined, combined.shape + (1,) + (1,)) combined = combined.view(vigra.VigraArray) combined.axistags = vigra.defaultAxistags('xytc') opUpsample.Input.setValue(combined) upsampledMembraneProbs = opUpsample.Output[:].wait() # get rid of t upsampledMembraneProbs = upsampledMembraneProbs[:, :, 0, :] upsampledMembraneProbs = upsampledMembraneProbs.view(vigra.VigraArray) upsampledMembraneProbs.axistags = vigra.defaultAxistags('xyc') # try to filter upsampledSmoothedMembraneProbs = computeDistanceRaw(upsampledMembraneProbs, 1.6, ddir) upsampledMembraneProbs = filter_by_size(upsampledSmoothedMembraneProbs, ddir) upsampledMembraneProbs = upsampledMembraneProbs.view(vigra.VigraArray) upsampledMembraneProbs.axistags = vigra.defaultAxistags('xyc') edgeIndicators.append(computeDistanceHessian(upsampledMembraneProbs, 5.0, ddir)) edgeIndicators.append(upsampledSmoothedMembraneProbs) segm = superpixels(combined.squeeze()) if debug_images: vigra.impex.writeImage(segm, ddir + "/superpixels.tiff") gridGr = graphs.gridGraph((d2.shape[0], d2.shape[1])) # !on original pixels for iind, indicator in enumerate(edgeIndicators): gridGraphEdgeIndicator = graphs.edgeFeaturesFromInterpolatedImage(gridGr, indicator) instance = vigra.graphs.ShortestPathPathDijkstra(gridGr) instances.append(instance) distances_same = [] distances_diff = [] for color, points in markedNodes.iteritems(): #going over points of *same* color if len(points)>1: print "Processing color", color for i in range(len(points)): node = map(long, points[i]) sourceNode = gridGr.coordinateToNode(node) instance.run(gridGraphEdgeIndicator, sourceNode, target=None) distances_all = instance.distances() sp_this = segm[node[0], node[1]] for j in range(i + 1, len(points)): # go over points of the same color other_node = map(long, points[j]) distances_same.append(distances_all[other_node[0], other_node[1]]) sp_other = segm[other_node[0], other_node[1]] if sp_this==sp_other: nsamesame = nsamesame + 1 #print "same color in the same superpixel!" else: nsamediff += 1 #targetNode = gridGr.coordinateToNode(other_node) #path = instance.run(gridGraphEdgeIndicator, sourceNode).path(pathType='coordinates', # target=targetNode) #max_on_path = numpy.max(distances_all[path]) #min_on_path = numpy.min(distances_all[path]) # print max_on_path, min_on_path # print path.shape #print "distance b/w", node, other_node, " = ", distances_all[other_node[0], other_node[1]] for newcolor, newpoints in markedNodes.iteritems(): # go over points of other colors if color == newcolor: continue for newi in range(len(newpoints)): other_node = map(long, newpoints[newi]) sp_other = segm[other_node[0], other_node[1]] if sp_this==sp_other: ndiffsame += 1 else: ndiffdiff += 1 distances_diff.append(distances_all[other_node[0], other_node[1]]) # highlight the source point in image distances_all[node[0], node[1]] = numpy.max(distances_all) outfile = ddir + "/" + str(node[0]) + "_" + str(node[1]) + "_" + str(iind) + ".tiff" vigra.impex.writeImage(distances_all, outfile) while len(all_distances_diff)<len(edgeIndicators): all_distances_diff.append([]) all_distances_same.append([]) all_distances_diff[iind].extend(distances_diff) all_distances_same[iind].extend(distances_same) #print "summary for edge indicator:", iind #print "points of same color:", distances_same #print "points of other colors:", distances_diff # print distances_same # vigra.impex.writeImage(combined, f2name+"_combined.tiff") # vigra.impex.writeImage(d3, f2name+"_synapse.tiff") # vigra.impex.writeImage(d2, f2name+"_membrane.tiff") print "same color in the same superpixels:", nsamesame print "same color, different superpixels:", nsamediff print "diff color, same superpixel:", ndiffsame print "diff color, diff superpixels", ndiffdiff analyze_distances(all_distances_same, all_distances_diff)
from vigra import Timer iEdgeMap = graphs.implicitMeanEdgeMap numpy.random.seed(42) # input shape = [200, 100, 100] data = numpy.random.rand(*shape).astype(numpy.float32) data = vigra.taggedView(data, "xyz") if False: labels = numpy.random.randint(5, size=shape[0] * shape[1] * shape[2]) labels = labels.reshape(shape).astype(numpy.uint32) labels = vigra.analysis.labelVolume(labels) adjListGraph = graphs.listGraph() gridGraph = graphs.gridGraph(shape) rag = graphs.regionAdjacencyGraph(gridGraph, labels) rag.writeHDF5("bla.h5", "dset") else: # load the region adjacency graph rag = graphs.loadGridRagHDF5("bla.h5", "dset") print rag.labels.shape, rag.labels.dtype, type(rag.labels) print "accumulate edge and node features" edgeCuesMean = rag.accumulateEdgeFeatures(iEdgeMap(rag.baseGraph, data)) edgeCuesMean = numpy.array([edgeCuesMean, edgeCuesMean]).T
def find_shortest_path(ifp, penaltypower, bounds): # Modify distancetransform # # a) Invert: the lowest values (i.e. the lowest penalty for the shortest path detection) should be at the center of # the current process ifp.invert_image(ids='curdisttransf') # # b) Set all values outside the process to infinity ifp.filter_values(ifp.amax('curdisttransf'), type='eq', setto=np.inf, ids='curdisttransf', targetids='curdisttransf_inf') # # c) Increase the value difference between pixels near the boundaries and pixels central within the processes # This increases the likelihood of the paths to follow the center of processes, thus avoiding short-cuts ifp.power(penaltypower, ids='curdisttransf_inf') indicator = ifp.get_image('curdisttransf_inf') gridgr = graphs.gridGraph(ifp.shape('curlabel')) ifp.logging('gridgr.shape = {}'.format(gridgr.shape)) indicator = indicator.astype(np.float32) gridgr_edgeind = graphs.edgeFeaturesFromImage(gridgr, indicator) instance = graphs.ShortestPathPathDijkstra(gridgr) # Get two local maxima indices = np.where(ifp.get_image('curlocmax') == 1) coords = zip(indices[0], indices[1], indices[2]) ifp.logging('Local maxima coordinates: {}'.format(coords)) ifp.set_data_dict({'pathsim': np.zeros(ifp.get_image('curlocmax').shape)}, append=True) ifp.logging('len(coords) = {}'.format(len(coords))) paths = [] for i in xrange(0, len(coords) - 1): for j in xrange(i + 1, len(coords)): ifp.logging('---') ifp.logging('i = {0}; j = {1}'.format(i, j)) source = coords[i] target = coords[j] targetNode = gridgr.coordinateToNode(target) sourceNode = gridgr.coordinateToNode(source) ifp.logging('Source = {}'.format(source)) ifp.logging('Target = {}'.format(target)) instance.run(gridgr_edgeind, sourceNode, target=targetNode) path = instance.path(pathType='coordinates') # Do not forget to correct for the offset caused by cropping! paths.append(path + [bounds[0][0], bounds[1][0], bounds[2][0]]) # for coords in path: # # ifp.logging('coords = {}'.format(coords)) # pass pathindices = np.swapaxes(path, 0, 1) ifp.get_image('pathsim')[pathindices[0], pathindices[1], pathindices[2]] = 1 # ifp.concatenate('disttransf', 'paths', target='paths_over_dist') ifp.astype(np.uint8, ('pathsim', 'curlocmax')) # ifp.anytask(vigra.filters.multiBinaryDilation, ('paths', 'locmax'), 3) ifp.swapaxes(0, 2, ids=('pathsim', 'curlocmax', 'curdisttransf')) ifp.anytask(vigra.filters.discDilation, 2, ids=('pathsim', 'curlocmax')) ifp.set_data_dict( { 'paths_over_dist': np.array([ ifp.get_image('pathsim'), ifp.get_image('curlocmax'), ifp.get_image('curdisttransf') ]) }, append=True) return paths
numpy.random.seed(42) # input shape = [200, 100, 100] data = numpy.random.rand(*shape).astype(numpy.float32) data = vigra.taggedView(data,"xyz") if False: labels = numpy.random.randint(5, size=shape[0]*shape[1]*shape[2]) labels = labels.reshape(shape).astype(numpy.uint32) labels = vigra.analysis.labelVolume(labels) adjListGraph = graphs.listGraph() gridGraph = graphs.gridGraph(shape) rag = graphs.regionAdjacencyGraph(gridGraph, labels) rag.writeHDF5("bla.h5", "dset") else : # load the region adjacency graph rag = graphs.loadGridRagHDF5("bla.h5","dset") print rag.labels.shape, rag.labels.dtype ,type(rag.labels) print "accumulate edge and node features" edgeCuesMean = rag.accumulateEdgeFeatures( iEdgeMap(rag.baseGraph, data) )
def eccentricity( img, label, distFunc = "exponential", showPathImage = False, percentageOfPaths = 100, imgSaveName = "" ): img = img.astype(numpy.uint8) dim = len(img.shape) ## Enlarge image by one pixel on each side bigShape = [] for s in img.shape: bigShape.append(s + 2) bigImg = numpy.ones(bigShape) slices = [] for i in range(dim): slices.append(slice(1, bigImg.shape[i]-1)) bigImg[ slices ] = img inside = numpy.where(bigImg==0) outside = numpy.where(bigImg==1) # ## Apply distanceTransform and modify (outside: high values, inside: low values) # distImage = vigra.filters.distanceTransform2D(bigImg.astype(numpy.float32)) # if showPathImage: # imgp = distImage.copy() # if distFunc == "exponential": # distImage = numpy.exp(distImage*-gamma) # elif distFunc == "linear": # maxDist = distImage.max() # distImage = maxDist - distImage # elif distFunc == "inverse": # w = numpy.where(distImage!=0) # distImage[w] = 1/distImage[w] # else: # print "wrong parameters for distFunc in eccentricity" ## Distance in the inside between two pixels is 1.0 distImage = bigImg.copy().astype(numpy.float32) distImage[inside]=1.0 ## Set the outside to a very high value distImage[outside]=10000.0 ## Image copy to draw the paths in imgp = distImage.copy() imgp[outside] = 100 ## Get image graph and its path finder gridGraph = vigraph.gridGraph(bigImg.shape[0:dim],False) graphShape = [] for s in distImage.shape: graphShape.append(s*2-1) edgeWeights = vigra.resize(distImage, graphShape, order=0) edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImageCorrected(gridGraph, edgeWeights) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) ## Find borders in img if dim == 2: bigLblImg = vigra.analysis.labelImage(bigImg.astype(numpy.uint8)) else: bigLblImg = vigra.analysis.labelVolume(bigImg.astype(numpy.uint8)) rag = vigraph.GridRegionAdjacencyGraph(gridGraph, bigLblImg) node = vigraph.GridRegionAdjacencyGraph.nodeFromId(rag, long( bigLblImg[inside][0] )) edges = vigraph._ragFindEdges(rag, gridGraph, rag.affiliatedEdges, bigLblImg, node) # ## Remove duplicates # edges_a = numpy.ascontiguousarray(edges) # unique_edges = numpy.unique(edges_a.view([('', edges_a.dtype)]*edges_a.shape[1])) # edges = unique_edges.view(edges_a.dtype).reshape((unique_edges.shape[0], edges_a.shape[1])) borderImg = numpy.zeros(bigImg.shape) for edge in edges: slices = [] for d in range(dim): slices.append( slice(edge[d], edge[d]+1) ) borderImg[slices] = 1 # ## Find borders in img # borderImg = numpy.zeros(bigImg.shape) # if dim == 2: # for y in range(bigImg.shape[1]-1): # for x in range(bigImg.shape[0]-1): # if bigImg[x,y] == 0: # if bigImg[x+1,y] == 1 or bigImg[x,y+1] == 1: # borderImg[x, y] = 1 # else: # if bigImg[x+1,y] == 0: # borderImg[x+1, y] = 1 # if bigImg[x,y+1] == 0: # borderImg[x, y+1] = 1 # else: # for z in range(bigImg.shape[2]-1): # for y in range(bigImg.shape[1]-1): # for x in range(bigImg.shape[0]-1): # if bigImg[x,y,z] == 0: # if bigImg[x+1,y,z] == 1 or bigImg[x,y+1,z] == 1 or bigImg[x,y,z+1] == 1: # borderImg[x, y, z] = 1 # else: # if bigImg[x+1,y,z] == 0: # borderImg[x+1,y,z] = 1 # if bigImg[x,y+1,z] == 0: # borderImg[x,y+1,z] = 1 # if bigImg[x,y,z+1] == 0: # borderImg[x,y,z+1] = 1 ## End points for paths (all points on the border) targets = numpy.where(borderImg==1) nTargets = len(targets[0]) ## Indices of start points for paths (random) nPoints = int(numpy.ceil(percentageOfPaths * nTargets / 100.0)) numpy.random.seed(42) starts = numpy.random.permutation(range(nTargets))[:nPoints] ## Compute paths maxPaths = [] maxPathLengths = [] for i in range(nPoints): sourceIndex = [] for d in range(dim): sourceIndex.append(int(targets[d][starts[i]])) source = gridGraph.coordinateToNode(sourceIndex) pathFinder.run(edgeWeights, source) maxPathLength = 0 for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) path = pathFinder.path(pathType='coordinates', target=target) pathLength = pathFinder.distance(target) if pathLength > maxPathLength or maxPathLength == 0: maxPathLength = pathLength maxPath = path maxPaths.append(maxPath) maxPathLengths.append(maxPathLength) imgp[sourceIndex[0], sourceIndex[1]] = 3*maxPathLength*maxPathLength if showPathImage: val = (imgp.max()+imgp.min())/2 for p in maxPaths: imgp[p[:,0], p[:,1]] = val if showPathImage: plt.figure(distFunc) plt.imshow(numpy.swapaxes(imgp, 1, 0), interpolation='none') if len(imgSaveName)>1: scipy.misc.imsave(imgSaveName, numpy.swapaxes(imgp, 1, 0)) return maxPathLengths
def eccentricity( img, distFunc = "exponential", showPathImage = False, percentageOfPaths = 100, imgSaveName = "" ): img = img.astype(numpy.uint8) dim = len(img.shape) ## Enlarge image by one pixel on each side bigShape = [] for s in img.shape: bigShape.append(s + 2) bigImg = numpy.ones(bigShape) slices = [] for i in range(dim): slices.append(slice(1, bigImg.shape[i]-1)) bigImg[ slices ] = img inside = numpy.where(bigImg==0) outside = numpy.where(bigImg==1) ## Apply distanceTransform and modify (outside: high values, inside: low values) distImage = vigra.filters.distanceTransform2D(bigImg.astype(numpy.float32)) imgp = distImage.copy() # if showPathImage: # imgp = distImage.copy() if distFunc == "exponential": distImage = numpy.exp(distImage*-gamma) elif distFunc == "linear": maxDist = distImage.max() distImage = maxDist - distImage + 10 elif distFunc == "inverse": w = numpy.where(distImage!=0) distImage[w] = 1/distImage[w] else: print "wrong parameters for distFunc in eccentricity" ## Distance in the inside between two pixels is 1.0 #distImage = bigImg.copy().astype(numpy.float32) #distImage[inside]=1.0 # if len(imgSaveName)>1: # plt.imshow(numpy.swapaxes(distImage, 1, 0)) # plt.savefig(imgSaveName+"_dist.png") # #scipy.misc.imsave(imgSaveName+"_dist.png", numpy.swapaxes(distImage, 1, 0)) ## Set the outside to a very high value distImage[outside]=1000.0 ## Image copy to draw the paths in #imgp = distImage.copy() imgp[outside] = 100 ## Get image graph and its path finder gridGraph = vigraph.gridGraph(bigImg.shape[0:dim],False) graphShape = [] for s in distImage.shape: graphShape.append(s*2-1) edgeWeights = vigra.resize(distImage, graphShape, order=0) #edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImage(gridGraph, edgeWeights) edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImageCorrected(gridGraph,edgeWeights) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) ## Find borders in img if dim == 2: bigLblImg = vigra.analysis.labelImage(bigImg.astype(numpy.uint8)) else: bigLblImg = vigra.analysis.labelVolume(bigImg.astype(numpy.uint8)) rag = vigraph.GridRegionAdjacencyGraph(gridGraph, bigLblImg) node = vigraph.GridRegionAdjacencyGraph.nodeFromId(rag, long( bigLblImg[inside][0] )) edges = vigraph._ragFindEdges(rag, gridGraph, rag.affiliatedEdges, bigLblImg, node) borderImg = numpy.zeros(bigImg.shape) for edge in edges: slices = [] for d in range(dim): slices.append( slice(edge[d], edge[d]+1) ) borderImg[slices] = 1 ## End points for paths (all points on the border) targets = numpy.where(borderImg==1) nTargets = len(targets[0]) ## Find the diameter (longest path) eccLength = numpy.empty(nTargets) eccLength.fill(-1) eccTargetPath = {} vpIndex = 0 vpGraphIndex = [] for d in range(dim): vpGraphIndex.append(int(targets[d][vpIndex])) vp = gridGraph.coordinateToNode(vpGraphIndex) visited = numpy.zeros(nTargets) while True: visited[vpIndex] = 1 pathFinder.run(edgeWeights, vp) eccChanged = False for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) pathLength = pathFinder.distance(target) m = max(eccLength[j], pathLength) if m > eccLength[j]: eccChanged = True eccLength[j] = m eccTargetPath[j] = pathFinder.path(pathType='coordinates', target=target) vpIndex = numpy.argmax(eccLength) vpGraphIndex = [] for d in range(dim): vpGraphIndex.append(int(targets[d][vpIndex])) vp = gridGraph.coordinateToNode(vpGraphIndex) if visited[vpIndex] or not eccChanged: break ## Find the length of the diameter (non-weighted) path = eccTargetPath[vpIndex] dMax = 0 for k in range(1, len(path)): diffCount = 0 for d in range(dim): if path[k][d] != path[k-1][d]: diffCount += 1 dMax += numpy.sqrt(diffCount) ## Find the midpoint of the diameter dMax = dMax/2 if len(path) == 0: path = numpy.empty( (1, 2), numpy.uint8 ) path[0][0] = targets[0][0] path[0][1] = targets[1][0] p1 = path[0] d1 = 0 for k in range(1, len(path)): p2 = path[k] d2 = d1 + numpy.linalg.norm(p2-p1) if d2 > dMax: if (abs(d2-dMax) < abs(d1-dMax)): p1 = p2 break p1 = p2 d1 = d2 ## Compute eccentricity from center (p1) to all points on border sourceIndex = [] for d in range(dim): sourceIndex.append(int(p1[d])) source = gridGraph.coordinateToNode(sourceIndex) pathFinder.run(edgeWeights, source) maxPathLength = 0 for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) pathLength = pathFinder.distance(target) maxPathLength = max(maxPathLength, pathLength) imgp[targetIndex[0], targetIndex[1]] = 40*pathLength imgp[ path[:,0], path[:,1] ] = 12*maxPathLength imgp[sourceIndex[0], sourceIndex[1]] = 40*maxPathLength plt.figure(distFunc) plt.imshow(numpy.swapaxes(imgp, 1, 0), interpolation='none') if len(imgSaveName)>1: scipy.misc.imsave(imgSaveName+".png", numpy.swapaxes(imgp, 1, 0))
def segmentation_example(): import vigra import opengm import sklearn import sklearn.mixture import numpy as np from vigra import graphs import matplotlib as mpl import plottool as pt pt.ensure_pylab_qt4() # load image and convert to LAB img_fpath = str(ut.grab_test_imgpath(str('lena.png'))) img = vigra.impex.readImage(img_fpath) imgLab = vigra.colors.transform_RGB2Lab(img) superpixelDiameter = 15 # super-pixel size slicWeight = 15.0 # SLIC color - spatial weight labels, nseg = vigra.analysis.slicSuperpixels(imgLab, slicWeight, superpixelDiameter) labels = vigra.analysis.labelImage(labels) - 1 # get 2D grid graph and RAG gridGraph = graphs.gridGraph(img.shape[0:2]) rag = graphs.regionAdjacencyGraph(gridGraph, labels) # Node Features nodeFeatures = rag.accumulateNodeFeatures(imgLab) nodeFeaturesImg = rag.projectNodeFeaturesToGridGraph(nodeFeatures) nodeFeaturesImg = vigra.taggedView(nodeFeaturesImg, "xyc") nodeFeaturesImgRgb = vigra.colors.transform_Lab2RGB(nodeFeaturesImg) nCluster = 5 g = sklearn.mixture.GMM(n_components=nCluster) g.fit(nodeFeatures[:, :]) clusterProb = g.predict_proba(nodeFeatures) # https://github.com/opengm/opengm/blob/master/src/interfaces/python/examples/tutorial/Irregular%20Factor%20Graphs.ipynb # https://github.com/opengm/opengm/blob/master/src/interfaces/python/examples/tutorial/Hard%20and%20Soft%20Constraints.ipynb clusterProbImg = rag.projectNodeFeaturesToGridGraph( clusterProb.astype(np.float32)) clusterProbImg = vigra.taggedView(clusterProbImg, "xyc") ndim_data = clusterProbImg.reshape((-1, nCluster)) pca = sklearn.decomposition.PCA(n_components=3) print(ndim_data.shape) pca.fit(ndim_data) print(ut.repr2(pca.explained_variance_ratio_, precision=2)) oldshape = (clusterProbImg.shape[0:2] + (-1,)) clusterProgImg3 = pca.transform(ndim_data).reshape(oldshape) print(clusterProgImg3.shape) # graphical model with as many variables # as superpixels, each has 3 states gm = opengm.gm(np.ones(rag.nodeNum, dtype=opengm.label_type) * nCluster) # convert probabilites to energies probs = np.clip(clusterProb, 0.00001, 0.99999) costs = -1.0 * np.log(probs) # add ALL unaries AT ONCE fids = gm.addFunctions(costs) gm.addFactors(fids, np.arange(rag.nodeNum)) # add a potts function beta = 40.0 # strength of potts regularizer regularizer = opengm.pottsFunction([nCluster] * 2, 0.0, beta) fid = gm.addFunction(regularizer) # get variable indices of adjacent superpixels # - or "u" and "v" node id's for edges uvIds = rag.uvIds() uvIds = np.sort(uvIds, axis=1) # add all second order factors at once gm.addFactors(fid, uvIds) # get super-pixels with slic on LAB image Inf = opengm.inference.BeliefPropagation parameter = opengm.InfParam(steps=10, damping=0.5, convergenceBound=0.001) inf = Inf(gm, parameter=parameter) class PyCallback(object): def __init__(self,): self.labels = [] def begin(self, inference): print("begin of inference") def end(self, inference): self.labels.append(inference.arg()) def visit(self, inference): gm = inference.gm() labelVector = inference.arg() print("energy %r" % (gm.evaluate(labelVector),)) self.labels.append(labelVector) callback = PyCallback() visitor = inf.pythonVisitor(callback, visitNth=1) inf.infer(visitor) pt.imshow(clusterProgImg3.swapaxes(0, 1)) # plot superpixels cmap = mpl.colors.ListedColormap(np.random.rand(nseg, 3)) pt.imshow(labels.swapaxes(0, 1).squeeze(), cmap=cmap) pt.imshow(nodeFeaturesImgRgb) cmap = mpl.colors.ListedColormap(np.random.rand(nCluster, 3)) for arg in callback.labels: arg = vigra.taggedView(arg, "n") argImg = rag.projectNodeFeaturesToGridGraph(arg.astype(np.uint32)) argImg = vigra.taggedView(argImg, "xy") # plot superpixels pt.imshow(argImg.swapaxes(0, 1).squeeze(), cmap=cmap)
def find_shortest_path(ifp): # Modify distancetransform # # a) Invert: the lowest values (i.e. the lowest penalty for the shortest path detection) should be at the center of # the current process ifp.invert_image(ids='curdisttransf') # # b) Set all values outside the process to infinity ifp.filter_values(ifp.amax('curdisttransf'), type='eq', setto=np.inf, ids='curdisttransf', targetids='curdisttransf_inf') # # c) Increase the value difference between pixels near the boundaries and pixels central within the processes # This increases the likelihood of the paths to follow the center of processes, thus avoiding short-cuts ifp.power(10, ids='curdisttransf_inf') indicator = ifp.get_image('curdisttransf_inf') gridgr = graphs.gridGraph(ifp.shape('curlabel')) ifp.logging('gridgr.shape = {}'.format(gridgr.shape)) indicator = indicator.astype(np.float32) gridgr_edgeind = graphs.edgeFeaturesFromImage(gridgr, indicator) instance = graphs.ShortestPathPathDijkstra(gridgr) # Get two local maxima indices = np.where(ifp.get_image('locmax') == 1) coords = zip(indices[0], indices[1], indices[2]) ifp.logging('Local maxima coordinates: {}'.format(coords)) # ifp.deepcopy_entry('locmax', 'paths') ifp.set_data_dict({'paths': np.zeros(ifp.get_image('locmax').shape)}, append=True) ifp.logging('len(coords) = {}'.format(len(coords))) for i in xrange(0, len(coords)-1): for j in xrange(i+1, len(coords)): ifp.logging('---') ifp.logging('i = {0}; j = {1}'.format(i, j)) source = coords[i] target = coords[j] targetNode = gridgr.coordinateToNode(target) sourceNode = gridgr.coordinateToNode(source) ifp.logging('Source = {}'.format(source)) ifp.logging('Target = {}'.format(target)) instance.run(gridgr_edgeind, sourceNode, target=targetNode) path = instance.path(pathType='coordinates') # for coords in path: # # ifp.logging('coords = {}'.format(coords)) # pass pathindices = np.swapaxes(path, 0, 1) ifp.get_image('paths')[pathindices[0], pathindices[1], pathindices[2]] = 1 # ifp.concatenate('disttransf', 'paths', target='paths_over_dist') ifp.astype(np.uint8, ('paths', 'locmax')) # ifp.anytask(vigra.filters.multiBinaryDilation, ('paths', 'locmax'), 3) ifp.swapaxes(0, 2, ids=('paths', 'locmax', 'curdisttransf')) ifp.anytask(vigra.filters.discDilation, 2, ids=('paths', 'locmax')) ifp.set_data_dict({'paths_over_dist': np.array([ifp.get_image('paths'), ifp.get_image('locmax'), ifp.get_image('curdisttransf')])}, append=True)
def get_segmentation(predict, pmin=0.5, minMemb=10, minSeg=10, sigMin=6, sigWeights=1, sigSmooth=0.1, cleanCloseSeeds=True, returnSeedsOnly=False, edgeLengths=None,nodeFeatures=None, nodeSizes=None, nodeLabels=None, nodeNumStop=None, beta=0, metric='l1', wardness=0.2, out=None): """ Get segmentation through watershed and agglomerative clustering :param predict: prediction map :return: segmentation map """ #use watershed and save superpixels map super_pixels = wsDtSegmentation(predict, pmin, minMemb, minSeg, sigMin, sigWeights, cleanCloseSeeds, returnSeedsOnly) # seeds = wsDtSegmentation(predict, pmin, minMemb, minSeg, sigMin, sigWeights, cleanCloseSeeds, True) # save_h5(seeds, "/home/stamylew/delme/seeds.h5", "data") print print "#Nodes in superpixels", len(np.unique(super_pixels)) # save_h5(super_pixels, "/home/stamylew/delme/super_pixels.h5", "data") #smooth prediction map probs = vf.gaussianSmoothing(predict, sigSmooth) # save_h5(probs, "/home/stamylew/delme/probs.h5", "data") #make grid graph grid_graph = vg.gridGraph(super_pixels.shape, False) grid_graph_edge_indicator = vg.edgeFeaturesFromImage(grid_graph, probs) #make region adjacency graph rag = vg.regionAdjacencyGraph(grid_graph, super_pixels) #accumulate edge features from grid graph node map edge_weights = rag.accumulateEdgeFeatures(grid_graph_edge_indicator) edge_weights_tag = "mean of the probabilities" #do agglomerative clustering def agglomerativeClustering_beststop_th05(graph, edgeWeights=None, edgeStoppers=None, edgeLengths=None, nodeFeatures=None, nodeSizes=None, nodeLabels=None, beta=0, metric=None, wardness=1.0, sameLabelMultiplier=1.0, out=None): vg.ac(graph, edgeWeights=edgeWeights, edgeStoppers=edgeStoppers, edgeLengths=edgeLengths, nodeFeatures=nodeFeatures, nodeSizes=nodeSizes, nodeLabels=nodeLabels, nodeNumStop=0, beta=beta, wardness=wardness, sameLabelMultiplier=sameLabelMultiplier, out=out) f = open('/tmp/ac_bestNodenumstop.txt', 'r') nodeNumStop = f.readline() f.close() print "best nodeNumStop:", nodeNumStop # in experiments if n of the groundtruth is n the file contains n-1. probably in the hc.hxx the # number is written to file too late. does this make any sense?? nodeNumStop = int(nodeNumStop) nodeNumStop += 1 ac_res, nodelabel_out_1 = vg.ac(graph, edgeWeights=edgeWeights, edgeStoppers=edgeStoppers, edgeLengths=edgeLengths, nodeFeatures=nodeFeatures, nodeSizes=nodeSizes, nodeLabels=nodeLabels, nodeNumStop=nodeNumStop, beta=beta, wardness=wardness, sameLabelMultiplier=sameLabelMultiplier, out=out) return ac_res, nodeNumStop, nodelabel_out_1 labels, _, _ = agglomerativeClustering_beststop_th05(rag, edgeWeights=edge_weights, edgeStoppers=edge_weights, edgeLengths=edgeLengths, nodeFeatures=nodeFeatures, nodeSizes=nodeSizes, nodeLabels=nodeLabels, beta=beta, metric=metric, wardness=0.1, sameLabelMultiplier=1.0, out=out) # labels = vg.agglomerativeClustering(rag, edge_weights, edgeLengths, nodeFeatures, nodeSizes, # nodeLabels, nodeNumStop, beta, metric, wardness, out) #segmentation data wsDt_data = np.zeros((8,1)) wsDt_data[:,0] = (pmin, minMemb, minSeg, sigMin, sigWeights, sigSmooth, cleanCloseSeeds, returnSeedsOnly) agglCl_data = edge_weights_tag, str(edgeLengths), str(nodeFeatures), str(nodeSizes), str(nodeLabels), str(nodeNumStop), str(beta), metric, str(wardness), str(out) #project labels back to data segmentation = rag.projectLabelsToBaseGraph(labels) print "#nodes in segmentation", len(np.unique(segmentation)) # save_h5(segmentation, "/home/stamylew/delme/segmap.h5", "data", None) return segmentation, super_pixels, wsDt_data, agglCl_data
def eccentricity(img, label, distFunc="exponential", showPathImage=False, percentageOfPaths=100, imgSaveName=""): img = img.astype(numpy.uint8) dim = len(img.shape) ## Enlarge image by one pixel on each side bigShape = [] for s in img.shape: bigShape.append(s + 2) bigImg = numpy.ones(bigShape) slices = [] for i in range(dim): slices.append(slice(1, bigImg.shape[i] - 1)) bigImg[slices] = img inside = numpy.where(bigImg == 0) outside = numpy.where(bigImg == 1) # ## Apply distanceTransform and modify (outside: high values, inside: low values) # distImage = vigra.filters.distanceTransform2D(bigImg.astype(numpy.float32)) # if showPathImage: # imgp = distImage.copy() # if distFunc == "exponential": # distImage = numpy.exp(distImage*-gamma) # elif distFunc == "linear": # maxDist = distImage.max() # distImage = maxDist - distImage # elif distFunc == "inverse": # w = numpy.where(distImage!=0) # distImage[w] = 1/distImage[w] # else: # print "wrong parameters for distFunc in eccentricity" ## Distance in the inside between two pixels is 1.0 distImage = bigImg.copy().astype(numpy.float32) distImage[inside] = 1.0 ## Set the outside to a very high value distImage[outside] = 10000.0 ## Image copy to draw the paths in imgp = distImage.copy() imgp[outside] = 100 ## Get image graph and its path finder gridGraph = vigraph.gridGraph(bigImg.shape[0:dim], False) graphShape = [] for s in distImage.shape: graphShape.append(s * 2 - 1) edgeWeights = vigra.resize(distImage, graphShape, order=0) edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImageCorrected( gridGraph, edgeWeights) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) ## Find borders in img if dim == 2: bigLblImg = vigra.analysis.labelImage(bigImg.astype(numpy.uint8)) else: bigLblImg = vigra.analysis.labelVolume(bigImg.astype(numpy.uint8)) rag = vigraph.GridRegionAdjacencyGraph(gridGraph, bigLblImg) node = vigraph.GridRegionAdjacencyGraph.nodeFromId( rag, long(bigLblImg[inside][0])) edges = vigraph._ragFindEdges(rag, gridGraph, rag.affiliatedEdges, bigLblImg, node) # ## Remove duplicates # edges_a = numpy.ascontiguousarray(edges) # unique_edges = numpy.unique(edges_a.view([('', edges_a.dtype)]*edges_a.shape[1])) # edges = unique_edges.view(edges_a.dtype).reshape((unique_edges.shape[0], edges_a.shape[1])) borderImg = numpy.zeros(bigImg.shape) for edge in edges: slices = [] for d in range(dim): slices.append(slice(edge[d], edge[d] + 1)) borderImg[slices] = 1 # ## Find borders in img # borderImg = numpy.zeros(bigImg.shape) # if dim == 2: # for y in range(bigImg.shape[1]-1): # for x in range(bigImg.shape[0]-1): # if bigImg[x,y] == 0: # if bigImg[x+1,y] == 1 or bigImg[x,y+1] == 1: # borderImg[x, y] = 1 # else: # if bigImg[x+1,y] == 0: # borderImg[x+1, y] = 1 # if bigImg[x,y+1] == 0: # borderImg[x, y+1] = 1 # else: # for z in range(bigImg.shape[2]-1): # for y in range(bigImg.shape[1]-1): # for x in range(bigImg.shape[0]-1): # if bigImg[x,y,z] == 0: # if bigImg[x+1,y,z] == 1 or bigImg[x,y+1,z] == 1 or bigImg[x,y,z+1] == 1: # borderImg[x, y, z] = 1 # else: # if bigImg[x+1,y,z] == 0: # borderImg[x+1,y,z] = 1 # if bigImg[x,y+1,z] == 0: # borderImg[x,y+1,z] = 1 # if bigImg[x,y,z+1] == 0: # borderImg[x,y,z+1] = 1 ## End points for paths (all points on the border) targets = numpy.where(borderImg == 1) nTargets = len(targets[0]) ## Indices of start points for paths (random) nPoints = int(numpy.ceil(percentageOfPaths * nTargets / 100.0)) numpy.random.seed(42) starts = numpy.random.permutation(range(nTargets))[:nPoints] ## Compute paths maxPaths = [] maxPathLengths = [] for i in range(nPoints): sourceIndex = [] for d in range(dim): sourceIndex.append(int(targets[d][starts[i]])) source = gridGraph.coordinateToNode(sourceIndex) pathFinder.run(edgeWeights, source) maxPathLength = 0 for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) path = pathFinder.path(pathType='coordinates', target=target) pathLength = pathFinder.distance(target) if pathLength > maxPathLength or maxPathLength == 0: maxPathLength = pathLength maxPath = path maxPaths.append(maxPath) maxPathLengths.append(maxPathLength) imgp[sourceIndex[0], sourceIndex[1]] = 3 * maxPathLength * maxPathLength if showPathImage: val = (imgp.max() + imgp.min()) / 2 for p in maxPaths: imgp[p[:, 0], p[:, 1]] = val if showPathImage: plt.figure(distFunc) plt.imshow(numpy.swapaxes(imgp, 1, 0), interpolation='none') if len(imgSaveName) > 1: scipy.misc.imsave(imgSaveName, numpy.swapaxes(imgp, 1, 0)) return maxPathLengths
def segmentation_example(): import vigra import opengm import sklearn import sklearn.mixture import numpy as np from vigra import graphs import matplotlib as mpl import plottool as pt pt.ensure_pylab_qt4() # load image and convert to LAB img_fpath = str(ut.grab_test_imgpath(str('lena.png'))) img = vigra.impex.readImage(img_fpath) imgLab = vigra.colors.transform_RGB2Lab(img) superpixelDiameter = 15 # super-pixel size slicWeight = 15.0 # SLIC color - spatial weight labels, nseg = vigra.analysis.slicSuperpixels(imgLab, slicWeight, superpixelDiameter) labels = vigra.analysis.labelImage(labels) - 1 # get 2D grid graph and RAG gridGraph = graphs.gridGraph(img.shape[0:2]) rag = graphs.regionAdjacencyGraph(gridGraph, labels) # Node Features nodeFeatures = rag.accumulateNodeFeatures(imgLab) nodeFeaturesImg = rag.projectNodeFeaturesToGridGraph(nodeFeatures) nodeFeaturesImg = vigra.taggedView(nodeFeaturesImg, "xyc") nodeFeaturesImgRgb = vigra.colors.transform_Lab2RGB(nodeFeaturesImg) nCluster = 5 g = sklearn.mixture.GMM(n_components=nCluster) g.fit(nodeFeatures[:, :]) clusterProb = g.predict_proba(nodeFeatures) # https://github.com/opengm/opengm/blob/master/src/interfaces/python/examples/tutorial/Irregular%20Factor%20Graphs.ipynb # https://github.com/opengm/opengm/blob/master/src/interfaces/python/examples/tutorial/Hard%20and%20Soft%20Constraints.ipynb clusterProbImg = rag.projectNodeFeaturesToGridGraph( clusterProb.astype(np.float32)) clusterProbImg = vigra.taggedView(clusterProbImg, "xyc") ndim_data = clusterProbImg.reshape((-1, nCluster)) pca = sklearn.decomposition.PCA(n_components=3) print(ndim_data.shape) pca.fit(ndim_data) print(ut.repr2(pca.explained_variance_ratio_, precision=2)) oldshape = (clusterProbImg.shape[0:2] + (-1, )) clusterProgImg3 = pca.transform(ndim_data).reshape(oldshape) print(clusterProgImg3.shape) # graphical model with as many variables # as superpixels, each has 3 states gm = opengm.gm(np.ones(rag.nodeNum, dtype=opengm.label_type) * nCluster) # convert probabilites to energies probs = np.clip(clusterProb, 0.00001, 0.99999) costs = -1.0 * np.log(probs) # add ALL unaries AT ONCE fids = gm.addFunctions(costs) gm.addFactors(fids, np.arange(rag.nodeNum)) # add a potts function beta = 40.0 # strength of potts regularizer regularizer = opengm.pottsFunction([nCluster] * 2, 0.0, beta) fid = gm.addFunction(regularizer) # get variable indices of adjacent superpixels # - or "u" and "v" node id's for edges uvIds = rag.uvIds() uvIds = np.sort(uvIds, axis=1) # add all second order factors at once gm.addFactors(fid, uvIds) # get super-pixels with slic on LAB image Inf = opengm.inference.BeliefPropagation parameter = opengm.InfParam(steps=10, damping=0.5, convergenceBound=0.001) inf = Inf(gm, parameter=parameter) class PyCallback(object): def __init__(self, ): self.labels = [] def begin(self, inference): print("begin of inference") def end(self, inference): self.labels.append(inference.arg()) def visit(self, inference): gm = inference.gm() labelVector = inference.arg() print("energy %r" % (gm.evaluate(labelVector), )) self.labels.append(labelVector) callback = PyCallback() visitor = inf.pythonVisitor(callback, visitNth=1) inf.infer(visitor) pt.imshow(clusterProgImg3.swapaxes(0, 1)) # plot superpixels cmap = mpl.colors.ListedColormap(np.random.rand(nseg, 3)) pt.imshow(labels.swapaxes(0, 1).squeeze(), cmap=cmap) pt.imshow(nodeFeaturesImgRgb) cmap = mpl.colors.ListedColormap(np.random.rand(nCluster, 3)) for arg in callback.labels: arg = vigra.taggedView(arg, "n") argImg = rag.projectNodeFeaturesToGridGraph(arg.astype(np.uint32)) argImg = vigra.taggedView(argImg, "xy") # plot superpixels pt.imshow(argImg.swapaxes(0, 1).squeeze(), cmap=cmap)
img = vigra.impex.readImage(filepath) # get super-pixels with slic on LAB image imgLab = vigra.colors.transform_RGB2Lab(img) labels, nseg = vigra.analysis.slicSuperpixels(imgLab, slicWeight, superpixelDiameter) labels = vigra.analysis.labelImage(labels) # compute gradient on interpolated image imgLabBig = vigra.resize(imgLab, [imgLab.shape[0] * 2 - 1, imgLab.shape[1] * 2 - 1]) gradMag = vigra.filters.gaussianGradientMagnitude(imgLabBig, sigmaGradMag) # get 2D grid graph and edgeMap for grid graph # from gradMag of interpolated image gridGraph = graphs.gridGraph(img.shape[0:2]) gridGraphEdgeIndicator = graphs.edgeFeaturesFromInterpolatedImage( gridGraph, gradMag) # get region adjacency graph from super-pixel labels rag = graphs.regionAdjacencyGraph(gridGraph, labels) # accumulate edge weights from gradient magnitude edgeIndicator = rag.accumulateEdgeFeatures(gridGraphEdgeIndicator) # accumulate node features from grid graph node map # which is just a plain image (with channels) nodeFeatures = rag.accumulateNodeFeatures(imgLab) resultFeatures = graphs.recursiveGraphSmoothing(rag, nodeFeatures, edgeIndicator,
def process_branch( branch_index, branch_rois ): # opFeatures and opThreshold are declared locally so this whole block can be parallelized! # (We use Input.setValue() instead of Input.connect() here.) opFeatures = OpPixelFeaturesPresmoothed(graph=tempGraph) # Compute the Hessian slicewise and create gridGraphs standard_scales = [0.3, 0.7, 1.0, 1.6, 3.5, 5.0, 10.0] standard_feature_ids = ['GaussianSmoothing', 'LaplacianOfGaussian', \ 'GaussianGradientMagnitude', 'DifferenceOfGaussians', \ 'StructureTensorEigenvalues', 'HessianOfGaussianEigenvalues'] opFeatures.Scales.setValue(standard_scales) opFeatures.FeatureIds.setValue(standard_feature_ids) # Select Hessian Eigenvalues at scale 5.0 scale_index = standard_scales.index(5.0) feature_index = standard_feature_ids.index('HessianOfGaussianEigenvalues') selection_matrix = numpy.zeros( (6,7), dtype=bool ) # all False selection_matrix[feature_index][scale_index] = True opFeatures.Matrix.setValue(selection_matrix) # opFeatures and opThreshold are declared locally so this whole block can be parallelized! # (We use Input.setValue() instead of Input.connect() here.) opThreshold = OpThresholdTwoLevels(graph=tempGraph) opThreshold.Channel.setValue(0) # We select SYNAPSE_CHANNEL before the data is given to opThreshold opThreshold.SmootherSigma.setValue({'x': 2.0, 'y': 2.0, 'z': 1.0}) #NOTE: two-level is much better. Maybe we can afford it? #opThreshold.CurOperator.setValue(0) # 0==one-level #opThreshold.SingleThreshold.setValue(0.4) #FIXME: solve the mess with uint8/float in predictions opThreshold.CurOperator.setValue(1) # 1==two-level opThreshold.HighThreshold.setValue(0.4) opThreshold.LowThreshold.setValue(0.2) previous_slice_objects = None previous_slice_roi = None conn_ids = [x.id for x in connector_infos] connector_infos_dict = dict(zip(conn_ids, connector_infos)) branch_node_count = len(branch_rois) for node_index_in_branch, (node_info, roi) in enumerate(branch_rois): with Timer() as timer: skeletonCoord = (node_info.x_px, node_info.y_px, node_info.z_px) logger.debug("skeleton point: {}".format( skeletonCoord )) #Add channel dimension roi_with_channel = numpy.zeros((2, roi.shape[1]+1), dtype=numpy.uint32) roi_with_channel[:, :-1] = roi[:] roi_with_channel[0, -1] = 0 roi_with_channel[1, -1] = 1 iz = roi[0][2] roi_hessian = (roi_with_channel[0]*2, roi_with_channel[1]*2-1) for x in range(roi.shape[1]): if roi[0][x] == 0: roi_hessian[0][x] = 0 roi_hessian[0][2] = iz roi_hessian[1][2] = iz+1 #we need the second eigenvalue roi_hessian[0][-1] = 1 roi_hessian[1][-1] = 2 WITH_CONNECTORS_ONLY = True if WITH_CONNECTORS_ONLY: if not node_info.id in node_to_connector.keys(): continue if debug_images: outdir1 = outdir+"raw/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".png" data = opPixelClassification3d.InputImages[-1](roi_with_channel[0], roi_with_channel[1]).wait() vigra.impex.writeImage(data.squeeze().astype(numpy.uint8), outfile) ''' outdir2 = outdir + "synapse_pred/" outfile = outdir2+"%.02d"%iz + ".png" data = opThreshold.InputImage(roi_with_channel[0], roi_with_channel[1]).wait() vigra.impex.writeImage(data.squeeze().astype(numpy.uint8), outfile) ''' start_pred = time.time() prediction_roi = numpy.append( roi_with_channel[:,:-1], [[0],[4]], axis=1 ) synapse_prediction_roi = numpy.append( prediction_roi[:,:-1], [[SYNAPSE_CHANNEL],[SYNAPSE_CHANNEL+1]], axis=1 ) membrane_prediction_roi = numpy.append( prediction_roi[:,:-1], [[MEMBRANE_CHANNEL],[MEMBRANE_CHANNEL+1]], axis=1 ) #synapse_predictions = opPixelClassification3d.PredictionProbabilities[-1](*prediction_roi).wait() synapse_predictions = opSynapsePredictionCache.Output(*synapse_prediction_roi).wait() synapse_predictions = vigra.taggedView( synapse_predictions, "xytc" ) if debug_images: outdir1 = outdir+"membrane/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".png" #membrane_predictions = opPixelClassification2d.HeadlessPredictionProbabilities[-1](*prediction_roi).wait() membrane_predictions = opMembranePredictionCache.Output(*membrane_prediction_roi).wait() vigra.impex.writeImage(membrane_predictions[..., 0].squeeze(), outfile) stop_pred = time.time() timing_logger.debug( "spent in first 3d prediction: {}".format( stop_pred-start_pred ) ) opThreshold.InputImage.setValue(synapse_predictions) opThreshold.InputImage.meta.drange = opPixelClassification3d.PredictionProbabilities[-1].meta.drange synapse_cc = opThreshold.Output[:].wait() if debug_images: outdir1 = outdir+"predictions_roi/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".tiff" #norm = numpy.where(synapse_cc[:, :, 0, 0]>0, 255, 0) vigra.impex.writeImage(synapse_predictions[...,0,0], outfile) if debug_images: outdir1 = outdir+"synapses_roi/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".tiff" norm = numpy.where(synapse_cc[:, :, 0, 0]>0, 255, 0) vigra.impex.writeImage(norm.astype(numpy.uint8), outfile) if numpy.sum(synapse_cc)==0: print "NO SYNAPSES IN THIS SLICE:", iz timing_logger.debug( "ROI TIMER: {}".format( timer.seconds() ) ) continue # Distances over Hessian start_hess = time.time() roi_hessian = ( tuple(map(long, roi_hessian[0])), tuple(map(long, roi_hessian[1])) ) upsampled_combined_membranes = opUpsample.Output(*roi_hessian).wait() upsampled_combined_membranes = vigra.taggedView(upsampled_combined_membranes, opUpsample.Output.meta.axistags ) opFeatures.Input.setValue(upsampled_combined_membranes) eigenValues = opFeatures.Output[...,1:2].wait() #we need the second eigenvalue eigenValues = numpy.abs(eigenValues[:, :, 0, 0]) stop_hess = time.time() timing_logger.debug( "spent for hessian: {}".format( stop_hess-start_hess ) ) shape_x = roi[1][0]-roi[0][0] shape_y = roi[1][1]-roi[0][1] shape_x = long(shape_x) shape_y = long(shape_y) start_gr = time.time() gridGr = graphs.gridGraph((shape_x, shape_y )) # !on original pixels gridGraphEdgeIndicator = graphs.edgeFeaturesFromInterpolatedImage(gridGr, eigenValues) #gridGraphs.append(gridGr) #graphEdges.append(gridGraphEdgeIndicator) stop_gr = time.time() timing_logger.debug( "creating graph: {}".format( stop_gr - start_gr ) ) if debug_images: outdir1 = outdir+"hessianUp/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".tiff" logger.debug( "saving hessian to file: {}".format( outfile ) ) vigra.impex.writeImage(eigenValues, outfile ) instance = vigra.graphs.ShortestPathPathDijkstra(gridGr) relative_coord = [skeletonCoord[0]-roi[0][0], skeletonCoord[1]-roi[0][1]] relative_coord = map(long, relative_coord) sourceNode = gridGr.coordinateToNode(relative_coord) start_dij = time.time() instance.run(gridGraphEdgeIndicator, sourceNode, target=None) distances = instance.distances() stop_dij = time.time() timing_logger.debug( "spent in dijkstra {}".format( stop_dij - start_dij ) ) if debug_images: outdir1 = outdir+"distances/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".tiff" logger.debug( "saving distances to file:".format( outfile ) ) # Create a "white" pixel at the source node distances[skeletonCoord[0]-roi[0][0], skeletonCoord[1]-roi[0][1]] = numpy.max(distances) vigra.impex.writeImage(distances, outfile ) # Distances over raw membrane probabilities roi_upsampled_membrane = numpy.asarray( roi_hessian ) roi_upsampled_membrane[:, -1] = [0,1] roi_upsampled_membrane = (map(long, roi_upsampled_membrane[0]), map(long, roi_upsampled_membrane[1])) connector_distances = None connector_coords = None if node_info.id in node_to_connector.keys(): connectors = node_to_connector[node_info.id] connector_info = connector_infos_dict[connectors[0]] #Convert to pixels con_x_px = int(connector_info.x_nm / float(X_RES)) con_y_px = int(connector_info.y_nm / float(Y_RES)) con_z_px = int(connector_info.z_nm / float(Z_RES)) connector_coords = (con_x_px-roi[0][0], con_y_px-roi[0][1]) if con_x_px>roi[0][0] and con_x_px<roi[1][0] and con_y_px>roi[0][1] and con_y_px<roi[1][1]: #this connector is inside our prediction roi, compute the distance field " con_relative = [long(con_x_px-roi[0][0]), long(con_y_px-roi[0][1])] sourceNode = gridGr.coordinateToNode(con_relative) instance.run(gridGraphEdgeIndicator, sourceNode, target=None) connector_distances = instance.distances() else: connector_distances = None upsampled_membrane_probabilities = opUpsample.Output(*roi_upsampled_membrane).wait().squeeze() upsampled_membrane_probabilities = vigra.filters.gaussianSmoothing(upsampled_membrane_probabilities, sigma=1.0) #print "UPSAMPLED MEMBRANE SHAPE: {} MAX: {} MIN: {}".format( upsampled_membrane_probabilities.shape, upsampled_membrane_probabilities.max(), upsampled_membrane_probabilities.min() ) gridGrRaw = graphs.gridGraph((shape_x, shape_y )) # !on original pixels gridGraphRawEdgeIndicator = graphs.edgeFeaturesFromInterpolatedImage(gridGrRaw, upsampled_membrane_probabilities) #gridGraphs.append(gridGrRaw) #graphEdges.append(gridGraphRawEdgeIndicator) instance_raw = vigra.graphs.ShortestPathPathDijkstra(gridGrRaw) sourceNode = gridGrRaw.coordinateToNode(relative_coord) instance_raw.run(gridGraphRawEdgeIndicator, sourceNode, target=None) distances_raw = instance_raw.distances() stop_dij = time.time() timing_logger.debug( "spent in dijkstra (raw probs) {}".format( stop_dij - start_dij ) ) if debug_images: outdir1 = outdir+"distances_raw/" try: os.makedirs(outdir1) except os.error: pass outfile = outdir1+"/{}-{}".format( iz, node_info.id ) + ".tiff" logger.debug( "saving distances (raw probs) to file:".format( outfile ) ) # Create a "white" pixel at the source node distances_raw[skeletonCoord[0]-roi[0][0], skeletonCoord[1]-roi[0][1]] = numpy.max(distances_raw) vigra.impex.writeImage(distances_raw, outfile ) if numpy.sum(synapse_cc)==0: continue with max_label_lock: synapse_objects_4d, maxLabelCurrent = normalize_synapse_ids( synapse_cc, roi, previous_slice_objects, previous_slice_roi, maxLabelSoFar[0] ) maxLabelSoFar[0] = maxLabelCurrent synapse_objects = synapse_objects_4d.squeeze() #add this synapse to the exported list previous_slice_objects = synapse_objects previous_slice_roi = roi ''' if numpy.sum(synapse_cc)==0: print "NO SYNAPSES IN THIS SLICE:", iz timing_logger.debug( "ROI TIMER: {}".format( timer.seconds() ) ) continue ''' synapseIds = set(synapse_objects.flat) synapseIds.remove(0) for sid in synapseIds: #find the pixel positions of this synapse syn_pixel_coords = numpy.where(synapse_objects == sid) synapse_size = len( syn_pixel_coords[0] ) #syn_pixel_coords = numpy.unravel_index(syn_pixels, distances.shape) #FIXME: offset by roi syn_average_x = numpy.average(syn_pixel_coords[0])+roi[0][0] syn_average_y = numpy.average(syn_pixel_coords[1])+roi[0][1] syn_distances = distances[syn_pixel_coords] mindist = numpy.min(syn_distances) syn_distances_raw = distances_raw[syn_pixel_coords] mindist_raw = numpy.min(syn_distances_raw) if connector_distances is not None: syn_distances_connector = connector_distances[syn_pixel_coords] min_conn_distance = numpy.min(syn_distances_connector) elif connector_coords is not None: euclidean_dists = [scipy.spatial.distance.euclidean(connector_coords, xy) for xy in zip(syn_pixel_coords[0], syn_pixel_coords[1])] min_conn_distance = numpy.min(euclidean_dists) else: min_conn_distance = 99999.0 # Determine average uncertainty # Get probabilities for this synapse's pixels flat_predictions = synapse_predictions.view(numpy.ndarray)[synapse_objects_4d[...,0] == sid] # If we pulled the data from cache, there may be only one channel. # In that case, we can't quite compute a proper uncertainty, # so we'll just pretend there were only two prediction channels to begin with. if flat_predictions.shape[-1] > 1: # Sort along channel axis flat_predictions.sort(axis=-1) # What's the difference between the highest and second-highest class? certainties = flat_predictions[:,-1] - flat_predictions[:,-2] else: # Pretend there were only two channels certainties = flat_predictions[:,0] - (1 - flat_predictions[:,0]) avg_certainty = numpy.average(certainties) avg_uncertainty = 1.0 - avg_certainty fields = {} fields["synapse_id"] = int(sid) fields["x_px"] = int(syn_average_x + 0.5) fields["y_px"] = int(syn_average_y + 0.5) fields["z_px"] = iz fields["size_px"] = synapse_size fields["distance_hessian"] = mindist fields["distance_raw_probs"] = mindist_raw fields["detection_uncertainty"] = avg_uncertainty fields["node_id"] = node_info.id fields["node_x_px"] = node_info.x_px fields["node_y_px"] = node_info.y_px fields["node_z_px"] = node_info.z_px if min_conn_distance!=99999.0: connectors = node_to_connector[node_info.id] connector_info = connector_infos_dict[connectors[0]] fields["nearest_connector_id"] = connector_info.id fields["nearest_connector_distance_nm"] = min_conn_distance fields["nearest_connector_x_nm"] = connector_info.x_nm fields["nearest_connector_y_nm"] = connector_info.y_nm fields["nearest_connector_z_nm"] = connector_info.z_nm else: fields["nearest_connector_id"] = -1 fields["nearest_connector_distance_nm"] = min_conn_distance fields["nearest_connector_x_nm"] = -1 fields["nearest_connector_y_nm"] = -1 fields["nearest_connector_z_nm"] = -1 with f_out_lock: csv_writer.writerow( fields ) fout.flush() with f_out_lock: node_overall_index[0] += 1 progress_callback( ProgressInfo( node_overall_index[0], skeleton_node_count, branch_index, skeleton_branch_count, node_index_in_branch, branch_node_count, maxLabelCurrent ) ) #Sanity check #outfile = outdir+"hessianUp/"+ "%.02d"%iz + ".tiff" #vigra.impex.writeImage(eigenValues, outfile) #outfile = outdir+"distances/"+ "%.02d"%iz + ".tiff" #vigra.impex.writeImage(distances, outfile) timing_logger.debug( "ROI TIMER: {}".format( timer.seconds() ) )
def eccentricity(img, distFunc="exponential", showPathImage=False, percentageOfPaths=100, imgSaveName=""): img = img.astype(numpy.uint8) dim = len(img.shape) ## Enlarge image by one pixel on each side bigShape = [] for s in img.shape: bigShape.append(s + 2) bigImg = numpy.ones(bigShape) slices = [] for i in range(dim): slices.append(slice(1, bigImg.shape[i] - 1)) bigImg[slices] = img inside = numpy.where(bigImg == 0) outside = numpy.where(bigImg == 1) ## Apply distanceTransform and modify (outside: high values, inside: low values) distImage = vigra.filters.distanceTransform2D(bigImg.astype(numpy.float32)) imgp = distImage.copy() # if showPathImage: # imgp = distImage.copy() if distFunc == "exponential": distImage = numpy.exp(distImage * -gamma) elif distFunc == "linear": maxDist = distImage.max() distImage = maxDist - distImage + 10 elif distFunc == "inverse": w = numpy.where(distImage != 0) distImage[w] = 1 / distImage[w] else: print "wrong parameters for distFunc in eccentricity" ## Distance in the inside between two pixels is 1.0 #distImage = bigImg.copy().astype(numpy.float32) #distImage[inside]=1.0 # if len(imgSaveName)>1: # plt.imshow(numpy.swapaxes(distImage, 1, 0)) # plt.savefig(imgSaveName+"_dist.png") # #scipy.misc.imsave(imgSaveName+"_dist.png", numpy.swapaxes(distImage, 1, 0)) ## Set the outside to a very high value distImage[outside] = 1000.0 ## Image copy to draw the paths in #imgp = distImage.copy() imgp[outside] = 100 ## Get image graph and its path finder gridGraph = vigraph.gridGraph(bigImg.shape[0:dim], False) graphShape = [] for s in distImage.shape: graphShape.append(s * 2 - 1) edgeWeights = vigra.resize(distImage, graphShape, order=0) #edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImage(gridGraph, edgeWeights) edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImageCorrected( gridGraph, edgeWeights) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) ## Find borders in img if dim == 2: bigLblImg = vigra.analysis.labelImage(bigImg.astype(numpy.uint8)) else: bigLblImg = vigra.analysis.labelVolume(bigImg.astype(numpy.uint8)) rag = vigraph.GridRegionAdjacencyGraph(gridGraph, bigLblImg) node = vigraph.GridRegionAdjacencyGraph.nodeFromId( rag, long(bigLblImg[inside][0])) edges = vigraph._ragFindEdges(rag, gridGraph, rag.affiliatedEdges, bigLblImg, node) borderImg = numpy.zeros(bigImg.shape) for edge in edges: slices = [] for d in range(dim): slices.append(slice(edge[d], edge[d] + 1)) borderImg[slices] = 1 ## End points for paths (all points on the border) targets = numpy.where(borderImg == 1) nTargets = len(targets[0]) ## Find the diameter (longest path) eccLength = numpy.empty(nTargets) eccLength.fill(-1) eccTargetPath = {} vpIndex = 0 vpGraphIndex = [] for d in range(dim): vpGraphIndex.append(int(targets[d][vpIndex])) vp = gridGraph.coordinateToNode(vpGraphIndex) visited = numpy.zeros(nTargets) while True: visited[vpIndex] = 1 pathFinder.run(edgeWeights, vp) eccChanged = False for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) pathLength = pathFinder.distance(target) m = max(eccLength[j], pathLength) if m > eccLength[j]: eccChanged = True eccLength[j] = m eccTargetPath[j] = pathFinder.path(pathType='coordinates', target=target) vpIndex = numpy.argmax(eccLength) vpGraphIndex = [] for d in range(dim): vpGraphIndex.append(int(targets[d][vpIndex])) vp = gridGraph.coordinateToNode(vpGraphIndex) if visited[vpIndex] or not eccChanged: break ## Find the length of the diameter (non-weighted) path = eccTargetPath[vpIndex] dMax = 0 for k in range(1, len(path)): diffCount = 0 for d in range(dim): if path[k][d] != path[k - 1][d]: diffCount += 1 dMax += numpy.sqrt(diffCount) ## Find the midpoint of the diameter dMax = dMax / 2 if len(path) == 0: path = numpy.empty((1, 2), numpy.uint8) path[0][0] = targets[0][0] path[0][1] = targets[1][0] p1 = path[0] d1 = 0 for k in range(1, len(path)): p2 = path[k] d2 = d1 + numpy.linalg.norm(p2 - p1) if d2 > dMax: if (abs(d2 - dMax) < abs(d1 - dMax)): p1 = p2 break p1 = p2 d1 = d2 ## Compute eccentricity from center (p1) to all points on border sourceIndex = [] for d in range(dim): sourceIndex.append(int(p1[d])) source = gridGraph.coordinateToNode(sourceIndex) pathFinder.run(edgeWeights, source) maxPathLength = 0 for j in range(nTargets): targetIndex = [] for d in range(dim): targetIndex.append(int(targets[d][j])) target = gridGraph.coordinateToNode(targetIndex) pathLength = pathFinder.distance(target) maxPathLength = max(maxPathLength, pathLength) imgp[targetIndex[0], targetIndex[1]] = 40 * pathLength imgp[path[:, 0], path[:, 1]] = 12 * maxPathLength imgp[sourceIndex[0], sourceIndex[1]] = 40 * maxPathLength plt.figure(distFunc) plt.imshow(numpy.swapaxes(imgp, 1, 0), interpolation='none') if len(imgSaveName) > 1: scipy.misc.imsave(imgSaveName + ".png", numpy.swapaxes(imgp, 1, 0))
import vigra.graphs as graphs import pylab import numpy as np import sys import matplotlib import pylab as plt import math from matplotlib.widgets import Slider, Button, RadioButtons # parameter: imPath = ('holyRegion.h5', 'im') # input image path labPath = ('segMaskOnly.h5', 'data') # labeled image path # load volume labels = vigra.impex.readHDF5(*labPath).astype(np.uint32)[:, :, 0:20] volume = vigra.impex.readHDF5(*imPath)[:, :, 0:20] gridGraph = graphs.gridGraph(labels.shape) rag = graphs.regionAdjacencyGraph(gridGraph, labels) rand = np.random.rand(rag.edgeNum) * 2 - 1 gui = vigra.graphs.TinyEdgeLabelGui(rag=rag, img=volume, edgeLabels=None, labelMode=True) gui.startGui() print gui.edgeLabels
# load image and convert to LAB img = vigra.impex.readImage(filepath) # get super-pixels with slic on LAB image imgLab = vigra.colors.transform_RGB2Lab(img) labels, nseg = vigra.analysis.slicSuperpixels(imgLab, slicWeight, superpixelDiameter) labels = vigra.analysis.labelImage(labels) # compute gradient on interpolated image imgLabBig = vigra.resize(imgLab, [imgLab.shape[0]*2-1, imgLab.shape[1]*2-1]) gradMag = vigra.filters.gaussianGradientMagnitude(imgLabBig, sigmaGradMag) # get 2D grid graph and edgeMap for grid graph # from gradMag of interpolated image gridGraph = graphs.gridGraph(img.shape[0:2]) gridGraphEdgeIndicator = graphs.edgeFeaturesFromInterpolatedImage(gridGraph, gradMag) # get region adjacency graph from super-pixel labels rag = graphs.regionAdjacencyGraph(gridGraph, labels) # accumulate edge weights from gradient magnitude edgeWeights = rag.accumulateEdgeFeatures(gridGraphEdgeIndicator) # accumulate node features from grid graph node map # which is just a plain image (with channels) nodeFeatures = rag.accumulateNodeFeatures(imgLab) # do agglomerativeClustering labels = graphs.agglomerativeClustering(graph=rag, edgeWeights=edgeWeights, beta=beta, nodeFeatures=nodeFeatures,
print imgLab.shape print "interpolate image" imgLabBig = vigra.resize(imgLab, [imgLab.shape[0] * 2 - 1, imgLab.shape[1] * 2 - 1]) # make a few edge weights gradmag = numpy.squeeze( vigra.filters.gaussianGradientMagnitude(imgLabBig, sigma)) hessian = numpy.squeeze( vigra.filters.hessianOfGaussianEigenvalues(imgLabBig[:, :, 0], sigma))[:, :, 0] hessian -= hessian.min() raw = 256 - imgLabBig[:, :, 0].copy() gridGraph = vigraph.gridGraph(imgLab.shape[:2], False) weights = makeWeights(3.0) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) visuimg = img.copy() ax = plt.gca() fig = plt.gcf() visuimg -= visuimg.min() visuimg /= visuimg.max() implot = ax.imshow(numpy.swapaxes(visuimg, 0, 1), cmap='gray') clickList = [] frozen = False
options.stdDev = (4.5, )*3 print "smooth" ev = bw.gaussianSmooth(ev, options) vigra.impex.writeHDF5(ev,"growmap.h5",'data') else: ev = vigra.impex.readHDF5("growmap.h5",'data') with vigra.Timer("watershedsNew"): labels, nseg = vigra.analysis.unionFindWatershed3D(ev,(100,100,100)) print "gridGraph" gridGraph = graphs.gridGraph(labels.shape) rag = graphs.regionAdjacencyGraph(gridGraph, labels) rag.writeHDF5("rag.h5",'data') else: rag = vigra.graphs.loadGridRagHDF5("rag.h5",'data') labels=rag.labels
img/=img.max() img*=255 print(imgLab.shape) print("interpolate image") imgLabSmall = imgLab # make a few edge weights gradmag = numpy.squeeze(vigra.filters.gaussianGradientMagnitude(imgLabSmall,sigma)) hessian = numpy.squeeze(vigra.filters.hessianOfGaussianEigenvalues(imgLabSmall[:,:,0],sigma))[:,:,0] hessian-=hessian.min() raw = 256-imgLabSmall[:,:,0].copy() gridGraph = vigraph.gridGraph(imgLab.shape[:2],False) weights = makeWeights(3.0) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) visuimg =img.copy() ax = plt.gca() fig = plt.gcf() visuimg-=visuimg.min() visuimg/=visuimg.max() implot = ax.imshow(numpy.swapaxes(visuimg,0,1),cmap='gray')
grayData.append([dist, "dist"]) grayData.append([res, "thinned"]) print "write thinned pmap transform" vigra.impex.writeHDF5(res, opt['thinnedDistTransformPMap1'], "data") skneuro.addHocViewer(grayData, segData) if False: print "make the graph and save it" print "read segmentation" seg = vigra.impex.readHDF5(opt['oversegL0'], "data") segData.append([seg, "seg"]) gridGraph = graphs.gridGraph(seg.shape[0:3]) print "make rag" # get region adjacency graph from super-pixel labels rag = graphs.regionAdjacencyGraph(gridGraph, seg, isDense=False) print "save rag to file" rag.writeHDF5(opt['ragL0'], 'data') if False: print "accumulate edge weights and save them" print "load rag" # get region adjacency graph from super-pixel labels rag = graphs.loadGridRagHDF5(opt['ragL0'], 'data') gridGraph = rag.baseGraph
def eccentricity( img, distFunc = "exponential", showPathImage = False, percentageOfPaths = 100, imgSaveName = "" ): ## Enlarge image by one pixel on each side img = img.astype(numpy.uint8) bigImg = numpy.ones( (img.shape[0]+2, img.shape[1]+2) ) bigImg[1:bigImg.shape[0]-1, 1:bigImg.shape[1]-1] = img ## Find borders in img (replace with graph functions) borderImg = numpy.zeros(bigImg.shape) for y in range(bigImg.shape[1]-1): for x in range(bigImg.shape[0]-1): if bigImg[x,y] == 0: if bigImg[x+1,y] == 1 or bigImg[x,y+1] == 1: borderImg[x, y] = 1 else: if bigImg[x+1,y] == 0: borderImg[x+1, y] = 1 if bigImg[x,y+1] == 0: borderImg[x, y+1] = 1 ## regionImageToCrackEdgeImage ( labelImage ) # ## Apply distanceTransform and modify (outside: high values, inside: low values) # distImage = vigra.filters.distanceTransform2D(bigImg.astype(numpy.float32)) # if showPathImage: # imgp = distImage.copy() # if distFunc == "exponential": # distImage = numpy.exp(distImage*-gamma) # elif distFunc == "linear": # maxDist = distImage.max() # distImage = maxDist - distImage # elif distFunc == "inverse": # w = numpy.where(distImage!=0) # distImage[w] = 1/distImage[w] # else: # print "wrong parameters for distFunc in eccentricity" ## Distance in the inside between two pixels is 1.0 distImage = bigImg.copy().astype(numpy.float32) distImage[numpy.where(bigImg==0)]=1.0 ## Set the outside to a very high value distImage[numpy.where(bigImg==1)]=10000.0 imgp = distImage.copy() ## Get image graph and its path finder gridGraph = vigraph.gridGraph(bigImg.shape[0:2],False) edgeWeights = vigra.resize(distImage,[distImage.shape[0]*2-1,distImage.shape[1]*2-1],order=0) edgeWeights = vigra.graphs.edgeFeaturesFromInterpolatedImageCorrected(gridGraph,edgeWeights) pathFinder = vigraph.ShortestPathPathDijkstra(gridGraph) ## End points for paths (all points on the border) targets = numpy.where(borderImg==1) tx,ty = targets nTargets = len(tx) ## Indices of start points for paths (random) nPoints = int(numpy.ceil(percentageOfPaths * nTargets / 100.0)) numpy.random.seed(42) starts = numpy.random.permutation(range(nTargets))[:nPoints] ## Compute paths maxPaths = [] maxPathLengths = [] for i in range(nPoints): source = gridGraph.coordinateToNode((int(tx[starts[i]]), int (ty[starts[i]]))) pathFinder.run(edgeWeights, source) maxPathLength = 0 for j in range(nTargets): target = gridGraph.coordinateToNode((int(tx[j]), int(ty[j]))) path = pathFinder.path(pathType='coordinates', target=target) pathLength = pathFinder.distance(target) if pathLength > maxPathLength or maxPathLength == 0: maxPathLength = pathLength maxPath = path maxPaths.append(maxPath) maxPathLengths.append(maxPathLength) if showPathImage or len(imgSaveName)>1: val = (imgp.max()+imgp.min())/2 for p in maxPaths: imgp[p[:,0], p[:,1]] = val if showPathImage: plt.figure(distFunc) plt.imshow(imgp, interpolation='none') if len(imgSaveName)>1: scipy.misc.imsave(imgSaveName, imgp) return maxPathLengths