def _process_and_get(self, *args, update_properties=None, index=0, **kwargs): # Loads a result from storage image_list_of_lists = self.preloaded_results[index] if not isinstance(image_list_of_lists, list): image_list_of_lists = [image_list_of_lists] new_list_of_lists = [] # Calls get for image_list in image_list_of_lists: if isinstance(image_list, list): new_list_of_lists.append([[ self.get(Image(image), **kwargs).merge_properties_from(image) for image in image_list ]]) else: new_list_of_lists.append( self.get(Image(image_list), **kwargs).merge_properties_from(image_list)) if update_properties: for image_list in new_list_of_lists: if not isinstance(new_list_of_lists, list): image_list = [image_list] for image in image_list: image.properties = [ dict(prop) for prop in image.properties ] update_properties(image, **kwargs) return new_list_of_lists
def _process_and_get(self, *args, update_properties=None, **kwargs): # Loads a result from storage if self.feature and ( not hasattr(self, "cache") or kwargs["update_tally"] - self.last_update >= kwargs["updates_per_reload"] ): if isinstance(self.feature, list): self.cache = [feature.resolve() for feature in self.feature] else: self.cache = self.feature.resolve() self.last_update = kwargs["update_tally"] if not self.feature: image_list_of_lists = args[0] else: image_list_of_lists = self.cache if not isinstance(image_list_of_lists, list): image_list_of_lists = [image_list_of_lists] new_list_of_lists = [] # Calls get np.random.seed(kwargs["hash_key"][0]) for image_list in image_list_of_lists: if isinstance(self.feature, list): # If multiple features, ensure consistent rng np.random.seed(kwargs["hash_key"][0]) if isinstance(image_list, list): new_list_of_lists.append( [ [ Image( self.get(Image(image), **kwargs) ).merge_properties_from(image) for image in image_list ] ] ) else: new_list_of_lists.append( Image(self.get(Image(image_list), **kwargs)).merge_properties_from( image_list ) ) if update_properties: if not isinstance(new_list_of_lists, list): new_list_of_lists = [new_list_of_lists] for image_list in new_list_of_lists: if not isinstance(image_list, list): image_list = [image_list] for image in image_list: image.properties = [dict(prop) for prop in image.properties] update_properties(image, **kwargs) return new_list_of_lists
def _continuous_get_training_data(self): index = 0 while True: # Stop generator if self.exit_signal: break new_image = self._get(self.feature, self.feature_kwargs) if self.label_function: new_label = Image(self.label_function(new_image)) if self.batch_function: new_image = Image(self.batch_function(new_image)) if new_image.ndim < self.ndim: new_image = [new_image] new_label = [new_label] for new_image_i, new_label_i in zip(new_image, new_label): if len(self.data) >= self.max_data_size: self.data[index % self.max_data_size] = (new_image_i, new_label_i) else: self.data.append((new_image_i, new_label_i)) index += 1
def get(self, image, sample, objective, **kwargs): # Grab properties from the objective to pass to the sample new_kwargs = objective.properties.current_value_dict(**kwargs) new_kwargs.update(kwargs) kwargs = new_kwargs list_of_scatterers = sample.resolve(**kwargs) if not isinstance(list_of_scatterers, list): list_of_scatterers = [list_of_scatterers] volume_samples = [ scatterer for scatterer in list_of_scatterers if not scatterer.get_property("is_field", default=False) ] field_samples = [ scatterer for scatterer in list_of_scatterers if scatterer.get_property("is_field", default=False) ] sample_volume, limits = _create_volume(volume_samples, **kwargs) sample_volume = Image(sample_volume) for scatterer in volume_samples + field_samples: sample_volume.merge_properties_from(scatterer) imaged_sample = objective.resolve( sample_volume, limits=limits, fields=field_samples, **kwargs ) upscale = kwargs["upscale"] shape = imaged_sample.shape if upscale > 1: mean_imaged_sample = np.reshape( imaged_sample, (shape[0] // upscale, upscale, shape[1] // upscale, upscale, shape[2]), ).mean(axis=(3, 1)) imaged_sample = Image(mean_imaged_sample).merge_properties_from( imaged_sample ) # Merge with input if not image: return imaged_sample if not isinstance(image, list): image = [image] for i in range(len(image)): image[i].merge_properties_from(imaged_sample) return image
def _process_and_get(self, image_list, **feature_input): if self.__distributed__: return [ Image(self.get(image, **feature_input)) for image in image_list ] else: new_list = self.get(image_list, **feature_input) if not isinstance(new_list, list): new_list = [Image(new_list)] return new_list
def _process_and_get(self, image_list, **feature_input) -> List[Image]: # Controls how the get function is called if self.__distributed__: # Call get on each image in list, and merge properties from corresponding image return [Image(self.get(image, **feature_input)).merge_properties_from(image) for image in image_list] else: # Call get on entire list. new_list = self.get(image_list, **feature_input) if not isinstance(new_list, list): new_list = [Image(new_list)] return new_list
def test_Background(self): noise = noises.Background(offset=0.5) input_image = Image(np.zeros((256, 256))) output_image = noise.resolve(input_image) self.assertIsInstance(output_image, Image) self.assertEqual(output_image.shape, (256, 256)) self.assertTrue(np.all(np.array(output_image) == 0.5))
def get(self, image, snr=None, **kwargs): image[image < 0] = 0 peak = np.max(image) rescale = snr**2 / peak noisy_image = Image(np.random.poisson(image * rescale) / rescale) noisy_image.properties = image.properties return noisy_image
def get(self, image, snr, background, **kwargs): image[image < 0] = 0 peak = np.abs(np.max(image) - background) rescale = snr**2 / peak**2 noisy_image = Image(np.random.poisson(image * rescale) / rescale) noisy_image.properties = image.properties return noisy_image ## IMGAUG IMGCORRUPTLIKE # Currently unavailable until there's a better way to implement constricted datatypes (only uint8) # Please see https://github.com/aleju/imgaug/blob/master/imgaug/augmenters/imgcorruptlike.py # for source implementation # import imgaug.augmenters as iaa # import deeptrack as dt # import inspect # def init_method(self, **kwargs): # dt.ImgAug.__init__(self, **kwargs) # augs = inspect.getmembers(iaa.blur, lambda x: inspect.isclass(x)) # for augname, aug in augs: # print(augname, aug.__module__) # globals()[augname] = type(augname, (aug, dt.ImgAug), { # "augmenter": aug, # "__init__": init_method})
def get(self, image, sample, objective, **kwargs): # Grab properties from the objective to pass to the sample new_kwargs = objective.properties.current_value_dict() new_kwargs.update(kwargs) kwargs = new_kwargs list_of_scatterers = sample.resolve(**kwargs) if not isinstance(list_of_scatterers, list): list_of_scatterers = [list_of_scatterers] sample_volume, limits = _create_volume(list_of_scatterers, **kwargs) sample_volume = Image(sample_volume) for scatterer in list_of_scatterers: sample_volume.merge_properties_from(scatterer) imaged_sample = objective.resolve(sample_volume, limits=limits, **kwargs) # Merge with input if not image: return imaged_sample if not isinstance(image, list): image = [image] for i in range(len(image)): image[i].merge_properties_from(imaged_sample) return image
def get(self, image, features=None, axis=None): image_list = [feature.resolve(image) for feature in features] merged_image = Image(np.concatenate(image_list, axis=axis)) image = Image(image) num_properties = len(image.properties) merged_properties = image.properties for im in image_list: merged_properties += im.properties[num_properties:] merged_image.properties = merged_properties return merged_image
def get(self, images, axis, features, **kwargs): if features is not None: images = [feature.resolve() for feature in features] result = Image(np.mean(images, axis=axis)) for image in images: result.merge_properties_from(image) return result
def get(self, image, snr, background, **kwargs): image[image < 0] = 0 peak = np.abs(np.max(image) - background) rescale = snr**2 / peak**2 noisy_image = Image(np.random.poisson(image * rescale) / rescale) noisy_image.properties = image.properties return noisy_image
def _pupil(self, shape, NA, wavelength, refractive_index_medium, voxel_size, upscale, pupil, aberration=None, include_aberration=True, defocus=0, **kwargs): # Calculates the pupil at each z-position in defocus. shape = np.array(shape) # Pupil radius R = NA / wavelength * np.array(voxel_size)[:2] x_radius = R[0] * shape[0] y_radius = R[1] * shape[1] x = (np.linspace(-(shape[0] / 2), shape[0] / 2 - 1, shape[0])) / x_radius + 1e-8 y = (np.linspace(-(shape[1] / 2), shape[1] / 2 - 1, shape[1])) / y_radius + 1e-8 W, H = np.meshgrid(y, x) RHO = W**2 + H**2 RHO[RHO > 1] = 1 pupil_function = ((RHO < 1) * 1.0).astype(np.complex) # Defocus z_shift = (2 * np.pi * refractive_index_medium / wavelength * voxel_size[2] * np.sqrt(1 - (NA / refractive_index_medium)**2 * RHO)) # Downsample the upsampled pupil pupil_function[np.isnan(pupil_function)] = 0 pupil_function[np.isinf(pupil_function)] = 0 pupil_function_is_nonzero = pupil_function != 0 if include_aberration: pupil = pupil or aberration if isinstance(pupil, Feature): pupil_function = pupil.resolve(pupil_function, **kwargs) elif isinstance(pupil, np.ndarray): pupil_function *= pupil pupil_functions = [] for z in defocus: pupil_at_z = Image(pupil_function) pupil_at_z[pupil_function_is_nonzero] *= np.exp( 1j * z_shift[pupil_function_is_nonzero] * z) pupil_functions.append(pupil_at_z) return pupil_functions
def _format_input(self, image_list, **kwargs) -> List[Image]: # Ensures the input is a list of Image. if image_list is None: return [] if not isinstance(image_list, list): image_list = [image_list] return [Image(image) for image in image_list]
def _process_and_get(self, *args, voxel_size, upsample, upsample_axes=None, crop_empty=True, **kwargs): # Post processes the created object to handle upsampling, # as well as cropping empty slices. # Calculates upsampled voxel_size if upsample_axes is None: upsample_axes = range(3) voxel_size = np.array(voxel_size) for axis in upsample_axes: voxel_size[axis] /= upsample # calls parent _process_and_get new_image = super()._process_and_get(*args, voxel_size=voxel_size, upsample=upsample, **kwargs) new_image = new_image[0] # Downsamples the image along the axes it was upsampled if upsample != 1 and upsample_axes: # Pad image to ensure it is divisible by upsample increase = np.array(new_image.shape) for axis in upsample_axes: increase[axis] = upsample - (new_image.shape[axis] % upsample) pad_width = [(0, inc) for inc in increase] new_image = np.pad(new_image, pad_width, mode='constant') # Finds reshape size for downsampling new_shape = [] for axis in range(new_image.ndim): if axis in upsample_axes: new_shape += [new_image.shape[axis] // upsample, upsample] else: new_shape += [new_image.shape[axis]] # Downsamples new_image = np.reshape(new_image, new_shape).mean( axis=tuple(np.array(upsample_axes, dtype=np.int32) * 2 + 1)) # Crops empty slices if crop_empty: new_image = new_image[~np.all(new_image == 0, axis=(1, 2))] new_image = new_image[:, ~np.all(new_image == 0, axis=(0, 2))] new_image = new_image[:, :, ~np.all(new_image == 0, axis=(0, 1))] return [Image(new_image)]
def get(self, image, sample=None, objective=None, pupil=None, **kwargs): new_kwargs = objective.properties.current_value_dict() new_kwargs.update(kwargs) kwargs = new_kwargs list_of_scatterers = sample.resolve(**kwargs) if not isinstance(list_of_scatterers, list): list_of_scatterers = [list_of_scatterers] sample_volume, limits = create_volume(list_of_scatterers, **kwargs) sample_volume = Image(sample_volume) for scatterer in list_of_scatterers: sample_volume.properties += scatterer.properties imaged_sample = objective.resolve(sample_volume, pupil=pupil, limits=limits) # Merge with input if not image: return imaged_sample if not isinstance(image, list): image = [image] for i in range(len(image)): image[i] += imaged_sample for prop in imaged_sample.properties: if not any([ prop["hash_key"] == prop2["hash_key"] for prop2 in image[i].properties ]): image[i].properties.append(prop) return image
def get(self, image, angle=None, axes=(1, 0), reshape=None, order=None, mode=None, cval=None, prefilter=None, **kwargs): new_image = Image( ndimage.rotate(image, angle, axes=axes, reshape=reshape, order=order, mode=mode, cval=cval, prefilter=prefilter)) new_image.properties = image.properties return new_image
def _create_volume(list_of_scatterers, pad=(0, 0, 0, 0), output_region=(None, None, None, None), refractive_index_medium=1.33, **kwargs): # Converts a list of scatterers into a volume. if not isinstance(list_of_scatterers, list): list_of_scatterers = [list_of_scatterers] volume = np.zeros((1, 1, 1), dtype=np.complex) # x, y, z limits of the volume limits = np.array([(0, 1), (0, 1), (0, 1)]) OR = np.zeros((4, )) for scatterer in list_of_scatterers: position = _get_position(scatterer, mode="corner", return_z=True) if scatterer.get_property("intensity", None) is not None: scatterer_value = scatterer.get_property("intensity") elif scatterer.get_property("refractive_index", None) is not None: scatterer_value = scatterer.get_property( "refractive_index") - refractive_index_medium else: scatterer_value = scatterer.get_property("value") scatterer = scatterer * scatterer_value if limits is None: limits = np.zeros((3, 2)) limits[:, 0] = np.round(position).astype(np.int32) limits[:, 1] = np.round(position).astype(np.int32) + 1 OR[0] = np.inf if output_region[0] is None else int(output_region[0] - limits[0, 0] - pad[0]) OR[1] = -np.inf if output_region[1] is None else int(output_region[1] - limits[1, 0] - pad[1]) OR[2] = np.inf if output_region[2] is None else int(output_region[2] - limits[0, 0] + pad[2]) OR[3] = -np.inf if output_region[3] is None else int(output_region[3] - limits[1, 0] + pad[3]) if (position[0] + scatterer.shape[0] < OR[0] or position[0] > OR[2] or position[1] + scatterer.shape[1] < OR[1] or position[1] > OR[3]): continue padded_scatterer = Image( np.pad(scatterer, [(2, 2), (2, 2), (0, 0)], 'constant', constant_values=0)) padded_scatterer.properties = scatterer.properties scatterer = padded_scatterer position = _get_position(scatterer, mode="corner", return_z=True) shape = np.array(scatterer.shape) if position is None: RuntimeWarning( "Optical device received a feature without a position property. It will be ignored." ) continue x_pos = position[0] + np.arange(scatterer.shape[0]) y_pos = position[1] + np.arange(scatterer.shape[1]) target_x_pos = np.round(x_pos) target_y_pos = np.round(y_pos) splined_scatterer = np.zeros_like(scatterer) for z in range(scatterer.shape[2]): scatterer_spline = RectBivariateSpline(x_pos, y_pos, np.real(scatterer[:, :, z])) splined_scatterer[1:-1, 1:-1, z] = scatterer_spline(target_x_pos[1:-1], target_y_pos[1:-1]) if scatterer.dtype == np.complex: scatterer_spline = RectBivariateSpline( x_pos, y_pos, np.imag(scatterer[:, :, z])) splined_scatterer[1:-1, 1:-1, z] += 1j * \ scatterer_spline(target_x_pos[1:-1], target_y_pos[1:-1]) scatterer = splined_scatterer position = np.round(position) new_limits = np.zeros(limits.shape, dtype=np.int32) for i in range(3): new_limits[i, :] = ( np.min([limits[i, 0], position[i]]), np.max([limits[i, 1], position[i] + shape[i]]), ) if not (np.array(new_limits) == np.array(limits)).all(): new_volume = np.zeros(np.diff(new_limits, axis=1)[:, 0].astype(np.int32), dtype=np.complex) old_region = (limits - new_limits).astype(np.int32) limits = limits.astype(np.int32) new_volume[old_region[0, 0]:old_region[0, 0] + limits[0, 1] - limits[0, 0], old_region[1, 0]:old_region[1, 0] + limits[1, 1] - limits[1, 0], old_region[2, 0]:old_region[2, 0] + limits[2, 1] - limits[2, 0]] = volume volume = new_volume limits = new_limits within_volume_position = position - limits[:, 0] # NOTE: Maybe shouldn't be additive. volume[int(within_volume_position[0]):int(within_volume_position[0] + shape[0]), int(within_volume_position[1]):int(within_volume_position[1] + shape[1]), int(within_volume_position[2]):int(within_volume_position[2] + shape[2])] += scatterer return volume, limits
def get(self, image, scale, translate, rotate, shear, **kwargs): assert ( image.ndim == 2 or image.ndim == 3 ), "Affine only supports 2-dimensional or 3-dimension inputs." dx, dy = translate fx, fy = scale cr = np.cos(rotate) sr = np.sin(rotate) k = np.tan(shear) scale_map = np.array([[1 / fx, 0], [0, 1 / fy]]) rotation_map = np.array([[cr, sr], [-sr, cr]]) shear_map = np.array([[1, 0], [-k, 1]]) mapping = scale_map @ rotation_map @ shear_map shape = image.shape center = np.array(shape[:2]) / 2 d = center - np.dot(mapping, center) - np.array([dy, dx]) # Clean up kwargs kwargs.pop("input", False) kwargs.pop("matrix", False) kwargs.pop("offset", False) kwargs.pop("output", False) # Call affine_transform if image.ndim == 2: new_image = utils.safe_call( ndimage.affine_transform, input=image, matrix=mapping, offset=d, **kwargs ) new_image = Image(new_image) new_image.merge_properties_from(image) image = new_image elif image.ndim == 3: for z in range(shape[-1]): image[:, :, z] = utils.safe_call( ndimage.affine_transform, input=image[:, :, z], matrix=mapping, offset=d, **kwargs ) # Map positions inverse_mapping = np.linalg.inv(mapping) for prop in image.properties: if "position" in prop: position = np.array(prop["position"]) prop["position"] = np.array( ( *( ( inverse_mapping @ (position[:2] - center + np.array([dy, dx])) + center ) ), *position[3:], ) ) return image
def plot( self, input_image: Image or List[Image] = None, resolve_kwargs: dict = None, interval: float = None, **kwargs ): """Visualizes the output of the feature. Resolves the feature and visualizes the result. If the output is an Image, show it using `pyplot.imshow`. If the output is a list, create an `Animation`. For notebooks, the animation is played inline using `to_jshtml()`. For scripts, the animation is played using the matplotlib backend. Any parameters in kwargs will be passed to `pyplot.imshow`. Parameters ---------- input_image : Image or List[Image], optional Passed as argument to `resolve` call resolve_kwargs : dict, optional Passed as kwarg arguments to `resolve` call interval : float The time between frames in animation in ms. Default 33. kwargs keyword arguments passed to the method pyplot.imshow() """ import matplotlib.pyplot as plt import matplotlib.animation as animation from IPython.display import HTML, display if input_image is not None: input_image = [Image(input_image)] output_image = self.resolve(input_image, **(resolve_kwargs or {})) # If a list, assume video if isinstance(output_image, Image): # Single image plt.imshow(output_image[:, :, 0], **kwargs) plt.show() else: # Assume video fig = plt.figure() images = [] plt.axis("off") for image in output_image: images.append([plt.imshow(image[:, :, 0], **kwargs)]) interval = ( interval or output_image[0].get_property("interval") or (1 / 30 * 1000) ) anim = animation.ArtistAnimation( fig, images, interval=interval, blit=True, repeat_delay=0 ) try: get_ipython # Throws NameError if not in Notebook display(HTML(anim.to_jshtml())) return anim except NameError as e: # Not in an notebook plt.show() except RuntimeError as e: # In notebook, but animation failed import ipywidgets as widgets Warning( "Javascript animation failed. This is a non-performant fallback." ) def plotter(frame=0): plt.imshow(output_image[frame][:, :, 0], **kwargs) plt.show() return widgets.interact( plotter, frame=widgets.IntSlider( value=0, min=0, max=len(images) - 1, step=1 ), )
def _create_volume(list_of_scatterers, pad=(0, 0, 0, 0), upscaled_output_region=(None, None, None, None), refractive_index_medium=1.33, upscale=1, **kwargs): # Converts a list of scatterers into a volume. if not isinstance(list_of_scatterers, list): list_of_scatterers = [list_of_scatterers] volume = np.zeros((1, 1, 1), dtype=np.complex) limits = None OR = np.zeros((4, )) OR[0] = np.inf if upscaled_output_region[0] is None else int( upscaled_output_region[0] - pad[0]) OR[1] = -np.inf if upscaled_output_region[1] is None else int( upscaled_output_region[1] - pad[1]) OR[2] = np.inf if upscaled_output_region[2] is None else int( upscaled_output_region[2] + pad[2]) OR[3] = -np.inf if upscaled_output_region[3] is None else int( upscaled_output_region[3] + pad[3]) for scatterer in list_of_scatterers: position = _get_position(scatterer, mode="corner", return_z=True) if scatterer.get_property("intensity", None) is not None: scatterer_value = scatterer.get_property("intensity") elif scatterer.get_property("refractive_index", None) is not None: scatterer_value = scatterer.get_property( "refractive_index") - refractive_index_medium else: scatterer_value = scatterer.get_property("value") scatterer = scatterer * scatterer_value if limits is None: limits = np.zeros((3, 2), dtype=np.int32) limits[:, 0] = np.floor(position).astype(np.int32) limits[:, 1] = np.floor(position).astype(np.int32) + 1 if (position[0] + scatterer.shape[0] < OR[0] or position[0] > OR[2] or position[1] + scatterer.shape[1] < OR[1] or position[1] > OR[3]): continue padded_scatterer = Image( np.pad(scatterer, [(2, 2), (2, 2), (2, 2)], 'constant', constant_values=0)) padded_scatterer.properties = scatterer.properties scatterer = padded_scatterer position = _get_position(scatterer, mode="corner", return_z=True) shape = np.array(scatterer.shape) if position is None: RuntimeWarning( "Optical device received an image without a position property. It will be ignored." ) continue splined_scatterer = np.zeros_like(scatterer) x_off = position[0] - np.floor(position[0]) y_off = position[1] - np.floor(position[1]) kernel = np.array([[0, 0, 0], [0, (1 - x_off) * (1 - y_off), (1 - x_off) * y_off], [0, x_off * (1 - y_off), x_off * y_off]]) for z in range(scatterer.shape[2]): splined_scatterer[:, :, z] = convolve(scatterer[:, :, z], kernel, mode="constant") scatterer = splined_scatterer position = np.floor(position) new_limits = np.zeros(limits.shape, dtype=np.int32) for i in range(3): new_limits[i, :] = ( np.min([limits[i, 0], position[i]]), np.max([limits[i, 1], position[i] + shape[i]]), ) if not (np.array(new_limits) == np.array(limits)).all(): new_volume = np.zeros(np.diff(new_limits, axis=1)[:, 0].astype(np.int32), dtype=np.complex) old_region = (limits - new_limits).astype(np.int32) limits = limits.astype(np.int32) new_volume[old_region[0, 0]:old_region[0, 0] + limits[0, 1] - limits[0, 0], old_region[1, 0]:old_region[1, 0] + limits[1, 1] - limits[1, 0], old_region[2, 0]:old_region[2, 0] + limits[2, 1] - limits[2, 0]] = volume volume = new_volume limits = new_limits within_volume_position = position - limits[:, 0] # NOTE: Maybe shouldn't be additive. volume[int(within_volume_position[0]):int(within_volume_position[0] + shape[0]), int(within_volume_position[1]):int(within_volume_position[1] + shape[1]), int(within_volume_position[2]):int(within_volume_position[2] + shape[2])] += scatterer return volume, limits
def get(self, illuminated_volume, limits, fields, **kwargs): ''' Convolves the image with a pupil function ''' # Pad volume padded_volume, limits = self._pad_volume(illuminated_volume, limits=limits, **kwargs) # Extract indexes of the output region pad = kwargs.get("padding", (0, 0, 0, 0)) output_region = np.array( kwargs.get("upscaled_output_region", (None, None, None, None))) output_region[0] = None if output_region[0] is None else int( output_region[0] - limits[0, 0] - pad[0]) output_region[1] = None if output_region[1] is None else int( output_region[1] - limits[1, 0] - pad[1]) output_region[2] = None if output_region[2] is None else int( output_region[2] - limits[0, 0] + pad[2]) output_region[3] = None if output_region[3] is None else int( output_region[3] - limits[1, 0] + pad[3]) padded_volume = padded_volume[output_region[0]:output_region[2], output_region[1]:output_region[3], :] z_limits = limits[2, :] output_image = Image(np.zeros((*padded_volume.shape[0:2], 1))) index_iterator = range(padded_volume.shape[2]) z_iterator = np.linspace(z_limits[0], z_limits[1], num=padded_volume.shape[2], endpoint=False) zero_plane = np.all(padded_volume == 0, axis=(0, 1), keepdims=False) # z_values = z_iterator[~zero_plane] volume = pad_image_to_fft(padded_volume, axes=(0, 1)) voxel_size = kwargs['voxel_size'] pupils = (self._pupil( volume.shape[:2], defocus=[1], include_aberration=False, **kwargs) + self._pupil(volume.shape[:2], defocus=[-z_limits[1]], include_aberration=True, **kwargs)) pupil_step = np.fft.fftshift(pupils[0]) if "illumination" in kwargs: light_in = np.ones(volume.shape[:2], dtype=np.complex) light_in = kwargs["illumination"].resolve(light_in, **kwargs) light_in = np.fft.fft2(light_in) else: light_in = np.zeros(volume.shape[:2], dtype=np.complex) light_in[0, 0] = light_in.size K = 2 * np.pi / kwargs["wavelength"] field_z = [_get_position(field, return_z=True)[-1] for field in fields] field_offsets = [ field.get_property("offset_z", default=0) for field in fields ] z = z_limits[1] for i, z in zip(index_iterator, z_iterator): light_in = light_in * pupil_step to_remove = [] for idx, fz in enumerate(field_z): if fz < z: propagation_matrix = self._pupil( fields[idx].shape, defocus=[z - fz - field_offsets[idx] / voxel_size[-1]], include_aberration=False, **kwargs)[0] propagation_matrix = propagation_matrix * np.exp( 1j * voxel_size[-1] * 2 * np.pi / kwargs["wavelength"] * kwargs["refractive_index_medium"] * (z - fz)) light_in += np.fft.fft2( fields[idx][:, :, 0]) * np.fft.fftshift(propagation_matrix) to_remove.append(idx) for idx in reversed(to_remove): fields.pop(idx) field_z.pop(idx) field_offsets.pop(idx) if zero_plane[i]: continue ri_slice = volume[:, :, i] light = np.fft.ifft2(light_in) light_out = light * np.exp(1j * ri_slice * voxel_size[-1] * K) light_in = np.fft.fft2(light_out) # Add remaining fields for idx, fz in enumerate(field_z): prop_dist = z - fz - field_offsets[idx] / voxel_size[-1] propagation_matrix = self._pupil(fields[idx].shape, defocus=[prop_dist], include_aberration=False, **kwargs)[0] propagation_matrix = propagation_matrix * np.exp( -1j * voxel_size[-1] * 2 * np.pi / kwargs["wavelength"] * kwargs["refractive_index_medium"] * prop_dist) light_in += np.fft.fft2( fields[idx][:, :, 0]) * np.fft.fftshift(propagation_matrix) light_in_focus = light_in * np.fft.fftshift(pupils[-1]) output_image = np.fft.ifft2( light_in_focus)[:padded_volume.shape[0], :padded_volume.shape[1]] output_image = np.expand_dims(output_image, axis=-1) output_image = Image(output_image[pad[0]:-pad[2], pad[1]:-pad[3]]) if not kwargs.get("return_field", False): output_image = np.square(np.abs(output_image)) output_image.properties = illuminated_volume.properties return output_image
def get(self, illuminated_volume, limits, **kwargs): ''' Convolves the image with a pupil function ''' # Pad volume padded_volume, limits = self._pad_volume(illuminated_volume, limits=limits, **kwargs) # Extract indexes of the output region pad = kwargs.get("padding", (0, 0, 0, 0)) output_region = np.array( kwargs.get("upscaled_output_region", (None, None, None, None))) output_region[0] = None if output_region[0] is None else int( output_region[0] - limits[0, 0] - pad[0]) output_region[1] = None if output_region[1] is None else int( output_region[1] - limits[1, 0] - pad[1]) output_region[2] = None if output_region[2] is None else int( output_region[2] - limits[0, 0] + pad[2]) output_region[3] = None if output_region[3] is None else int( output_region[3] - limits[1, 0] + pad[3]) padded_volume = padded_volume[output_region[0]:output_region[2], output_region[1]:output_region[3], :] z_limits = limits[2, :] output_image = Image(np.zeros((*padded_volume.shape[0:2], 1))) index_iterator = range(padded_volume.shape[2]) # Get planes in volume where not all values are 0. z_iterator = np.linspace(z_limits[0], z_limits[1], num=padded_volume.shape[2], endpoint=False) zero_plane = np.all(padded_volume == 0, axis=(0, 1), keepdims=False) z_values = z_iterator[~zero_plane] # Further pad image to speed up fft volume = pad_image_to_fft(padded_volume, axes=(0, 1)) pupils = self._pupil(volume.shape[:2], defocus=z_values, **kwargs) pupil_iterator = iter(pupils) # Loop through voluma and convole sample with pupil function for i, z in zip(index_iterator, z_iterator): if zero_plane[i]: continue image = volume[:, :, i] pupil = Image(next(pupil_iterator)) psf = np.square(np.abs(np.fft.ifft2(np.fft.fftshift(pupil)))) optical_transfer_function = np.fft.fft2(psf) fourier_field = np.fft.fft2(image) convolved_fourier_field = fourier_field * optical_transfer_function field = Image(np.fft.ifft2(convolved_fourier_field)) # Discard remaining imaginary part (should be 0 up to rounding error) field = np.real(field) output_image[:, :, 0] += field[:padded_volume. shape[0], :padded_volume.shape[1]] output_image = output_image[pad[0]:-pad[2], pad[1]:-pad[3]] try: output_image.properties = illuminated_volume.properties + pupil.properties except UnboundLocalError: output_image.properties = illuminated_volume.properties return output_image
def plot(self, input_image=None, interval=None, **kwargs): ''' Resolves the image and shows the result Parameters ---------- shape shape of the image to be drawn input_image kwargs keyword arguments passed to the method plt.imshow() ''' import matplotlib.pyplot as plt import matplotlib.animation as animation from IPython.display import HTML, display if input_image is not None: input_image = [Image(input_image)] output_image = self.resolve(input_image) # If a list, assume video if isinstance(output_image, Image): # Single image plt.imshow(output_image[:, :, 0], **kwargs) plt.show() else: # Assume video fig = plt.figure() images = [] for image in output_image: images.append([plt.imshow(image[:, :, 0], **kwargs)]) interval = (interval or get_property(output_image[0], "interval") or (1 / 30 * 1000)) anim = animation.ArtistAnimation(fig, images, interval=interval, blit=True, repeat_delay=0) try: get_ipython # Throws NameError if not in Notebook display(HTML(anim.to_jshtml())) except NameError as e: # Not in an notebook plt.show() except RuntimeError as e: # In notebook, but animation failed import ipywidgets as widgets Warning( "Javascript animation failed. This is a non-performant fallback." ) def plotter(frame=0): plt.imshow(output_image[frame][:, :, 0], **kwargs) plt.show() return widgets.interact(plotter, frame=widgets.IntSlider( value=0, min=0, max=len(images) - 1, step=1))
def _process_and_get(self, images, **kwargs): if isinstance(images, list) and len(images) != 1: list_of_labels = super()._process_and_get(images, **kwargs) else: if isinstance(images, list): images = images[0] list_of_labels = [] for prop in images.properties: if "position" in prop: inp = Image(np.array(images)) inp.append(prop) out = Image(self.get(inp, **kwargs)) out.merge_properties_from(inp) list_of_labels.append(out) output_region = kwargs["output_region"] output = np.zeros( (output_region[2], output_region[3], kwargs["number_of_masks"]) ) for label in list_of_labels: positions = _get_position(label) for position in positions: p0 = np.round(position - output_region[0:2]) if np.any(p0 > output.shape[0:2]) or np.any(p0 + label.shape[0:2] < 0): continue crop_x = int(-np.min([p0[0], 0])) crop_y = int(-np.min([p0[1], 0])) crop_x_end = int( label.shape[0] - np.max([p0[0] + label.shape[0] - output.shape[0], 0]) ) crop_y_end = int( label.shape[1] - np.max([p0[1] + label.shape[1] - output.shape[1], 0]) ) labelarg = label[crop_x:crop_x_end, crop_y:crop_y_end, :] p0[0] = np.max([p0[0], 0]) p0[1] = np.max([p0[1], 0]) p0 = p0.astype(np.int) output_slice = output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1] ] for label_index in range(kwargs["number_of_masks"]): if isinstance(kwargs["merge_method"], list): merge = kwargs["merge_method"][label_index] else: merge = kwargs["merge_method"] if merge == "add": output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1], label_index, ] += labelarg[..., label_index] elif merge == "overwrite": output_slice[ labelarg[..., label_index] != 0, label_index ] = labelarg[labelarg[..., label_index] != 0, label_index] output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1], label_index, ] = output_slice[..., label_index] elif merge == "or": output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1], label_index, ] = (output_slice[..., label_index] != 0) | ( labelarg[..., label_index] != 0 ) elif merge == "mul": output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1], label_index, ] *= labelarg[..., label_index] else: # No match, assume function output[ p0[0] : p0[0] + labelarg.shape[0], p0[1] : p0[1] + labelarg.shape[1], label_index, ] = merge( output_slice[..., label_index], labelarg[..., label_index] ) output = Image(output) for label in list_of_labels: output.merge_properties_from(label) return output
def test_Gaussian(self): noise = noises.Gaussian(mu=0.1, sigma=0.05) input_image = Image(np.zeros((256, 256))) output_image = noise.resolve(input_image) self.assertIsInstance(output_image, Image) self.assertEqual(output_image.shape, (256, 256))
def get(self, illuminated_volume, limits, **kwargs): ''' Convolves the image with a pupil function ''' # Pad volume padded_volume, limits = self._pad_volume(illuminated_volume, limits=limits, **kwargs) # Extract indexes of the output region pad = kwargs.get("padding", (0, 0, 0, 0)) output_region = np.array( kwargs.get("output_region", (None, None, None, None))) output_region[0] = None if output_region[0] is None else int( output_region[0] - limits[0, 0] - pad[0]) output_region[1] = None if output_region[1] is None else int( output_region[1] - limits[1, 0] - pad[1]) output_region[2] = None if output_region[2] is None else int( output_region[2] - limits[0, 0] + pad[2]) output_region[3] = None if output_region[3] is None else int( output_region[3] - limits[1, 0] + pad[3]) padded_volume = padded_volume[output_region[0]:output_region[2], output_region[1]:output_region[3], :] z_limits = limits[2, :] output_image = Image(np.zeros((*padded_volume.shape[0:2], 1))) index_iterator = range(padded_volume.shape[2]) z_iterator = np.linspace(z_limits[0], z_limits[1], num=padded_volume.shape[2], endpoint=False) zero_plane = np.all(padded_volume == 0, axis=(0, 1), keepdims=False) # z_values = z_iterator[~zero_plane] volume = pad_image_to_fft(padded_volume, axes=(0, 1)) voxel_size = kwargs['voxel_size'] pupils = (self._pupil( volume.shape[:2], defocus=[1], include_aberration=False, **kwargs) + self._pupil(volume.shape[:2], defocus=[-z_limits[1]], include_aberration=True, **kwargs)) pupil_step = np.fft.fftshift(pupils[0]) if "illumination" in kwargs: light_in = np.ones(volume.shape[:2]) light_in = kwargs["illumination"].resolve(light_in, **kwargs) light_in = np.fft.fft2(light_in) else: light_in = np.zeros(volume.shape[:2]) light_in[0, 0] = light_in.size K = 2 * np.pi / kwargs["wavelength"] for i, z in zip(index_iterator, z_iterator): light_in = light_in * pupil_step if zero_plane[i]: continue ri_slice = volume[:, :, i] light = np.fft.ifft2(light_in) light_out = light * np.exp(1j * ri_slice * voxel_size[-1] * K) light_in = np.fft.fft2(light_out) light_in_focus = light_in * np.fft.fftshift(pupils[-1]) output_image = np.fft.ifft2( light_in_focus)[:padded_volume.shape[0], :padded_volume.shape[1]] output_image = np.expand_dims(output_image, axis=-1) output_image = Image(output_image[pad[0]:-pad[2], pad[1]:-pad[3]]) if not kwargs.get("return_field", False): output_image = np.square(np.abs(output_image)) output_image.properties = illuminated_volume.properties return output_image
def test_Poisson(self): noise = noises.Poisson(snr=20) input_image = Image(np.ones((256, 256)) * 0.1) output_image = noise.resolve(input_image) self.assertIsInstance(output_image, Image) self.assertEqual(output_image.shape, (256, 256))
def pupil(self, shape, NA=None, wavelength=None, refractive_index_medium=None, voxel_size=None, defocus=None, upscale=None, pupil=None, aberration=None, include_aberration=True, **kwargs): ''' Calculates pupil function Parameters ---------- shape The shape of the pupil function kwargs The current values of the properties of the optical device ''' shape = np.array(shape) upscaled_shape = shape * upscale # Pupil radius R = NA / wavelength * np.array(voxel_size)[:2] x_radius = R[0] * upscaled_shape[0] y_radius = R[1] * upscaled_shape[1] x = (np.linspace(-(upscaled_shape[0] / 2), upscaled_shape[0] / 2 - 1, upscaled_shape[0])) / x_radius + 1e-8 y = (np.linspace(-(upscaled_shape[1] / 2), upscaled_shape[1] / 2 - 1, upscaled_shape[1])) / y_radius + 1e-8 W, H = np.meshgrid(y, x) RHO = W**2 + H**2 RHO[RHO > 1] = 1 pupil_function = ((RHO < 1) * 1.0).astype(np.complex) # Defocus z_shift = (2 * np.pi * refractive_index_medium / wavelength * voxel_size[2] * np.sqrt(1 - (NA / refractive_index_medium * RHO)**2)) # Downsample the upsampled pupil if upscale > 1: pupil_function = np.reshape( pupil_function, (shape[0], upscale, shape[1], upscale)).mean(axis=(3, 1)) z_shift = np.reshape( z_shift, (shape[0], upscale, shape[1], upscale)).mean(axis=(3, 1)) pupil_function[np.isnan(pupil_function)] = 0 pupil_function[np.isinf(pupil_function)] = 0 pupil_function_is_nonzero = pupil_function != 0 if include_aberration: pupil = pupil or aberration if isinstance(pupil, Feature): pupil_function = pupil.resolve(pupil_function, **kwargs) elif isinstance(pupil, np.ndarray): pupil_function *= pupil pupil_functions = [] for z in defocus: pupil_at_z = Image(pupil_function) pupil_at_z[pupil_function_is_nonzero] *= np.exp( 1j * z_shift[pupil_function_is_nonzero] * z) pupil_functions.append(pupil_at_z) return pupil_functions