def __init__(self, root_dir, phase, transformer_config, mirror_padding=(0, 32, 32), expand_dims=True): assert os.path.isdir(root_dir), 'root_dir is not a directory' assert phase in ['train', 'val', 'test'] # use mirror padding only during the 'test' phase if phase in ['train', 'val']: mirror_padding = None if mirror_padding is not None: assert len(mirror_padding) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase # load raw images images_dir = os.path.join(root_dir, 'images') assert os.path.isdir(images_dir) self.images, self.paths = self._load_files(images_dir, expand_dims) self.file_path = images_dir min_value, max_value, mean, std = calculate_stats(self.images) logger.info(f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}') transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) # load raw images transformer self.raw_transform = transformer.raw_transform() if phase != 'test': # load labeled images masks_dir = os.path.join(root_dir, 'masks') assert os.path.isdir(masks_dir) self.masks, _ = self._load_files(masks_dir, expand_dims) assert len(self.images) == len(self.masks) # load label images transformer self.masks_transform = transformer.label_transform() else: self.masks = None self.masks_transform = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_imgs = [] for img in self.images: padded_img = np.pad(img, pad_width=pad_width, mode='reflect') padded_imgs.append(padded_img) self.images = padded_imgs
def __init__(self, file_path, phase, slice_builder_config, transformer_config, mirror_padding=(16, 32, 32), raw_internal_path='raw', label_internal_path='label', weight_internal_path=None): """ :param file_path: path to H5 file containing raw data as well as labels and per pixel weights (optional) :param phase: 'train' for training, 'val' for validation, 'test' for testing; data augmentation is performed only during the 'train' phase :para'/home/adrian/workspace/ilastik-datasets/VolkerDeconv/train'm slice_builder_config: configuration of the SliceBuilder :param transformer_config: data augmentation configuration :param mirror_padding (int or tuple): number of voxels padded to each axis :param raw_internal_path (str or list): H5 internal path to the raw dataset :param label_internal_path (str or list): H5 internal path to the label dataset :param weight_internal_path (str or list): H5 internal path to the per pixel weights """ assert phase in ['train', 'val', 'test'] if phase in ['train', 'val']: mirror_padding = None if mirror_padding is not None: if isinstance(mirror_padding, int): mirror_padding = (mirror_padding, ) * 3 else: assert len(mirror_padding ) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase self.file_path = file_path # convert raw_internal_path, label_internal_path and weight_internal_path to list for ease of computation if isinstance(raw_internal_path, str): raw_internal_path = [raw_internal_path] if isinstance(label_internal_path, str): label_internal_path = [label_internal_path] if isinstance(weight_internal_path, str): weight_internal_path = [weight_internal_path] internal_paths = list(raw_internal_path) if label_internal_path is not None: internal_paths.extend(label_internal_path) if weight_internal_path is not None: internal_paths.extend(weight_internal_path) input_file = self.create_h5_file(file_path, internal_paths) self.raws = self.fetch_and_check(input_file, raw_internal_path) # calculate global min, max, mean and std for normalization min_value, max_value, mean, std = calculate_stats(self.raws) logger.info( f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}' ) self.transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) self.raw_transform = self.transformer.raw_transform() if phase != 'test': # create label/weight transform only in train/val phase self.label_transform = self.transformer.label_transform() # Fetch labels for segmentation and regression separately self.labels_seg = self.fetch_and_check(input_file, label_internal_path) self.labels_reg = self.fetch_and_check(input_file, label_internal_path) if weight_internal_path is not None: # look for the weight map in the raw file self.weight_maps = self.fetch_and_check( input_file, weight_internal_path) self.weight_transform = self.transformer.weight_transform() else: self.weight_maps = None self._check_dimensionality(self.raws, self.labels_seg) self._check_dimensionality(self.raws, self.labels_reg) else: # 'test' phase used only for predictions so ignore the label dataset self.labels = None self.weight_maps = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_volumes = [] for raw in self.raws: if raw.ndim == 4: channels = [ np.pad(r, pad_width=pad_width, mode='reflect') for r in raw ] padded_volume = np.stack(channels) else: padded_volume = np.pad(raw, pad_width=pad_width, mode='reflect') padded_volumes.append(padded_volume) self.raws = padded_volumes if phase == 'train' or phase == 'val': # Dilate the labels for segmentation self.dilation_list = copy.deepcopy(self.labels_seg) self.dilated_labels = [] for each_vol in self.dilation_list: self.label_dilate = each_vol self.inv_label = np.logical_not(self.label_dilate) self.label_dist_transform = ndimage.distance_transform_edt( self.inv_label) self.label_thresh_tr = self.label_dist_transform > 2 self.label_thresh_tr = np.logical_not( self.label_thresh_tr).astype(np.float64) self.dilated_labels.append(self.label_thresh_tr) self.labels_seg = self.dilated_labels # EDT of labels for regression (not including vector edt currently) self.edt_list = copy.deepcopy(self.labels_reg) self.edt_labels = [] for each_edt_vol in self.edt_list: self.edt_label = vigra.filters.distanceTransform( each_edt_vol[0].astype(np.float32)) self.edt_label = np.expand_dims(self.edt_label, axis=0) #self.vec_edt = vigra.filters.vectorDistanceTransform(each_edt_vol[0].astype(np.float32)) #self.vec_edt = np.transpose(self.vec_edt, (3,0,1,2)) #self.new_label = np.concatenate((self.edt_label, self.vec_edt), axis=0) #self.edt_labels.append(self.new_label) self.edt_labels.append(self.edt_label) self.labels_reg = self.edt_labels # build slice indices for raw and label data sets if phase == 'train' or phase == 'val': slice_builder_seg = get_slice_builder(self.raws, self.labels_seg, self.weight_maps, slice_builder_config) slice_builder_reg = get_slice_builder(self.raws, self.labels_reg, self.weight_maps, slice_builder_config) # For testing, get only the raw slices slice_builder = get_slice_builder(self.raws, None, self.weight_maps, slice_builder_config) self.raw_slices = slice_builder.raw_slices if phase == 'train' or phase == 'val': self.label_slices_seg = slice_builder_seg.label_slices_seg self.label_slices_reg = slice_builder_reg.label_slices_reg self.weight_slices = slice_builder.weight_slices self.patch_count = len(self.raw_slices) logger.info(f'Number of patches: {self.patch_count}')
def __init__(self, file_path, phase, slice_builder_config, transformer_config, mirror_padding=(16, 32, 32), raw_internal_path='raw', label_internal_path='label', weight_internal_path=None): """ :param file_path: path to H5 file containing raw data as well as labels and per pixel weights (optional) :param phase: 'train' for training, 'val' for validation, 'test' for testing; data augmentation is performed only during the 'train' phase :para'/home/adrian/workspace/ilastik-datasets/VolkerDeconv/train'm slice_builder_config: configuration of the SliceBuilder :param transformer_config: data augmentation configuration :param mirror_padding (int or tuple): number of voxels padded to each axis :param raw_internal_path (str or list): H5 internal path to the raw dataset :param label_internal_path (str or list): H5 internal path to the label dataset :param weight_internal_path (str or list): H5 internal path to the per pixel weights """ assert phase in ['train', 'val', 'test'] if phase in ['train', 'val']: mirror_padding = None if mirror_padding is not None: if isinstance(mirror_padding, int): mirror_padding = (mirror_padding,) * 3 else: assert len(mirror_padding) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase self.file_path = file_path # convert raw_internal_path, label_internal_path and weight_internal_path to list for ease of computation if isinstance(raw_internal_path, str): raw_internal_path = [raw_internal_path] if isinstance(label_internal_path, str): label_internal_path = [label_internal_path] if isinstance(weight_internal_path, str): weight_internal_path = [weight_internal_path] internal_paths = list(raw_internal_path) if label_internal_path is not None: internal_paths.extend(label_internal_path) if weight_internal_path is not None: internal_paths.extend(weight_internal_path) input_file = self.create_h5_file(file_path, internal_paths) self.raws = self.fetch_datasets(input_file, raw_internal_path) # calculate global min, max, mean and std for normalization min_value, max_value, mean, std = calculate_stats(self.raws) logger.info(f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}') self.transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) self.raw_transform = self.transformer.raw_transform() if phase != 'test': # create label/weight transform only in train/val phase self.label_transform = self.transformer.label_transform() self.labels = self.fetch_datasets(input_file, label_internal_path) if weight_internal_path is not None: # look for the weight map in the raw file self.weight_maps = self.fetch_datasets(input_file, weight_internal_path) self.weight_transform = self.transformer.weight_transform() else: self.weight_maps = None self._check_dimensionality(self.raws, self.labels) else: # 'test' phase used only for predictions so ignore the label dataset self.labels = None self.weight_maps = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_volumes = [] for raw in self.raws: if raw.ndim == 4: channels = [np.pad(r, pad_width=pad_width, mode='reflect') for r in raw] padded_volume = np.stack(channels) else: padded_volume = np.pad(raw, pad_width=pad_width, mode='reflect') padded_volumes.append(padded_volume) self.raws = padded_volumes # build slice indices for raw and label data sets slice_builder = get_slice_builder(self.raws, self.labels, self.weight_maps, slice_builder_config) self.raw_slices = slice_builder.raw_slices self.label_slices = slice_builder.label_slices self.weight_slices = slice_builder.weight_slices self.patch_count = len(self.raw_slices) logger.info(f'Number of patches: {self.patch_count}')
def __init__(self, root_dir, phase, transformer_config, mirror_padding=(0, 32, 32), expand_dims=True, instance_ratio=None, random_seed=0): assert os.path.isdir(root_dir), f'{root_dir} is not a directory' assert phase in ['train', 'val', 'test'] # use mirror padding only during the 'test' phase if phase in ['train', 'val']: mirror_padding = None if mirror_padding is not None: assert len(mirror_padding ) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase # load raw images images_dir = os.path.join(root_dir, 'images') assert os.path.isdir(images_dir) self.images, self.paths = self._load_files(images_dir, expand_dims) self.file_path = images_dir self.instance_ratio = instance_ratio min_value, max_value, mean, std = calculate_stats(self.images) logger.info( f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}' ) transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) # load raw images transformer self.raw_transform = transformer.raw_transform() if phase != 'test': # load labeled images masks_dir = os.path.join(root_dir, 'masks') assert os.path.isdir(masks_dir) self.masks, _ = self._load_files(masks_dir, expand_dims) # prepare for training with sparse object supervision (allow sparse objects only in training phase) if self.instance_ratio is not None and phase == 'train': assert 0 < self.instance_ratio <= 1 rs = np.random.RandomState(random_seed) self.masks = [ sample_instances(m, self.instance_ratio, rs) for m in self.masks ] assert len(self.images) == len(self.masks) # load label images transformer self.masks_transform = transformer.label_transform() else: self.masks = None self.masks_transform = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_imgs = [] for img in self.images: padded_img = np.pad(img, pad_width=pad_width, mode='reflect') padded_imgs.append(padded_img) self.images = padded_imgs
def __init__(self, file_path, phase, slice_builder_config, transformer_config, mirror_padding=(16, 32, 32), raw_internal_path='raw', label_internal_path='label', weight_internal_path=None): """ :param file_path: path to H5 file containing raw data as well as labels and per pixel weights (optional) :param phase: 'train' for training, 'val' for validation, 'test' for testing; data augmentation is performed only during the 'train' phase :para'/home/adrian/workspace/ilastik-datasets/VolkerDeconv/train'm slice_builder_config: configuration of the SliceBuilder :param transformer_config: data augmentation configuration :param mirror_padding (int or tuple): number of voxels padded to each axis :param raw_internal_path (str or list): H5 internal path to the raw dataset :param label_internal_path (str or list): H5 internal path to the label dataset :param weight_internal_path (str or list): H5 internal path to the per pixel weights """ assert phase in ['train', 'val', 'test'] if phase in ['train', 'val']: mirror_padding = None if mirror_padding is not None: if isinstance(mirror_padding, int): mirror_padding = (mirror_padding, ) * 3 else: assert len(mirror_padding ) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase self.file_path = file_path # convert raw_internal_path, label_internal_path and weight_internal_path to list for ease of computation if isinstance(raw_internal_path, str): raw_internal_path = [raw_internal_path] if isinstance(label_internal_path, str): label_internal_path = [label_internal_path] if isinstance(weight_internal_path, str): weight_internal_path = [weight_internal_path] internal_paths = list(raw_internal_path) if label_internal_path is not None: internal_paths.extend(label_internal_path) if weight_internal_path is not None: internal_paths.extend(weight_internal_path) input_file = self.create_h5_file(file_path, internal_paths) # label dilation routine added here ##### START ##### # self.label = input_file['label'] # self.inv_label = np.logical_not(self.label) # self.label_dist_transform = ndimage.distance_transform_edt(self.inv_label) # self.label_thresh_tr = self.label_dist_transform > 3 # self.label_thresh_tr = np.logical_not(self.label_thresh_tr).astype(np.float64) # input_file['label'] = self.label_thresh_tr ##### END ##### self.raws = self.fetch_and_check(input_file, raw_internal_path) # calculate global min, max, mean and std for normalization min_value, max_value, mean, std = calculate_stats(self.raws) logger.info( f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}' ) self.transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) self.raw_transform = self.transformer.raw_transform() if phase != 'test': # create label/weight transform only in train/val phase self.label_transform = self.transformer.label_transform() self.labels = self.fetch_and_check(input_file, label_internal_path) if weight_internal_path is not None: # look for the weight map in the raw file self.weight_maps = self.fetch_and_check( input_file, weight_internal_path) self.weight_transform = self.transformer.weight_transform() else: self.weight_maps = None self._check_dimensionality(self.raws, self.labels) else: # 'test' phase used only for predictions so ignore the label dataset self.labels = None self.weight_maps = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_volumes = [] for raw in self.raws: if raw.ndim == 4: channels = [ np.pad(r, pad_width=pad_width, mode='reflect') for r in raw ] padded_volume = np.stack(channels) else: padded_volume = np.pad(raw, pad_width=pad_width, mode='reflect') padded_volumes.append(padded_volume) self.raws = padded_volumes # for Thresh_IoU eval metric # if phase != 'test': ###### temporal batch passing channel setup # # Modify only the train vol ground truth for dilation and thus better context # if phase != 'test': # for peak matching eval metric # self.dilation_list = copy.deepcopy(self.labels) # self.dilated_labels = [] # # apply dilation to each vol in the batch # for each_vol in self.dilation_list: # self.label_dilate = each_vol # self.vol_channels = [] # for channel_num, ch in enumerate(self.label_dilate): # self.inv_label = np.logical_not(self.label_dilate[channel_num]) # self.label_dist_transform = ndimage.distance_transform_edt(self.inv_label) # self.label_thresh_tr = self.label_dist_transform > 2 # self.label_thresh_tr = np.logical_not(self.label_thresh_tr).astype(np.float64) # self.vol_channels.append(self.label_thresh_tr) # self.output_thresh_tr = torch.concatenate((self.vol_channels[0], self.vol_channels[1], self.vol_channels[2]), axis=0) # self.dilated_labels.append(self.output_thresh_tr) # self.labels = self.dilated_labels if phase == '!test': self.dilation_list = copy.deepcopy(self.labels) self.dilated_labels = [] for each_vol in self.dilation_list: self.label_dilate = each_vol self.inv_label = np.logical_not(self.label_dilate) self.label_dist_transform = ndimage.distance_transform_edt( self.inv_label) self.label_thresh_tr = self.label_dist_transform > 2 self.label_thresh_tr = np.logical_not( self.label_thresh_tr).astype(np.float64) self.dilated_labels.append(self.label_thresh_tr) self.labels = self.dilated_labels # build slice indices for raw and label data sets slice_builder = get_slice_builder(self.raws, self.labels, self.weight_maps, slice_builder_config) self.raw_slices = slice_builder.raw_slices self.label_slices = slice_builder.label_slices self.weight_slices = slice_builder.weight_slices self.patch_count = len(self.raw_slices) logger.info(f'Number of patches: {self.patch_count}')
def __init__(self, file_path, phase, slice_builder_config, transformer_config, mirror_padding=(16, 32, 32), raw_internal_path='raw', label_internal_path='label', weight_internal_path=None, instance_ratio=None, random_seed=0): """ :param file_path: path to nifti file from dicom file :param phase: 'train' for training, 'val' for validation, 'test' for testing; data augmentation is performed only during the 'train' phase :para'/home/adrian/workspace/ilastik-datasets/VolkerDeconv/train'm slice_builder_config: configuration of the SliceBuilder :param transformer_config: data augmentation configuration :param mirror_padding (int or tuple): number of voxels padded to each axis :param raw_internal_path (str or list): H5 internal path to the raw dataset :param label_internal_path (str or list): H5 internal path to the label dataset :param weight_internal_path (str or list): H5 internal path to the per pixel weights :param a number between (0, 1]: specifies a fraction of ground truth instances to be sampled from the dense ground truth labels """ assert phase in ['train', 'val', 'test'] if phase in ['train', 'val']: raise mirror_padding = None if mirror_padding is not None: if isinstance(mirror_padding, int): mirror_padding = (mirror_padding, ) * 3 else: assert len(mirror_padding ) == 3, f"Invalid mirror_padding: {mirror_padding}" self.mirror_padding = mirror_padding self.phase = phase self.file_path = file_path self.instance_ratio = instance_ratio # convert raw_internal_path, label_internal_path and weight_internal_path to list for ease of computation if isinstance(weight_internal_path, str): weight_internal_path = [weight_internal_path] nifti = nib.load(file_path) arr = nifti.get_fdata() self.raws = [np.fliplr(arr).transpose((2, 1, 0))] self.affine = [nifti.affine] self.header = [nifti.header] min_value, max_value, mean, std = None, None, None, None #self.ds_stats() self.transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) self.raw_transform = self.transformer.raw_transform() if phase != 'test': raise # not yet # create label/weight transform only in train/val phase self.label_transform = self.transformer.label_transform() self.labels = self.fetch_and_check(input_file, label_internal_path) if self.instance_ratio is not None: assert 0 < self.instance_ratio <= 1 rs = np.random.RandomState(random_seed) self.labels = [ sample_instances(m, self.instance_ratio, rs) for m in self.labels ] if weight_internal_path is not None: # look for the weight map in the raw file self.weight_maps = self.fetch_and_check( input_file, weight_internal_path) self.weight_transform = self.transformer.weight_transform() else: self.weight_maps = None self._check_dimensionality(self.raws, self.labels) else: # 'test' phase used only for predictions so ignore the label dataset self.labels = None self.weight_maps = None # add mirror padding if needed if self.mirror_padding is not None: z, y, x = self.mirror_padding pad_width = ((z, z), (y, y), (x, x)) padded_volumes = [] for raw in self.raws: if raw.ndim == 4: channels = [ np.pad(r, pad_width=pad_width, mode='reflect') for r in raw ] padded_volume = np.stack(channels) else: padded_volume = np.pad(raw, pad_width=pad_width, mode='reflect') padded_volumes.append(padded_volume) self.raws = padded_volumes # build slice indices for raw and label data sets assert 'name' in slice_builder_config if slice_builder_config['name'] == "AroundCenterSliceBuilder": assert 'centers_internal_path' in slice_builder_config centers_internal_path = slice_builder_config.get( 'centers_internal_path', 'centers') self.centers = self.fetch_and_check(input_file, [centers_internal_path]) slice_builder = get_slice_builder(self.raws, self.labels, self.weight_maps, slice_builder_config, centers=self.centers) else: slice_builder = get_slice_builder(self.raws, self.labels, self.weight_maps, slice_builder_config) self.raw_slices = slice_builder.raw_slices self.label_slices = slice_builder.label_slices self.weight_slices = slice_builder.weight_slices self.patch_count = len(self.raw_slices) logger.info(f'Number of patches: {self.patch_count}')
def __init__(self, file_path, phase, slice_builder_config, transformer_config, raw_internal_path='raw', label_internal_path='label', weight_internal_path=None, mirror_padding=False, pad_width=20): """ :param file_path: path to H5 file containing raw data as well as labels and per pixel weights (optional) :param phase: 'train' for training, 'val' for validation, 'test' for testing; data augmentation is performed only during the 'train' phase :param slice_builder_config: configuration of the SliceBuilder :param transformer_config: data augmentation configuration :param raw_internal_path (str or list): H5 internal path to the raw dataset :param label_internal_path (str or list): H5 internal path to the label dataset :param weight_internal_path (str or list): H5 internal path to the per pixel weights :param mirror_padding (bool): pad with the reflection of the vector mirrored on the first and last values along each axis. Only applicable during the 'test' phase :param pad_width: number of voxels padded to the edges of each axis (only if `mirror_padding=True`) """ assert phase in ['train', 'val', 'test'] self.phase = phase self.file_path = file_path self.mirror_padding = mirror_padding self.pad_width = pad_width # convert raw_internal_path, label_internal_path and weight_internal_path to list for ease of computation if isinstance(raw_internal_path, str): raw_internal_path = [raw_internal_path] if isinstance(label_internal_path, str): label_internal_path = [label_internal_path] if isinstance(weight_internal_path, str): weight_internal_path = [weight_internal_path] with h5py.File(file_path, 'r') as input_file: # WARN: we load everything into memory due to hdf5 bug when reading H5 from multiple subprocesses, i.e. # File "h5py/_proxy.pyx", line 84, in h5py._proxy.H5PY_H5Dread # OSError: Can't read data (inflate() failed) self.raws = [ input_file[internal_path][...] for internal_path in raw_internal_path ] # calculate global min, max, mean and std for normalization min_value, max_value, mean, std = self._calculate_stats(self.raws) logger.info( f'Input stats: min={min_value}, max={max_value}, mean={mean}, std={std}' ) self.transformer = transforms.get_transformer(transformer_config, min_value=min_value, max_value=max_value, mean=mean, std=std) self.raw_transform = self.transformer.raw_transform() if phase != 'test': # create label/weight transform only in train/val phase self.label_transform = self.transformer.label_transform() self.labels = [ input_file[internal_path][...] for internal_path in label_internal_path ] if weight_internal_path is not None: # look for the weight map in the raw file self.weight_maps = [ input_file[internal_path][...] for internal_path in weight_internal_path ] self.weight_transform = self.transformer.weight_transform() else: self.weight_maps = None self._check_dimensionality(self.raws, self.labels) else: # 'test' phase used only for predictions so ignore the label dataset self.labels = None self.weight_maps = None # add mirror padding if needed if self.mirror_padding: padded_volumes = [] for raw in self.raws: if raw.ndim == 4: channels = [ np.pad(r, pad_width=self.pad_width, mode='reflect') for r in raw ] padded_volume = np.stack(channels) else: padded_volume = np.pad(raw, pad_width=self.pad_width, mode='reflect') padded_volumes.append(padded_volume) self.raws = padded_volumes # build slice indices for raw and label data sets slice_builder = _get_slice_builder(self.raws, self.labels, self.weight_maps, slice_builder_config) self.raw_slices = slice_builder.raw_slices self.label_slices = slice_builder.label_slices self.weight_slices = slice_builder.weight_slices self.patch_count = len(self.raw_slices) logger.info(f'Number of patches: {self.patch_count}')