def _computeGaussianSmoothing(self, vol, sigma, roi, in2d): if WITH_FAST_FILTERS: # Use fast filters (if available) result = numpy.zeros(vol.shape).astype(vol.dtype) assert vol.channelIndex == 0 for channel in range(vol.shape[0]): c_slice = slice(channel, channel + 1) if in2d: for z in range(vol.shape[1]): result[c_slice, z : z + 1] = fastfilters.gaussianSmoothing( vol[c_slice, z : z + 1], sigma, window_size=self.WINDOW_SIZE ) else: result[c_slice] = fastfilters.gaussianSmoothing(vol[c_slice], sigma, window_size=self.WINDOW_SIZE) roi = roiToSlice(*roi) return result[roi] else: # Use Vigra's filters if in2d: sigma = (0, sigma, sigma) # vigra's filter functions need roi without channels axis vigra_roi = (roi[0][1:], roi[1][1:]) return vigra.filters.gaussianSmoothing(vol, sigma, roi=vigra_roi, window_size=self.WINDOW_SIZE)
def _computeGaussianSmoothing(self, vol, sigma, roi, in2d): if WITH_FAST_FILTERS: # Use fast filters (if available) result = numpy.zeros(vol.shape).astype(vol.dtype) assert vol.channelIndex == 0 for channel in range(vol.shape[0]): c_slice = slice(channel, channel + 1) if in2d: for z in range(vol.shape[1]): result[c_slice, z:z + 1] = fastfilters.gaussianSmoothing( vol[c_slice, z:z + 1], sigma, window_size=self.WINDOW_SIZE) else: result[c_slice] = fastfilters.gaussianSmoothing( vol[c_slice], sigma, window_size=self.WINDOW_SIZE) roi = roiToSlice(*roi) return result[roi] else: # Use Vigra's filters if in2d: sigma = (0, sigma, sigma) # vigra's filter functions need roi without channels axis vigra_roi = (roi[0][1:], roi[1][1:]) return vigra.filters.gaussianSmoothing( vol, sigma, roi=vigra_roi, window_size=self.WINDOW_SIZE)
def pmapToHeightMap(pmap): r = int(min(3.0 * scale, 1.0) + 0.5) footprint, origin = makeBall(r=r) blurredSmall = fastfilters.gaussianSmoothing(pmap, 1.0*scale) blurredLarge = fastfilters.gaussianSmoothing(pmap, 6.0*scale) blurredSuperLarge = fastfilters.gaussianSmoothing(pmap, 10.0*scale) combined = pmap + blurredSuperLarge*0.3 + 0.15*blurredLarge + 0.1*blurredSmall r = int(min(5.0 * scale, 1.0) + 0.5) footprint, origin = makeBall(r=r) combined = scipy.ndimage.percentile_filter(input=combined, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) if False: nifty.viewer.view3D(pmap, show=False, title='pm',cmap='gray') nifty.viewer.view3D(medianImg, show=False, title='medianImg',cmap='gray') nifty.viewer.view3D(combined, show=False, title='combined',cmap='gray') pylab.show() return combined
def distance_transform_watershed(input_, threshold, sigma_seeds, sigma_weights=2., min_size=100, alpha=.9, pixel_pitch=None, apply_nonmax_suppression=False): """ Compute watershed segmentation based on distance transform seeds. Following the procedure outlined in "Multicut brings automated neurite segmentation closer to human performance": https://hci.iwr.uni-heidelberg.de/sites/default/files/publications/files/217205318/beier_17_multicut.pdf Arguments: input_ [np.ndarray] - input height map. threshold [float] - value for the threshold applied before distance tranform. sigma_seeds [float] - smoothing factor for the watershed seed map. sigma_weigths [float] - smoothing factor for the watershed weight map (default: 2). min_size [int] - minimal size of watershed segments (default: 100) alpha [float] - alpha used to blend input_ and distance_transform in order to obtain the watershed weight map (default: .9) pixel_pitch [listlike[int]] - anisotropy factor used to compute the distance transform (default: None) apply_nonmax_suppression [bool] - whetther to apply non-maxmimum suppression to filter out seeds. Needs nifty. (default: False) """ if apply_nonmax_suppression and nonMaximumDistanceSuppression is None: raise ValueError( "Non-maximum suppression is only available with nifty.") # threshold the input and compute distance transform thresholded = (input_ > threshold).astype('uint32') dt = vigra.filters.distanceTransform(thresholded, pixel_pitch=pixel_pitch) # compute seeds from maxima of the (smoothed) distance transform if sigma_seeds > 0: dt = ff.gaussianSmoothing(dt, sigma_seeds) compute_maxima = vigra.analysis.localMaxima if dt.ndim == 2 else vigra.analysis.localMaxima3D seeds = compute_maxima(dt, marker=np.nan, allowAtBorder=True, allowPlateaus=True) seeds = np.isnan(seeds) if apply_nonmax_suppression: seeds = non_maximum_suppression(dt, seeds) seeds = vigra.analysis.labelMultiArrayWithBackground(seeds.view('uint8')) # normalize and invert distance transform dt = 1. - (dt - dt.min()) / dt.max() # compute weights from input and distance transform if sigma_weights > 0.: hmap = alpha * ff.gaussianSmoothing(input_, sigma_weights) + (1. - alpha) * dt else: hmap = alpha * input_ + (1. - alpha) * dt # compute watershed ws, max_id = watershed(hmap, seeds, size_filter=min_size) return ws, max_id
def pmapToHeightMap(pmap): footprint, origin = makeBall(r=3) medianImg = scipy.ndimage.percentile_filter( input=pmap, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) if False: blurredSmall = vigra.gaussianSmoothing( pmap.T, 1.0, ).T blurredLarge = vigra.gaussianSmoothing( pmap.T, 6.0, ).T blurredSuperLarge = vigra.gaussianSmoothing( pmap.T, 10.0, ).T else: blurredSmall = fastfilters.gaussianSmoothing( pmap, 1.0, ) blurredLarge = fastfilters.gaussianSmoothing( pmap, 6.0, ) blurredSuperLarge = fastfilters.gaussianSmoothing( pmap, 10.0, ) combined = medianImg + blurredSuperLarge * 0.3 + 0.15 * blurredLarge + 0.1 * blurredSmall footprint, origin = makeBall(r=3) combined = scipy.ndimage.percentile_filter( input=combined, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) combined = fastfilters.gaussianSmoothing(combined, 1.3) #if False: # nifty.viewer.view3D(pmap, show=False, title='pm',cmap='gray') # nifty.viewer.view3D(medianImg, show=False, title='medianImg',cmap='gray') # nifty.viewer.view3D(combined, show=False, title='combined',cmap='gray') # pylab.show() return combined
def filter_fn(self, source_raw: numpy.ndarray) -> numpy.ndarray: a = fastfilters.gaussianSmoothing(source_raw, sigma=self.sigma0, window_size=self.window_size) b = fastfilters.gaussianSmoothing(source_raw, sigma=self.sigma1, window_size=self.window_size) return a - b
def filter_fn( self, source_raw: "ndarray[Any, dtype[float32]]" ) -> "ndarray[Any, dtype[float32]]": a = fastfilters.gaussianSmoothing(source_raw, sigma=self.sigma0, window_size=self.window_size) b = fastfilters.gaussianSmoothing(source_raw, sigma=self.sigma1, window_size=self.window_size) return a - b
def __call__(self, raw): f = fastfilters.gaussianSmoothing(raw, self.sigma) f -= self.mi f /= (self.ma - self.mi) return f[:, :, :, None]
def test_border_bug(): a = np.ones((150,150), dtype=np.float32) a[:] = np.nan a[25:125, 25:125] = 0 for _ in range(10): res = ff.gaussianSmoothing(a[25:125, 25:125], np.sqrt(99), window_size=10) ok_(np.all(res == 0))
def __init__(self, raw, sigma): self.sigma = sigma f = fastfilters.gaussianSmoothing(raw, self.sigma) self.mi = numpy.min(f) self.ma = numpy.max(f) self.range = (self.ma - self.mi) / tolFactor self.mi -= self.range self.ma += self.range
def _computeGaussianSmoothing(self, vol, sigma, roi): if WITH_FAST_FILTERS: # Use fast filters (if available) if vol.channels > 1: result = numpy.zeros(vol.shape).astype(vol.dtype) chInd = vol.channelIndex chSlice = [slice(None) for dim in range(len(vol.shape))] for channel in range(vol.channels): chSlice[chInd] = slice(channel, channel+1) result[chSlice] = fastfilters.gaussianSmoothing(vol[chSlice], sigma, window_size=self.WINDOW_SIZE) else: result = fastfilters.gaussianSmoothing(vol, sigma, window_size = self.WINDOW_SIZE) roi = roiToSlice(*roi) return result[roi] else: # Use Vigra's filters return vigra.filters.gaussianSmoothing(vol, sigma, roi=roi, window_size=self.WINDOW_SIZE)
def __call__(self, dataIn, slicing, featureArray): fIndex = 0 dataIn = numpy.require(dataIn,'float32').squeeze() dataWithChannel = extractChannels(dataIn, self.usedChannels) slicingEv = slicing + [slice(0,2)] for c in range(dataWithChannel.shape[2]): data = dataWithChannel[:,:,c] # pre-smoothed sigmaPre = self.sigmas[0]/2.0 preS = fastfilters.gaussianSmoothing(data, sigmaPre) for sigma in self.sigmas: neededScale = getScale(target=sigma, presmoothed=sigmaPre) preS = fastfilters.gaussianSmoothing(preS, neededScale) sigmaPre = sigma featureArray[:,:,fIndex] = preS[slicing] fIndex += 1 featureArray[:,:,fIndex] = fastfilters.laplacianOfGaussian(preS, neededScale)[slicing] fIndex += 1 featureArray[:,:,fIndex] = fastfilters.gaussianGradientMagnitude(preS, neededScale)[slicing] fIndex += 1 featureArray[:,:,fIndex:fIndex+2] = fastfilters.hessianOfGaussianEigenvalues(preS, neededScale)[slicingEv] fIndex += 2 #print("array shape",featureArray[:,:,:,fIndex:fIndex+3].shape) feat = fastfilters.structureTensorEigenvalues(preS, float(sigma)*0.3, float(sigma)*0.7)[slicingEv] #print("feat shape",feat.shape) featureArray[:,:,fIndex:fIndex+2] = feat fIndex += 2 assert fIndex == self.n_features
def test_border_bug(): a = np.ones((150, 150), dtype=np.float32) a[:] = np.nan a[25:125, 25:125] = 0 for _ in range(10): res = ff.gaussianSmoothing(a[25:125, 25:125], np.sqrt(99), window_size=10) ok_(np.all(res == 0))
def pmapToHeightMap(pmap): footprint, origin = makeBall(r=3) medianImg = scipy.ndimage.percentile_filter(input=pmap, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) if False: blurredSmall = vigra.gaussianSmoothing(pmap.T, 1.0,).T blurredLarge = vigra.gaussianSmoothing(pmap.T, 6.0,).T blurredSuperLarge = vigra.gaussianSmoothing(pmap.T, 10.0,).T else: blurredSmall = fastfilters.gaussianSmoothing(pmap, 1.0,) blurredLarge = fastfilters.gaussianSmoothing(pmap, 6.0,) blurredSuperLarge = fastfilters.gaussianSmoothing(pmap, 10.0,) combined = medianImg + blurredSuperLarge*0.3 + 0.15*blurredLarge + 0.1*blurredSmall footprint, origin = makeBall(r=3) combined = scipy.ndimage.percentile_filter(input=combined, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) if False: nifty.viewer.view3D(pmap, show=False, title='pm',cmap='gray') nifty.viewer.view3D(medianImg, show=False, title='medianImg',cmap='gray') nifty.viewer.view3D(combined, show=False, title='combined',cmap='gray') pylab.show() return combined
def _computeGaussianSmoothing(self, vol, sigma, roi): invalid_z = vol.shape[ 1] == 1 or sigma < .3 or sigma * self.WINDOW_SIZE > vol.shape[1] if invalid_z and vol.shape[1] > 1 and not self.ComputeIn2d.value: logger.warning( f'PixelFeaturesPresmoothed: Pre-smoothing in 2d for sigma {sigma:.2f} (z dimension too small)' ) if WITH_FAST_FILTERS: # Use fast filters (if available) result = numpy.zeros(vol.shape).astype(vol.dtype) assert vol.channelIndex == 0 for channel in range(vol.shape[0]): c_slice = slice(channel, channel + 1) if self.ComputeIn2d.value or invalid_z: for z in range(vol.shape[1]): result[c_slice, z:z + 1] = fastfilters.gaussianSmoothing( vol[c_slice, z:z + 1], sigma, window_size=self.WINDOW_SIZE) else: result[c_slice] = fastfilters.gaussianSmoothing( vol[c_slice], sigma, window_size=self.WINDOW_SIZE) roi = roiToSlice(*roi) return result[roi] else: # Use Vigra's filters if invalid_z or self.ComputeIn2d.value: sigma = (0, sigma, sigma) # vigra's filter functions need roi without channels axis vigra_roi = (roi[0][1:], roi[1][1:]) return vigra.filters.gaussianSmoothing( vol, sigma, roi=vigra_roi, window_size=self.WINDOW_SIZE)
def pmapToHeightMap(pmap): r = int(min(3.0 * scale, 1.0) + 0.5) footprint, origin = makeBall(r=r) blurredSmall = fastfilters.gaussianSmoothing(pmap, 1.0 * scale) blurredLarge = fastfilters.gaussianSmoothing(pmap, 6.0 * scale) blurredSuperLarge = fastfilters.gaussianSmoothing( pmap, 10.0 * scale) combined = pmap + blurredSuperLarge * 0.3 + 0.15 * blurredLarge + 0.1 * blurredSmall r = int(min(5.0 * scale, 1.0) + 0.5) footprint, origin = makeBall(r=r) combined = scipy.ndimage.percentile_filter( input=combined, #size=(20,20,20), footprint=footprint, #origin=origin, mode='reflect', percentile=50.0) if False: nifty.viewer.view3D(pmap, show=False, title='pm', cmap='gray') nifty.viewer.view3D(medianImg, show=False, title='medianImg', cmap='gray') nifty.viewer.view3D(combined, show=False, title='combined', cmap='gray') pylab.show() return combined
def _apply_coord(old_coord): coord = transform_coordinate(old_coord) # range check if any(co < 0 or co >= maxr for co, maxr in zip(coord, max_range)): return # get the coordinates to iterate over and the interpolation weights coords, weights = interpolate_coordinates(coord) # iterate over coordinates and compute the output value val = 0. for coord, weight in zip(coords, weights): chunk_id = blocking.coordinatesToBlockId(list(coord)) chunk, offset = chunk_cache.get(chunk_id, (None, None)) if chunk is None: chunk_pos = blocking.blockGridPosition(chunk_id) if sigma is None: block = blocking.getBlock(chunk_id) chunk_bb = tuple( slice(beg, end) for beg, end in zip(block.begin, block.end)) else: block = blocking.getBlockWithHalo(chunk_id, list(halo)) chunk_bb = tuple( slice(beg, end) for beg, end in zip( block.outerBlock.begin, block.outerBlock.end)) chunk = data[chunk_bb] if sigma is not None: chunk = ff.gaussianSmoothing(chunk, sigma) inner_bb = tuple( slice(beg, end) for beg, end in zip(block.innerBlockLocal.begin, block.innerBlockLocal.end)) chunk = chunk[inner_bb] offset = [cp * ch for cp, ch in zip(chunk_pos, chunks)] chunk_cache[chunk_id] = (chunk, offset) chunk_coord = tuple(oc - of for oc, of in zip(coord, offset)) val += weight * chunk[chunk_coord] out_coord = tuple(co - of for co, of in zip(old_coord, start)) out[out_coord] = val
def differenceOfGausssiansFF(image, sigma0, sigma1, window_size): return fastfilters.gaussianSmoothing(image, sigma0, window_size) - fastfilters.gaussianSmoothing( image, sigma1, window_size )
def gaussian(a, *, scale): return fastfilters.gaussianSmoothing(a, scale)
import fastfilters as ff import numpy as np a = np.ones((150, 150), dtype=np.float32) a[:] = np.nan a[25:125, 25:125] = 1 for _ in range(10): res = ff.gaussianSmoothing(a[25:125, 25:125], np.sqrt(99), window_size=5) assert (np.any(np.isnan(res)) == False) assert (np.any(np.where(res < -1000)) == False)
import fastfilters as ff import numpy as np a = np.ones((150,150), dtype=np.float32) a[:] = np.nan a[25:125, 25:125] = 1 for _ in range(10): res = ff.gaussianSmoothing(a[25:125, 25:125], np.sqrt(99), window_size=5) assert(np.any(np.isnan(res)) == False) assert(np.any(np.where(res < -1000)) == False)