def __init__(self, nii, spacing=_default_spacing, plot_type="grid", **kwargs): """Load deformation field. Parameters ---------- nii : str/array/nifti Source of the image data to load. This can be either: (a) The path to a NIfTI file; (b) A nibabel.nifti1.Nifti1Image object; (c) The path to a file containing a NumPy array; (d) A NumPy array. """ Image.__init__(self, nii, **kwargs) if not self.valid: return if self.data.ndim != 5: raise RuntimeError( f"Deformation field in {nii} must contain a " "five-dimensional array!" ) self.data = self.data[:, :, :, 0, :] self.set_spacing(spacing)
def __init__( self, nii=None, dose=None, mask=None, jacobian=None, df=None, structs=None, multi_structs=None, timeseries=None, struct_colors=None, structs_as_mask=False, struct_names=None, compare_structs=False, comp_type="auto", ignore_empty_structs=False, ignore_unpaired_structs=False, structs_to_keep=None, structs_to_ignore=None, autoload_structs=True, mask_threshold=0.5, **kwargs, ): """Load a MultiImage object. Parameters ---------- nii : str/nifti/array Path to a .nii/.npy file, or an nibabel nifti object/numpy array. title : str, default=None Title for this image when plotted. If None and <nii> is loaded from a file, the filename will be used. dose : str/nifti/array, default=None Path or object from which to load dose field. mask : str/nifti/array, default=None Path or object from which to load mask array. jacobian : str/nifti/array, default=None Path or object from which to load jacobian determinant field. df : str/nifti/array, default=None Path or object from which to load deformation field. structs : str/list, default=None A string containing a path, directory, or wildcard pointing to nifti file(s) containing structure(s). Can also be a list of paths/directories/wildcards. struct_colors : dict, default=None Custom colors to use for structures. Dictionary keys can be a structure name or a wildcard matching structure name(s). Values should be any valid matplotlib color. structs_as_mask : bool, default=False If True, structures will be used as masks. struct_names : list/dict, default=None For multi_structs, this parameter will be used to name the structures. Can either be a list (i.e. the first structure in the file will be given the first name in the list and so on), or a dict of numbers and names (e.g. {1: "first structure"} etc). compare_structs : bool, default=False If True, structures will be paired together into comparisons. mask_threshold : float, default=0.5 Threshold on mask array; voxels with values below this threshold will be masked (or values above, if <invert_mask> is True). """ # Flags for image type self.dose_as_im = False self.dose_comp = False self.timeseries = False # Load the scan image if nii is not None: Image.__init__(self, nii, **kwargs) self.timeseries = False # Load a dose field only elif dose is not None and timeseries is None: self.dose_as_im = True Image.__init__(self, dose, **kwargs) dose = None # Load a timeseries of images elif timeseries is not None: self.timeseries = True dates = self.get_date_dict(timeseries) self.dates = list(dates.keys()) if "title" in kwargs: kwargs.pop("title") self.ims = { date: Image(file, title=date, **kwargs) for date, file in dates.items() } Image.__init__(self, dates[self.dates[0]], title=self.dates[0], **kwargs) self.date = self.dates[0] else: raise TypeError("Must provide either <nii>, <dose>, or " "<timeseries!>") if not self.valid: return # Load extra overlays self.load_to(dose, "dose", kwargs) self.load_to(mask, "mask", kwargs) self.load_to(jacobian, "jacobian", kwargs) self.load_df(df) # Load structs self.comp_type = comp_type self.load_structs( structs, multi_structs, names=struct_names, colors=struct_colors, compare_structs=compare_structs, ignore_empty=ignore_empty_structs, ignore_unpaired=ignore_unpaired_structs, comp_type=comp_type, to_keep=structs_to_keep, to_ignore=structs_to_ignore, autoload=autoload_structs ) # Mask settings self.structs_as_mask = structs_as_mask if self.has_structs and structs_as_mask: self.has_mask = True self.mask_threshold = mask_threshold self.set_masks()
def __init__( self, shape, filename=None, origin=(0, 0, 0), voxel_sizes=(1, 1, 1), intensity=-1024, noise_std=None, ): """Create data to write to a NIfTI file, initially containing a blank image array. Parameters ---------- shape : int/tuple Dimensions of the image array to create. If an int is given, the image will be created with dimensions (shape, shape, shape). filename : str, default=None Name of output NIfTI file. If given, the NIfTI file will automatically be written; otherwise, no file will be written until the "write" method is called. origin : tuple, default=(0, 0, 0) Origin in mm for the image. voxel_sizes : tuple, default=(1, 1, 1) Voxel sizes in mm for the image. intensity : float, default=-1000 Intensity in HU for the background of the image. noise_std : float, default=None Standard deviation of Gaussian noise to apply to the image. If None, no noise will be applied. """ # Create image properties self.shape = make_three(shape) voxel_sizes = [abs(v) for v in make_three(voxel_sizes)] self.affine = np.array( [ [ -voxel_sizes[0], 0, 0, origin[0] + (self.shape[0] - 1) * voxel_sizes[0], ], [0, voxel_sizes[1], 0, origin[1]], [0, 0, voxel_sizes[2], origin[2]], [0, 0, 0, 1], ] ) self.max_hu = 0 if noise_std is None else noise_std * 3 self.min_hu = -self.max_hu if self.max_hu != 0 else -20 self.noise_std = noise_std self.bg_intensity = intensity self.background = self.make_background() self.shapes = [] self.structs = [] self.groups = {} self.shape_count = {} self.translation = None self.rotation = None # Initialise as Image Image.__init__(self, self.background, affine=self.affine) # Write to file if a filename is given if filename is not None: self.filename = os.path.expanduser(filename) self.write()