def test_equality(self): x = 10 y = 10 z = 3 pixel_id = sitk.sitkUInt8 size = (x, y, z) direction = (0, 1, 0, 1, 0, 0, 0, 0, 1) image = sitk.Image([x, y, z], pixel_id) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut1 = img.ImageProperties(image) dut2 = img.ImageProperties(image) self.assertTrue(dut1 == dut2) self.assertFalse(dut1 != dut2) image = sitk.Image([x, y, z], sitk.sitkInt8) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut1 = img.ImageProperties(image) self.assertTrue(dut1 == dut2) self.assertFalse(dut1 != dut2) image = sitk.Image([x, y, z], sitk.sitkVectorUInt8, 2) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut1 = img.ImageProperties(image) self.assertTrue(dut1 == dut2) self.assertFalse(dut1 != dut2)
def test_non_equality(self): x = 10 y = 10 z = 3 pixel_id = sitk.sitkUInt8 size = (x, y, z) direction = (0, 1, 0, 1, 0, 0, 0, 0, 1) image = sitk.Image([x, y, z], pixel_id) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut1 = img.ImageProperties(image) different_size = (x, y, 2) # non-equal size image = sitk.Image(different_size, pixel_id) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut2 = img.ImageProperties(image) self.assertFalse(dut1 == dut2) self.assertTrue(dut1 != dut2) # non-equal origin image = sitk.Image(size, pixel_id) image.SetOrigin(different_size) image.SetSpacing(size) image.SetDirection(direction) dut2 = img.ImageProperties(image) self.assertFalse(dut1 == dut2) self.assertTrue(dut1 != dut2) # non-equal spacing different_size = (x, y, 2) image = sitk.Image(size, pixel_id) image.SetOrigin(size) image.SetSpacing(different_size) image.SetDirection(direction) dut2 = img.ImageProperties(image) self.assertFalse(dut1 == dut2) self.assertTrue(dut1 != dut2) # non-equal direction different_size = (x, y, 2) image = sitk.Image(size, pixel_id) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection((1, 0, 0, 0, 1, 0, 0, 0, 1)) dut2 = img.ImageProperties(image) self.assertFalse(dut1 == dut2) self.assertTrue(dut1 != dut2)
def __call__(self, file_name: str, id_: str, category: str, subject_id: str) -> \ typing.Tuple[np.ndarray, typing.Union[conv.ImageProperties, None]]: if category == 'images': img = sitk.ReadImage( file_name, sitk.sitkFloat32) # load as float32 (otherwise is int) return sitk.GetArrayFromImage(img), conv.ImageProperties(img) else: img = sitk.ReadImage(file_name, sitk.sitkUInt8) return sitk.GetArrayFromImage(img), conv.ImageProperties(img)
def load_atlas_images(directory: str): """Loads the T1 and T2 atlas images. Args: directory (str): The atlas data directory. """ global atlas_t1 global atlas_t2 atlas_t1 = sitk.ReadImage(os.path.join(directory, 'mni_icbm152_t1_tal_nlin_sym_09a_mask.nii.gz')) atlas_t2 = sitk.ReadImage(os.path.join(directory, 'mni_icbm152_t2_tal_nlin_sym_09a.nii.gz')) if not conversion.ImageProperties(atlas_t1) == conversion.ImageProperties(atlas_t2): raise ValueError('T1w and T2w atlas images have not the same image properties')
def extract(self, reader: rd.Reader, params: dict, extracted: dict) -> None: """see :meth:`.Extractor.extract`""" subject_index_expr = expr.IndexExpression( params[defs.KEY_SUBJECT_INDEX]) shape = reader.read(defs.LOC_IMGPROP_SHAPE, subject_index_expr).tolist() direction = reader.read(defs.LOC_IMGPROP_DIRECTION, subject_index_expr).tolist() spacing = reader.read(defs.LOC_IMGPROP_SPACING, subject_index_expr).tolist() origin = reader.read(defs.LOC_IMGPROP_ORIGIN, subject_index_expr).tolist() # todo: everything in memory? image = sitk.Image(shape, sitk.sitkUInt8) image.SetDirection(direction) image.SetSpacing(spacing) image.SetOrigin(origin) # todo number_of_components_per_pixel and pixel_id img_properties = conv.ImageProperties(image) if self.do_pickle: # pickle to prevent from problems since own class img_properties = pickle.dumps(img_properties) extracted[defs.KEY_PROPERTIES] = img_properties
def test_is_two_dimensional(self): x = 10 y = 10 image = sitk.Image([x, y], sitk.sitkUInt8) dut = img.ImageProperties(image) self.assertEqual(dut.is_two_dimensional(), True) self.assertEqual(dut.is_three_dimensional(), False) self.assertEqual(dut.is_vector_image(), False)
def test_is_vector_image(self): x = 10 y = 10 number_of_components_per_pixel = 3 image = sitk.Image([x, y], sitk.sitkVectorUInt8, number_of_components_per_pixel) dut = img.ImageProperties(image) self.assertEqual(dut.is_two_dimensional(), True) self.assertEqual(dut.is_three_dimensional(), False) self.assertEqual(dut.is_vector_image(), True)
def __call__(self, file_name: str, id_: str, category: str, subject_id: str) -> \ typing.Tuple[np.ndarray, typing.Union[conv.ImageProperties, None]]: # note that this function works only if the COORDINATE-case is executed before all others if id_ == data.FileTypes.COORDINATE.name: # note that the "---" is an ugly hack to be able to pass two paths... probability_file, gt_file = file_name.split('---') # get properties img_gt = sitk.ReadImage(gt_file) self.properties = conv.ImageProperties(img_gt) self.gt_arr = sitk.GetArrayFromImage(img_gt) # get probabilities img_proba = sitk.ReadImage(probability_file) proba_arr = sitk.GetArrayFromImage(img_proba) proba_arr = proba_arr[..., 1] # get probabilities of foreground class # get indices of probabilites larger some value # meaning construct the point cloud proba_indices = np.nonzero(proba_arr > self.probability_threshold) proba_indices = np.array(proba_indices[::-1]) proba_indices = np.transpose(proba_indices) # shape is (N, 3) self.indices = proba_indices self.probabilities = np.zeros((self.indices.shape[0], 1), np.float32) # shape is (N, 1) self.labels = np.zeros((self.indices.shape[0], 1), np.uint8) # shape is (N, 1) for idx, (x, y, z) in enumerate(self.indices): self.probabilities[idx] = proba_arr[z, y, x] self.labels[idx] = self.gt_arr[z, y, x] return self.indices, self.properties elif id_ == data.FileTypes.INDICES.name: # todo: needed return self.indices, self.properties elif id_ == data.FileTypes.LABEL.name: return self.labels, self.properties elif id_ == data.FileTypes.GTM.name: return self.gt_arr, self.properties elif id_ == data.FileTypes.IMAGE_INFORMATION.name: img = sitk.ReadImage(file_name) img = sitk.GetArrayFromImage(img) img = img[..., 1] # get probabilities of foreground class img_arr = img.copy() img_arr = np.expand_dims(img_arr, -1) cubes = self._extract_cubes(img_arr) return cubes.astype(np.float32), self.properties else: raise ValueError('id "{}" unknown'.format(id_))
def setUp(self): dim_x = 5 dim_y = 10 dim_z = 3 self.no_vector_components = 4 # some unordinary origins, spacings and directions self.origin_spacing_2d = (dim_x, dim_y) self.direction_2d = (0, 1, 1, 0) self.origin_spacing_3d = (dim_x, dim_y, dim_z) self.direction_3d = (1, 0, 0, 0, 1, 0, 0, 0, 1) # set up images image = sitk.Image((dim_x, dim_y, dim_z), sitk.sitkUInt8) image.SetOrigin(self.origin_spacing_3d) image.SetSpacing(self.origin_spacing_3d) image.SetDirection(self.direction_3d) self.properties_3d = img.ImageProperties(image) image = sitk.Image((dim_x, dim_y), sitk.sitkUInt8) image.SetOrigin(self.origin_spacing_2d) image.SetSpacing(self.origin_spacing_2d) image.SetDirection(self.direction_2d) self.properties_2d = img.ImageProperties(image) # set up numpy arrays (note the inverted order of the dimension) self.array_image_shape_2d = np.zeros((dim_y, dim_x), np.uint8) self.array_2d_vector = np.zeros( (dim_y * dim_x, self.no_vector_components), np.uint8) self.array_image_shape_2d_vector = np.zeros( (dim_y, dim_x, self.no_vector_components), np.uint8) self.array_image_shape_3d = np.zeros((dim_z, dim_y, dim_x), np.uint8) self.array_3d_vector = np.zeros( (dim_z * dim_y * dim_x, self.no_vector_components), np.uint8) self.array_image_shape_3d_vector = np.zeros( (dim_z, dim_y, dim_x, self.no_vector_components), np.uint8)
def load_atlas_images(directory: str): """Loads the T1 and T2 atlas images. Args: directory (str): The atlas data directory. """ global atlas_t1 global atlas_t2 global reference_img atlas_t1 = sitk.ReadImage( os.path.join(directory, 'mni_icbm152_t1_tal_nlin_sym_09a_mask.nii.gz')) atlas_t2 = sitk.ReadImage( os.path.join(directory, 'mni_icbm152_t2_tal_nlin_sym_09a.nii.gz')) reference_img = sitk.ReadImage( '/Users/leo/Documents/MBE/Semester_3/Medical_image_analysis_lab/MIALab/data/train/100307/T1native.nii.gz' ) #reference_img = sitk.Resample(atlas_t2, reference_img) if not conversion.ImageProperties(atlas_t1) == conversion.ImageProperties( atlas_t2): raise ValueError( 'T1w and T2w atlas images have not the same image properties')
def extract(self, reader: rd.Reader, params: dict, extracted: dict) -> None: subject_index_expr = expr.IndexExpression(params['subject_index']) shape = reader.read(df.INFO_SHAPE, subject_index_expr).tolist() direction = reader.read(df.INFO_DIRECTION, subject_index_expr).tolist() spacing = reader.read(df.INFO_SPACING, subject_index_expr).tolist() origin = reader.read(df.INFO_ORIGIN, subject_index_expr).tolist() # todo: everything in memory? image = sitk.Image(shape, sitk.sitkUInt8) image.SetDirection(direction) image.SetSpacing(spacing) image.SetOrigin(origin) # todo number_of_components_per_pixel and pixel_id img_properties = conv.ImageProperties(image) if self.do_pickle: # pickle to prevent from problems since own class img_properties = pickle.dumps(img_properties) extracted['properties'] = img_properties
def test_properties(self): x = 10 y = 10 z = 3 pixel_id = sitk.sitkUInt8 size = (x, y, z) direction = (0, 1, 0, 1, 0, 0, 0, 0, 1) image = sitk.Image([x, y, z], pixel_id) image.SetOrigin(size) image.SetSpacing(size) image.SetDirection(direction) dut = img.ImageProperties(image) self.assertEqual(dut.size, size) self.assertEqual(dut.origin, size) self.assertEqual(dut.spacing, size) self.assertEqual(dut.direction, direction) self.assertEqual(dut.dimensions, z) self.assertEqual(dut.number_of_components_per_pixel, 1) self.assertEqual(dut.pixel_id, pixel_id)
def __init__(self, id_: str, path: str, images: dict): """Initializes a new instance of the BrainImage class. Args: id_ (str): An identifier. path (str): Full path to the image directory. images (dict): The images, where the key is a :py:class:`BrainImageTypes` and the value is a SimpleITK image. """ self.id_ = id_ self.path = path self.images = images # ensure we have an image to get the image properties if len(images) == 0: raise ValueError('No images provided') self.image_properties = conversion.ImageProperties(self.images[list( self.images.keys())[0]]) self.feature_images = {} self.feature_matrix = None # a tuple (features, labels),
def __call__(self, file_name: str, id_: str, category: str, subject_id: str) -> \ typing.Tuple[np.ndarray, typing.Union[conv.ImageProperties, None]]: if id_ == FileTypes.AGE.name: with open(file_name, 'r') as f: value = np.asarray([int(f.readline().split(':')[1].strip())]) return value, None if id_ == FileTypes.GPA.name: with open(file_name, 'r') as f: value = np.asarray( [float(f.readlines()[1].split(':')[1].strip())]) return value, None if id_ == FileTypes.SEX.name: with open(file_name, 'r') as f: value = np.asarray([f.readlines()[2].split(':')[1].strip()]) return value, None if category == 'images': img = sitk.ReadImage(file_name, sitk.sitkFloat32) else: img = sitk.ReadImage(file_name, sitk.sitkUInt8) return sitk.GetArrayFromImage(img), conv.ImageProperties(img)
def __call__(self, file_name: str, id_: str, category: str, subject_id: str) -> \ typing.Tuple[np.ndarray, typing.Union[conv.ImageProperties, None]]: if id_ == FileTypes.AGE.name: with open(file_name, 'r') as f: value = np.asarray([int(f.readline().split(':')[1].strip())]) return value, None if id_ == FileTypes.GPA.name: with open(file_name, 'r') as f: value = np.asarray([float(f.readlines()[1].split(':')[1].strip())]) return value, None if id_ == FileTypes.GENDER.name: with open(file_name, 'r') as f: value = np.array(f.readlines()[2].split(':')[1].strip()) return value, None if category == defs.KEY_IMAGES: img = sitk.ReadImage(file_name, sitk.sitkFloat32) else: # this is the ground truth (defs.KEY_LABELS), which will be loaded as unsigned integer img = sitk.ReadImage(file_name, sitk.sitkUInt8) return sitk.GetArrayFromImage(img), conv.ImageProperties(img)
def __call__(self, file_name: str, id_: str, category: str, subject_id: str) -> \ typing.Tuple[np.ndarray, typing.Union[conv.ImageProperties, None]]: img = sitk.ReadImage(file_name) return sitk.GetArrayFromImage(img), conv.ImageProperties(img)
def pre_process(id_: str, paths: dict, **kwargs) -> structure.BrainImage: """Loads and processes an image. The processing includes: - Registration - Pre-processing - Feature extraction Args: id_ (str): An image identifier. paths (dict): A dict, where the keys are an image identifier of type structure.BrainImageTypes and the values are paths to the images. Returns: (structure.BrainImage): """ print('-' * 10, 'Processing', id_) # load image path = paths.pop( id_, '') # the value with key id_ is the root directory of the image img = {img_key: sitk.ReadImage(path) for img_key, path in paths.items()} img = structure.BrainImage(id_, path, img) # construct T1 pipeline pipeline_t1 = fltr.FilterPipeline() if kwargs.get('zscore_pre', False): pipeline_t1.add_filter(fltr_prep.NormalizeZScore()) if kwargs.get('registration_pre', False): pipeline_t1.add_filter(fltr_reg.MultiModalRegistration()) pipeline_t1.set_param(fltr_reg.MultiModalRegistrationParams(atlas_t1), 1) # execute pipeline on T1 image img.images[structure.BrainImageTypes.T1] = pipeline_t1.execute( img.images[structure.BrainImageTypes.T1]) # construct T2 pipeline pipeline_t2 = fltr.FilterPipeline() if kwargs.get('zscore_pre', False): pipeline_t2.add_filter(fltr_prep.NormalizeZScore()) # execute pipeline on T2 image img.images[structure.BrainImageTypes.T2] = pipeline_t2.execute( img.images[structure.BrainImageTypes.T2]) if kwargs.get('registration_pre', False): # get transformation transform = pipeline_t1.filters[1].transform # apply transformation of T1 image registration to T2 image image_t2 = img.images[structure.BrainImageTypes.T2] image_t2 = sitk.Resample(image_t2, atlas_t1, transform, sitk.sitkLinear, 0.0, image_t2.GetPixelIDValue()) img.images[structure.BrainImageTypes.T2] = image_t2 # apply transformation of T1 image registration to ground truth image_ground_truth = img.images[structure.BrainImageTypes.GroundTruth] image_ground_truth = sitk.Resample( image_ground_truth, atlas_t1, transform, sitk.sitkNearestNeighbor, 0, image_ground_truth.GetPixelIDValue()) img.images[structure.BrainImageTypes.GroundTruth] = image_ground_truth # update image properties to atlas image properties after registration img.image_properties = conversion.ImageProperties(atlas_t1) # extract the features feature_extractor = FeatureExtractor(img, **kwargs) img = feature_extractor.execute() img.feature_images = {} return img
def pre_process(id_: str, paths: dict, **kwargs) -> structure.BrainImage: """Loads and processes an image. The processing includes: - Registration - Pre-processing - Feature extraction Args: id_ (str): An image identifier. paths (dict): A dict, where the keys are an image identifier of type structure.BrainImageTypes and the values are paths to the images. Returns: (structure.BrainImage): """ print('-' * 10, 'Processing', id_) # load image path = paths.pop( id_, '') # the value with key id_ is the root directory of the image path_to_transform = paths.pop( structure.BrainImageTypes.RegistrationTransform, '') img = {img_key: sitk.ReadImage(path) for img_key, path in paths.items()} transform = sitk.ReadTransform(path_to_transform) img = structure.BrainImage(id_, path, img, transform) # construct pipeline for brain mask registration # we need to perform this before the T1w and T2w pipeline because the registered mask is used for skull-stripping pipeline_brain_mask = fltr.FilterPipeline() if kwargs.get('registration_pre', False): pipeline_brain_mask.add_filter(fltr_prep.ImageRegistration()) pipeline_brain_mask.set_param( fltr_prep.ImageRegistrationParameters(atlas_t1, img.transformation, True), len(pipeline_brain_mask.filters) - 1) # execute pipeline on the brain mask image img.images[ structure.BrainImageTypes.BrainMask] = pipeline_brain_mask.execute( img.images[structure.BrainImageTypes.BrainMask]) # construct pipeline for T1w image pre-processing pipeline_t1 = fltr.FilterPipeline() if kwargs.get('registration_pre', False): pipeline_t1.add_filter(fltr_prep.ImageRegistration()) pipeline_t1.set_param( fltr_prep.ImageRegistrationParameters(atlas_t1, img.transformation), len(pipeline_t1.filters) - 1) if kwargs.get('skullstrip_pre', False): pipeline_t1.add_filter(fltr_prep.SkullStripping()) pipeline_t1.set_param( fltr_prep.SkullStrippingParameters( img.images[structure.BrainImageTypes.BrainMask]), len(pipeline_t1.filters) - 1) if kwargs.get('normalization_pre', False): pipeline_t1.add_filter(fltr_prep.ImageNormalization()) # execute pipeline on the T1w image img.images[structure.BrainImageTypes.T1w] = pipeline_t1.execute( img.images[structure.BrainImageTypes.T1w]) # construct pipeline for T2w image pre-processing pipeline_t2 = fltr.FilterPipeline() if kwargs.get('registration_pre', False): pipeline_t2.add_filter(fltr_prep.ImageRegistration()) pipeline_t2.set_param( fltr_prep.ImageRegistrationParameters(atlas_t2, img.transformation), len(pipeline_t2.filters) - 1) if kwargs.get('skullstrip_pre', False): pipeline_t2.add_filter(fltr_prep.SkullStripping()) pipeline_t2.set_param( fltr_prep.SkullStrippingParameters( img.images[structure.BrainImageTypes.BrainMask]), len(pipeline_t2.filters) - 1) if kwargs.get('normalization_pre', False): pipeline_t2.add_filter(fltr_prep.ImageNormalization()) # execute pipeline on the T2w image img.images[structure.BrainImageTypes.T2w] = pipeline_t2.execute( img.images[structure.BrainImageTypes.T2w]) # construct pipeline for ground truth image pre-processing pipeline_gt = fltr.FilterPipeline() if kwargs.get('registration_pre', False): pipeline_gt.add_filter(fltr_prep.ImageRegistration()) pipeline_gt.set_param( fltr_prep.ImageRegistrationParameters(atlas_t1, img.transformation, True), len(pipeline_gt.filters) - 1) # execute pipeline on the ground truth image img.images[structure.BrainImageTypes.GroundTruth] = pipeline_gt.execute( img.images[structure.BrainImageTypes.GroundTruth]) # update image properties to atlas image properties after registration img.image_properties = conversion.ImageProperties( img.images[structure.BrainImageTypes.T1w]) # extract the features feature_extractor = FeatureExtractor(img, **kwargs) img = feature_extractor.execute() img.feature_images = { } # we free up memory because we only need the img.feature_matrix # for training of the classifier return img
def _read_map(self, file_name): img = sitk.ReadImage(file_name) np_data = sitk.GetArrayFromImage(img) # shape=(5, 350, 350) and dtype=float32 properties = pymia_conv.ImageProperties(img) return np_data, properties
def main(hdf_file: str): extractor = extr.ComposeExtractor([ extr.NamesExtractor(), extr.DataExtractor(), extr.SelectiveDataExtractor(), extr.DataExtractor(('numerical', ), ignore_indexing=True), extr.DataExtractor(('gender', ), ignore_indexing=True), extr.DataExtractor(('mask', ), ignore_indexing=False), extr.SubjectExtractor(), extr.FilesExtractor(categories=(defs.KEY_IMAGES, defs.KEY_LABELS, 'mask', 'numerical', 'gender')), extr.IndexingExtractor(), extr.ImagePropertiesExtractor() ]) dataset = extr.PymiaDatasource(hdf_file, extr.SliceIndexing(), extractor) for i in range(len(dataset)): item = dataset[i] index_expr = item[defs.KEY_INDEX_EXPR] # type: data.IndexExpression root = item[defs.KEY_FILE_ROOT] image = None # type: sitk.Image for i, file in enumerate( item[defs.KEY_PLACEHOLDER_FILES.format('images')]): image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image).astype(np.float32) np_img = (np_img - np_img.mean()) / np_img.std() np_slice = np_img[index_expr.expression] if (np_slice != item[defs.KEY_IMAGES][..., i]).any(): raise ValueError('slice not equal') # for any image image_properties = conv.ImageProperties(image) if image_properties != item[defs.KEY_PROPERTIES]: raise ValueError('image properties not equal') for file in item[defs.KEY_PLACEHOLDER_FILES.format('labels')]: image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image) np_img = np.expand_dims( np_img, axis=-1 ) # due to the convention of having the last dim as number of channels np_slice = np_img[index_expr.expression] if (np_slice != item[defs.KEY_LABELS]).any(): raise ValueError('slice not equal') for file in item[defs.KEY_PLACEHOLDER_FILES.format('mask')]: image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image) np_img = np.expand_dims( np_img, axis=-1 ) # due to the convention of having the last dim as number of channels np_slice = np_img[index_expr.expression] if (np_slice != item['mask']).any(): raise ValueError('slice not equal') for file in item[defs.KEY_PLACEHOLDER_FILES.format('numerical')]: with open(os.path.join(root, file), 'r') as f: lines = f.readlines() age = float(lines[0].split(':')[1].strip()) gpa = float(lines[1].split(':')[1].strip()) if age != item['numerical'][0][0] or gpa != item['numerical'][0][1]: raise ValueError('value not equal') for file in item[defs.KEY_PLACEHOLDER_FILES.format('gender')]: with open(os.path.join(root, file), 'r') as f: gender = f.readlines()[2].split(':')[1].strip() if gender != str(item['gender'][0]): raise ValueError('value not equal') print('All test passed!')
def main(hdf_file: str): extractor = extr.ComposeExtractor([ extr.NamesExtractor(), extr.DataExtractor(), extr.SelectiveDataExtractor(), extr.DataExtractor(('numerical', ), ignore_indexing=True), extr.DataExtractor(('sex', ), ignore_indexing=True), extr.DataExtractor(('mask', ), ignore_indexing=False), extr.SubjectExtractor(), extr.FilesExtractor(categories=('images', 'labels', 'mask', 'numerical', 'sex')), extr.IndexingExtractor(), extr.ImagePropertiesExtractor() ]) dataset = extr.ParameterizableDataset(hdf_file, extr.SliceIndexing(), extractor) for i in range(len(dataset)): item = dataset[i] index_expr = item['index_expr'] # type: pymia_data.IndexExpression root = item['file_root'] image = None # type: sitk.Image for i, file in enumerate(item['images_files']): image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image).astype(np.float32) np_img = (np_img - np_img.mean()) / np_img.std() np_slice = np_img[index_expr.expression] if (np_slice != item['images'][..., i]).any(): raise ValueError('slice not equal') # for any image image_properties = conv.ImageProperties(image) if image_properties != item['properties']: raise ValueError('image properties not equal') for file in item['labels_files']: image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image) np_img = np.expand_dims( np_img, axis=-1 ) # due to the convention of having the last dim as number of channels np_slice = np_img[index_expr.expression] if (np_slice != item['labels']).any(): raise ValueError('slice not equal') for file in item['mask_files']: image = sitk.ReadImage(os.path.join(root, file)) np_img = sitk.GetArrayFromImage(image) np_img = np.expand_dims( np_img, axis=-1 ) # due to the convention of having the last dim as number of channels np_slice = np_img[index_expr.expression] if (np_slice != item['mask']).any(): raise ValueError('slice not equal') for file in item['numerical_files']: with open(os.path.join(root, file), 'r') as f: lines = f.readlines() age = float(lines[0].split(':')[1].strip()) gpa = float(lines[1].split(':')[1].strip()) if age != item['numerical'][0][0] or gpa != item['numerical'][0][1]: raise ValueError('value not equal') for file in item['sex_files']: with open(os.path.join(root, file), 'r') as f: sex = f.readlines()[2].split(':')[1].strip() if sex != str(item['sex'][0]): raise ValueError('value not equal') print('All test passed!')