orig_shape = img.shape if len(orig_shape) < 3: img = img[np.newaxis, ...] # background subtraction in each slice for z in range(img.shape[0]): im = np.array(img[z], dtype=np.dtype(img.dtype).newbyteorder('L')) im = cv2.blur(im, (3, 3)) img[z], _ = subtract_background_rolling_ball(im, self.size) img.shape = orig_shape return self.input filter_manager.add_filter(RollingBackgroundSubtract()) class BackgroundSubtract(FilterBase): """ Subtracts provided background image from the input image using the specified method. Background removal is done z-slice by z-slice. Call using :meth:`filter_image` with 'BackgroundSubtract' as filter. Attributes: input (array): 2D or 3D mage to pass through filter. background (str or array): Background image to subtract from data. Dimensions must match input dimensions. shift_z (int): Value to shift planes along Z.
if self.input.ndim == 2: labeled_1_img = labeled_1_img[1:-1, 1:-1] else: labeled_1_img = labeled_1_img[1:-1, 1:-1, 1:-1] out = io.empty(os.path.join(self.temp_dir, 'output.tif'), shape=labeled_1_img.shape, dtype=labeled_1_img.dtype) out[:] = labeled_1_img return out class LabelBySize(FilterBase): """Changes the value of all labels in a labeled image to their volume. Good for determining size thresholds. Attributes: input (array): Labeled Image to pass through filter, munt be memmapped. output (array): Filter result. """ def __init__(self): super().__init__(temp_dir=True) def _generate_output(self): return label_by_size(self.input, self.input) filter_manager.add_filter(Label()) filter_manager.add_filter(LabelBySize())
Attributes: input (array): Image to pass through filter. output (array): Filter result. size (float or tuple): Size of sliding window to calc median. If float, will apply same window to all axes. Default: 3. """ def __init__(self): self.size = 3 super().__init__() def _generate_output(self): return median_filter(self.input, self.size) filter_manager.add_filter(Median()) class Median2D(FilterBase): """Median filter applys slice-wise. Faster than 3D implimentation. Call using :meth:`filter_image` with 'Median2D' as filter. Attributes: input (array): Image to pass through filter. output (array): Filter result. size (int): Size of sliding window to calc median. Must be an odd integer. Default: 3. """ def __init__(self):
Attributes: input (array): Image to pass through filter. output (array): Filter result. size (float or tuple): Size of sliding window to look for max. If float, will apply same window to all axes. Default: (3, 3, 3). """ def __init__(self): self.size = (3, 3, 3) super().__init__() def _generate_output(self): img = self.input orig_shape = img.shape if len(orig_shape) < 3: img = img[np.newaxis, ...] struct = filterKernel(ftype='sphere', size=self.size) data = binary_erosion(img, structure=struct) img.shape = orig_shape return data.astype(np.uint8) filter_manager.add_filter(Erode())
__version__ = __version__ __maintainer__ = 'Ricardo Azevedo' __email__ = '*****@*****.**' __status__ = "Development" class ThresholdMinimum(FilterBase): """ Thresholds am image setting all values below threshold to 0. Attributes: input (array): Image to pass through filter. output (array): Filter result. min (float): minimum threshold. """ def __init__(self): self.min = 0 super().__init__() def _generate_output(self): if len(self.input.shape) == 3: self.input[:] = min_threshold_3d(self.input, self.min) return self.input else: self.input = self.input[self.input < self.min] = 0 return self.input filter_manager.add_filter(ThresholdMinimum())
self._initialize_Ilastik() # create temp npy input_fn = str((self.temp_dir / Path(self.input.filename).stem).with_suffix('.npy')) io.writeData(input_fn, self.input) output_fn = str(self.temp_dir / 'out_prelim.npy') ilinp = self._filename_to_input_arg(input_fn) ilout = self._filename_to_output_arg(output_fn) cmd_args = f'--project="{self.project}" {ilout} {ilinp}' self.run_headless(cmd_args) output = io.readData(output_fn) output_chan = self.temp_dir / 'out.npy' # transpose to restore input dimensionality output_chan = io.writeData(output_chan, output[..., self.output_channel], returnMemmap=True) return output_chan def _validate_input(self): if not isinstance(self.input, np.memmap): raise RuntimeError('Ilastik input must be a memory mapped array') filter_manager.add_filter(PixelClassification())
Call using :meth:`filter_image` with 'HMax' as filter. Attributes: input (array): Image to pass through filter. output (array): Filter result. hMax (float): h parameter of h-max transform """ def __init__(self): self.hMax = None super().__init__() def _generate_output(self): img = self.input orig_shape = img.shape if len(orig_shape) < 3: img = img[np.newaxis, ...] seed = img.copy() seed[seed >= self.hMax] = seed[seed >= self.hMax] - self.hMax res = reconstruct(seed, img) res.shape = orig_shape return res filter_manager.add_filter(HMax())
class Standardize(FilterBase): """Applies (I-mean) / SD to standardize data Parameters ---------- self.input: ndarray (2-D, 3-D, ...) of integers Input self.input. output: ndarray Standardized self.input. If provided as argument, must be of datatype "float". """ def __init__(self): super().__init__() def _generate_output(self): original_ndim = original_out_ndim = self.input.ndim if original_ndim == 2: self.input = self.input[np.newaxis, ...] _standardize(self.input, self.input) if original_ndim == 2: self.input.shape = self.input.shape[1:] return self.input filter_manager.add_filter(Standardize())
mask_s = np.array(mask[z]) slice[mask_s == 0] = 0 sink = cv2.max(sink, slice) else: for z in range(self.input.shape[0]): sink = cv2.max(sink, self.input[z]) return sink if method == 'min': max_v = np.iinfo(self.input.dtype).max sink = np.full(self.input.shape[1:], max_v, dtype=self.input.dtype) if self.mask: for z in range(self.input.shape[0]): slice = np.array(self.input[z]) mask_s = np.array(mask[z]) slice[mask_s == 0] = max_v sink = cv2.min(sink, slice) else: for z in range(self.input.shape[0]): sink = cv2.min(sink, self.input[z]) sink = sink sink[sink == max_v] = 0 return sink filter_manager.add_filter(Project())
if self.save_mask: self.log.info(f'saving mask to {self.save_mask}') io.writeData(self.save_mask, mask) # mask input # not working self.log.info(f'masking image') for z in range(self.input.shape[2]): im = self.input[:, :, z] im[mask[:, :, z] == 0] = 0 self.input[:, :, z] = im return self.input filter_manager.add_filter(ExtractSurface()) def erode(mask, sink, offset_z, offset_x, processes=1): # offset surface in z mask = io.readData(mask) sink = io.readData(sink) z_idxs = list(range(mask.shape[-1])) z_chunks = [z_idxs[i::processes] for i in range(processes)] z_args = [(mask.filename, sink.filename, z_idxs, offset_x) for z_idxs in z_chunks] x_idxs = list(range(mask.shape[0])) x_chunks = [x_idxs[i::processes] for i in range(processes)]
super().__init__() def _generate_output(self): img = self.input.astype( 'float32') # always convert to float for downstream processing orig_shape = img.shape if len(orig_shape) < 3: img = img[np.newaxis, ...] self.size = self.size + (self.size[-1], ) self.sigma = self.sigma + (self.sigma[-1], ) self.sigma2 = self.sigma2 + (self.sigma2[-1], ) if self.size: fdog = filterKernel(ftype='DoG', size=self.size, sigma=self.sigma, sigma2=self.sigma2) fdog = fdog.astype('float32') img = correlate(img, fdog) img[img < 0] = 0 img.shape = orig_shape return img filter_manager.add_filter(DoG())