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())
