def apply_learning(self, smap, vector, bmu, radius, rate, func, params, batchlearn=False): toric, shape = params['toric'], params['shape'] if numpy.ma.isMaskedArray(vector): vector = vector.filled(0) if toric: bigshape = tuple(map(lambda x: 3*x, shape)) midselect = tuple([ slice(s, 2*s) for s in shape ]) features = numpy.ones(bigshape) copy_coord = lambda p, s: tuple([p+i*s for i in range(3)]) all_coords = [ copy_coord(coord, s) for coord, s in zip(bmu, shape) ] for p in itertools.product(*all_coords): features[p] = 0 distance = distance_transform_edt(features)[midselect] else: features = numpy.ones(shape) features[bmu] = 0 distance = distance_transform_edt(features) #radmap = numpy.exp( -sqdistance / (2.*radius)**2 ) radmap = func(distance, rate, radius) if not batchlearn: adjmap = (smap - vector) * radmap[..., None] smap -= adjmap else: adjmap = radmap[..., None] return adjmap
def calc_bwdist(data): """ Given data (binary), return distance function :param data: :return: """ return 0.5 * (distance_transform_edt(data == 0) + distance_transform_edt(data == 1)) - 0.5
def distance_trend(times, frames, threshold=25, min_size=12): nf = len(frames) zt = filters.gaussian_filter(frames,1.5) > threshold d_outer = np.zeros((nf,) + frames[0].shape) d_inner = np.zeros((nf,) + frames[0].shape) for i in range(nf): skmorph.remove_small_objects(zt, min_size=min_size, in_place=True) d_outer[i] = morphology.distance_transform_edt(np.invert(zt[i])) d_inner[i] = morphology.distance_transform_edt(zt[i]) return d_outer, d_inner
def spread_labels(labels,maxdist=9999999): """Spread the given labels to the background""" distances,features = morphology.distance_transform_edt(labels==0,return_distances=1,return_indices=1) indexes = features[0]*labels.shape[1]+features[1] spread = labels.ravel()[indexes.ravel()].reshape(*labels.shape) spread *= (distances<maxdist) return spread
def InitialGuess(y,I): #-- nearest neighbor interpolation (in case of missing values) if any(~I): try: from scipy.ndimage.morphology import distance_transform_edt #if license('test','image_toolbox') #[z,L] = bwdist(I); L = distance_transform_edt(1-I) z = y; z[~I] = y[L[~I]]; except: # If BWDIST does not exist, NaN values are all replaced with the # same scalar. The initial guess is not optimal and a warning # message thus appears. z = y; z[~I] = mean(y[I]); else: z = y; # coarse fast smoothing z = dctND(z,f=dct) k = array(z.shape) m = ceil(k/10)+1 d = [] for i in xrange(len(k)): d.append(arange(m[i],k[i])) d = np.array(d).astype(int) z[d] = 0. z = dctND(z,f=idct) return z
def _set_distance_transform(self): """ Compute the Euclidean distance transform of the valid to the invalid area. Stores the result in self._px_to_edge """ if self._px_to_edge is None: self._px_to_edge = morphology.distance_transform_edt(self._mask > 0)
def distMapUpdate(distMap, binaryImg, placedCircle): "Update a part of the distance map" radiusCirc = (placedCircle.radius).astype(np.int16) circCenter = placedCircle.center lowerLeftCoordX = circCenter[0] - 2* radiusCirc lowerLeftCoordY = circCenter[1] - 2* radiusCirc mapToUpdate = np.ones((radiusCirc*4,radiusCirc*4)) #print lowerLeftCoordX, lowerLeftCoordY #print radiusCirc #print mapToUpdate.shape lowerLeftCoordX,lowerLeftCoordY,limitX,limitY = ConsiderLimitsFrame(lowerLeftCoordX,lowerLeftCoordY,radiusCirc,binaryImg) mapToUpdate = np.ones((limitX,limitY)) for i in range(0,limitX): for j in range(0,limitY): mapToUpdate[i,j] = binaryImg [lowerLeftCoordX+i,lowerLeftCoordY+j] distMapUpdate = distance_transform_edt(mapToUpdate) for i in range(limitX): for j in range(limitY): distMap[lowerLeftCoordX+i,lowerLeftCoordY+j] = distMapUpdate [i,j] return distMap
def __surface_distances(input1, input2, voxelspacing=None, connectivity=1): """ The distances between the surface voxel of binary objects in input1 and their nearest partner surface voxel of a binary object in input2. """ input1 = numpy.atleast_1d(input1.astype(numpy.bool)) input2 = numpy.atleast_1d(input2.astype(numpy.bool)) if voxelspacing is not None: voxelspacing = _ni_support._normalize_sequence(voxelspacing, input1.ndim) voxelspacing = numpy.asarray(voxelspacing, dtype=numpy.float64) if not voxelspacing.flags.contiguous: voxelspacing = voxelspacing.copy() # binary structure footprint = generate_binary_structure(input1.ndim, connectivity) # extract only 1-pixel border line of objects input1_border = input1 - binary_erosion(input1, structure=footprint, iterations=1) input2_border = input2 - binary_erosion(input2, structure=footprint, iterations=1) # compute average surface distance # Note: scipys distance transform is calculated only inside the borders of the # foreground objects, therefore the input has to be reversed dt = distance_transform_edt(~input2_border, sampling=voxelspacing) sds = dt[input1_border] return sds
def __surface_distances(result, reference, voxelspacing=None, connectivity=1): """ The distances between the surface voxel of binary objects in result and their nearest partner surface voxel of a binary object in reference. """ result = numpy.atleast_1d(result.astype(numpy.bool)) reference = numpy.atleast_1d(reference.astype(numpy.bool)) if voxelspacing is not None: voxelspacing = _ni_support._normalize_sequence(voxelspacing, result.ndim) voxelspacing = numpy.asarray(voxelspacing, dtype=numpy.float64) if not voxelspacing.flags.contiguous: voxelspacing = voxelspacing.copy() # binary structure footprint = generate_binary_structure(result.ndim, connectivity) # test for emptiness if 0 == numpy.count_nonzero(result): raise RuntimeError('The first supplied array does not contain any binary object.') if 0 == numpy.count_nonzero(reference): raise RuntimeError('The second supplied array does not contain any binary object.') # extract only 1-pixel border line of objects result_border = result - binary_erosion(result, structure=footprint, iterations=1) reference_border = reference - binary_erosion(reference, structure=footprint, iterations=1) # compute average surface distance # Note: scipys distance transform is calculated only inside the borders of the # foreground objects, therefore the input has to be reversed dt = distance_transform_edt(~reference_border, sampling=voxelspacing) sds = dt[result_border] return sds
def split_object(self, labeled_image): """ split object when it's necessary """ labeled_image = labeled_image.astype(np.uint16) labeled_mask = np.zeros_like(labeled_image, dtype=np.uint16) labeled_mask[labeled_image != 0] = 1 #ift structuring element about center point. This only affects eccentric structuring elements (i.e. selem with even num=============================== labeled_image = skr.median(labeled_image, skm.disk(4)) labeled_mask = np.zeros_like(labeled_image, dtype=np.uint16) labeled_mask[labeled_image != 0] = 1 distance = scipym.distance_transform_edt(labeled_image).astype(np.uint16) #======================================================================= # binary = np.zeros(np.shape(labeled_image)) # binary[labeled_image > 0] = 1 #======================================================================= distance = skr.mean(distance, skm.disk(15)) l_max = skr.maximum(distance, skm.disk(5)) #l_max = skf.peak_local_max(distance, indices=False,labels=labeled_image, footprint=np.ones((3,3))) l_max = l_max - distance <= 0 l_max = skr.maximum(l_max.astype(np.uint8), skm.disk(6)) marker = ndimage.label(l_max)[0] split_image = skm.watershed(-distance, marker) split_image[split_image[0,0] == split_image] = 0 return split_image
def run(self, workspace): labeled_nuclei = workspace.object_set.get_objects(self.primary_objects.value).get_segmented() cell_image = workspace.image_set.get_image(self.image_name.value).pixel_data[:,:] image_collection = [] cell_treshold = otsu(cell_image, min_threshold=0, max_threshold=1) cell_binary = (cell_image >= cell_treshold) cell_distance = scipym.distance_transform_edt(cell_binary).astype(np.uint16) cell_labeled = skm.watershed(-cell_distance, labeled_nuclei, mask=cell_binary) # #fil hall and filter on syze the object in cell_labeled # cell_labeled = self.filter_on_border(cell_labeled) cell_labeled = fill_labeled_holes(cell_labeled) objects = cellprofiler.objects.Objects() objects.segmented = cell_labeled objects.parent_image = cell_image workspace.object_set.add_objects(objects, self.object_name.value) image_collection.append((cell_image, "Original")) image_collection.append((cell_labeled, "Labelized image")) workspace.display_data.image_collection = image_collection
def _make_costgrid(mask, ext, z): """Computes a costgrid following Kienholz et al. (2014) Eq. (2) Parameters ---------- mask : numpy.array The glacier mask. ext : numpy.array The glacier boundaries' mask. z : numpy.array The terrain height. Returns ------- numpy.array of the costgrid """ dis = np.where(mask, distance_transform_edt(mask), np.NaN) z = np.where(mask, z, np.NaN) dmax = np.nanmax(dis) zmax = np.nanmax(z) zmin = np.nanmin(z) cost = ((dmax - dis) / dmax * cfg.PARAMS['f1']) ** cfg.PARAMS['a'] + \ ((z - zmin) / (zmax - zmin) * cfg.PARAMS['f2']) ** cfg.PARAMS['b'] # This is new: we make the cost to go over boundaries # arbitrary high to avoid the lines to jump over adjacent boundaries cost[np.where(ext)] = np.nanmax(cost[np.where(ext)]) * 50 return np.where(mask, cost, np.Inf)
def medial(image): """Creates a medial axis transform image Args ---- image: ndarray The image of which the medial axis is to be calculated. This should be a binary image. visualise: bool Option to visualise the medial axis transform. Returns ------- out: ndarray A boolean image with the medial axis pixels """ # Remove noise and make sure it's thresholded im = thresholds(image) # Calculate distance to all border pixels for each non-border pixel dist = distance_transform_edt(im) # Calculate laplacian lap = laplace(dist, mode="constant") # Select items that are maximums and therefore less than 0 out = lap < 0 # Mask all items that are outside the boundaries # using the original image resultImage = np.logical_and(np.logical_not(out), im ) return dist, lap, resultImage
def predict(self, times, frames, output_times): nout = len(output_times) nf = len(frames) last_idx = np.argmax(times) zt = frames[last_idx] < self.thresh skmorph.remove_small_objects(zt, min_size=self.min_size, in_place=True) d = morphology.distance_transform_edt(np.invert(zt)) return np.tile(d, (nout,1,1))
def fun(batch): # Invert batch batch = 1. - batch # Merge batch and channel dimensions bshape = batch.shape batch = batch.reshape((bshape[0] * bshape[1], bshape[2], bshape[3])) # Distance transform by channel transbatch = np.array([np.exp(-gain * distance_transform_edt(img)) for img in batch]) # Reshape batch and return return transbatch.reshape(bshape)
def _extract_mask_distance(image, mask = slice(None), voxelspacing = None): """ Internal, single-image version of `mask_distance`. """ if isinstance(mask, slice): mask = numpy.ones(image.shape, numpy.bool) distance_map = distance_transform_edt(mask, sampling=voxelspacing) return _extract_intensities(distance_map, mask)
def conspicuity_int_hist(im, mask=None, use_sigmoid=False, morph_proc=True, type='hypo', a=3): if mask is None: mask = np.ones_like(im) class1, rv = tools.dominant_class(im, roi=mask) field = skimor.binary_closing(class1, selem=skimor.disk(3)) field = skimor.binary_opening(field, selem=skimor.disk(3)) field = (1 - field) * mask dist = scindimor.distance_transform_edt(field, return_distances=True) diff = abs(im - rv.mean()) im_int = dist * diff # plt.figure() # i = cv2.resize(255*(class1 > 0).astype(np.uint8), (115, 215)) # plt.imshow(i, 'gray'), plt.axis('off') # plt.show() # plt.figure() # plt.subplot(141), plt.imshow(cv2.resize(im, (115, 215)), 'gray'), plt.axis('off') # plt.subplot(142), plt.imshow(cv2.resize(dist, (115, 215)), 'jet'), plt.axis('off') # plt.subplot(143), plt.imshow(cv2.resize(diff, (115, 215)), 'jet'), plt.axis('off') # plt.subplot(144), plt.imshow(cv2.resize(im_int, (115, 215)), 'jet'), plt.axis('off') # plt.show() # im_int = skiexp.rescale_intensity(1 - rv.pdf(im), out_range=(0, 1)) # plt.figure() # plt.subplot(121), plt.imshow(im_int, 'gray') # plt.subplot(122), plt.imshow(im_int2, 'gray'), plt.colorbar() # plt.show() mean_v = rv.mean() # plt.figure() # plt.subplot(141), plt.imshow(im, 'gray'), plt.title('input') # plt.subplot(142), plt.imshow(class1, 'gray'), plt.title('class1') # plt.subplot(143), plt.imshow(field, 'gray'), plt.title('field') # plt.subplot(144), plt.imshow(im_int, 'gray'), plt.title('dist') # plt.show() im_res = conspicuity_processing(im_int, mask, use_sigmoid=use_sigmoid, a=a, c=mean_v, sigm_t=0.2, use_morph=morph_proc, radius=3) return im_res
def surface_dist(input1, input2, sampling=1, connectivity=1): input1 = np.squeeze(input1) input2 = np.squeeze(input2) input_1 = np.atleast_1d(input1.astype(np.bool)) input_2 = np.atleast_1d(input2.astype(np.bool)) conn = morphology.generate_binary_structure(input_1.ndim, connectivity) ## S = input_1 - morphology.binary_erosion(input_1, conn) ## Sprime = input_2 - morphology.binary_erosion(input_2, conn) S = np.bitwise_xor(input_1, morphology.binary_erosion(input_1, conn)) Sprime = np.bitwise_xor(input_2, morphology.binary_erosion(input_2, conn)) dta = morphology.distance_transform_edt(~S, sampling) dtb = morphology.distance_transform_edt(~Sprime, sampling) sds = np.concatenate([np.ravel(dta[Sprime != 0]), np.ravel(dtb[S != 0])]) return sds
def compute_surface_distance_per_label(y_1, y_2, sampling=1, connectivity=1): y1 = np.atleast_1d(y_1.astype(np.bool)) y2 = np.atleast_1d(y_2.astype(np.bool)) conn = morphology.generate_binary_structure(y1.ndim, connectivity) S1 = y1.astype(np.float32) - morphology.binary_erosion(y1, conn).astype( np.float32) S2 = y2.astype(np.float32) - morphology.binary_erosion(y2, conn).astype( np.float32) S1 = S1.astype(np.bool) S2 = S2.astype(np.bool) dta = morphology.distance_transform_edt(~S1, sampling) dtb = morphology.distance_transform_edt(~S2, sampling) sds = np.concatenate([np.ravel(dta[S2 != 0]), np.ravel(dtb[S1 != 0])]) return sds
def get_mask_and_dist(mask_paths): mask_paths = list(mask_paths) sample = np.array(Image.open(mask_paths[0])) mask = np.zeros_like(sample) dist = np.full(sample.shape, np.inf) for mask_path in mask_paths: mask_ = np.array(Image.open(mask_path)) mask_ = np.where(mask_, 1, 0) dist_ = distance_transform_edt(mask_) + distance_transform_edt(1 - mask_) dist = np.dstack((dist, dist_)) dist = np.amin(dist, axis=2) mask_d = binary_dilation(mask_, structure=generate_binary_structure(2, 2), iterations=2).astype(mask_.dtype) mask_ = mask_d - mask_ mask = np.logical_or(mask_, mask) mask = np.where(mask, 1, 0) return mask, dist
def spread_labels(labels, maxdist=9999999): """Spread the given labels to the background""" print("** spread_labels: labels=%s" % desc(labels)) distances, features = morphology.distance_transform_edt(labels==0, return_distances=1, return_indices=1) indexes = features[0]*labels.shape[1] + features[1] print("indexes=%s" % desc(indexes)) spread = labels.ravel()[indexes.ravel()].reshape(*labels.shape) print("spread=%s" % desc(spread)) spread *= (distances<maxdist) print("spread=%s" % desc(spread)) return spread
def prox_job(pa): pa_thres = 0.5 mask = pa > pa_thres t = time.time() dt= distance_transform_edt(1-mask) m = np.mean(dt) m = 50 temp_mask = (dt > m) dt[np.logical_not(temp_mask)] /= float(m) dt[temp_mask] = 1 return dt.flatten() / np.max(dt)
def GenerateObstacleCostF(OBST, epsilon): obs_cost = np.zeros((N, N)) for i in range(OBST.shape[0]): t = np.ones((N, N)) t[OBST[i, 0], OBST[i, 1]] = 0 t_cost = distance_transform_edt(t) t_cost[t_cost > epsilon[i]] = epsilon[i] t_cost = 1 / (2 * epsilon[i]) * (t_cost - epsilon[i])**2 obs_cost = obs_cost + t_cost gx, gy = np.gradient(obs_cost) return obs_cost, gx, gy
def calc_center_distance(laminD, aspect, asPercentile=False): '''Calculate center distance. Center is by default defined as the voxel(s) with the highest lamin distance, otherwise as the top percentile. Args: mask (np.ndarray): binary image. aspect (tuple[float]): pixel/voxel dimension proportion. asPercentile (bool): define center as percentile. ''' # Center as top percentile if asPercentile: centrD = distance_transform_edt(laminD < np.percentile(laminD, 99.), aspect[3 - len(laminD.shape):]) # Center as top value else: centrD = distance_transform_edt(laminD != laminD.max(), aspect[3 - len(laminD.shape):]) return (centrD)
def get_distance_transform(img, center): img = img.astype(float) H, W = img.shape[-2:] edges = 1.0 - canny(img.squeeze()) dt = distance_transform_edt(edges, 0.8) dt_original = np.expand_dims(dt.copy(), 0) # r, c = int(center[0]), int(center[1]) # dt[dt > dt[r, c]] = dt[r, c] # dt = (dt - np.min(dt)) / (np.max(dt) - np.min(dt)) dt = np.expand_dims(dt, 0) dt_original /= np.sqrt(H**2 + W**2) return dt, dt_original
def initiation_probabilities(self): """Return probability matrix based on distances to nearest fracture""" # Compute distance matrix d = distance_transform_edt(1 - self.grid) # Raise to the power of gamma d[d != 0] = np.power(d[d != 0], self.gamma) # Normalize by Z = \sum_ij d_ij d /= np.sum(d) return d
def Pc(Yor, Y_hator, tetha=5, c=1.0): Y = np.copy(Yor) Y_hat = np.copy(Y_hator) Y[Y != c] = 0 Y[Y == c] = 1.0 Y_hat[Y_hat != c] = 0 Y_hat[Y_hat == c] = 1.0 Bgt = Y - binary_erosion(Y, structure=np.ones((3, 3))) Bps = Y_hat - binary_erosion(Y_hat, structure=np.ones((3, 3))) D = distance_transform_edt(1 - Bgt) D_Bpd = D[Bps == 1.0] return np.sum(D_Bpd < tetha) / (float(np.sum(Bps == 1.0)) + 1)
def make_distance_map(image_shape, centres): # Distance transform f = np.ones(image_shape, bool) for idx in range(centres.shape[1]): x = int(min(max(0, centres[0, idx]), image_shape[0] - 1)) y = int(min(max(0, centres[1, idx]), image_shape[1] - 1)) f[x, y] = False distance_map = distance_transform_edt(f) return distance_map
def build_binary_structure(connectivity, n_dims, shape=None): """Return a dilation/erosion element with provided connectivity""" if shape is None: shape = [connectivity * 2 + 1] * n_dims else: shape = reformat_to_list(shape, length=n_dims) dist = np.ones(shape) center = tuple([tuple([int(s / 2)]) for s in shape]) dist[center] = 0 dist = distance_transform_edt(dist) struct = (dist <= connectivity) * 1 return struct
def signedDistanceField2D_(ground_truth_map, cell_size): # regularize unknow area to open area map = (ground_truth_map > 0.75) # inverse map inv_map = 1 - map # get signed distance from map and inverse map map_dist = distance_transform_edt(inv_map) # bwdist(map); inv_map_dist = distance_transform_edt(map) # bwdist(inv_map); field = map_dist - inv_map_dist # metric field = field * cell_size # field = float(field); # limit inf if math.isinf(field[0, 0]): field = np.ones(field.shape) * 1000 return field
def fun(batch): # Invert batch batch = 1. - batch # Merge batch and channel dimensions bshape = batch.shape batch = batch.reshape( (bshape[0] * bshape[1], bshape[2], bshape[3])) # Distance transform by channel transbatch = np.array( [np.exp(-gain * distance_transform_edt(img)) for img in batch]) # Reshape batch and return return transbatch.reshape(bshape)
def _ws_slice(self, z, input_, output): thresholded = input_[z] < self.threshold_dt dt = distance_transform_edt(thresholded).astype('float32') if self.sigma_seeds > 0.: dt = vigra.filters.gaussianSmoothing(dt, self.sigma_seeds) seeds = vigra.analysis.localMaxima(dt, allowPlateaus=True, allowAtBorder=True, marker=np.nan) seeds = vigra.analysis.labelImageWithBackground(np.isnan(seeds).view('uint8')) ws, max_id = vigra.analysis.watershedsNew(input_[z], seeds=seeds) if self.size_filter > 0: ws, max_id = filter_by_size(input_[z], ws, self.size_filter) output[z] = ws.astype('uint64') return max_id
def flat_label_to_edge_label(label, ): """ Converts a segmentation label (H,W) to a binary edgemap (H,W) """ radius = 2 one_hot_basis = np.eye(cityscapes.N_CLASSES) one_hot = one_hot_basis[label] one_hot_pad = np.pad(one_hot, ((1, 1), (1, 1), (0, 0)), mode='constant', constant_values=0) edgemap = np.zeros(one_hot.shape[:-1]) for i in range(cityscapes.N_CLASSES): dist = distance_transform_edt(one_hot_pad[..., i]) + \ distance_transform_edt(1.0 - one_hot_pad[..., i]) dist = dist[1:-1, 1:-1] dist[dist > radius] = 0 edgemap += dist edgemap = np.expand_dims(edgemap, axis=-1) edgemap = (edgemap > 0).astype(np.uint8) return edgemap
def provide(self, request): voxel_size = self.spec[self.raw].voxel_size shape = gp.Coordinate((1, ) + request[self.raw].roi.get_shape()) noise = np.abs(np.random.randn(*shape)) smoothed_noise = gaussian_filter(noise, sigma=self.smoothness) seeds = np.zeros(shape, dtype=int) for i in range(self.n_objects): if i == 0: num_points = 100 else: num_points = self.points_per_skeleton points = np.stack([ np.random.randint(0, shape[dim], num_points) for dim in range(3) ], axis=1) tree = skelerator.Tree(points) skeleton = skelerator.Skeleton(tree, [1, 1, 1], "linear", generate_graph=False) seeds = skeleton.draw(seeds, np.array([0, 0, 0]), i + 1) seeds[maximum_filter(seeds, size=4) != seeds] = 0 seeds_dt = distance_transform_edt(seeds == 0) + 5. * smoothed_noise gt_data = cwatershed(seeds_dt, seeds).astype(np.uint64)[0] - 1 labels = np.unique(gt_data) raw_data = np.zeros_like(gt_data, dtype=np.uint8) value = 0 for label in labels: raw_data[gt_data == label] = value value += 255.0 / self.n_objects spec = request[self.raw].copy() spec.voxel_size = (1, 1) raw = gp.Array(raw_data, spec) spec = request[self.gt].copy() spec.voxel_size = (1, 1) gt_crop = (request[self.gt].roi - request[self.raw].roi.get_begin()) / voxel_size gt_crop = gt_crop.to_slices() gt = gp.Array(gt_data[gt_crop], spec) batch = gp.Batch() batch[self.raw] = raw batch[self.gt] = gt return batch
def calculate_surface_distances(array_a, array_b, spacing, connectivity=1): """ reference url: https://mlnotebook.github.io/post/surface-distance-function/ """ array_a = np.atleast_1d(array_a.astype(np.bool)) array_b = np.atleast_1d(array_b.astype(np.bool)) conn = morphology.generate_binary_structure(array_a.ndim, connectivity) S = array_a ^ morphology.binary_erosion(array_a, conn) Sprime = array_b ^ morphology.binary_erosion(array_b, conn) distance_atob = morphology.distance_transform_edt(~S, spacing) distance_btoa = morphology.distance_transform_edt(~Sprime, spacing) total_surface_distances = np.concatenate([ np.ravel(distance_atob[Sprime != 0]), np.ravel(distance_btoa[S != 0]) ]) return total_surface_distances
def create_prepost_dt( clefts, labels, voxel_size, cleft_to_presyn_neuron_id, cleft_to_postsyn_neuron_id, bg_value=0, include_cleft=True, normalize_mode="tanh", normalize_args=50, ): max_distance = min(dim * vs for dim, vs in zip(clefts.shape, voxel_size)) presyn_distances = -np.ones(clefts.shape, dtype=np.float) * max_distance postsyn_distances = -np.ones(clefts.shape, dtype=np.float) * max_distance contained_cleft_ids = np.unique(clefts) for cleft_id in contained_cleft_ids: if cleft_id != bg_value: d = -distance_transform_edt(clefts != cleft_id, sampling=voxel_size) try: pre_neuron_id = np.array( list(cleft_to_presyn_neuron_id[cleft_id])) pre_mask = np.any(labels[..., None] == pre_neuron_id[None, ...], axis=-1) if include_cleft: pre_mask = np.any([pre_mask, clefts == cleft_id], axis=0) presyn_distances[pre_mask] = np.max((presyn_distances, d), axis=0)[pre_mask] except KeyError: warnings.warn("No Key in Pre Dict %s" % str(cleft_id)) try: post_neuron_id = np.array( list(cleft_to_postsyn_neuron_id[cleft_id])) post_mask = np.any(labels[..., None] == post_neuron_id[None, ...], axis=-1) if include_cleft: post_mask = np.any([post_mask, clefts == cleft_id], axis=0) postsyn_distances[post_mask] = np.max((postsyn_distances, d), axis=0)[post_mask] except KeyError: warnings.warn("No Key in Post Dict %s" % str(cleft_id)) if normalize is not None: presyn_distances = normalize(presyn_distances, normalize_mode, normalize_args=normalize_args) postsyn_distances = normalize(postsyn_distances, normalize_mode, normalize_args=normalize_args) return presyn_distances, postsyn_distances
def make_buffer(self, output_file): """ Create a buffer raster from 0 to 1 over a set distance. Args: output_file: where to save this raster """ # make a raster of the same extent, but with # square resolution which is dependant on distance buffer llc = self.extent[1] urc = self.extent[3] if self.over is None: transform = self.raster.ds.GetGeoTransform() dx = [transform[1], -transform[5]] nrows = self.raster.ds.RasterXSize ncols = self.raster.ds.RasterYSize else: dx = [self.distance / self.over, self.distance / self.over] # note this changes our extent if "over" is set nrows = int(ceil((urc[0] - llc[0]) / dx[0])) ncols = int(ceil((urc[1] - llc[1]) / dx[1])) # fill with edge value dist = np.full((ncols, nrows), 0.0) # then fill in the middle, # except where there is no data dist[1:-1, 1:-1] = 1 if self.over is None: orig_raster = self.raster.get_array() nodata = self.raster.nodata # TODO this will only work if dist and orig_raster # are the same size dist[orig_raster == nodata] = 0 # they also be nan...(shouldn't as we swap it out...) dist[np.isnan(orig_raster)] = 0 # we now extend this mask - we only need to do this, if the # no data occurs (i.e. no contiguous data) if (nodata in orig_raster): mask = np.full((ncols, nrows), False) mask[dist == 0] = True mask = self.extend_mask(mask, 1) dist[mask] = 0 # calc euclidian distance and convert to 0 -> 1 scale dist = distance_transform_edt(dist, sampling=[dx[0], dx[1]]) dist = dist / self.distance dist[dist > 1] = 1.0 # create a suitable output filename self.__write_raster__(output_file, np.flipud(dist), dx, [llc, urc], self.raster.ds.GetProjection())
def validdatagenerator(self): while True: # Randomize the indices to make an array indices_arr = np.random.permutation(len(self.valid_pat)) for batch in range(0, len(indices_arr), self.batch_size): # slice out the current batch according to batch-size current_batch = indices_arr[batch:(batch + self.batch_size)] # initializing the arrays, x_train and y_train n = 0 x_valid = np.ndarray((self.batch_size, self.img_rows, self.img_cols, self.img_slcs, 1), dtype=np.float32) y_valid = np.ndarray((self.batch_size, self.img_rows, self.img_cols, self.img_slcs, 1), dtype=np.float32) for i in current_batch: x1 = self.valid_pat[i] t1 = self.valid_sub_pat[i] xof1 = self.x_centvalid[i] - 80 xof2 = self.x_centvalid[i] + 80 yof1 = self.y_centvalid[i] - 80 yof2 = self.y_centvalid[i] + 80 if yof2 > 512: yof1 = 352 yof2 = 512 valid_img_in = np.load( os.path.join(self.data_dir, "CT_{}_{}.npy".format( x1, t1)))[xof1:xof2, yof1:yof2, self.z_startvalid[i]:self.z_endvalid[i]] valid_img_roi = np.load( os.path.join( self.data_dir, "ROI_{}_{}_{}.npy".format( x1, t1, self.roi_interest)))[ xof1:xof2, yof1:yof2, self.z_startvalid[i]:self.z_endvalid[i]] valid_img_in_equalized = np.zeros(valid_img_in.shape) inverse_image = np.ones(valid_img_roi.shape) for r in range(valid_img_in.shape[2]): imagenew = valid_img_in[:, :, r] valid_img_in_equalized[:, :, r] = image_histogram_equalization( imagenew)[0] valid_img_dist = distance_transform_edt( inverse_image - valid_img_roi.astype('float32')) # Appending them to existing batch x_valid[n:(n + 1), :, :, :, 0] = valid_img_in_equalized / 255 y_valid[n:(n + 1), :, :, :, 0] = valid_img_roi n += 1 yield (x_valid, y_valid)
def generate_trimap(self, alpha): # alpha \in [0, 1] should be taken into account # be careful when dealing with regions of alpha=0 and alpha=1 fg = np.array(np.equal(alpha, 255).astype(np.float32)) unknown = np.array(np.not_equal(alpha, 0).astype( np.float32)) # unknown = alpha > 0 unknown = unknown - fg # image dilation implemented by Euclidean distance transform unknown = morphology.distance_transform_edt( unknown == 0) <= np.random.randint(1, 20) trimap = fg * 255 trimap[unknown] = 128 return trimap.astype(np.uint8)
def prox_job2(pa): pa_thres = 0.5 mask = pa > pa_thres t = time.time() dt,ind= distance_transform_edt(1-mask, return_indices=True) inds = ind.T.reshape(-1, 3) m = np.mean(dt) m = 50 temp_mask = (dt > m) dt[np.logical_not(temp_mask)] /= float(m) dt[temp_mask] = 1 return dt.flatten() / np.max(dt)
def make_distance_map(image_shape, centres): # Distance transform f = np.ones(image_shape, bool) for idx in xrange(centres.shape[1]): x = int(min(max(0, centres[0, idx]), image_shape[0] - 1)) y = int(min(max(0, centres[1, idx]), image_shape[1] - 1)) f[x, y] = False distance_map = distance_transform_edt(f) return distance_map
def generate_boundary(path, image_name, mode, num_classes, ignore_label, total_num): # create the output filename dst = f"../boundary/{mode}/{image_name}" # do the conversion semantic_image = cv2.imread(f"{path}/{image_name}", cv2.IMREAD_GRAYSCALE) onehot_image = np.array([semantic_image == i for i in range(num_classes)]).astype(np.uint8) # change the ignored label to 0 onehot_image[onehot_image == ignore_label] = 0 boundary_image = np.zeros(onehot_image.shape[1:]) # for boundary conditions onehot_image = np.pad(onehot_image, ((0, 0), (1, 1), (1, 1)), mode='constant', constant_values=0) for i in range(num_classes): dist = distance_transform_edt(onehot_image[i, :]) + distance_transform_edt(1.0 - onehot_image[i, :]) dist = dist[1:-1, 1:-1] dist[dist > 2] = 0 boundary_image += dist boundary_image = (boundary_image > 0).astype(np.uint8) cv2.imwrite(dst, boundary_image) global boundary_progress boundary_progress += 1 print("\rProgress: {:>3} %".format(boundary_progress * 100 / total_num), end=' ') sys.stdout.flush()
def onehot_to_binary_edges(mask, radius, num_classes): """ Converts a segmentation mask (K,H,W) to a binary edgemap (H,W) """ if radius < 0: return mask # We need to pad the borders for boundary conditions mask_pad = np.pad(mask, ((0, 0), (1, 1), (1, 1)), mode='constant', constant_values=0) edgemap = np.zeros(mask.shape[1:]) for i in range(num_classes): # ti qu lun kuo dist = distance_transform_edt(mask_pad[i, :]) + distance_transform_edt(1.0 - mask_pad[i, :]) dist = dist[1:-1, 1:-1] dist[dist > radius] = 0 edgemap += dist # edgemap = np.expand_dims(edgemap, axis=0) edgemap = (edgemap > 0).astype(np.uint8)*255 return edgemap
def get_weights(labels_batch): weights = np.array([]) labels_batch_numpy = labels_batch.numpy() n = labels_batch_numpy.shape[0] labels_batch_numpy = labels_batch_numpy.astype('uint8') for i in range(n): label = labels_batch_numpy[i][0] trnsf = distance_transform_edt(label) trnsf = ((np.abs((trnsf.max() - trnsf))/trnsf.max())*(label)+1) trnsf = trnsf.flatten() weights = np.concatenate((weights, trnsf)) weights = torch.from_numpy(weights) return weights
def onehot_to_multiclass_edges(mask, radius, num_classes): """ Converts a segmentation mask (K,H,W) to an edgemap (K,H,W) """ if radius < 0: return mask # We need to pad the borders for boundary conditions mask_pad = np.pad(mask, ((0, 0), (1, 1), (1, 1)), mode='constant', constant_values=0) channels = [] for i in range(num_classes): dist = distance_transform_edt( mask_pad[i, :]) + distance_transform_edt(1.0 - mask_pad[i, :]) dist = dist[1:-1, 1:-1] dist[dist > radius] = 0 dist = (dist > 0).astype(np.uint8) channels.append(dist) return np.array(channels)
def generate_sd_field(track_wall_pixels, contained_pixel_position): track_pixels = flood_fill(track_wall_pixels, contained_pixel_position, 1, connectivity=1) # fill in the pixels between the track walls occupied_pixels = np.where(track_wall_pixels == 1, 0, 1) # prepare pixels for distance transform by making occupied pixels 0 and uoccupied pixels 1 d_field = np.array(distance_transform_edt(occupied_pixels)) # negate distances outside of the track walls for y, row in enumerate(d_field): for x, distance in enumerate(row): if track_pixels[y][x] == 0: d_field[y][x] = -distance return d_field
def process(self, batch, request: BatchRequest): labels = batch[self.label_array_key].data spec = batch[self.label_array_key].spec.copy() spec.dtype = self.dtype binarized = labels != 0 dt = -distance_transform_edt(np.logical_not(binarized), sampling=spec.voxel_size).astype( self.dtype) expanded = Array(data=dt, spec=spec) batch.arrays[self.distance_array_key] = expanded
def regression_label(self): if self.__regression_label is None: # reg_oriental_label = np.zeros(self.size+[self.divisions], dtype=np.float) angle = np.zeros(self.size+[self.divisions]).reshape(-1, self.divisions) reg_distance_label = np.zeros(self.size+[2], dtype=np.float) orient = np.zeros(len(self.lines)) dist_pre_line = np.zeros([len(self.lines)]+self.size) mask = self.mask() for idx, l in enumerate(self.lines): dist_pre_line[idx] = distance_transform_edt(mask != (idx+1)) orient[idx] = l.angle() _, [indicesY, indicesX] = distance_transform_edt(mask==0, return_indices=True) dx = indicesX - np.tile(range(self.size[1]), (self.size[0], 1)) dy = indicesY - np.tile(range(self.size[0]), (self.size[1], 1)).transpose() theta = orient[np.argmin(dist_pre_line, 0).reshape(-1)] # [H*W] angle[:] = [-np.pi/2 + k*np.pi / self.divisions for k in range(self.divisions)] d_theta = theta - angle.transpose() reg_oriental_label = d_theta.reshape([-1]+self.size).transpose() reg_distance_label[:,:,1] = dx reg_distance_label[:,:,0] = dy self.__regression_label = [reg_distance_label, reg_oriental_label] return self.__regression_label
def create_bad_labels(): from scipy.ndimage.morphology import distance_transform_edt thresholds = [100, 150, 175, 180, 190, 200, 220, 250] l = [] for threshold in thresholds: x = numpy.ones((480, 854)) dt = distance_transform_edt(x) z = numpy.zeros((480, 854)) z[:] = 255 negatives = dt > threshold z[negatives] = 0 l.append(numpy.expand_dims(z, axis=2)) return l
def kernel(mask,smooth=5.,x=None,y=None,sigma=None): K = distance_transform_edt(mask, sampling=None, return_distances=True, return_indices=False, distances=None, indices=None) K = K > (smooth/5.) K = gaussian_filter(numpy.array(K,dtype=numpy.float64),smooth) if x is not None and y is not None and sigma is not None: # multiply by gaussian darkfield kernel Ny, Nx = M.shape cx = (Nx-1)/2 cy = (Ny-1)/2 X,Y = numpy.ogrid[0:Ny, 0:Nx] R = numpy.hypot(X - (cx + x), Y - (cx + y)) G = numpy.exp(-R**2/(2*sigma**2)) K = K*G return K
def write_vol_file(self,): next_seg = io.loadmat("%s/segs_all_time_stamps/timestamp_%d_label_map.mat" % (self.ws_data.workspace_location, self.time_point + self.direction))["ws"] current_vol = io.loadmat("%s/init_watershed_all_time_stamps/vol_t_%d.mat" % (self.ws_data.workspace_location, self.time_point))["vol"] from scipy.ndimage.morphology import distance_transform_edt dt = distance_transform_edt(next_seg>1) dt = 1 - dt / float(dt.max()) dt = dt / 2. + 0.5 current_vol = current_vol * dt io.savemat("%s/init_watershed_all_time_stamps/vol_t_%d_propagate.mat"% (self.ws_data.workspace_location, self.time_point), {"vol":current_vol})
def get_surround_volume_v3(volume, distance=5, wall_level=0, prob=False, return_origin_instead_of_bbox=True, padding=5): """ Return the volume with voxels surrounding the ``active" voxels in the input volume set to 1 (prob=False) or 1 - vol (prob=True) Args: volume: (vol, origin) wall_level (float): voxels with value above this level are regarded as active. distance (int): surrounding voxels are closer than distance (in unit of voxel) from any active voxels. prob (bool): if True, surround voxels are assigned 1 - voxel value; if False, surround voxels are assigned 1. padding (int): extra zero-padding, in unit of voxels. Returns: (surround_volume, surround_volume_origin) """ from scipy.ndimage.morphology import distance_transform_edt distance = int(np.round(distance)) # Identify the bounding box for the surrouding area. vol, origin = volume # if bbox is None: bbox = volume_origin_to_bbox(vol > wall_level, origin) xmin, xmax, ymin, ymax, zmin, zmax = bbox roi_xmin = xmin - distance - padding roi_ymin = ymin - distance - padding roi_zmin = zmin - distance - padding roi_xmax = xmax + distance + padding roi_ymax = ymax + distance + padding roi_zmax = zmax + distance + padding roi_bbox = np.array((roi_xmin,roi_xmax,roi_ymin,roi_ymax,roi_zmin,roi_zmax)) vol_roi = crop_and_pad_volume(vol, in_bbox=bbox, out_bbox=roi_bbox) dist_vol = distance_transform_edt(vol_roi < wall_level) roi_surround_vol = (dist_vol > 0) & (dist_vol < distance) # surround part is True, otherwise False. if prob: surround_vol = np.zeros_like(vol_roi) surround_vol[roi_surround_vol] = 1. - vol_roi[roi_surround_vol] if return_origin_instead_of_bbox: return surround_vol, roi_bbox[[0,2,4]] else: return surround_vol, roi_bbox else: if return_origin_instead_of_bbox: return roi_surround_vol, roi_bbox[[0,2,4]] else: return roi_surround_vol, roi_bbox
def apply_learning(self, smap, k, bmu, radius, rate): i,j = bmu if self.metric == 'RMSD': vector = self.align(self.inputvectors[k], smap[i,j])[0] else: vector = self.inputvectors[k] shape = (self.X, self.Y) if self.toricMap: bigshape = tuple(map(lambda x: 3*x, shape)) midselect = tuple([ slice(s, 2*s) for s in shape ]) features = numpy.ones(bigshape) copy_coord = lambda p, s: tuple([p+i*s for i in range(3)]) all_coords = [ copy_coord(coord, s) for coord, s in zip(bmu, shape) ] for p in itertools.product(*all_coords): features[p] = 0 distance = distance_transform_edt(features)[midselect] else: features = numpy.ones(shape) features[bmu] = 0 distance = distance_transform_edt(features) #radmap = numpy.exp( -sqdistance / (2.*radius)**2 ) radmap = rate * numpy.exp( - distance**2 / (2.*radius)**2 ) adjmap = (smap - vector) * radmap[..., None] smap -= adjmap
def get_seeds_using_class_1(self, class1): dist_data = np.where(class1 == 1, False, True) dist_data *= self.segmentation > 0 dists = distance_transform_edt(dist_data) seeds = dists > 0.5 * dists.max() all_seeds = np.zeros(self.data3d.shape, dtype=np.int) # allSeeds[np.nonzero(self.segmentation)] = 80 all_seeds[np.nonzero(class1)] = 1 # zdrava tkan all_seeds[np.nonzero(seeds)] = 2 # outliers # kvuli segmentaci pomoci random walkera se omezi obraz pouze na # segmentovana jatra a cevy all_seeds = np.where(self.segmentation == 0, -1, all_seeds) return all_seeds
def raw_data_to_maps(raw_data, raw_width, raw_height): cropped_map = np.flipud(np.reshape(np.matrix(raw_data, dtype=np.uint8), (raw_width, raw_height)))[map_origin_y:map_origin_y + map_height, map_origin_x:map_origin_x + map_width] walls = cropped_map.copy() cropped_map[cropped_map > 0] = 1 walls = median_filter(walls, size=(median_filter_size / resolution)) walls[walls == 0] = 255 walls[walls == 100] = 0 walls[walls == 1] = 0 walls[walls == 157] = 0 path = distance_transform_edt(1 - median_filter(cropped_map, size=median_filter_size / resolution)) path[path * resolution > max_wall_distance] = 0 path[path * resolution < min_wall_distance] = 0 path[path > 0] = 0x0000FF return path, walls
def distmap_volume(B,perimeter_image=None): """Moberg & Sosik biovolume algorithm returns volume and representative transect""" if perimeter_image is None: perimeter_image = find_perimeter(B) D = distance_transform_edt(1-perimeter_image) + 1 D = D * (B>0) Dm = np.ma.array(D,mask=1-B) # representative transect x = 4 * np.ma.mean(Dm) - 2 # diamond correction c1 = x**2 / (x**2 + 2*x + 0.5) # circle correction # c2 = np.pi / 2 # volume = c1 * c2 * 2 * np.sum(D) volume = c1 * np.pi * np.sum(D) # return volume and representative transect return volume, x
def gauss_degrade(image,margin=1.0,change=None,noise=0.02,minmargin=0.5,inner=1.0): if image.ndim==3: image = mean(image,axis=2) m = mean([amin(image),amax(image)]) image = 1*(image>m) if margin<minmargin: return 1.0*image pixels = sum(image) if change is not None: npixels = int((1.0+change)*pixels) else: edt = distance_transform_edt(image==0) npixels = sum(edt<=(margin+1e-4)) r = int(max(1,2*margin+0.5)) ri = int(margin+0.5-inner) if ri<=0: mask = binary_dilation(image,iterations=r)-image else: mask = binary_dilation(image,iterations=r)-binary_erosion(image,iterations=ri) image += mask*randn(*image.shape)*noise*min(1.0,margin**2) smoothed = gaussian_filter(1.0*image,margin) frac = max(0.0,min(1.0,npixels*1.0/prod(image.shape))) threshold = mquantiles(smoothed,prob=[1.0-frac])[0] result = (smoothed>threshold) return 1.0*result
def InitialGuess(y, I): # Initial Guess with weighted/missing data # nearest neighbor interpolation (in case of missing values) z = y if (1 - I).any(): notI = ~I z, L = distance_transform_edt(notI, return_indices=True) z[notI] = y[L.flat[notI]] # coarse fast smoothing using one-tenth of the DCT coefficients siz = z.shape d = z.ndim z = dctn(z) for k in range(d): z[int((siz[k] + 0.5) / 10) + 1::, ...] = 0 z = z.reshape(np.roll(siz, -k)) z = z.transpose(np.roll(range(z.ndim), -1)) # z = shiftdim(z,1); z = idctn(z) return z
def all_gaps(c): """Computes a list of all the pairwise gaps between connected components of an image.""" # c,n = morph.label(c>0) n = len(unique(c))-1 if n<2: return [] #imshow(where(c>0,c%3+1,0),cmap=cm.jet) dts = [] for i,v in enumerate(unique(c)): if v==0: continue dt = morphology.distance_transform_edt(c!=v) dts.append(dt) result = [] for i in range(len(dts)): for j in range(i+1,len(dts)): dt1,dt2 = dts[i],dts[j] dtm = minimum(dt1,dt2) mv = amin(dtm[(dt1<=dtm+1)&(dt2<=dtm+1)]) result.append((i,j,mv)) result.append((j,i,mv)) return result
def kernel(mask,smooth=5.,x=None,y=None,sigma=None,mask_expand=1.,N_gaussians=1): if mask_expand > 0.: K = distance_transform_edt(mask, sampling=None, return_distances=True, return_indices=False, distances=None, indices=None) K = K > mask_expand K = numpy.array(K, dtype=numpy.float64) else: K = numpy.array(mask, dtype=numpy.float64) K = gaussian_filter(K,smooth) if x is not None and y is not None and sigma is not None and N_gaussians > 0: signs_x = [1,1,-1,-1] signs_y = [1,-1,1,-1] G = numpy.zeros_like(K) Ny, Nx = mask.shape cx = (Nx-1)/2 cy = (Ny-1)/2 X,Y = numpy.ogrid[0:Ny, 0:Nx] for i,sign_x,sign_y in zip(range(N_gaussians), signs_x, signs_y): # multiply by gaussian darkfield kernel Rsq = (X - (cx + sign_x*x))**2 + (Y - (cx + sign_y*y))**2 G += numpy.exp(-Rsq/(2*sigma**2)) K = K*G return K